Skip to content

Commit dfd544f

Browse files
author
ottcs
committed
Particles _step optimized, and refactoring
1 parent 3d8c0db commit dfd544f

File tree

1 file changed

+142
-135
lines changed

1 file changed

+142
-135
lines changed

‎nightly/zephyr.js‎

Lines changed: 142 additions & 135 deletions
Original file line numberDiff line numberDiff line change
@@ -1,30 +1,43 @@
11
"use strict"
2-
PIXI.Keys = {};
3-
PIXI.Mouse = {};
2+
43
PIXI.Audio = {};
54
PIXI.File = {};
65
PIXI.Particles = {};
76

7+
// ZEPHYR FUNCTIONALITY //
8+
89
PIXI.Zephyr = {
910
version: "ZephyrJS 23.1.26",
1011
compatible: "PixiJS v7.1.1",
12+
_spriteFix: (s) => { // Returns the actual x/y width/height of a scaled and anchored Sprite
13+
let w = s.width * (s.scale ? s.scale.x : 1);
14+
let h = s.height * (s.scale ? s.scale.y : 1);
15+
return {
16+
x: s.x - (s.anchor ? s.anchor.x * w : 0) + Math.min(0, w),
17+
y: s.y - (s.anchor ? s.anchor.y * h : 0) + Math.min(0, h),
18+
width: Math.abs(w),
19+
height: Math.abs(h)
20+
}
21+
},
1122
useKeys: () => {
12-
PIXI.Keys.map = new Map();
13-
PIXI.Keys.down = (key) => {
14-
if (PIXI.Keys.map.size > 0 && PIXI.Keys.map.has(key)) {
15-
PIXI.Keys.map.set(key, false);
16-
return true;
17-
}
18-
return false;
19-
};
20-
PIXI.Keys.fired = (key) => {
21-
if (PIXI.Keys.map.size > 0 && PIXI.Keys.map.get(key)) {
22-
PIXI.Keys.map.set(key, false);
23-
return true;
24-
}
25-
return false;
23+
PIXI.Keys = {
24+
map: new Map(),
25+
down: (key) => {
26+
if (PIXI.Keys.map.size > 0 && PIXI.Keys.map.has(key)) {
27+
PIXI.Keys.map.set(key, false);
28+
return true;
29+
}
30+
return false;
31+
},
32+
fired: (key) => {
33+
if (PIXI.Keys.map.size > 0 && PIXI.Keys.map.get(key)) {
34+
PIXI.Keys.map.set(key, false);
35+
return true;
36+
}
37+
return false;
38+
},
2639
};
27-
40+
// EVENTS //
2841
window.addEventListener('keydown', (e) => {
2942
PIXI.Keys.map.set(e.code, true);
3043
});
@@ -33,157 +46,151 @@ PIXI.Zephyr = {
3346
});
3447
},
3548
useMouse: () => {
36-
PIXI.Mouse.bounds = document.getElementsByTagName("html")[0].getBoundingClientRect();
37-
PIXI.Mouse.container = document.getElementsByTagName("html")[0];
38-
PIXI.Mouse.x = -1;
39-
PIXI.Mouse.y = -1;
40-
PIXI.Mouse.setContainer = (view) => {
41-
let b = view.getBoundingClientRect();
42-
if (b.width * b.height == 0) {
43-
console.error("Cannot use PIXI.Mouse.setContainer() with an invalid element.");
44-
} else {
45-
PIXI.Mouse.container = view;
46-
PIXI.Mouse.bounds = PIXI.Mouse.container.getBoundingClientRect();
49+
PIXI.Mouse = {
50+
// COORDS //
51+
bounds: document.getElementsByTagName("html")[0].getBoundingClientRect(),
52+
container: document.getElementsByTagName("html")[0],
53+
x: 0,
54+
y: 0,
55+
setContainer: (view) => {
56+
let b = view.getBoundingClientRect();
57+
if (b.width * b.height == 0) {
58+
console.error("Cannot use PIXI.Mouse.setContainer() with an invalid element.");
59+
} else {
60+
PIXI.Mouse.container = view;
61+
PIXI.Mouse.bounds = PIXI.Mouse.container.getBoundingClientRect();
62+
}
63+
},
64+
// BUTTONS //
65+
ALIAS: ["Primary", "Middle", "Secondary"],
66+
map: new Map(),
67+
down: (btn) => {
68+
if (PIXI.Mouse.map.size > 0 && PIXI.Mouse.map.has(btn)) {
69+
PIXI.Mouse.map.set(btn, false);
70+
return true;
71+
}
72+
return false;
73+
},
74+
fired: (btn) => {
75+
if (PIXI.Mouse.map.size > 0 && PIXI.Mouse.map.get(btn)) {
76+
PIXI.Mouse.map.set(btn, false);
77+
return true;
78+
}
79+
return false;
4780
}
4881
}
82+
// EVENTS //
4983
window.onresize = () => {
5084
PIXI.Mouse.bounds = PIXI.Mouse.container.getBoundingClientRect();
5185
}
52-
53-
PIXI.Mouse.alias = ["Primary", "Middle", "Secondary"];
54-
55-
PIXI.Mouse.map = new Map();
56-
PIXI.Mouse.down = (btn) => {
57-
if (PIXI.Mouse.map.size > 0 && PIXI.Mouse.map.has(btn)) {
58-
PIXI.Mouse.map.set(btn, false);
59-
return true;
60-
}
61-
return false;
62-
}
63-
64-
PIXI.Mouse.fired = (btn) => {
65-
if (PIXI.Mouse.map.size > 0 && PIXI.Mouse.map.get(btn)) {
66-
PIXI.Mouse.map.set(btn, false);
67-
return true;
68-
}
69-
return false;
70-
}
71-
7286
window.addEventListener('mouseup', (e) => {
73-
PIXI.Mouse.map.delete(PIXI.Mouse.alias[e.button]);
87+
PIXI.Mouse.map.delete(PIXI.Mouse.ALIAS[e.button]);
7488
});
7589
window.addEventListener('mousedown', (e) => {
76-
PIXI.Mouse.map.set(PIXI.Mouse.alias[e.button], true);
90+
PIXI.Mouse.map.set(PIXI.Mouse.ALIAS[e.button], true);
7791
});
7892
window.addEventListener('mousemove', (e) => {
7993
PIXI.Mouse.x = (e.x - PIXI.Mouse.bounds.left + window.pageXOffset) / PIXI.Mouse.bounds.width * PIXI.Mouse.container.width;
8094
PIXI.Mouse.y = (e.y - PIXI.Mouse.bounds.top + window.pageYOffset) / PIXI.Mouse.bounds.height * PIXI.Mouse.container.height;
8195
});
8296
},
8397
useAudio: () => {
84-
PIXI.Audio.ctx = new AudioContext();
85-
PIXI.Audio.buffers = new Map();
86-
PIXI.Audio.player = function () {
87-
if (PIXI.Audio.buffers.has(this.src)) {
88-
let aud = PIXI.Audio.ctx.createBufferSource();
89-
aud.buffer = PIXI.Audio.buffers.get(this.src);
90-
aud.connect(PIXI.Audio.ctx.destination);
91-
aud.start(0);
92-
}
93-
}
94-
PIXI.Audio.from = (src) => {
95-
let r = new XMLHttpRequest();
96-
r.open('GET', src, true);
97-
r.responseType = 'arraybuffer';
98+
PIXI.Audio = {
99+
ctx: new AudioContext(),
100+
buffers: new Map(), // Stores all audio buffers
101+
_player: function () { // Shared function for all Audio objects
102+
if (PIXI.Audio.buffers.has(this.src)) {
103+
let aud = PIXI.Audio.ctx.createBufferSource();
104+
aud.buffer = PIXI.Audio.buffers.get(this.src);
105+
aud.connect(PIXI.Audio.ctx.destination);
106+
aud.start(0);
107+
}
108+
},
109+
from: (src) => {
110+
let r = new XMLHttpRequest();
111+
r.open('GET', src, true);
112+
r.responseType = 'arraybuffer';
98113

99-
// Decode asynchronously
100-
r.onload = () => {
101-
PIXI.Audio.ctx.decodeAudioData(r.response, function (buffer) {
102-
PIXI.Audio.buffers.set(src, buffer);
103-
});
104-
}
105-
r.send();
106-
return {
107-
src: src,
108-
play: PIXI.Audio.player
114+
r.onload = () => { // Decode asynchronously
115+
PIXI.Audio.ctx.decodeAudioData(r.response, function (buffer) {
116+
PIXI.Audio.buffers.set(src, buffer); // Store audio buffer once
117+
})
118+
}
119+
r.send();
120+
return { src: src, play: PIXI.Audio._player };
109121
}
110122
}
111123
},
112124
useFile: () => {
113-
PIXI.File.write = async (object, fName) => {
114-
let file = new Blob([JSON.stringify(object)], { type: JSON });
115-
var a = document.createElement("a"),
116-
url = URL.createObjectURL(file);
117-
a.href = url;
118-
a.download = fName + ".json";
119-
document.body.appendChild(a);
120-
a.click();
121-
setTimeout(() => {
122-
document.body.removeChild(a);
123-
window.URL.revokeObjectURL(url);
124-
}, 0);
125-
};
126-
PIXI.File.open = async () => {
127-
[fileHandle] = await window.showOpenFilePicker();
128-
let file = await fileHandle.getFile();
129-
let contents = await file.text();
130-
return JSON.parse(contents);
131-
};
125+
PIXI.File = {
126+
write: async (object, fName) => {
127+
let file = new Blob([JSON.stringify(object)], { type: JSON });
128+
var a = document.createElement("a"),
129+
url = URL.createObjectURL(file);
130+
a.href = url;
131+
a.download = fName + ".json";
132+
document.body.appendChild(a);
133+
a.click();
134+
setTimeout(() => {
135+
document.body.removeChild(a);
136+
window.URL.revokeObjectURL(url);
137+
}, 0);
138+
},
139+
open: async () => {
140+
[fileHandle] = await window.showOpenFilePicker();
141+
let file = await fileHandle.getFile();
142+
let contents = await file.text();
143+
return JSON.parse(contents);
144+
}
145+
}
132146
},
133147
useParticles: () => {
134-
PIXI.Particles.from = (src, size) => {
135-
let res = new PIXI.ParticleContainer(size);
136-
res.baseTexture = PIXI.Texture.from(src);
137-
res.life = 128;
138-
res.speed = 1;
139-
res.direction = 0;
140-
res.spread = 6.2831853072;
141-
res.spawnTime = 0;
142-
res._initParticle = (p) => {
143-
let r = (Math.random() - 0.5) * res.spread + res.direction;
144-
p.move = { x: res.speed * Math.cos(r), y: res.speed * Math.sin(r) };
145-
p.x = p.y = 0;
146-
p.life = res.life;
147-
return p;
148-
}
149-
res.step = (deltaTime) => {
150-
if (res.children.length < size) {
151-
res.spawnTime -= deltaTime;
152-
if (res.spawnTime <= 0) {
153-
res.spawnTime = res.life / size;
154-
let p = res._initParticle(new PIXI.Sprite(res.baseTexture));
148+
PIXI.Particles = {
149+
_step: function (deltaTime) {
150+
const init = (p) => {
151+
let r = (Math.random() - 0.5) * this.spread + this.direction;
152+
p.move = { x: this.speed * Math.cos(r), y: this.speed * Math.sin(r) };
153+
p.x = p.y = 0;
154+
p.life = this.life;
155+
}
156+
if (this.children.length < this.size) {
157+
this.spawnTime -= deltaTime;
158+
if (this.spawnTime <= 0) {
159+
this.spawnTime = this.life / this.size;
160+
let p = new PIXI.Sprite(this.baseTexture);
155161
p.anchor = { x: 0.5, y: 0.5 }
156-
res.addChild(p);
162+
init(p);
163+
this.addChild(p);
157164
}
158165
}
159-
res.children.forEach(p => {
166+
this.children.forEach(p => {
160167
p.x += p.move.x * deltaTime;
161168
p.y += p.move.y * deltaTime;
162-
if ((p.life -= deltaTime * res.speed) <= 0)
163-
p = res._initParticle(p);
169+
if ((p.life -= deltaTime * this.speed) <= 0)
170+
init(p);
164171
});
165-
}
166-
return res;
167-
}
168-
},
169-
helper: {
170-
spriteFix: (s) => { // Returns the actual x/y width/height of a scaled and anchored Sprite
171-
let w = s.width * (s.scale ? s.scale.x : 1);
172-
let h = s.height * (s.scale ? s.scale.y : 1);
173-
return {
174-
x: s.x - (s.anchor ? s.anchor.x * w : 0) + Math.min(0, w),
175-
y: s.y - (s.anchor ? s.anchor.y * h : 0) + Math.min(0, h),
176-
width: Math.abs(w),
177-
height: Math.abs(h)
172+
},
173+
from: (src, size) => {
174+
let res = new PIXI.ParticleContainer(size);
175+
res.size = size;
176+
res.baseTexture = PIXI.Texture.from(src);
177+
res.life = 128;
178+
res.speed = 1;
179+
res.direction = 0;
180+
res.spread = 6.2831853072;
181+
res.spawnTime = 0;
182+
res.step = PIXI.Particles._step;
183+
return res;
178184
}
179185
}
180186
}
181187
}
188+
182189
// Collision testing methods
183190
PIXI.collision = {
184191
aabb: (a, b) => { // Axis-Aligned Bounding Box method
185-
let aFix = PIXI.Zephyr.helper.spriteFix(a);
186-
let bFix = PIXI.Zephyr.helper.spriteFix(b);
192+
let aFix = PIXI.Zephyr._spriteFix(a);
193+
let bFix = PIXI.Zephyr._spriteFix(b);
187194
return !(
188195
aFix.x + a.width < bFix.x ||
189196
aFix.y + a.height < bFix.y ||
@@ -192,8 +199,8 @@ PIXI.collision = {
192199
);
193200
},
194201
radius: (a, b) => { // Circle collision, for objects a and b, provided they ha
195-
let aFix = PIXI.Zephyr.helper.spriteFix(a);
196-
let bFix = PIXI.Zephyr.helper.spriteFix(b);
202+
let aFix = PIXI.Zephyr._spriteFix(a);
203+
let bFix = PIXI.Zephyr._spriteFix(b);
197204
return (
198205
Math.sqrt(Math.pow(aFix.x - bFix.x, 2) + Math.pow(aFix.y - bFix.y, 2)) <= a.r + b.r
199206
);

0 commit comments

Comments
 (0)