BlueGit

projects-timfalken-com meteors

chore: project skeleton, build script and vendored frameworkv3

Add package.json, .gitignore and src/build.sh (same concatenate-to-build/
pattern as the raytracer). Vendor framework.js so CI does not need to clone
frameworkv3 to produce a playable build/.

timfa Grok Bot · pushed by timfa

Authored 2026-11-13 · 4 days ago

Hash
38119c81cf3424b32c49b7ecd580a292dba88f4e
Parent
5d75a033
4 files changed +5370 −0
.gitignore added +5 −0
@@ -0,0 +1,5 @@
1 node_modules/
2 *.log
3 .DS_Store
4 __pycache__/
5 *.pyc
@@ -0,0 +1,5 @@
1node_modules/
2*.log
3.DS_Store
4__pycache__/
5*.pyc
build/framework.js added +5313 −0
@@ -0,0 +1,5313 @@
1 /*
2 * AUTO-GENERATED FILE — DO NOT EDIT BY HAND.
3 *
4 * Built by glbuild.sh from the modular sources in this repository.
5 * Make changes in the framework/ source tree, then rebuild.
6 * Upstream: https://gitlab.com/Timfa/frameworkv3
7 */
8
9 /*
10 * Start File:
11 * framework/extensions/polyfills.js
12 */
13 if (!Math.sign)
14 {
15 Math.sign = function (x)
16 {
17 x = +x; // convert to a number
18 if (x === 0 || isNaN(x))
19 {
20 return Number(x);
21 }
22 return x > 0 ? 1 : -1;
23 };
24 }
25
26 (function (e) { var t = function () { try { return !!Symbol.iterator; } catch (e) { return false; } }; var n = t(); var r = function (e) { var t = { next: function () { var t = e.shift(); return { done: t === void 0, value: t }; } }; if (n) { t[Symbol.iterator] = function () { return t; }; } return t; }; var i = function (e) { return encodeURIComponent(e).replace(/%20/g, "+"); }; var o = function (e) { return decodeURIComponent(e).replace(/\+/g, " "); }; var a = function () { var t = function (e) { Object.defineProperty(this, "_entries", { value: {} }); if (typeof e === "string") { if (e !== "") { e = e.replace(/^\?/, ""); var n = e.split("&"); var r; for (var i = 0; i < n.length; i++) { r = n[i].split("="); this.append(o(r[0]), r.length > 1 ? o(r[1]) : ""); } } } else if (e instanceof t) { var a = this; e.forEach(function (e, t) { a.append(e, t); }); } }; var a = t.prototype; a.append = function (e, t) { if (e in this._entries) { this._entries[e].push(t.toString()); } else { this._entries[e] = [t.toString()]; } }; a.delete = function (e) { delete this._entries[e]; }; a.get = function (e) { return e in this._entries ? this._entries[e][0] : null; }; a.getAll = function (e) { return e in this._entries ? this._entries[e].slice(0) : []; }; a.has = function (e) { return e in this._entries; }; a.set = function (e, t) { this._entries[e] = [t.toString()]; }; a.forEach = function (e, t) { var n; for (var r in this._entries) { if (this._entries.hasOwnProperty(r)) { n = this._entries[r]; for (var i = 0; i < n.length; i++) { e.call(t, n[i], r, this); } } } }; a.keys = function () { var e = []; this.forEach(function (t, n) { e.push(n); }); return r(e); }; a.values = function () { var e = []; this.forEach(function (t) { e.push(t); }); return r(e); }; a.entries = function () { var e = []; this.forEach(function (t, n) { e.push([n, t]); }); return r(e); }; if (n) { a[Symbol.iterator] = a.entries; } a.toString = function () { var e = []; this.forEach(function (t, n) { e.push(i(n) + "=" + i(t)); }); return e.join("&"); }; e.URLSearchParams = t; }; if (!("URLSearchParams" in e) || new URLSearchParams("?a=1").toString() !== "a=1") { a(); } })(typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : this); (function (e) { var t = function () { try { var e = new URL("b", "http://a"); e.pathname = "c%20d"; return e.href === "http://a/c%20d" && e.searchParams; } catch (e) { return false; } }; var n = function () { var t = e.URL; var n = function (e, t) { if (typeof e !== "string") {e = String(e);} var n = document.implementation.createHTMLDocument(""); window.doc = n; if (t) { var r = n.createElement("base"); r.href = t; n.head.appendChild(r); } var i = n.createElement("a"); i.href = e; n.body.appendChild(i); i.href = i.href; if (i.protocol === ":" || !/:/.test(i.href)) { throw new TypeError("Invalid URL"); } Object.defineProperty(this, "_anchorElement", { value: i }); }; var r = n.prototype; var i = function (e) { Object.defineProperty(r, e, { get: function () { return this._anchorElement[e]; }, set: function (t) { this._anchorElement[e] = t; }, enumerable: true }); };["hash", "host", "hostname", "port", "protocol", "search"].forEach(function (e) { i(e); }); Object.defineProperties(r, { toString: { get: function () { var e = this; return function () { return e.href; }; } }, href: { get: function () { return this._anchorElement.href.replace(/\?$/, ""); }, set: function (e) { this._anchorElement.href = e; }, enumerable: true }, pathname: { get: function () { return this._anchorElement.pathname.replace(/(^\/?)/, "/"); }, set: function (e) { this._anchorElement.pathname = e; }, enumerable: true }, origin: { get: function () { var e = { "http:": 80, "https:": 443, "ftp:": 21 }[this._anchorElement.protocol]; var t = this._anchorElement.port != e && this._anchorElement.port !== ""; return this._anchorElement.protocol + "//" + this._anchorElement.hostname + (t ? ":" + this._anchorElement.port : ""); }, enumerable: true }, password: { get: function () { return ""; }, set: function (e) { }, enumerable: true }, username: { get: function () { return ""; }, set: function (e) { }, enumerable: true }, searchParams: { get: function () { var e = new URLSearchParams(this.search); var t = this;["append", "delete", "set"].forEach(function (n) { var r = e[n]; e[n] = function () { r.apply(e, arguments); t.search = e.toString(); }; }); return e; }, enumerable: true } }); n.createObjectURL = function (e) { return t.createObjectURL.apply(t, arguments); }; n.revokeObjectURL = function (e) { return t.revokeObjectURL.apply(t, arguments); }; e.URL = n; }; if (!t()) { n(); } if (e.location !== void 0 && !("origin" in e.location)) { var r = function () { return e.location.protocol + "//" + e.location.hostname + (e.location.port ? ":" + e.location.port : ""); }; try { Object.defineProperty(e.location, "origin", { get: r, enumerable: true }); } catch (t) { setInterval(function () { e.location.origin = r(); }, 100); } } })(typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : this);
27 /*
28 * End File:
29 * framework/extensions/polyfills.js
30 */
31
32 /*
33 * Start File:
34 * framework/extensions/extentions.js
35 */
36 /**
37 * Extending exising functionality
38 */
39
40 Array.prototype.remove = function (element)
41 {
42 var index = this.indexOf(element);
43
44 if (index > -1)
45 {
46 this.splice(index, 1);
47 }
48 else
49 {
50 console.error("Element not part of array!", this, element);
51 }
52 };
53
54 Array.prototype.removeAt = function (index)
55 {
56 if (index > -1)
57 {
58 this.splice(index, 1);
59 }
60 };
61
62 Array.prototype.contains = function (element)
63 {
64 var index = this.indexOf(element);
65
66 return index > -1;
67 };
68
69 Math.clamp = function (number, min, max)
70 {
71 return Math.min(max, Math.max(min, number));
72 };
73
74 Math.randomRange = function (min, max)
75 {
76 return min + (Math.random() * (max - min));
77 };
78
79 Math.lerp = function (a, b, t)
80 {
81 return a + (b - a) * t;
82 };
83
84 Array.prototype.random = function ()
85 {
86 return this[Math.floor((Math.random() * this.length))];
87 };
88 /*
89 * End File:
90 * framework/extensions/extentions.js
91 */
92
93 /*
94 * Start File:
95 * framework/extensions/thirdparty.js
96 */
97 //TWEENJS
98 var TWEEN = TWEEN || function () { var n = []; return { getAll: function () { return n; }, removeAll: function () { n = []; }, add: function (t) { n.push(t); }, remove: function (t) { var r = n.indexOf(t); -1 !== r && n.splice(r, 1); }, update: function (t, r) { if (0 === n.length) {return !1;} var i = 0; for (t = void 0 !== t ? t : TWEEN.now(); i < n.length;){n[i].update(t) || r ? i++ : n.splice(i, 1);} return !0; } }; }(); !function () { void 0 === this.window && void 0 !== this.process ? TWEEN.now = function () { var n = process.hrtime(); return 1e3 * n[0] + n[1] / 1e3; } : void 0 !== this.window && void 0 !== window.performance && void 0 !== window.performance.now ? TWEEN.now = window.performance.now.bind(window.performance) : void 0 !== Date.now ? TWEEN.now = Date.now : TWEEN.now = function () { return (new Date).getTime(); }; }(), TWEEN.Tween = function (n) { var t = n, r = {}, i = {}, o = {}, u = 1e3, e = 0, a = !1, f = !1, c = !1, s = 0, h = null, l = TWEEN.Easing.Linear.None, E = TWEEN.Interpolation.Linear, p = [], d = null, v = !1, w = null, I = null, M = null, C = null, S = null, ST = null; for (var T in n) {r[T] = parseFloat(n[T], 10);} this.to = function (n, t) { return void 0 !== t && (u = t), i = n, this; }, this.start = function (n) { TWEEN.add(this), f = !0, v = !1, h = void 0 !== n ? n : TWEEN.now(), h += s; for (var u in i) { if (i[u] instanceof Array) { if (0 === i[u].length) {continue;} i[u] = [t[u]].concat(i[u]); } void 0 !== r[u] && (r[u] = t[u], r[u] instanceof Array == !1 && (r[u] *= 1), o[u] = r[u] || 0); } return this; }, this.stop = function () { return f ? (TWEEN.remove(this), f = !1, null !== M && M.call(S), this.stopChainedTweens(), this) : this; }, this.stopChainedTweens = function () { for (var n = 0, t = p.length; t > n; n++){p[n].stop();} }, this.delay = function (n) { return s = n, this; }, this.repeat = function (n) { return e = n, this; }, this.yoyo = function (n) { return a = n, this; }, this.easing = function (n) { return l = n, this; }, this.interpolation = function (n) { return E = n, this; }, this.chain = function () { return p = arguments, this; }, this.onStart = function (n, c) { return d = n, ST = c, this; }, this.onUpdate = function (n) { return w = n, this; }, this.onComplete = function (n, c) { return I = n, C = c, this; }, this.onStop = function (n, c) { return M = n, S = c, this; }, this.update = function (n) { var f, M, T; if (h > n) {return !0;} v === !1 && (null !== d && d.call(ST), v = !0), M = (n - h) / u, M = M > 1 ? 1 : M, T = l(M); for (f in i) {if (void 0 !== r[f]) { var N = r[f] || 0, W = i[f]; W instanceof Array ? t[f] = E(W, T) : ("string" == typeof W && (W = "+" === W.charAt(0) || "-" === W.charAt(0) ? N + parseFloat(W, 10) : parseFloat(W, 10)), "number" == typeof W && (t[f] = N + (W - N) * T)); }} if (null !== w && w.call(t, T), 1 === M) { if (e > 0) { isFinite(e) && e--; for (f in o) { if ("string" == typeof i[f] && (o[f] = o[f] + parseFloat(i[f], 10)), a) { var O = o[f]; o[f] = i[f], i[f] = O; } r[f] = o[f]; } return a && (c = !c), h = n + s, !0; } null !== I && I.call(C); for (var m = 0, g = p.length; g > m; m++){p[m].start(h + u);} return !1; } return !0; }; }, TWEEN.Easing = { Linear: { None: function (n) { return n; } }, Quadratic: { In: function (n) { return n * n; }, Out: function (n) { return n * (2 - n); }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n : -.5 * (--n * (n - 2) - 1); } }, Cubic: { In: function (n) { return n * n * n; }, Out: function (n) { return --n * n * n + 1; }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n * n : .5 * ((n -= 2) * n * n + 2); } }, Quartic: { In: function (n) { return n * n * n * n; }, Out: function (n) { return 1 - --n * n * n * n; }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n * n * n : -.5 * ((n -= 2) * n * n * n - 2); } }, Quintic: { In: function (n) { return n * n * n * n * n; }, Out: function (n) { return --n * n * n * n * n + 1; }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n * n * n * n : .5 * ((n -= 2) * n * n * n * n + 2); } }, Sinusoidal: { In: function (n) { return 1 - Math.cos(n * Math.PI / 2); }, Out: function (n) { return Math.sin(n * Math.PI / 2); }, InOut: function (n) { return .5 * (1 - Math.cos(Math.PI * n)); } }, Exponential: { In: function (n) { return 0 === n ? 0 : Math.pow(1024, n - 1); }, Out: function (n) { return 1 === n ? 1 : 1 - Math.pow(2, -10 * n); }, InOut: function (n) { return 0 === n ? 0 : 1 === n ? 1 : (n *= 2) < 1 ? .5 * Math.pow(1024, n - 1) : .5 * (-Math.pow(2, -10 * (n - 1)) + 2); } }, Circular: { In: function (n) { return 1 - Math.sqrt(1 - n * n); }, Out: function (n) { return Math.sqrt(1 - --n * n); }, InOut: function (n) { return (n *= 2) < 1 ? -.5 * (Math.sqrt(1 - n * n) - 1) : .5 * (Math.sqrt(1 - (n -= 2) * n) + 1); } }, Elastic: { In: function (n) { return 0 === n ? 0 : 1 === n ? 1 : -Math.pow(2, 10 * (n - 1)) * Math.sin(5 * (n - 1.1) * Math.PI); }, Out: function (n) { return 0 === n ? 0 : 1 === n ? 1 : Math.pow(2, -10 * n) * Math.sin(5 * (n - .1) * Math.PI) + 1; }, InOut: function (n) { return 0 === n ? 0 : 1 === n ? 1 : (n *= 2, 1 > n ? -.5 * Math.pow(2, 10 * (n - 1)) * Math.sin(5 * (n - 1.1) * Math.PI) : .5 * Math.pow(2, -10 * (n - 1)) * Math.sin(5 * (n - 1.1) * Math.PI) + 1); } }, Back: { In: function (n) { var t = 1.70158; return n * n * ((t + 1) * n - t); }, Out: function (n) { var t = 1.70158; return --n * n * ((t + 1) * n + t) + 1; }, InOut: function (n) { var t = 2.5949095; return (n *= 2) < 1 ? .5 * (n * n * ((t + 1) * n - t)) : .5 * ((n -= 2) * n * ((t + 1) * n + t) + 2); } }, Bounce: { In: function (n) { return 1 - TWEEN.Easing.Bounce.Out(1 - n); }, Out: function (n) { return 1 / 2.75 > n ? 7.5625 * n * n : 2 / 2.75 > n ? 7.5625 * (n -= 1.5 / 2.75) * n + .75 : 2.5 / 2.75 > n ? 7.5625 * (n -= 2.25 / 2.75) * n + .9375 : 7.5625 * (n -= 2.625 / 2.75) * n + .984375; }, InOut: function (n) { return .5 > n ? .5 * TWEEN.Easing.Bounce.In(2 * n) : .5 * TWEEN.Easing.Bounce.Out(2 * n - 1) + .5; } } }, TWEEN.Interpolation = { Linear: function (n, t) { var r = n.length - 1, i = r * t, o = Math.floor(i), u = TWEEN.Interpolation.Utils.Linear; return 0 > t ? u(n[0], n[1], i) : t > 1 ? u(n[r], n[r - 1], r - i) : u(n[o], n[o + 1 > r ? r : o + 1], i - o); }, Bezier: function (n, t) { for (var r = 0, i = n.length - 1, o = Math.pow, u = TWEEN.Interpolation.Utils.Bernstein, e = 0; i >= e; e++){r += o(1 - t, i - e) * o(t, e) * n[e] * u(i, e);} return r; }, CatmullRom: function (n, t) { var r = n.length - 1, i = r * t, o = Math.floor(i), u = TWEEN.Interpolation.Utils.CatmullRom; return n[0] === n[r] ? (0 > t && (o = Math.floor(i = r * (1 + t))), u(n[(o - 1 + r) % r], n[o], n[(o + 1) % r], n[(o + 2) % r], i - o)) : 0 > t ? n[0] - (u(n[0], n[0], n[1], n[1], -i) - n[0]) : t > 1 ? n[r] - (u(n[r], n[r], n[r - 1], n[r - 1], i - r) - n[r]) : u(n[o ? o - 1 : 0], n[o], n[o + 1 > r ? r : o + 1], n[o + 2 > r ? r : o + 2], i - o); }, Utils: { Linear: function (n, t, r) { return (t - n) * r + n; }, Bernstein: function (n, t) { var r = TWEEN.Interpolation.Utils.Factorial; return r(n) / r(t) / r(n - t); }, Factorial: function () { var n = [1]; return function (t) { var r = 1; if (n[t]) {return n[t];} for (var i = t; i > 1; i--){r *= i;} return n[t] = r, r; }; }(), CatmullRom: function (n, t, r, i, o) { var u = .5 * (r - n), e = .5 * (i - t), a = o * o, f = o * a; return (2 * t - 2 * r + u + e) * f + (-3 * t + 3 * r - 2 * u - e) * a + u * o + t; } } }, function (n) { "function" == typeof define && define.amd ? define([], function () { return TWEEN; }) : "undefined" != typeof module && "object" == typeof exports ? module.exports = TWEEN : void 0 !== n && (n.TWEEN = TWEEN); }(this);
99 /*
100 * End File:
101 * framework/extensions/thirdparty.js
102 */
103
104 /*
105 * Start File:
106 * framework/util/vector.js
107 */
108 class vector
109 {
110 x = 0;
111 y = 0;
112
113 constructor (x, y)
114 {
115 this.x = x;
116
117 this.y = y;
118 }
119
120 get length ()
121 {
122 return Math.sqrt((this.x * this.x) + (this.y * this.y));
123 }
124
125 get lengthSq ()
126 {
127 return (this.x * this.x) + (this.y * this.y);
128 }
129
130 getLength ()
131 {
132 return Math.sqrt((this.x * this.x) + (this.y * this.y));
133 }
134
135
136 toAngle ()
137 {
138 let angle = (Math.atan2(this.y, this.x) * 180 / Math.PI) + 90;
139 if (angle < 0)
140 {angle += 360;}
141 return angle;
142 }
143
144 static fromAngle (angle)
145 {
146 angle = 360 - ((angle + 180) % 360);
147 angle = (angle / 180) * Math.PI;
148 return new vector(Math.sin(angle), Math.cos(angle));
149 }
150
151 normalize ()
152 {
153 var newVector = this.getCopy();
154 var length = newVector.length;
155
156 if (length != 0)
157 {
158 newVector.x /= length;
159 newVector.y /= length;
160 }
161
162 return newVector;
163 }
164
165
166 lerpTo (otherVector, t)
167 {
168 var delta = otherVector.subtract(this);
169
170 return this.add(delta.stretch(t));
171 }
172
173 lerpToInto (otherVector, t, out)
174 {
175 out.x = this.x + (otherVector.x - this.x) * t;
176 out.y = this.y + (otherVector.y - this.y) * t;
177 return out;
178 }
179
180
181 distanceToSq (otherVector)
182 {
183 var dX = this.x - otherVector.x;
184 var dY = this.y - otherVector.y;
185 return (dX * dX) + (dY * dY);
186 }
187
188 distanceTo (otherVector)
189 {
190 return Math.sqrt(this.distanceToSq(otherVector));
191 }
192
193
194 add (otherVector)
195 {
196 var newVector = this.getCopy();
197
198 newVector.x += otherVector.x;
199 newVector.y += otherVector.y;
200
201 return newVector;
202 }
203
204
205 subtract (otherVector)
206 {
207 var newVector = this.getCopy();
208
209 newVector.x -= otherVector.x;
210 newVector.y -= otherVector.y;
211
212 return newVector;
213 }
214
215
216 multiply (otherVector)
217 {
218 var newVector = this.getCopy();
219
220 newVector.x *= otherVector.x;
221 newVector.y *= otherVector.y;
222
223 return newVector;
224 }
225
226
227 divide (otherVector)
228 {
229 var newVector = this.getCopy();
230
231 newVector.x /= otherVector.x;
232 newVector.y /= otherVector.y;
233
234 return newVector;
235 }
236
237
238 stretch (length)
239 {
240 var newVector = this.getCopy();
241
242 newVector.x *= length;
243 newVector.y *= length;
244
245 return newVector;
246 }
247
248 rotate (degrees)
249 {
250 var ca = Math.cos(degrees * (Math.PI / 180));
251 var sa = Math.sin(degrees * (Math.PI / 180));
252 return new vector(ca * this.x - sa * this.y, sa * this.x + ca * this.y);
253 }
254
255 deltaAngle (otherVector)
256 {
257 var a = this.toAngle() * (Math.PI / 180);
258 var b = otherVector.toAngle() * (Math.PI / 180);
259
260 return Math.atan2(Math.sin(a - b), Math.cos(a - b)) * (180 / Math.PI);
261 }
262
263 cross (otherVector)
264 {
265 return this.x * otherVector.y - this.y * otherVector.x;
266 }
267
268
269 getCopy ()
270 {
271 return new vector(this.x, this.y);
272 }
273 };
274 /*
275 * End File:
276 * framework/util/vector.js
277 */
278
279 /*
280 * Start File:
281 * framework/util/ease.js
282 */
283 //ease functions
284
285 var ease = {
286
287 //
288 // Basic ease functions
289 //
290
291 easeConstant: function (time, begin, change, duration)
292 {
293 "use strict";
294 return begin;
295 },
296
297 easeLinear: function (time, begin, change, duration)
298 {
299 "use strict";
300 var val = time / duration;
301 return begin + change * val;
302 },
303
304 easeInPower: function (time, begin, change, duration, power)
305 {
306 "use strict";
307 var val;
308 if (power === undefined) { power = 3; }
309 val = Math.pow(time / duration, power);
310 return begin + change * val;
311 },
312
313 easeOutPower: function (time, begin, change, duration, power)
314 {
315 "use strict";
316 var val = tbEase.easeInPower(duration - time, 1, -1, duration, power);
317 return begin + change * val;
318 },
319
320 easeInOutPower: function (time, begin, change, duration, power)
321 {
322 "use strict";
323 var val;
324 if (time < duration / 2)
325 {
326 val = tbEase.easeInPower(time, 0, 0.5, duration / 2, power);
327 } else
328 {
329 val = tbEase.easeInPower(duration - time, 1, -0.5, duration / 2, power);
330 }
331 return begin + change * val;
332 },
333
334 easeOutInPower: function (time, begin, change, duration, power)
335 {
336 "use strict";
337 var val;
338 if (time < duration / 2)
339 {
340 val = tbEase.easeInPower(duration / 2 - time, 0.5, -0.5, duration / 2, power);
341 } else
342 {
343 val = tbEase.easeInPower(time - duration / 2, 0.5, 0.5, duration / 2, power);
344 }
345 return begin + change * val;
346 },
347
348 easeInQuadratic: function (time, begin, change, duration)
349 {
350 "use strict";
351 return tbEase.easeInPower(time, begin, change, duration, 2);
352 },
353
354 easeOutQuadratic: function (time, begin, change, duration)
355 {
356 "use strict";
357 return tbEase.easeOutPower(time, begin, change, duration, 2);
358 },
359
360 easeInOutQuadratic: function (time, begin, change, duration)
361 {
362 "use strict";
363 return tbEase.easeInOutPower(time, begin, change, duration, 2);
364 },
365
366 easeOutInQuadratic: function (time, begin, change, duration)
367 {
368 "use strict";
369 return tbEase.easeOutInPower(time, begin, change, duration, 2);
370 },
371
372 easeInCubic: function (time, begin, change, duration)
373 {
374 "use strict";
375 return tbEase.easeInPower(time, begin, change, duration, 3);
376 },
377
378 easeOutCubic: function (time, begin, change, duration)
379 {
380 "use strict";
381 return tbEase.easeOutPower(time, begin, change, duration, 3);
382 },
383
384 easeInOutCubic: function (time, begin, change, duration)
385 {
386 "use strict";
387 return tbEase.easeInOutPower(time, begin, change, duration, 3);
388 },
389
390 easeOutInCubic: function (time, begin, change, duration)
391 {
392 "use strict";
393 return tbEase.easeOutInPower(time, begin, change, duration, 3);
394 },
395
396 easeInQuartic: function (time, begin, change, duration)
397 {
398 "use strict";
399 return tbEase.easeInPower(time, begin, change, duration, 4);
400 },
401
402 easeOutQuartic: function (time, begin, change, duration)
403 {
404 "use strict";
405 return tbEase.easeOutPower(time, begin, change, duration, 4);
406 },
407
408 easeInOutQuartic: function (time, begin, change, duration)
409 {
410 "use strict";
411 return tbEase.easeInOutPower(time, begin, change, duration, 4);
412 },
413
414 easeOutInQuartic: function (time, begin, change, duration)
415 {
416 "use strict";
417 return tbEase.easeOutInPower(time, begin, change, duration, 4);
418 },
419
420 easeInQuintic: function (time, begin, change, duration)
421 {
422 "use strict";
423 return tbEase.easeInPower(time, begin, change, duration, 5);
424 },
425
426 easeOutQuintic: function (time, begin, change, duration)
427 {
428 "use strict";
429 return tbEase.easeOutPower(time, begin, change, duration, 5);
430 },
431
432 easeInOutQuintic: function (time, begin, change, duration)
433 {
434 "use strict";
435 return tbEase.easeInOutPower(time, begin, change, duration, 5);
436 },
437
438 easeOutInQuintic: function (time, begin, change, duration)
439 {
440 "use strict";
441 return tbEase.easeOutInPower(time, begin, change, duration, 5);
442 },
443
444 easeInExponential: function (time, begin, change, duration, power)
445 {
446 "use strict";
447 var val, base;
448 if (power === undefined) { power = 8; }
449 base = Math.pow(2, -power); // The exponential function will not cover the whole range from 0-1 so we must correct it
450 val = (Math.pow(2, power * time / duration - power) - base) / (1 - base);
451 return begin + change * val;
452 },
453
454 easeOutExponential: function (time, begin, change, duration, power)
455 {
456 "use strict";
457 var val = tbEase.easeInExponential(duration - time, 1, -1, duration, power);
458 return begin + change * val;
459 },
460
461 easeInOutExponential: function (time, begin, change, duration, power)
462 {
463 "use strict";
464 var val;
465 if (time < duration / 2)
466 {
467 val = tbEase.easeInExponential(time, 0, 0.5, duration / 2, power);
468 } else
469 {
470 val = tbEase.easeInExponential(duration - time, 1, -0.5, duration / 2, power);
471 }
472 return begin + change * val;
473 },
474
475 easeOutInExponential: function (time, begin, change, duration, power)
476 {
477 "use strict";
478 var val;
479 if (time < duration / 2)
480 {
481 val = tbEase.easeInExponential(duration / 2 - time, 0.5, -0.5, duration / 2, power);
482 } else
483 {
484 val = tbEase.easeInExponential(time - duration / 2, 0.5, 0.5, duration / 2, power);
485 }
486 return begin + change * val;
487 },
488
489 easeInSine: function (time, begin, change, duration)
490 {
491 "use strict";
492 var val = 1 - Math.cos(time / duration * Math.PI / 2);
493 return begin + change * val;
494 },
495
496 easeOutSine: function (time, begin, change, duration)
497 {
498 "use strict";
499 var val = tbEase.easeInSine(duration - time, 1, -1, duration);
500 return begin + change * val;
501 },
502
503 easeInOutSine: function (time, begin, change, duration)
504 {
505 "use strict";
506 var val;
507 if (time < duration / 2)
508 {
509 val = tbEase.easeInSine(time, 0, 0.5, duration / 2);
510 } else
511 {
512 val = tbEase.easeInSine(duration - time, 1, -0.5, duration / 2);
513 }
514 return begin + change * val;
515 },
516
517 easeOutInSine: function (time, begin, change, duration)
518 {
519 "use strict";
520 var val;
521 if (time < duration / 2)
522 {
523 val = tbEase.easeInSine(duration / 2 - time, 0.5, -0.5, duration / 2);
524 } else
525 {
526 val = tbEase.easeInSine(time - duration / 2, 0.5, 0.5, duration / 2);
527 }
528 return begin + change * val;
529 },
530
531 easeInCircular: function (time, begin, change, duration)
532 {
533 "use strict";
534 var val = 1 - Math.sqrt(1 - Math.pow(time / duration, 2));
535 return begin + change * val;
536 },
537
538 easeOutCircular: function (time, begin, change, duration)
539 {
540 "use strict";
541 var val = tbEase.easeInCircular(duration - time, 1, -1, duration);
542 return begin + change * val;
543 },
544
545 easeInOutCircular: function (time, begin, change, duration)
546 {
547 "use strict";
548 var val;
549 if (time < duration / 2)
550 {
551 val = tbEase.easeInCircular(time, 0, 0.5, duration / 2);
552 } else
553 {
554 val = tbEase.easeInCircular(duration - time, 1, -0.5, duration / 2);
555 }
556 return begin + change * val;
557 },
558
559 easeOutInCircular: function (time, begin, change, duration)
560 {
561 "use strict";
562 var val;
563 if (time < duration / 2)
564 {
565 val = tbEase.easeInCircular(duration / 2 - time, 0.5, -0.5, duration / 2);
566 } else
567 {
568 val = tbEase.easeInCircular(time - duration / 2, 0.5, 0.5, duration / 2);
569 }
570 return begin + change * val;
571 },
572
573 easeInElastic: function (time, begin, change, duration, oscillations, stiffness)
574 {
575 "use strict";
576 var val;
577 if (oscillations === undefined) { oscillations = 3; }
578 if (stiffness === undefined) { stiffness = 8; }
579 val = Math.sin((1 - time / duration) * 2 * Math.PI * oscillations + Math.PI / 2); // Create the correct sign
580 val *= tbEase.easeInExponential(time, 0, 1, duration, stiffness); // Multiply with an exponential ease in
581 return begin + change * val;
582 },
583
584 easeOutElastic: function (time, begin, change, duration, oscillations, stiffness)
585 {
586 "use strict";
587 var val = tbEase.easeInElastic(duration - time, 1, -1, duration, oscillations, stiffness);
588 return begin + change * val;
589 },
590
591 easeInOutElastic: function (time, begin, change, duration, oscillations, stiffness)
592 {
593 "use strict";
594 var val;
595 if (time < duration / 2)
596 {
597 val = tbEase.easeInElastic(time, 0, 0.5, duration / 2, oscillations, stiffness);
598 } else
599 {
600 val = tbEase.easeInElastic(duration - time, 1, -0.5, duration / 2, oscillations, stiffness);
601 }
602 return begin + change * val;
603 },
604
605 easeOutInElastic: function (time, begin, change, duration, oscillations, stiffness)
606 {
607 "use strict";
608 var val;
609 if (time < duration / 2)
610 {
611 val = tbEase.easeInElastic(duration / 2 - time, 0.5, -0.5, duration / 2, oscillations, stiffness);
612 } else
613 {
614 val = tbEase.easeInElastic(time - duration / 2, 0.5, 0.5, duration / 2, oscillations, stiffness);
615 }
616 return begin + change * val;
617 },
618
619 easeInOvershoot: function (time, begin, change, duration, overshoot)
620 {
621 "use strict";
622 var val;
623 if (overshoot === undefined) { overshoot = 1.70158; }
624 val = (1 + overshoot) * Math.pow(time / duration, 3) - overshoot * Math.pow(time / duration, 2);
625 return begin + change * val;
626
627 },
628
629 easeOutOvershoot: function (time, begin, change, duration, overshoot)
630 {
631 "use strict";
632 var val = tbEase.easeInOvershoot(duration - time, 1, -1, duration, overshoot);
633 return begin + change * val;
634 },
635
636 easeInOutOvershoot: function (time, begin, change, duration, overshoot)
637 {
638 "use strict";
639 var val;
640 if (time < duration / 2)
641 {
642 val = tbEase.easeInOvershoot(time, 0, 0.5, duration / 2, overshoot);
643 } else
644 {
645 val = tbEase.easeInOvershoot(duration - time, 1, -0.5, duration / 2, overshoot);
646 }
647 return begin + change * val;
648 },
649
650 easeOutInOvershoot: function (time, begin, change, duration, overshoot)
651 {
652 "use strict";
653 var val;
654 if (time < duration / 2)
655 {
656 val = tbEase.easeInOvershoot(duration / 2 - time, 0.5, -0.5, duration / 2, overshoot);
657 } else
658 {
659 val = tbEase.easeInOvershoot(time - duration / 2, 0.5, 0.5, duration / 2, overshoot);
660 }
661 return begin + change * val;
662 },
663
664 easeInBounce: function (time, begin, change, duration, number, factor)
665 {
666 "use strict";
667 var bounces, i, w, width, height, val;
668 // Correct the arguments
669 if (number === undefined) { number = 4; }
670 if (factor === undefined) { factor = 2; } else { factor = Math.sqrt(factor); }
671 // Create the list of bounces
672 bounces = [1];
673 width = 1;
674 for (i = 1; i < number; i += 1)
675 {
676 bounces.push(bounces[i - 1] * factor);
677 width += bounces[i];
678 }
679 // Compute total size
680 width -= bounces[number - 1] / 2; // We don't use the last half bounce
681 height = Math.pow(bounces[number - 1], 2);
682 time = time / duration * width;
683 // Find the correct bounce
684 w = 0;
685 for (i = 0; i < number; i += 1)
686 {
687 if (time > bounces[i]) { time -= bounces[i]; } else { w = bounces[i]; break; }
688 }
689 // Now compute the value
690 val = -4 * Math.pow(time - w / 2, 2) + w * w;
691 return begin + change * val / height;
692 },
693
694 easeOutBounce: function (time, begin, change, duration, number, factor)
695 {
696 "use strict";
697 var val = tbEase.easeInBounce(duration - time, 1, -1, duration, number, factor);
698 return begin + change * val;
699 },
700
701 easeInOutBounce: function (time, begin, change, duration, number, factor)
702 {
703 "use strict";
704 var val;
705 if (time < duration / 2)
706 {
707 val = tbEase.easeInBounce(time, 0, 0.5, duration / 2, number, factor);
708 } else
709 {
710 val = tbEase.easeInBounce(duration - time, 1, -0.5, duration / 2, number, factor);
711 }
712 return begin + change * val;
713 },
714
715 easeOutInBounce: function (time, begin, change, duration, number, factor)
716 {
717 "use strict";
718 var val;
719 if (time < duration / 2)
720 {
721 val = tbEase.easeInBounce(duration / 2 - time, 0.5, -0.5, duration / 2, number, factor);
722 } else
723 {
724 val = tbEase.easeInBounce(time - duration / 2, 0.5, 0.5, duration / 2, number, factor);
725 }
726 return begin + change * val;
727 }
728 };
729
730 // Methods above call tbEase.*; alias so composed easings resolve at runtime.
731 var tbEase = ease;
732 /*
733 * End File:
734 * framework/util/ease.js
735 */
736
737 /*
738 * Start File:
739 * framework/util/timingUtil.js
740 */
741 /**
742 /* Timing utility
743 /*/
744
745 var timingUtil =
746 {
747 delayUntilCondition: function (conditionFunction, conditionContext, callback, context, interval)
748 {
749 interval = interval || 1;
750
751 if (conditionFunction.call(conditionContext))
752 {
753 callback.call(context);
754 }
755 else
756 {
757 setTimeout(function ()
758 {
759 timingUtil.delayUntilCondition(conditionFunction, conditionContext, callback, context, interval);
760 }, interval);
761 }
762 },
763
764 delayUntilNextFrame: function (callback, context)
765 {
766 requestAnimationFrame(function ()
767 {
768 callback.call(context);
769 });
770 },
771
772 delay: function (milliseconds, callback, context)
773 {
774 return setTimeout(function ()
775 {
776 callback.call(context);
777 }, milliseconds);
778 },
779
780 stop: function (timer)
781 {
782 clearTimeout(timer);
783 },
784
785 repeat: function (milliseconds, callback, context)
786 {
787 return setInterval(function ()
788 {
789 callback.call(context);
790 }, milliseconds);
791 }
792 };
793
794 // Historical alias — some call sites used TimingUtil casing.
795 var TimingUtil = timingUtil;
796
797 /*
798 * End File:
799 * framework/util/timingUtil.js
800 */
801
802 /*
803 * Start File:
804 * framework/util/signal.js
805 */
806 // Basic event listeners, modeled after Phaser Signals
807
808 class Signal
809 {
810 listeners = [];
811
812 dispatch ()
813 {
814 for (var i = 0; i < this.listeners.length; i++)
815 {
816 this.listeners[i].callback.apply(this.listeners[i].context, arguments);
817 }
818
819 for (var i = this.listeners.length - 1; i >= 0; i--)
820 {
821 if (this.listeners[i].once)
822 {
823 this.listeners.splice(i, 1);
824 }
825 }
826 }
827
828 add (callback, context, once)
829 {
830 if (!this.contains(callback, context))
831 {
832 this.listeners.push({ callback: callback, context: context, once: once });
833 }
834 }
835
836 addOnce (callback, context)
837 {
838 this.add(callback, context, true);
839 }
840
841 contains (callback, context)
842 {
843 for (var i = this.listeners.length - 1; i >= 0; i--)
844 {
845 if (this.listeners[i].callback === callback && this.listeners[i].context === context)
846 {
847 return true;
848 }
849 }
850
851 return false;
852 }
853
854 remove (callback, context)
855 {
856 for (var i = this.listeners.length - 1; i >= 0; i--)
857 {
858 if (this.listeners[i].callback === callback && this.listeners[i].context === context)
859 {
860 this.listeners.splice(i, 1);
861 break;
862 }
863 }
864 }
865
866 removeAll ()
867 {
868 this.listeners = [];
869 }
870 }
871
872 /*
873 * End File:
874 * framework/util/signal.js
875 */
876
877 /*
878 * Start File:
879 * framework/util/cookie.js
880 */
881 var CookieManager =
882 {
883 setCookie: function (cname, cvalue, exdays = 365)
884 {
885 const d = new Date();
886
887 d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));
888 const expires = "expires=" + d.toUTCString();
889 const name = encodeURIComponent(cname);
890 const value = encodeURIComponent(cvalue);
891
892 document.cookie = name + "=" + value + ";" + expires + ";path=/;SameSite=Lax";
893 },
894
895 getCookie: function (cname)
896 {
897 const name = encodeURIComponent(cname) + "=";
898 const ca = document.cookie.split(';');
899
900 for (let i = 0; i < ca.length; i++)
901 {
902 let c = ca[i];
903
904 while (c.charAt(0) == ' ')
905 {
906 c = c.substring(1);
907 }
908
909 if (c.indexOf(name) == 0)
910 {
911 return decodeURIComponent(c.substring(name.length, c.length));
912 }
913 }
914
915 return "";
916 },
917
918 deleteCookie: function (cname)
919 {
920 document.cookie = encodeURIComponent(cname) + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/;SameSite=Lax";
921 }
922 };
923
924 /*
925 * End File:
926 * framework/util/cookie.js
927 */
928
929 /*
930 * Start File:
931 * framework/util/urlParams.js
932 */
933 var UrlParams =
934 {
935 get: function (key)
936 {
937 var url_string = window.location.href;
938 var url = new URL(url_string);
939 var c = url.searchParams.get(key);
940
941 return c;
942 },
943
944 set: function (key, value)
945 {
946 var url_string = window.location.href;
947 var url = new URL(url_string);
948 url.searchParams.set(key, value);
949
950 // replaceState avoids flooding history when params change often.
951 window.history.replaceState(null, "", url);
952 }
953 };
954
955 /*
956 * End File:
957 * framework/util/urlParams.js
958 */
959
960 /*
961 * Start File:
962 * framework/util/input.js
963 */
964
965
966 var GameInput =
967 {
968 keys: {},
969 g_keyStatus: [],
970 g_pKeyStatus: [],
971
972 g_pressKeyStatus: [],
973 g_ppressKeyStatus: [],
974
975 g_pressBlacklist: [],
976
977 g_mouseDown: false,
978 g_mouseDownThisFrame: false,
979
980 g_altMouseDown: false,
981 g_altMouseDownThisFrame: false,
982
983 g_middleMouseDown: false,
984 g_middleMouseDownThisFrame: false,
985
986 trueMousePosition: null,
987 mousePosition: null,
988
989 MouseButtons: {
990 Left: 0,
991 Middle: 1,
992 Right: 2
993 },
994
995 g_init: function ()
996 {
997 GameInput.trueMousePosition = new vector(0, 0);
998 GameInput.mousePosition = new vector(0, 0);
999
1000 document.onkeydown = GameInput.g_setKeyStatus;
1001 document.onkeyup = GameInput.g_setKeyStatus;
1002
1003 document.oncontextmenu = function () { return false; };
1004
1005 document.onmousedown = function (e)
1006 {
1007 switch (e.button)
1008 {
1009 case GameInput.MouseButtons.Left: GameInput.g_mouseDownThisFrame = true; break;
1010 case GameInput.MouseButtons.Middle: GameInput.g_middleMouseDownThisFrame = true; break;
1011 case GameInput.MouseButtons.Right: GameInput.g_altMouseDownThisFrame = true; break;
1012 }
1013 };
1014
1015 document.onmouseup = function (e)
1016 {
1017 switch (e.button)
1018 {
1019 case GameInput.MouseButtons.Left:
1020 GameInput.g_mouseDownThisFrame = false;
1021 GameInput.g_mouseDown = false;
1022 break;
1023 case GameInput.MouseButtons.Middle:
1024 GameInput.g_middleMouseDownThisFrame = false;
1025 GameInput.g_middleMouseDown = false;
1026 break;
1027 case GameInput.MouseButtons.Right:
1028 GameInput.g_altMouseDownThisFrame = false;
1029 GameInput.g_altMouseDown = false;
1030 break;
1031 }
1032 };
1033
1034 document.onmousemove = function (e)
1035 {
1036 if (!GameInput.trueMousePosition)
1037 { GameInput.trueMousePosition = new vector(); }
1038
1039 GameInput.trueMousePosition.x = e.x;
1040 GameInput.trueMousePosition.y = e.y;
1041 };
1042
1043 var el = document.getElementsByTagName("body")[0];
1044 el.addEventListener("touchstart", function () { GameInput.g_mouseDownThisFrame = true; }, false);
1045 el.addEventListener("touchend", function () { GameInput.g_mouseDownThisFrame = false; GameInput.g_mouseDown = false; }, false);
1046 el.addEventListener("touchcancel", function () { GameInput.g_mouseDownThisFrame = false; GameInput.g_mouseDown = false; }, false);
1047 el.addEventListener("touchmove", function () { return false; }, false);
1048 },
1049
1050 g_setKeyStatus: function (e)
1051 {
1052 GameInput.keys[e.key] = e.which;
1053 GameInput.g_keyStatus[e.which] = (e.type == "keydown");
1054
1055 if (!GameInput.g_pressBlacklist[e.which])
1056 { GameInput.g_pressKeyStatus[e.which] = (e.type == "keydown"); }
1057
1058 GameInput.g_pressBlacklist[e.which] = (e.type == "keydown"); //only allow single presses if key has been released once
1059 },
1060
1061 g_updateKeys: function ()
1062 {
1063 GameInput.mousePosition = GameInput.trueMousePosition;
1064
1065 // Snapshot previous frame — a bare assignment aliases the live array.
1066 GameInput.g_pKeyStatus = GameInput.g_keyStatus.slice();
1067 GameInput.g_ppressKeyStatus = GameInput.g_pressKeyStatus;
1068 GameInput.g_pressKeyStatus = [];
1069
1070 if (GameInput.g_mouseDown && GameInput.g_mouseDownThisFrame)
1071 {
1072 GameInput.g_mouseDownThisFrame = false;
1073 }
1074
1075 if (GameInput.g_mouseDownThisFrame && !GameInput.g_mouseDown)
1076 {
1077 GameInput.g_mouseDown = true;
1078 }
1079
1080 if (GameInput.g_altMouseDown && GameInput.g_altMouseDownThisFrame)
1081 {
1082 GameInput.g_altMouseDownThisFrame = false;
1083 }
1084
1085 if (GameInput.g_altMouseDownThisFrame && !GameInput.g_altMouseDown)
1086 {
1087 GameInput.g_altMouseDown = true;
1088 }
1089
1090 if (GameInput.g_middleMouseDown && GameInput.g_middleMouseDownThisFrame)
1091 {
1092 GameInput.g_middleMouseDownThisFrame = false;
1093 }
1094
1095 if (GameInput.g_middleMouseDownThisFrame && !GameInput.g_middleMouseDown)
1096 {
1097 GameInput.g_middleMouseDown = true;
1098 }
1099 },
1100
1101
1102 isPressed: function (keyCode)
1103 {
1104 if (GameInput.g_ppressKeyStatus[keyCode] == null)
1105 { return false; }
1106 else
1107 { return GameInput.g_ppressKeyStatus[keyCode]; }
1108 },
1109
1110
1111 isHeld: function (keyCode)
1112 {
1113 if (GameInput.g_pKeyStatus[keyCode] == null)
1114 { return false; }
1115 else
1116 { return GameInput.g_pKeyStatus[keyCode]; }
1117 },
1118
1119 _pressedState: { left: false, middle: false, right: false },
1120 _heldState: { left: false, middle: false, right: false },
1121
1122 mousePressed: function (btn)
1123 {
1124 switch (btn)
1125 {
1126 case GameInput.MouseButtons.Left: return GameInput.g_mouseDownThisFrame;
1127 case GameInput.MouseButtons.Middle: return GameInput.g_middleMouseDownThisFrame;
1128 case GameInput.MouseButtons.Right: return GameInput.g_altMouseDownThisFrame;
1129 }
1130
1131 const state = GameInput._pressedState;
1132 state.left = GameInput.g_mouseDownThisFrame;
1133 state.middle = GameInput.g_middleMouseDownThisFrame;
1134 state.right = GameInput.g_altMouseDownThisFrame;
1135 return state;
1136 },
1137
1138 mouseHeld: function (btn)
1139 {
1140 switch (btn)
1141 {
1142 case GameInput.MouseButtons.Left: return GameInput.g_mouseDown;
1143 case GameInput.MouseButtons.Middle: return GameInput.g_middleMouseDown;
1144 case GameInput.MouseButtons.Right: return GameInput.g_altMouseDown;
1145 }
1146
1147 const state = GameInput._heldState;
1148 state.left = GameInput.g_mouseDown;
1149 state.middle = GameInput.g_middleMouseDown;
1150 state.right = GameInput.g_altMouseDown;
1151 return state;
1152 }
1153 };//
1154 /*
1155 * End File:
1156 * framework/util/input.js
1157 */
1158
1159 /*
1160 * Start File:
1161 * framework/util/audio.js
1162 */
1163 var GameAudio =
1164 {
1165 active: false,
1166 sounds: {},
1167 path: "",
1168 volume: 1,
1169 multiplay: true,
1170 supported: ["mp3", "ogg", "wav", "mp4", "aac"],
1171
1172 init: function (collection, containingFolder)
1173 {
1174 console.log("GAME: Loading sounds. (Note: Only supported from online-source, will fail when executed on local files.)");
1175
1176 try
1177 {
1178 if (typeof Audio !== "function" && typeof Audio !== "object")
1179 {
1180 throw new Error("HTML5 Audio is not supported in this browser");
1181 }
1182
1183 if (containingFolder == null)
1184 { containingFolder = ""; }
1185
1186 if (containingFolder != "")
1187 { containingFolder += "/"; }
1188
1189 this.path = containingFolder;
1190 this.sounds = {};
1191
1192 for (var i = 0; i < collection.length; i++)
1193 {
1194 var entry = collection[i];
1195 var name = entry.name;
1196 if (!name)
1197 { continue; }
1198
1199 var audio = new Audio();
1200 audio.preload = "auto";
1201 audio.volume = entry.volume != null ? entry.volume : this.volume;
1202 audio.src = this.resolveUrl(entry);
1203
1204 // Kick off preload without blocking init.
1205 audio.load();
1206
1207 this.sounds[name] = audio;
1208 }
1209
1210 this.active = true;
1211 }
1212 catch (err)
1213 {
1214 this.active = false;
1215 console.log("GAME: ERROR: Sounds could not be loaded. Sound will not be available.");
1216 }
1217 },
1218
1219 resolveUrl: function (entry)
1220 {
1221 if (entry.url)
1222 { return entry.url; }
1223
1224 var ext = entry.ext || this.pickExtension();
1225 if (ext.charAt(0) === ".")
1226 { ext = ext.substring(1); }
1227
1228 return this.path + entry.name + "." + ext;
1229 },
1230
1231 pickExtension: function ()
1232 {
1233 var probe = new Audio();
1234
1235 for (var i = 0; i < this.supported.length; i++)
1236 {
1237 var ext = this.supported[i];
1238 var mime = this.mimeFor(ext);
1239 if (mime && probe.canPlayType(mime))
1240 { return ext; }
1241 }
1242
1243 return "mp3";
1244 },
1245
1246 mimeFor: function (ext)
1247 {
1248 switch (ext)
1249 {
1250 case "mp3": return "audio/mpeg";
1251 case "ogg": return "audio/ogg";
1252 case "wav": return "audio/wav";
1253 case "mp4":
1254 case "aac": return 'audio/mp4; codecs="mp4a.40.2"';
1255 default: return "";
1256 }
1257 },
1258
1259 play: function (name)
1260 {
1261 if (!this.active)
1262 { return; }
1263
1264 var source = this.sounds[name];
1265 if (!source)
1266 {
1267 console.warn("GAME: Sound '" + name + "' was not loaded.");
1268 return;
1269 }
1270
1271 var clip = this.multiplay ? source.cloneNode() : source;
1272 clip.volume = source.volume;
1273
1274 if (!this.multiplay)
1275 {
1276 try { clip.currentTime = 0; }
1277 catch (err) { /* ignore seek errors before load */ }
1278 }
1279
1280 var playPromise = clip.play();
1281 if (playPromise && typeof playPromise.catch === "function")
1282 {
1283 playPromise.catch(function ()
1284 {
1285 // Autoplay policies can reject until a user gesture; ignore.
1286 });
1287 }
1288 }
1289 };
1290
1291 /*
1292 * End File:
1293 * framework/util/audio.js
1294 */
1295
1296 /*
1297 * Start File:
1298 * framework/util/ray.js
1299 */
1300 class Ray
1301 {
1302 static Cast (scene, origin, direction, maxLength = -1)
1303 {
1304 direction = direction.normalize();
1305 const hits = []; // {hitObj, hitPoint}
1306 for (var i = 0; i < scene.activeObjects.length; i++)
1307 {
1308 let castAngle = direction.toAngle();
1309
1310 if (scene.activeObjects[i] != this && scene.activeObjects[i].collider.enabled)
1311 {
1312 var hw = scene.activeObjects[i].transform.size.x / 2;
1313 var hh = scene.activeObjects[i].transform.size.y / 2;
1314
1315 const points =
1316 [
1317 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y - hh),
1318 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y - hh),
1319 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y + hh),
1320 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y + hh)
1321 ];
1322
1323 points.sort((p1, p2) => p1.subtract(origin).length - p2.subtract(origin).length).pop();
1324
1325 for (let p = 0; p < points.length; p++)
1326 {
1327 const point = points[p];
1328 const deltaDistance = point.subtract(origin).length;
1329
1330 if (deltaDistance > maxLength && maxLength > 0)
1331 {
1332 continue;
1333 }
1334
1335 const stretched = direction.stretch(Math.min(deltaDistance, maxLength > 0 ? maxLength : deltaDistance));
1336
1337 const calcPoint = origin.add(stretched);
1338
1339 if (scene.activeObjects[i].collider.isInBounds(calcPoint))
1340 {
1341 //determine in between which vector angles ray is
1342 var angles = points.map(p => Ray.mapPointToPointAndAngle(p, origin));
1343
1344 pointLoop:
1345 for (let pa = 0; pa < angles.length; pa++)
1346 {
1347 for (let pb = 0; pb < angles.length; pb++)
1348 {
1349 if (angles[pa].angle - angles[pb].angle > 270 || angles[pb].angle - angles[pa].angle > 270)
1350 {
1351
1352 castAngle = (castAngle + 180) % 360;
1353 angles.forEach(pIn => pIn.angle = (pIn.angle + 180) % 360);
1354 break pointLoop;
1355 }
1356 }
1357 }
1358
1359 angles = angles.sort((a, b) => b.angle - a.angle);
1360
1361 if (angles[1].length > angles[0].length && angles[1].length > angles[2].length)
1362 {
1363 //only one face can be hit at this time, which is between angles[0] and angles[2]
1364 angles.removeAt(1); //remove the center, connecting to the un-hittable face
1365 }
1366 else
1367 {
1368 //one of two faces can be hit at this time, either angles[0]-angles[1] or angles[1]-angles[2]
1369 (castAngle > angles[1].angle) ? angles.pop() : angles.shift(); //figure out on which side we are, and remove the furthest
1370 }
1371
1372 //calc % of angle in relation to the angles it is between
1373 const smallAngle = Math.min(angles[1].angle, angles[0].angle);
1374 const percent = (castAngle - smallAngle) / (Math.max(angles[1].angle, angles[0].angle) - smallAngle);
1375
1376 const hitPoint = angles[1].point.lerpTo(angles[0].point, percent);
1377 hits.push({
1378 hitObj: scene.activeObjects[i],
1379 hitPoint: hitPoint,
1380 length: hitPoint.subtract(origin).length
1381 });
1382 break;
1383 }
1384 }
1385 }
1386 }
1387
1388 if (hits.length === 0)
1389 { return undefined; }
1390
1391 let shortest = hits[0];
1392
1393 for (let i = 1; i < hits.length; i++)
1394 {
1395 if (hits[i].length < shortest.length)
1396 {
1397 shortest = hits[i];
1398 }
1399 }
1400
1401 return shortest;
1402 }
1403
1404 static mapPointToPointAndAngle (point, origin)
1405 {
1406 const delta = point.subtract(origin);
1407
1408 return {
1409 point: point,
1410 angle: delta.toAngle(),
1411 length: delta.length
1412 };
1413 }
1414 }
1415 /*
1416 * End File:
1417 * framework/util/ray.js
1418 */
1419
1420 /*
1421 * Start File:
1422 * framework/util/quadTree.js
1423 */
1424 /**
1425 * Quadtree is a data-structure that contains a root node, and child nodes up to a defined depth. These nodes can be considered 'buckets' that can hold up to X objects.
1426 * When that number is exceeded (and the maximum depth is not yet reached), the node will split up into 4 separate nodes
1427 * (top left, top right, bottom left, bottom right),
1428 * dividing up the objects into the correct quadrant based on their location.
1429 *
1430 */
1431
1432 class QuadTree
1433 {
1434 constructor (width, height, maxDepth = 7, bucketSize = 30)
1435 {
1436 this.root = new Node(0, 0, width, height, 0, null, "", this);
1437
1438 this.maxDepth = maxDepth;
1439 this.bucketSize = bucketSize;
1440
1441 this.width = width;
1442 this.height = height;
1443
1444 // Reused across queries (results are valid until the next query).
1445 this._queryNodes = [];
1446 this._queryResult = [];
1447 this._queryScored = [];
1448 }
1449
1450 /**
1451 * Adds object to the quadtree. if the amount of objects in the target node is higher than
1452 * the permitted size, it divides up into 4 new nodes. Contents of this node is then divided up.
1453 * @param {GameObject} object
1454 * @returns {void}
1455 */
1456 add (object)
1457 {
1458 let dirOfOob = this.outOfBounds(object);
1459 while (dirOfOob)
1460 {
1461 this.embiggen(dirOfOob);
1462 dirOfOob = this.outOfBounds(object);
1463 }
1464
1465 // Node.add may split and move the object into a descendant leaf
1466 // (divide sets object.node). Otherwise assign the leaf we inserted into.
1467 const node = this.findNodeFromRoot(object);
1468 node.add(object);
1469 if (!object.node)
1470 { object.node = node; }
1471 }
1472
1473 /**
1474 * Removes object from quadtree. If the total amount of objects held by siblings is lower than the maximum size,
1475 * a cleanup phase is triggered to remove the objects from siblings, moved up to parent node
1476 * @param {GameObject} object
1477 * @returns {void}
1478 */
1479
1480 remove (object)
1481 {
1482 const node = object.node || (!this.root.hasChildren ? this.root : null);
1483
1484 if (node && node.remove(object))
1485 {
1486 object.node = null;
1487 }
1488 }
1489
1490 /**
1491 * Retrieves objects within range of a given position. Sorted by distance from position
1492 *
1493 * @param {vector} position
1494 * @param {number} range (radius)
1495 * @returns {GameObject[]} result
1496 */
1497
1498 getObjectsInRange (position, range)
1499 {
1500 return this.getObjectsOfTypesInRange(position, range, null);
1501 }
1502
1503 /**
1504 * Retrieves objects within range of a given position matching a type. Sorted by distance from position
1505 *
1506 * @param {vector} position
1507 * @param {number} range (radius)
1508 * @param {class[]} types
1509 * @returns {GameObject[]} result
1510 */
1511
1512 getObjectsOfTypesInRange (position, range, types, options)
1513 {
1514 const typeFilter = Array.isArray(types)
1515 ? types.filter(t => t != null)
1516 : (types != null ? [types] : []);
1517
1518 return this.collectInRange(position, range, (obj) =>
1519 {
1520 if (typeFilter.length === 0)
1521 { return true; }
1522
1523 for (let i = 0, len = typeFilter.length; i < len; i++)
1524 {
1525 if (obj instanceof typeFilter[i])
1526 { return true; }
1527 }
1528
1529 return false;
1530 }, options);
1531 }
1532
1533 getObjectsWithTagInRange (position, range, tags, options)
1534 {
1535 const tagFilter = Array.isArray(tags)
1536 ? tags.filter(t => t != null)
1537 : (tags != null ? [tags] : []);
1538
1539 return this.collectInRange(position, range, (obj) =>
1540 {
1541 if (tagFilter.length === 0)
1542 { return true; }
1543
1544 const objTags = obj.tags;
1545 if (!objTags || objTags.length === 0)
1546 { return false; }
1547
1548 for (let i = 0, len = tagFilter.length; i < len; i++)
1549 {
1550 const want = tagFilter[i];
1551 for (let j = 0, jl = objTags.length; j < jl; j++)
1552 {
1553 if (objTags[j] == want)
1554 { return true; }
1555 }
1556 }
1557
1558 return false;
1559 }, options);
1560 }
1561
1562 getClosestObjectWithTagInRange (position, range, tags)
1563 {
1564 const tagFilter = Array.isArray(tags)
1565 ? tags.filter(t => t != null)
1566 : (tags != null ? [tags] : []);
1567
1568 return this.getClosestObjectInRange(position, range, (obj) =>
1569 {
1570 if (tagFilter.length === 0)
1571 { return true; }
1572
1573 const objTags = obj.tags;
1574 if (!objTags || objTags.length === 0)
1575 { return false; }
1576
1577 for (let i = 0, len = tagFilter.length; i < len; i++)
1578 {
1579 const want = tagFilter[i];
1580 for (let j = 0, jl = objTags.length; j < jl; j++)
1581 {
1582 if (objTags[j] == want)
1583 { return true; }
1584 }
1585 }
1586
1587 return false;
1588 });
1589 }
1590
1591 /**
1592 * @param {vector} position
1593 * @param {number} range
1594 * @param {Function} predicate
1595 * @param {{ sort?: boolean }} [options] - sort defaults true (closest first)
1596 * @returns {GameObject[]} reused buffer — consume before the next query
1597 */
1598 collectInRange (position, range, predicate, options)
1599 {
1600 const sort = !options || options.sort !== false;
1601 const rangeSq = range * range;
1602 const result = this._queryResult;
1603 result.length = 0;
1604
1605 const nodes = this._queryNodes;
1606 nodes.length = 0;
1607 nodes.push(this.root);
1608
1609 if (!sort)
1610 {
1611 while (nodes.length > 0)
1612 {
1613 const node = nodes.pop();
1614
1615 if (!this.isInRange(position, range, node))
1616 { continue; }
1617
1618 if (node.hasChildren)
1619 {
1620 nodes.push(node.topleft, node.topright, node.bottomleft, node.bottomright);
1621 continue;
1622 }
1623
1624 const objects = node.objects;
1625 for (let i = 0, len = objects.length; i < len; i++)
1626 {
1627 const obj = objects[i];
1628 const distSq = obj.transform.position.distanceToSq(position);
1629 if (distSq > 0 && distSq < rangeSq && predicate(obj))
1630 { result.push(obj); }
1631 }
1632 }
1633
1634 return result;
1635 }
1636
1637 const scored = this._queryScored;
1638 scored.length = 0;
1639
1640 while (nodes.length > 0)
1641 {
1642 const node = nodes.pop();
1643
1644 if (!this.isInRange(position, range, node))
1645 { continue; }
1646
1647 if (node.hasChildren)
1648 {
1649 nodes.push(node.topleft, node.topright, node.bottomleft, node.bottomright);
1650 continue;
1651 }
1652
1653 const objects = node.objects;
1654 for (let i = 0, len = objects.length; i < len; i++)
1655 {
1656 const obj = objects[i];
1657 const distSq = obj.transform.position.distanceToSq(position);
1658 if (distSq > 0 && distSq < rangeSq && predicate(obj))
1659 { scored.push({ obj, dist: distSq }); }
1660 }
1661 }
1662
1663 if (scored.length > 1)
1664 { scored.sort((a, b) => a.dist - b.dist); }
1665
1666 for (let i = 0, len = scored.length; i < len; i++)
1667 { result.push(scored[i].obj); }
1668
1669 return result;
1670 }
1671
1672 getClosestObjectInRange (position, range, predicate)
1673 {
1674 const rangeSq = range * range;
1675 const nodes = this._queryNodes;
1676 nodes.length = 0;
1677 nodes.push(this.root);
1678 let closest = null;
1679 let closestDistSq = rangeSq;
1680
1681 while (nodes.length > 0)
1682 {
1683 const node = nodes.pop();
1684
1685 if (!this.isInRange(position, range, node))
1686 { continue; }
1687
1688 if (node.hasChildren)
1689 {
1690 nodes.push(node.topleft, node.topright, node.bottomleft, node.bottomright);
1691 continue;
1692 }
1693
1694 const objects = node.objects;
1695 for (let i = 0, len = objects.length; i < len; i++)
1696 {
1697 const obj = objects[i];
1698 const distSq = obj.transform.position.distanceToSq(position);
1699 if (distSq > 0 && distSq < closestDistSq && predicate(obj))
1700 {
1701 closestDistSq = distSq;
1702 closest = obj;
1703 }
1704 }
1705 }
1706
1707 return closest;
1708 }
1709
1710 isInRange (vector, range, node)
1711 {
1712 var points =
1713 [
1714 vector.x - range,
1715 vector.x + range,
1716 vector.y - range,
1717 vector.y + range
1718 ];
1719
1720 if (points[1] >= node.x1 && points[0] <= node.x2)
1721 {
1722 if (points[3] >= node.y1 && points[2] <= node.y2)
1723 {
1724 return true;
1725 }
1726 }
1727 return false;
1728 }
1729
1730 embiggen (dirOfOob)
1731 {
1732 // Place the current root as a child of a 2x parent that grows into the
1733 // out-of-bounds direction (L←, R→, U↑, D↓).
1734 if (dirOfOob == "L")
1735 {
1736 this.root = this.root.createParent("topright");
1737 }
1738 else if (dirOfOob == "R")
1739 {
1740 this.root = this.root.createParent("topleft");
1741 }
1742 else if (dirOfOob == "U")
1743 {
1744 this.root = this.root.createParent("bottomleft");
1745 }
1746 else if (dirOfOob == "D")
1747 {
1748 this.root = this.root.createParent("topleft");
1749 }
1750
1751 this.width = this.root.lengthX;
1752 this.height = this.root.lengthY;
1753 }
1754
1755 traverseTo (path)
1756 {
1757 let node = this.root;
1758
1759 for (let i = 0, len = path.length; i < len; i++)
1760 {
1761 if (!node.hasChildren)
1762 { return node; }
1763
1764 node = node.getChildren()[path[i]];
1765 }
1766
1767 return node;
1768 }
1769
1770 findNodeFromRoot (object)
1771 {
1772 return this.findNodeFromRootAtPosition(object.transform.position);
1773 }
1774
1775 findNodeFromRootAtPosition (position)
1776 {
1777 let node = this.root;
1778
1779 while (node && node.hasChildren)
1780 {
1781 node = node.findChildNode(position) || node.topleft;
1782 }
1783
1784 return node || this.root;
1785 }
1786
1787 show (ctx)
1788 {
1789 this.showAll(this.root, ctx);
1790 }
1791
1792 showAll (node, ctx)
1793 {
1794 node.show(ctx);
1795
1796 if (node.hasChildren)
1797 {
1798 node.getChildren().forEach((element) => this.showAll(element, ctx));
1799 }
1800 }
1801
1802 update (/* deltaTime */)
1803 {
1804 // Merge/split happen eagerly on add/remove; nothing to tick per frame.
1805 }
1806
1807 outOfBounds (object)
1808 {
1809 const pos = object.transform.position;
1810
1811 if (pos.x < this.root.x1)
1812 {
1813 return "L";
1814 }
1815
1816 if (pos.x > this.root.x2)
1817 {
1818 return "R";
1819 }
1820
1821 if (pos.y < this.root.y1)
1822 {
1823 return "U";
1824 }
1825
1826 if (pos.y > this.root.y2)
1827 {
1828 return "D";
1829 }
1830
1831 return false;
1832 }
1833 }
1834
1835 class Node
1836 {
1837 get canBeMerged ()
1838 {
1839 // Leaf siblings may collapse into their parent when the parent's
1840 // whole subtree fits in one bucket again.
1841 return !this.hasChildren && this.parent && this.parent.recursiveCount <= this.quadTree.bucketSize;
1842 }
1843
1844 get shouldSplit ()
1845 {
1846 return !this.hasChildren
1847 && this.recursiveCount > this.quadTree.bucketSize
1848 && this.depth < this.quadTree.maxDepth;
1849 }
1850
1851 get hasChildren ()
1852 {
1853 return this.bottomright != null; //assume the rest is there too
1854 }
1855
1856 constructor (x1, y1, x2, y2, depth, parent, name, quadTree)
1857 {
1858 this.name = name;
1859
1860 this.x1 = x1;
1861 this.x2 = x2;
1862 this.y1 = y1;
1863 this.y2 = y2;
1864
1865 this.objects = [];
1866
1867 this.topleft = null;
1868 this.topright = null;
1869 this.bottomleft = null;
1870 this.bottomright = null;
1871
1872 this.parent = parent;
1873
1874 this.depth = depth;
1875 this.recursiveCount = 0;
1876
1877 this.lengthX = this.x2 - this.x1;
1878 this.lengthY = this.y2 - this.y1;
1879
1880 this.halfLengthX = this.lengthX / 2;
1881 this.halfLengthY = this.lengthY / 2;
1882
1883 this.quadTree = quadTree;
1884 }
1885
1886 addCount ()
1887 {
1888 this.recursiveCount++;
1889
1890 this.parent && this.parent.addCount();
1891
1892 if (this.shouldSplit)
1893 {
1894 this.divide();
1895 }
1896 }
1897
1898 removeCount ()
1899 {
1900 this.recursiveCount--;
1901
1902 // Merge before notifying the parent. If the parent is checked first,
1903 // it still sees this node as a branch and skips the collapse; after
1904 // this node merges into a leaf the parent never re-checks.
1905 if (this.hasChildren)
1906 {
1907 let merge = true;
1908 const children = this.getChildren();
1909 for (let i = 0, l = children.length; i < l; i++)
1910 {
1911 if (!children[i].canBeMerged)
1912 { merge = false; }
1913 }
1914
1915 if (merge)
1916 {
1917 this.merge();
1918 }
1919 }
1920
1921 this.parent && this.parent.removeCount();
1922 }
1923
1924 remove (obj)
1925 {
1926 const index = this.objects ? this.objects.indexOf(obj) : -1;
1927 if (index >= 0)
1928 {
1929 this.objects.splice(index, 1);
1930 this.removeCount();
1931 return true;
1932 }
1933
1934 return false;
1935 }
1936
1937 add (obj, ignoreCount)
1938 {
1939 if (this.objects.indexOf(obj) < 0)
1940 {
1941 this.objects.push(obj);
1942
1943 if (!ignoreCount)
1944 { this.addCount(); }
1945 }
1946 }
1947
1948 divide ()
1949 {
1950 this.createNodes();
1951 const center = new vector((this.x1 + this.x2) / 2, (this.y1 + this.y2) / 2);
1952
1953 this.objects.forEach(object =>
1954 {
1955 if (object.transform.position.y > center.y)
1956 {
1957 if (object.transform.position.x > center.x)
1958 {
1959 object.node = this.bottomright;
1960 this.bottomright.add(object, true);
1961 }
1962 else
1963 {
1964 object.node = this.bottomleft;
1965 this.bottomleft.add(object, true);
1966 }
1967 }
1968 else
1969 {
1970 if (object.transform.position.x > center.x)
1971 {
1972 object.node = this.topright;
1973 this.topright.add(object, true);
1974 }
1975 else
1976 {
1977 object.node = this.topleft;
1978 this.topleft.add(object, true);
1979 }
1980 }
1981 });
1982
1983 this.objects = [];
1984
1985 // add(..., true) skips counting so the parent is not double-counted.
1986 // Children still need a correct local recursiveCount, and may themselves
1987 // need to split when this redistribute dumps more than bucketSize in one cell.
1988 this.getChildren().forEach(child =>
1989 {
1990 child.recursiveCount = child.objects.length;
1991 if (child.shouldSplit)
1992 {
1993 child.divide();
1994 }
1995 });
1996 }
1997
1998 merge ()
1999 {
2000 this.getChildren().forEach(child =>
2001 {
2002 child.getObjects().forEach(object =>
2003 {
2004 this.add(object, true);
2005 object.node = this;
2006 });
2007 });
2008
2009 this.removeNodes();
2010 }
2011
2012 size ()
2013 {
2014 if (this.objects != null)
2015 {
2016 return this.objects.length;
2017 }
2018 return 0;
2019 }
2020
2021 getObjects ()
2022 {
2023 return this.objects;
2024 }
2025
2026 getChildren ()
2027 {
2028 if (!this.hasChildren)
2029 {
2030 return [];
2031 }
2032
2033 return [this.topleft, this.topright, this.bottomleft, this.bottomright];
2034 }
2035
2036 findChildNode (position)
2037 {
2038 if (!this.hasChildren)
2039 { return this; }
2040
2041 // Same midpoint rule as divide() so add/remove/query stay consistent,
2042 // and we never return undefined on shared edges.
2043 const midX = this.x1 + this.halfLengthX;
2044 const midY = this.y1 + this.halfLengthY;
2045
2046 if (position.y > midY)
2047 {
2048 return position.x > midX ? this.bottomright : this.bottomleft;
2049 }
2050
2051 return position.x > midX ? this.topright : this.topleft;
2052 }
2053
2054 createNodes ()
2055 {
2056 if (this.hasChildren)
2057 { return; }
2058
2059 const depth = this.depth + 1;
2060
2061 this.topleft = new Node(this.x1, this.y1, this.x1 + this.halfLengthX, this.y1 + this.halfLengthY, depth, this, this.name + 0, this.quadTree);
2062
2063 this.topright = new Node(this.x1 + this.halfLengthX, this.y1, this.x2, this.y1 + this.halfLengthY, depth, this, this.name + 1, this.quadTree);
2064
2065 this.bottomleft = new Node(this.x1, this.y1 + this.halfLengthY, this.x1 + this.halfLengthX, this.y2, depth, this, this.name + 2, this.quadTree);
2066
2067 this.bottomright = new Node(this.x1 + this.halfLengthX, this.y1 + this.halfLengthY, this.x2, this.y2, depth, this, this.name + 3, this.quadTree);
2068
2069 return this.getChildren();
2070 }
2071
2072 createParent (nodePosition)
2073 {
2074 let parentNode;
2075
2076 if (nodePosition == "topleft")
2077 {
2078 parentNode = new Node(this.x1, this.y1, this.x1 + (this.lengthX * 2), this.y1 + (this.lengthY * 2), this.depth - 1, null, "", this.quadTree);
2079
2080 parentNode.topleft = this;
2081 }
2082
2083 if (nodePosition == "topright")
2084 {
2085 parentNode = new Node(this.x1 - this.lengthX, this.y1, this.x1 + this.lengthX, this.y1 + (this.lengthY * 2), this.depth - 1, null, "", this.quadTree);
2086
2087 parentNode.topright = this;
2088 }
2089
2090 if (nodePosition == "bottomleft")
2091 {
2092 parentNode = new Node(this.x1, this.y1 - this.lengthY, this.x1 + (this.lengthX * 2), this.y1 + this.lengthY, this.depth - 1, null, "", this.quadTree);
2093
2094 parentNode.bottomleft = this;
2095 }
2096
2097 if (nodePosition == "bottomright")
2098 {
2099 parentNode = new Node(this.x1 - this.lengthX, this.y1 - this.lengthY, this.x1 + this.lengthX, this.y1 + this.lengthY, this.depth - 1, null, "", this.quadTree);
2100
2101 parentNode.bottomright = this;
2102 }
2103
2104 this.parent = parentNode;
2105 parentNode.recursiveCount = this.recursiveCount;
2106
2107 if (!parentNode.topleft)
2108 {
2109 parentNode.topleft = new Node(parentNode.x1, parentNode.y1, parentNode.x1 + parentNode.halfLengthX, parentNode.y1 + parentNode.halfLengthY, this.depth, parentNode, parentNode.name + 0, this.quadTree);
2110 }
2111
2112 if (!parentNode.topright)
2113 {
2114 parentNode.topright = new Node(parentNode.x1 + parentNode.halfLengthX, parentNode.y1, parentNode.x2, parentNode.y1 + parentNode.halfLengthY, this.depth, parentNode, parentNode.name + 1, this.quadTree);
2115 }
2116
2117 if (!parentNode.bottomleft)
2118 {
2119 parentNode.bottomleft = new Node(parentNode.x1, parentNode.y1 + parentNode.halfLengthY, parentNode.x1 + parentNode.halfLengthX, parentNode.y2, this.depth, parentNode, parentNode.name + 2, this.quadTree);
2120 }
2121
2122 if (!parentNode.bottomright)
2123 {
2124 parentNode.bottomright = new Node(parentNode.x1 + parentNode.halfLengthX, parentNode.y1 + parentNode.halfLengthY, parentNode.x2, parentNode.y2, this.depth, parentNode, parentNode.name + 3, this.quadTree);
2125 }
2126
2127 parentNode.reconfigureNames("");
2128 return parentNode;
2129 }
2130
2131 startReconfigureNames ()
2132 {
2133 let parent = this;
2134 while (parent.parent)
2135 {
2136 parent = parent.parent;
2137 }
2138
2139 parent.reconfigureNames("");
2140 }
2141
2142 reconfigureNames (name)
2143 {
2144 this.name = name;
2145 const children = this.getChildren();
2146 for (let i = 0, l = children.length; i < l; i++)
2147 {
2148 children[i].reconfigureNames(name + i);
2149 }
2150 }
2151
2152 removeNodes ()
2153 {
2154 this.topleft = null;
2155 this.topright = null;
2156 this.bottomleft = null;
2157 this.bottomright = null;
2158 }
2159
2160 show (ctx)
2161 {
2162 ctx.strokeStyle = "white";
2163 ctx.strokeRect(this.x1, this.y1, this.lengthX, this.lengthY);
2164 }
2165 }
2166 /*
2167 * End File:
2168 * framework/util/quadTree.js
2169 */
2170
2171 /*
2172 * Start File:
2173 * framework/util/particleEmitter.js
2174 */
2175 class ParticleEmitter
2176 {
2177 static pool = [];
2178 enabled = false;
2179 mine = [];
2180 position = null;
2181
2182 emissionRate = 0;
2183 emissionTimer = 0;
2184 emissionAngle = 0;
2185
2186 startRotation = 0;
2187 startVelocity = 0;
2188 startAngularVelocity = 0;
2189 acceleration = null;
2190 angularAcceleration = 0;
2191 sprite = null;
2192 startSize = null;
2193 endSize = null;
2194 lifetimeMin = 0;
2195 lifetimeMax = 0;
2196 fadeIn = 0;
2197 fadeOut = 0;
2198 animationSpeed = 0;
2199 startFrame = 0;
2200
2201 friction = null;
2202 angularFriction = 0;
2203
2204 constructor (position, sprite, emissionRate, emissionAngle,
2205 startRotation, startVelocity, startAngularVelocity, acceleration,
2206 angularAcceleration, startSize, endSize, lifetimeMin,
2207 lifetimeMax = -1, fadeIn = 0, fadeOut = 0, startFrame = 0, animationSpeed = 0)
2208 {
2209 if (lifetimeMax < 0)
2210 { lifetimeMax = lifetimeMin; }
2211
2212 this.position = position;
2213 this.sprite = sprite;
2214
2215 this.emissionRate = emissionRate;
2216 this.emissionTimer = emissionRate;
2217 this.emissionAngle = emissionAngle;
2218
2219 this.startRotation = startRotation;
2220 this.startVelocity = startVelocity * 10;
2221 this.startAngularVelocity = startAngularVelocity * 10;
2222 this.acceleration = acceleration.stretch(10);
2223 this.angularAcceleration = angularAcceleration * 10;
2224 this.startSize = startSize;
2225 this.endSize = endSize;
2226 this.lifetimeMin = lifetimeMin;
2227 this.lifetimeMax = lifetimeMax;
2228 this.fadeIn = fadeIn;
2229 this.fadeOut = fadeOut;
2230 this.startFrame = startFrame;
2231 this.animationSpeed = animationSpeed;
2232
2233 this.friction = new vector(0, 0);
2234 }
2235
2236 start ()
2237 {
2238 this.enabled = true;
2239 }
2240
2241 stop ()
2242 {
2243 this.enabled = false;
2244 }
2245
2246 emit (amount = 1)
2247 {
2248 for (let i = 0; i < amount; i++)
2249 {
2250 const newParticle = ParticleEmitter.unPool();
2251 this.mine.push(newParticle);
2252
2253 const velocity = vector.fromAngle(this.emissionAngle).stretch(this.startVelocity);
2254 newParticle.emit(this, this.position.x, this.position.y, this.startRotation,
2255 velocity.x, velocity.y, this.startAngularVelocity, this.acceleration.x,
2256 this.acceleration.y, this.angularAcceleration, this.sprite, this.startSize.x,
2257 this.startSize.y, this.endSize.x, this.endSize.y, this.lifetimeMin,
2258 this.lifetimeMax, this.fadeIn, this.fadeOut, this.startFrame, this.animationSpeed,
2259 this.friction.getCopy(), this.angularFriction);
2260 }
2261 }
2262
2263 update (deltaTime)
2264 {
2265 if (this.enabled)
2266 { this.emissionTimer -= deltaTime; }
2267
2268 if (this.emissionTimer <= 0)
2269 {
2270 this.emissionTimer = this.emissionRate;
2271 this.emit();
2272 }
2273
2274 // Backwards so dispose()/remove during update cannot skip particles.
2275 for (let i = this.mine.length - 1; i >= 0; i--)
2276 {
2277 this.mine[i].update(deltaTime);
2278 }
2279 }
2280
2281 draw (scene)
2282 {
2283 for (let i = 0; i < this.mine.length; i++)
2284 {
2285 this.mine[i].draw(scene);
2286 }
2287 }
2288
2289 dispose (particle)
2290 {
2291 this.mine.remove(particle);
2292 ParticleEmitter.returnToPool(particle);
2293 }
2294
2295 static unPool () //get a particle from the static pool
2296 {
2297 if (ParticleEmitter.pool.length > 0)
2298 {
2299 return ParticleEmitter.pool.pop();
2300 }
2301
2302 return new Particle();
2303 }
2304
2305 static returnToPool (particle)
2306 {
2307 if (!ParticleEmitter.pool.contains(particle))
2308 {
2309 ParticleEmitter.pool.push(particle);
2310 }
2311 }
2312 }
2313
2314 class Particle
2315 {
2316 parent = null;
2317 position = null;
2318 rotation = 0;
2319 velocity = null;
2320 angularVelocity = 0;
2321 acceleration = null;
2322 angularAcceleration = 0;
2323 sprite = null;
2324 animTimer = 0;
2325 animationSpeed = 0;
2326 subImage = 0;
2327 startSize = null;
2328 endSize = null;
2329 fadeInTime = 0;
2330 fadeInStart = 0;
2331 fadeOutTime = 0;
2332 lifeTime = 0;
2333 lifeTimeStart = 0;
2334 friction = null;
2335 angularfriction = 0;
2336
2337 constructor ()
2338 {
2339 this.position = new vector(0, 0);
2340 this.velocity = new vector(0, 0);
2341 this.acceleration = new vector(0, 0);
2342 this.startSize = new vector(0, 0);
2343 this.endSize = new vector(0, 0);
2344 }
2345
2346 emit (parent, x, y, r, vx, vy, va, ax, ay, ar, spr, ssx, ssy, esx, esy, lmin, lmax, fi = 0, fo = 0, sf = 0, as = 0, fric, anfric)
2347 {
2348 this.parent = parent;
2349 this.position.x = x;
2350 this.position.y = y;
2351 this.rotation = r;
2352 this.velocity.x = vx;
2353 this.velocity.y = vy;
2354 this.angularVelocity = va;
2355 this.acceleration.x = ax;
2356 this.acceleration.y = ay;
2357 this.angularAcceleration = ar;
2358 this.sprite = spr;
2359 this.startSize.x = ssx;
2360 this.startSize.y = ssy;
2361 this.endSize.x = esx;
2362 this.endSize.y = esy;
2363 this.lifeTime = Math.randomRange(lmin, lmax);
2364 this.lifeTimeStart = this.lifeTime;
2365 this.fadeInTime = fi;
2366 this.fadeInStart = fi;
2367 this.fadeOutTime = fo;
2368 this.animationSpeed = as;
2369 this.animTimer = as;
2370 this.subImage = sf;
2371 this.friction = fric ? fric.getCopy() : new vector(0, 0);
2372 this.angularFriction = anfric;
2373 }
2374
2375 update (deltaTime)
2376 {
2377 this.position.x += this.velocity.x * deltaTime;
2378 this.position.y += this.velocity.y * deltaTime;
2379 this.velocity.x += this.acceleration.x * deltaTime;
2380 this.velocity.y += this.acceleration.y * deltaTime;
2381
2382 this.velocity.x += this.friction.x * deltaTime * -Math.sign(this.velocity.x * 10);
2383 this.velocity.y += this.friction.y * deltaTime * -Math.sign(this.velocity.y * 10);
2384
2385 this.rotation += this.angularVelocity * deltaTime;
2386 this.angularVelocity += this.angularAcceleration * deltaTime;
2387
2388 this.angularVelocity += this.angularFriction * deltaTime * -Math.sign(this.angularVelocity * 10);
2389
2390 this.lifeTime -= deltaTime;
2391
2392 if (this.fadeInTime > 0)
2393 { this.fadeInTime -= deltaTime; }
2394
2395 if (this.animationSpeed > 0)
2396 {
2397 this.animTimer -= deltaTime;
2398
2399 if (this.animTimer <= 0)
2400 {
2401 this.animTimer = this.animationSpeed;
2402 this.subImage = (this.subImage + 1) % this.sprite.subImages;
2403 }
2404 }
2405
2406 if (this.lifeTime <= 0)
2407 { this.parent.dispose(this); }
2408 }
2409
2410 draw (scene)
2411 {
2412 const foAlpha = this.fadeOutTime > 0
2413 ? Math.min(1, this.lifeTime / this.fadeOutTime)
2414 : 1;
2415
2416 const fiAlpha = this.fadeInStart > 0
2417 ? 1 - (this.fadeInTime / this.fadeInStart)
2418 : 1;
2419
2420 this.sprite.draw(
2421 scene,
2422 Math.round(this.position.x),
2423 Math.round(this.position.y),
2424 Math.lerp(this.endSize.x, this.startSize.x, this.lifeTime / this.lifeTimeStart),
2425 Math.lerp(this.endSize.y, this.startSize.y, this.lifeTime / this.lifeTimeStart),
2426 this.rotation,
2427 false,
2428 false,
2429 Math.min(fiAlpha, foAlpha),
2430 this.subImage
2431 );
2432 }
2433 }
2434 /*
2435 * End File:
2436 * framework/util/particleEmitter.js
2437 */
2438
2439 /*
2440 * Start File:
2441 * framework/engine/gl/shader.js
2442 */
2443 class Shader
2444 {
2445 static DEFAULT_VERT = [
2446 "attribute vec2 a_position;",
2447 "attribute vec2 a_texCoord;",
2448 "uniform mat4 u_matrix;",
2449 "varying vec2 v_texCoord;",
2450 "void main() {",
2451 " gl_Position = u_matrix * vec4(a_position, 0.0, 1.0);",
2452 " v_texCoord = a_texCoord;",
2453 "}"
2454 ].join("\n");
2455
2456 static DEFAULT_FRAG = [
2457 "precision mediump float;",
2458 "uniform sampler2D u_texture;",
2459 "uniform float u_alpha;",
2460 "varying vec2 v_texCoord;",
2461 "void main() {",
2462 " vec4 color = texture2D(u_texture, v_texCoord);",
2463 " gl_FragColor = vec4(color.rgb, color.a * u_alpha);",
2464 "}"
2465 ].join("\n");
2466
2467 // Fullscreen NDC quad for screen-space / post-process passes.
2468 static SCREEN_VERT = [
2469 "attribute vec2 a_position;",
2470 "attribute vec2 a_texCoord;",
2471 "varying vec2 v_texCoord;",
2472 "void main() {",
2473 " gl_Position = vec4(a_position, 0.0, 1.0);",
2474 " v_texCoord = a_texCoord;",
2475 "}"
2476 ].join("\n");
2477
2478 static SCREEN_COPY_FRAG = [
2479 "precision mediump float;",
2480 "uniform sampler2D u_texture;",
2481 "varying vec2 v_texCoord;",
2482 "void main() {",
2483 " gl_FragColor = texture2D(u_texture, v_texCoord);",
2484 "}"
2485 ].join("\n");
2486
2487 constructor (vertSource, fragSource)
2488 {
2489 this.vertSource = vertSource || Shader.DEFAULT_VERT;
2490 this.fragSource = fragSource || Shader.DEFAULT_FRAG;
2491 this._programs = new WeakMap();
2492 }
2493
2494 static fragment (fragSource)
2495 {
2496 return new Shader(Shader.DEFAULT_VERT, fragSource);
2497 }
2498
2499 static screenFragment (fragSource)
2500 {
2501 return new Shader(Shader.SCREEN_VERT, fragSource);
2502 }
2503
2504 getProgramInfo (gl)
2505 {
2506 let info = this._programs.get(gl);
2507 if (info)
2508 { return info; }
2509
2510 const program = Shader._createProgram(gl, this.vertSource, this.fragSource);
2511 if (!program)
2512 { return null; }
2513
2514 info = {
2515 program: program,
2516 attribs: {
2517 position: gl.getAttribLocation(program, "a_position"),
2518 texCoord: gl.getAttribLocation(program, "a_texCoord")
2519 },
2520 uniforms: {}
2521 };
2522
2523 const numUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
2524 for (let i = 0; i < numUniforms; i++)
2525 {
2526 const uniformInfo = gl.getActiveUniform(program, i);
2527 if (!uniformInfo)
2528 { continue; }
2529
2530 info.uniforms[uniformInfo.name] = {
2531 location: gl.getUniformLocation(program, uniformInfo.name),
2532 type: uniformInfo.type,
2533 size: uniformInfo.size
2534 };
2535 }
2536
2537 this._programs.set(gl, info);
2538 return info;
2539 }
2540
2541 static _createShader (gl, type, source)
2542 {
2543 const shader = gl.createShader(type);
2544 gl.shaderSource(shader, source);
2545 gl.compileShader(shader);
2546
2547 if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))
2548 {
2549 console.error("Shader compile error:", gl.getShaderInfoLog(shader));
2550 console.error(source);
2551 gl.deleteShader(shader);
2552 return null;
2553 }
2554
2555 return shader;
2556 }
2557
2558 static _createProgram (gl, vertSource, fragSource)
2559 {
2560 const vertexShader = Shader._createShader(gl, gl.VERTEX_SHADER, vertSource);
2561 const fragmentShader = Shader._createShader(gl, gl.FRAGMENT_SHADER, fragSource);
2562 if (!vertexShader || !fragmentShader)
2563 { return null; }
2564
2565 const program = gl.createProgram();
2566 gl.attachShader(program, vertexShader);
2567 gl.attachShader(program, fragmentShader);
2568 gl.linkProgram(program);
2569
2570 gl.deleteShader(vertexShader);
2571 gl.deleteShader(fragmentShader);
2572
2573 if (!gl.getProgramParameter(program, gl.LINK_STATUS))
2574 {
2575 console.error("Shader link error:", gl.getProgramInfoLog(program));
2576 gl.deleteProgram(program);
2577 return null;
2578 }
2579
2580 return program;
2581 }
2582 }
2583
2584 /*
2585 * End File:
2586 * framework/engine/gl/shader.js
2587 */
2588
2589 /*
2590 * Start File:
2591 * framework/engine/gl/builtinShaders.js
2592 */
2593 // Built-in screen-space / effect shaders. Games can use these without fetching files.
2594 // Expand this set over time into the default framework shader bundle.
2595
2596 Shader.Builtin = Shader.Builtin || {};
2597
2598 Shader.Builtin.BLOOM_BRIGHT_FRAG = [
2599 "precision mediump float;",
2600 "uniform sampler2D u_texture;",
2601 "uniform float u_threshold;",
2602 "uniform float u_softKnee;",
2603 "varying vec2 v_texCoord;",
2604 "void main() {",
2605 " vec4 color = texture2D(u_texture, v_texCoord);",
2606 // Peak channel (not Rec.709 luma) so reds are not weaker than greens/blues.
2607 " float peak = max(color.r, max(color.g, color.b)) * color.a;",
2608 " float knee = max(u_softKnee, 0.001);",
2609 " float soft = smoothstep(u_threshold, u_threshold + knee, peak);",
2610 // Normalize by peak so saturated colors contribute similar bloom energy.
2611 " float invPeak = 1.0 / max(peak, 0.001);",
2612 " vec3 balanced = color.rgb * invPeak * soft;",
2613 " gl_FragColor = vec4(balanced, 1.0);",
2614 "}"
2615 ].join("\n");
2616
2617 // Max-filter dilate: fattens 1–4px hotspots so later blur has something to spread.
2618 Shader.Builtin.BLOOM_DILATE_FRAG = [
2619 "precision mediump float;",
2620 "uniform sampler2D u_texture;",
2621 "uniform vec2 u_resolution;",
2622 "uniform float u_radius;",
2623 "varying vec2 v_texCoord;",
2624 "void main() {",
2625 " vec2 px = u_radius / max(u_resolution, vec2(1.0));",
2626 " vec4 c = texture2D(u_texture, v_texCoord);",
2627 " c = max(c, texture2D(u_texture, v_texCoord + vec2(px.x, 0.0)));",
2628 " c = max(c, texture2D(u_texture, v_texCoord - vec2(px.x, 0.0)));",
2629 " c = max(c, texture2D(u_texture, v_texCoord + vec2(0.0, px.y)));",
2630 " c = max(c, texture2D(u_texture, v_texCoord - vec2(0.0, px.y)));",
2631 " c = max(c, texture2D(u_texture, v_texCoord + px));",
2632 " c = max(c, texture2D(u_texture, v_texCoord - px));",
2633 " c = max(c, texture2D(u_texture, v_texCoord + vec2(px.x, -px.y)));",
2634 " c = max(c, texture2D(u_texture, v_texCoord + vec2(-px.x, px.y)));",
2635 " vec2 px2 = px * 2.0;",
2636 " c = max(c, texture2D(u_texture, v_texCoord + vec2(px2.x, 0.0)));",
2637 " c = max(c, texture2D(u_texture, v_texCoord - vec2(px2.x, 0.0)));",
2638 " c = max(c, texture2D(u_texture, v_texCoord + vec2(0.0, px2.y)));",
2639 " c = max(c, texture2D(u_texture, v_texCoord - vec2(0.0, px2.y)));",
2640 " gl_FragColor = c;",
2641 "}"
2642 ].join("\n");
2643
2644 // Wider separable blur (13-tap). u_direction (1,0)/(0,1); u_blurSize in texels.
2645 Shader.Builtin.BLOOM_BLUR_FRAG = [
2646 "precision mediump float;",
2647 "uniform sampler2D u_texture;",
2648 "uniform vec2 u_resolution;",
2649 "uniform vec2 u_direction;",
2650 "uniform float u_blurSize;",
2651 "varying vec2 v_texCoord;",
2652 "void main() {",
2653 " vec2 step = u_direction * u_blurSize / max(u_resolution, vec2(1.0));",
2654 " vec4 c = vec4(0.0);",
2655 " c += texture2D(u_texture, v_texCoord - step * 6.0) * 0.009;",
2656 " c += texture2D(u_texture, v_texCoord - step * 5.0) * 0.019;",
2657 " c += texture2D(u_texture, v_texCoord - step * 4.0) * 0.038;",
2658 " c += texture2D(u_texture, v_texCoord - step * 3.0) * 0.071;",
2659 " c += texture2D(u_texture, v_texCoord - step * 2.0) * 0.111;",
2660 " c += texture2D(u_texture, v_texCoord - step) * 0.147;",
2661 " c += texture2D(u_texture, v_texCoord) * 0.160;",
2662 " c += texture2D(u_texture, v_texCoord + step) * 0.147;",
2663 " c += texture2D(u_texture, v_texCoord + step * 2.0) * 0.111;",
2664 " c += texture2D(u_texture, v_texCoord + step * 3.0) * 0.071;",
2665 " c += texture2D(u_texture, v_texCoord + step * 4.0) * 0.038;",
2666 " c += texture2D(u_texture, v_texCoord + step * 5.0) * 0.019;",
2667 " c += texture2D(u_texture, v_texCoord + step * 6.0) * 0.009;",
2668 " gl_FragColor = c;",
2669 "}"
2670 ].join("\n");
2671
2672 // Combine: add bloom while keeping / boosting chroma (avoids gray wash at high intensity).
2673 Shader.Builtin.BLOOM_COMBINE_FRAG = [
2674 "precision mediump float;",
2675 "uniform sampler2D u_texture;",
2676 "uniform sampler2D u_scene;",
2677 "uniform float u_intensity;",
2678 "uniform float u_saturation;",
2679 "uniform float u_colorPreserve;",
2680 "varying vec2 v_texCoord;",
2681 "void main() {",
2682 " vec4 scene = texture2D(u_scene, v_texCoord);",
2683 " vec4 bloom = texture2D(u_texture, v_texCoord);",
2684 " vec3 bloomCol = bloom.rgb;",
2685 " float bloomPeak = max(bloomCol.r, max(bloomCol.g, bloomCol.b));",
2686 " bloomCol = mix(vec3(bloomPeak), bloomCol, u_saturation);",
2687 // Hue from scene peak (not luma) so red bullets keep chroma under colorPreserve.
2688 " float scenePeak = max(scene.r, max(scene.g, scene.b));",
2689 " vec3 sceneHue = scene.rgb / max(scenePeak, 0.04);",
2690 " bloomCol *= mix(vec3(1.0), sceneHue, clamp(u_colorPreserve, 0.0, 1.0));",
2691 " bloomCol *= u_intensity;",
2692 // Soft add: keeps punchy color instead of clipping hard to white/gray.
2693 " vec3 rgb = scene.rgb + bloomCol * (1.0 - scene.rgb * 0.35);",
2694 " float bloomA = max(bloomCol.r, max(bloomCol.g, bloomCol.b));",
2695 " float a = max(scene.a, min(bloomA, 1.0));",
2696 " gl_FragColor = vec4(rgb, a);",
2697 "}"
2698 ].join("\n");
2699
2700 /**
2701 * Multi-pass bloom for a RenderLayer / scene.postShaders.
2702 *
2703 * options:
2704 * - threshold, softKnee, intensity, blurSize
2705 * - saturation: bloom chroma boost (1 = neutral, >1 = juicier)
2706 * - colorPreserve: 0–1 tint bloom with the original sprite hue
2707 * - smallSources: dilate tiny bright pixels before blur (good for 3–4px bullets)
2708 * - dilate: explicit dilate radius in texels (overrides smallSources default)
2709 * - scales: number of H/V blur scale pairs (default 2 with smallSources, else 1)
2710 * - halfRes: run dilate + blur at half resolution when true (default true)
2711 */
2712 Shader.getBloomPostChain = function (options)
2713 {
2714 options = options || {};
2715 const threshold = options.threshold != null ? options.threshold : 0.4;
2716 const softKnee = options.softKnee != null ? options.softKnee : 0.3;
2717 const intensity = options.intensity != null ? options.intensity : 1.25;
2718 const blurSize = options.blurSize != null ? options.blurSize : 3.0;
2719 const saturation = options.saturation != null ? options.saturation : 1.0;
2720 const colorPreserve = options.colorPreserve != null ? options.colorPreserve : 0.0;
2721 const smallSources = !!options.smallSources;
2722
2723 let dilateRadius = 0;
2724 if (options.dilate != null)
2725 { dilateRadius = options.dilate; }
2726 else if (smallSources)
2727 { dilateRadius = 4.5; } // fatter hotspots so tiny bullets bloom closer to large ones
2728
2729 const scales = options.scales != null
2730 ? options.scales
2731 : (smallSources ? 2 : 1);
2732
2733 // Dilate + blur at half-res (~4× less fill). Bright extract + combine stay full-res.
2734 const halfResBlur = options.halfRes !== false;
2735 const halfPass = halfResBlur ? { scale: 0.5 } : {};
2736 // At half-res, texel-sized kernels cover ~2× world space — keep visual width similar.
2737 const resScale = halfResBlur ? 0.5 : 1;
2738
2739 if (!Shader._bloomBright || Shader._bloomBright.fragSource !== Shader.Builtin.BLOOM_BRIGHT_FRAG)
2740 {
2741 Shader._bloomBright = Shader.screenFragment(Shader.Builtin.BLOOM_BRIGHT_FRAG);
2742 Shader._bloomDilate = Shader.screenFragment(Shader.Builtin.BLOOM_DILATE_FRAG);
2743 Shader._bloomBlur = Shader.screenFragment(Shader.Builtin.BLOOM_BLUR_FRAG);
2744 Shader._bloomCombine = Shader.screenFragment(Shader.Builtin.BLOOM_COMBINE_FRAG);
2745 }
2746
2747 const chain = [
2748 { shader: Shader._bloomBright, uniforms: { u_threshold: threshold, u_softKnee: softKnee } }
2749 ];
2750
2751 if (dilateRadius > 0)
2752 {
2753 chain.push(Object.assign({
2754 shader: Shader._bloomDilate,
2755 uniforms: { u_radius: dilateRadius * resScale }
2756 }, halfPass));
2757 }
2758
2759 const scaleFactors = [1, 2.2, 4.5, 8];
2760 for (let i = 0; i < scales; i++)
2761 {
2762 const size = blurSize * scaleFactors[Math.min(i, scaleFactors.length - 1)] * resScale;
2763 chain.push(Object.assign({
2764 shader: Shader._bloomBlur,
2765 uniforms: { u_direction: [1, 0], u_blurSize: size }
2766 }, halfPass));
2767 chain.push(Object.assign({
2768 shader: Shader._bloomBlur,
2769 uniforms: { u_direction: [0, 1], u_blurSize: size }
2770 }, halfPass));
2771 }
2772
2773 chain.push({
2774 shader: Shader._bloomCombine,
2775 uniforms: {
2776 u_intensity: intensity,
2777 u_saturation: saturation,
2778 u_colorPreserve: colorPreserve
2779 }
2780 });
2781 return chain;
2782 };
2783
2784 // --- Sprite effect builtins -------------------------------------------------
2785
2786 Shader.Builtin.BUMPMAP_FRAG = [
2787 "precision mediump float;",
2788 "uniform sampler2D u_texture;",
2789 "uniform sampler2D u_bump;",
2790 "uniform float u_alpha;",
2791 "uniform vec2 u_worldCenter;",
2792 "uniform vec2 u_worldSize;",
2793 "uniform float u_rotationRad;",
2794 "uniform int u_lightCount;",
2795 "uniform vec2 u_lightPos[16];",
2796 "uniform vec3 u_lightColor[16];",
2797 "uniform float u_ambient;",
2798 "uniform float u_specular;",
2799 // 0 = height map (R), 1 = tangent-space normal map (RGB)
2800 "uniform float u_bumpMode;",
2801 "varying vec2 v_texCoord;",
2802 "void main() {",
2803 " vec4 albedo = texture2D(u_texture, v_texCoord);",
2804 " vec3 normal;",
2805 " if (u_bumpMode < 0.5) {",
2806 " float hL = texture2D(u_bump, v_texCoord + vec2(-0.01, 0.0)).r;",
2807 " float hR = texture2D(u_bump, v_texCoord + vec2(0.01, 0.0)).r;",
2808 " float hU = texture2D(u_bump, v_texCoord + vec2(0.0, -0.01)).r;",
2809 " float hD = texture2D(u_bump, v_texCoord + vec2(0.0, 0.01)).r;",
2810 " normal = normalize(vec3(hL - hR, hU - hD, 0.35));",
2811 " } else {",
2812 " vec3 nSample = texture2D(u_bump, v_texCoord).xyz * 2.0 - 1.0;",
2813 " normal = normalize(nSample);",
2814 " }",
2815 " float c = cos(u_rotationRad);",
2816 " float s = sin(u_rotationRad);",
2817 " normal = normalize(vec3(c * normal.x - s * normal.y, s * normal.x + c * normal.y, normal.z));",
2818 " vec2 local = (v_texCoord - vec2(0.5)) * u_worldSize;",
2819 " vec2 world = u_worldCenter + vec2(c * local.x - s * local.y, s * local.x + c * local.y);",
2820 " vec3 lighting = vec3(u_ambient);",
2821 " for (int i = 0; i < 16; i++) {",
2822 " if (i >= u_lightCount) { break; }",
2823 " vec2 toLight = u_lightPos[i] - world;",
2824 " float dist = max(length(toLight), 0.001);",
2825 " vec3 lightDir = normalize(vec3(toLight / dist, 0.75));",
2826 " float diff = max(dot(normal, lightDir), 0.0);",
2827 " float atten = 1.0 / (1.0 + dist * 0.006 + dist * dist * 0.00004);",
2828 " float spec = pow(diff, 24.0) * u_specular;",
2829 " lighting += u_lightColor[i] * (diff + spec) * atten;",
2830 " }",
2831 " gl_FragColor = vec4(albedo.rgb * lighting, albedo.a * u_alpha);",
2832 "}"
2833 ].join("\n");
2834
2835 // Replace pure R/G/B paint channel with u_replaceColor.
2836 Shader.Builtin.COLOUR_REPLACE_FRAG = [
2837 "precision mediump float;",
2838 "uniform sampler2D u_texture;",
2839 "uniform float u_alpha;",
2840 "uniform float u_channel;",
2841 "uniform vec3 u_replaceColor;",
2842 "varying vec2 v_texCoord;",
2843 "void main() {",
2844 " vec4 color = texture2D(u_texture, v_texCoord);",
2845 " float ch = color.r;",
2846 " float other = max(color.g, color.b);",
2847 " if (u_channel > 0.5 && u_channel < 1.5) { ch = color.g; other = max(color.r, color.b); }",
2848 " if (u_channel >= 1.5) { ch = color.b; other = max(color.r, color.g); }",
2849 " float mask = clamp((ch - other) * 1.75, 0.0, 1.0);",
2850 " vec3 rgb = mix(color.rgb, u_replaceColor, mask);",
2851 " gl_FragColor = vec4(rgb, color.a * u_alpha);",
2852 "}"
2853 ].join("\n");
2854
2855 // Clip sprite where secondary map luminance < u_amount (0 = full, 1 = gone).
2856 Shader.Builtin.DISINTEGRATE_FRAG = [
2857 "precision mediump float;",
2858 "uniform sampler2D u_texture;",
2859 "uniform sampler2D u_secondary;",
2860 "uniform float u_alpha;",
2861 "uniform float u_amount;",
2862 "varying vec2 v_texCoord;",
2863 "void main() {",
2864 " vec4 color = texture2D(u_texture, v_texCoord);",
2865 " float ref = texture2D(u_secondary, v_texCoord).r;",
2866 " if (ref < u_amount) { discard; }",
2867 " float edge = smoothstep(u_amount, u_amount + 0.08, ref);",
2868 " gl_FragColor = vec4(color.rgb, color.a * u_alpha * edge);",
2869 "}"
2870 ].join("\n");
2871
2872 Shader.getBumpmapShader = function ()
2873 {
2874 if (!Shader._bumpmap || Shader._bumpmap.fragSource !== Shader.Builtin.BUMPMAP_FRAG)
2875 { Shader._bumpmap = Shader.fragment(Shader.Builtin.BUMPMAP_FRAG); }
2876 return Shader._bumpmap;
2877 };
2878
2879 Shader.getColourReplaceShader = function ()
2880 {
2881 if (!Shader._colourReplace)
2882 { Shader._colourReplace = Shader.fragment(Shader.Builtin.COLOUR_REPLACE_FRAG); }
2883 return Shader._colourReplace;
2884 };
2885
2886 Shader.getDisintegrateShader = function ()
2887 {
2888 if (!Shader._disintegrate)
2889 { Shader._disintegrate = Shader.fragment(Shader.Builtin.DISINTEGRATE_FRAG); }
2890 return Shader._disintegrate;
2891 };
2892
2893 // --- Screen-space effect builtins ------------------------------------------
2894
2895 Shader.Builtin.DIRECTIONAL_BLUR_FRAG = [
2896 "precision mediump float;",
2897 "uniform sampler2D u_texture;",
2898 "uniform vec2 u_resolution;",
2899 "uniform vec2 u_direction;",
2900 "uniform float u_length;",
2901 "varying vec2 v_texCoord;",
2902 "void main() {",
2903 " vec2 dir = u_direction;",
2904 " float len = length(dir);",
2905 " if (len > 0.0001) { dir /= len; } else { dir = vec2(1.0, 0.0); }",
2906 " vec2 step = dir * u_length / max(u_resolution, vec2(1.0));",
2907 " vec4 c = vec4(0.0);",
2908 " c += texture2D(u_texture, v_texCoord - step * 2.0) * 0.12;",
2909 " c += texture2D(u_texture, v_texCoord - step) * 0.23;",
2910 " c += texture2D(u_texture, v_texCoord) * 0.30;",
2911 " c += texture2D(u_texture, v_texCoord + step) * 0.23;",
2912 " c += texture2D(u_texture, v_texCoord + step * 2.0) * 0.12;",
2913 " gl_FragColor = c;",
2914 "}"
2915 ].join("\n");
2916
2917 Shader.Builtin.RADIAL_BLUR_FRAG = [
2918 "precision mediump float;",
2919 "uniform sampler2D u_texture;",
2920 "uniform vec2 u_center;",
2921 "uniform float u_amount;",
2922 "varying vec2 v_texCoord;",
2923 "void main() {",
2924 " vec2 toCenter = u_center - v_texCoord;",
2925 " vec4 c = vec4(0.0);",
2926 " for (int i = 0; i < 8; i++) {",
2927 " float t = float(i) / 7.0;",
2928 " vec2 uv = v_texCoord + toCenter * t * u_amount;",
2929 " c += texture2D(u_texture, uv);",
2930 " }",
2931 " gl_FragColor = c / 8.0;",
2932 "}"
2933 ].join("\n");
2934
2935 Shader.Builtin.COLOR_ADJUST_FRAG = [
2936 "precision mediump float;",
2937 "uniform sampler2D u_texture;",
2938 "uniform float u_saturation;",
2939 "uniform float u_contrast;",
2940 "uniform float u_brightness;",
2941 "varying vec2 v_texCoord;",
2942 "void main() {",
2943 " vec4 color = texture2D(u_texture, v_texCoord);",
2944 " float lum = dot(color.rgb, vec3(0.299, 0.587, 0.114));",
2945 " vec3 rgb = mix(vec3(lum), color.rgb, u_saturation);",
2946 " rgb = (rgb - 0.5) * u_contrast + 0.5 + u_brightness;",
2947 " gl_FragColor = vec4(rgb, color.a);",
2948 "}"
2949 ].join("\n");
2950
2951 Shader.getDirectionalBlurPostChain = function (options)
2952 {
2953 options = options || {};
2954 const direction = options.direction || [1, 0];
2955 const length = options.length != null ? options.length : 8;
2956
2957 if (!Shader._directionalBlur)
2958 { Shader._directionalBlur = Shader.screenFragment(Shader.Builtin.DIRECTIONAL_BLUR_FRAG); }
2959
2960 return [{
2961 shader: Shader._directionalBlur,
2962 uniforms: {
2963 u_direction: [direction[0], direction[1]],
2964 u_length: length
2965 }
2966 }];
2967 };
2968
2969 Shader.getRadialBlurPostChain = function (options)
2970 {
2971 options = options || {};
2972 const amount = options.amount != null ? options.amount : 0.15;
2973 const center = options.center || [0.5, 0.5];
2974
2975 if (!Shader._radialBlur)
2976 { Shader._radialBlur = Shader.screenFragment(Shader.Builtin.RADIAL_BLUR_FRAG); }
2977
2978 return [{
2979 shader: Shader._radialBlur,
2980 uniforms: {
2981 u_amount: amount,
2982 u_center: [center[0], center[1]]
2983 }
2984 }];
2985 };
2986
2987 Shader.getColorAdjustPostChain = function (options)
2988 {
2989 options = options || {};
2990 const saturation = options.saturation != null ? options.saturation : 1.0;
2991 const contrast = options.contrast != null ? options.contrast : 1.0;
2992 const brightness = options.brightness != null ? options.brightness : 0.0;
2993
2994 if (!Shader._colorAdjust)
2995 { Shader._colorAdjust = Shader.screenFragment(Shader.Builtin.COLOR_ADJUST_FRAG); }
2996
2997 return [{
2998 shader: Shader._colorAdjust,
2999 uniforms: {
3000 u_saturation: saturation,
3001 u_contrast: contrast,
3002 u_brightness: brightness
3003 }
3004 }];
3005 };
3006
3007 /*
3008 * End File:
3009 * framework/engine/gl/builtinShaders.js
3010 */
3011
3012 /*
3013 * Start File:
3014 * framework/engine/gl/glContext.js
3015 */
3016 class GLContext
3017 {
3018 static MAX_LIGHTS = 16;
3019
3020 constructor (canvas)
3021 {
3022 this.canvas = canvas;
3023
3024 // 2D sprites do not benefit from MSAA; disabling avoids extra GPU cost.
3025 const attrs = { alpha: true, premultipliedAlpha: false, antialias: false };
3026 this.gl = canvas.getContext("webgl", attrs) || canvas.getContext("experimental-webgl", attrs);
3027
3028 if (!this.gl)
3029 { throw new Error("WebGL is not supported in this browser."); }
3030
3031 const gl = this.gl;
3032 gl.enable(gl.BLEND);
3033 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3034 gl.disable(gl.DEPTH_TEST);
3035 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
3036
3037 this.defaultShader = new Shader(Shader.DEFAULT_VERT, Shader.DEFAULT_FRAG);
3038 this.screenCopyShader = new Shader(Shader.SCREEN_VERT, Shader.SCREEN_COPY_FRAG);
3039 this.textures = new WeakMap();
3040 // Defaults for getTexture uploads. Games can switch to NEAREST for pixel art.
3041 this.textureMinFilter = gl.LINEAR;
3042 this.textureMagFilter = gl.LINEAR;
3043
3044 // Reused per-sprite uploads (avoid allocating Float32Array every draw).
3045 this._uvData = new Float32Array(8);
3046 this._matrixData = new Float32Array(16);
3047
3048 this.positionBuffer = gl.createBuffer();
3049 gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);
3050 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
3051 -0.5, -0.5,
3052 0.5, -0.5,
3053 -0.5, 0.5,
3054 0.5, 0.5
3055 ]), gl.STATIC_DRAW);
3056
3057 this.texCoordBuffer = gl.createBuffer();
3058 gl.bindBuffer(gl.ARRAY_BUFFER, this.texCoordBuffer);
3059 gl.bufferData(gl.ARRAY_BUFFER, this._uvData, gl.DYNAMIC_DRAW);
3060
3061 // Fullscreen NDC quad (triangle strip) + UVs (v=0 at bottom, matches FBO sampling).
3062 this.screenPositionBuffer = gl.createBuffer();
3063 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenPositionBuffer);
3064 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
3065 -1, -1,
3066 1, -1,
3067 -1, 1,
3068 1, 1
3069 ]), gl.STATIC_DRAW);
3070
3071 this.screenTexCoordBuffer = gl.createBuffer();
3072 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenTexCoordBuffer);
3073 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
3074 0, 0,
3075 1, 0,
3076 0, 1,
3077 1, 1
3078 ]), gl.STATIC_DRAW);
3079
3080 // [0] = scene (stable during post), [1]/[2] = full-res ping-pong,
3081 // [3]/[4] = half-res ping-pong for pass.scale < 1 blur.
3082 this.framebuffers = [null, null, null, null, null];
3083 this.colorTextures = [null, null, null, null, null];
3084 this._offscreenIndex = 0;
3085 this._lastWidth = 0;
3086 this._lastHeight = 0;
3087 this._halfWidth = 0;
3088 this._halfHeight = 0;
3089 this._postUniforms = {};
3090 this._resUniform = [0, 0];
3091 this.setSize(canvas.width, canvas.height);
3092 }
3093
3094 setSize (width, height)
3095 {
3096 const gl = this.gl;
3097 width = Math.max(1, width | 0);
3098 height = Math.max(1, height | 0);
3099
3100 if (width !== this._lastWidth || height !== this._lastHeight)
3101 {
3102 this._lastWidth = width;
3103 this._lastHeight = height;
3104 this._halfWidth = Math.max(1, width >> 1);
3105 this._halfHeight = Math.max(1, height >> 1);
3106 gl.viewport(0, 0, width, height);
3107 this._rebuildFramebuffers(width, height);
3108 }
3109 }
3110
3111 _destroyFramebuffers ()
3112 {
3113 const gl = this.gl;
3114 for (let i = 0; i < this.framebuffers.length; i++)
3115 {
3116 if (this.framebuffers[i])
3117 {
3118 gl.deleteFramebuffer(this.framebuffers[i]);
3119 this.framebuffers[i] = null;
3120 }
3121
3122 if (this.colorTextures[i])
3123 {
3124 gl.deleteTexture(this.colorTextures[i]);
3125 this.colorTextures[i] = null;
3126 }
3127 }
3128 }
3129
3130 _rebuildFramebuffers (width, height)
3131 {
3132 const gl = this.gl;
3133 this._destroyFramebuffers();
3134
3135 this._halfWidth = Math.max(1, width >> 1);
3136 this._halfHeight = Math.max(1, height >> 1);
3137
3138 for (let i = 0; i < 5; i++)
3139 {
3140 const texW = i < 3 ? width : this._halfWidth;
3141 const texH = i < 3 ? height : this._halfHeight;
3142
3143 const texture = gl.createTexture();
3144 gl.bindTexture(gl.TEXTURE_2D, texture);
3145 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
3146 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
3147 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
3148 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
3149 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texW, texH, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
3150
3151 const fb = gl.createFramebuffer();
3152 gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
3153 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
3154
3155 const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
3156 if (status !== gl.FRAMEBUFFER_COMPLETE)
3157 {
3158 console.error("Framebuffer incomplete:", status);
3159 }
3160
3161 this.framebuffers[i] = fb;
3162 this.colorTextures[i] = texture;
3163 }
3164
3165 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3166 gl.bindTexture(gl.TEXTURE_2D, null);
3167 }
3168
3169 clear (r, g, b, a = 1)
3170 {
3171 const gl = this.gl;
3172 gl.clearColor(r / 255, g / 255, b / 255, a);
3173 gl.clear(gl.COLOR_BUFFER_BIT);
3174 }
3175
3176 clearTransparent ()
3177 {
3178 const gl = this.gl;
3179 gl.clearColor(0, 0, 0, 0);
3180 gl.clear(gl.COLOR_BUFFER_BIT);
3181 }
3182
3183 beginOffscreenPass ()
3184 {
3185 const gl = this.gl;
3186 this._offscreenIndex = 0;
3187 gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffers[0]);
3188 gl.viewport(0, 0, this._lastWidth, this._lastHeight);
3189 gl.enable(gl.BLEND);
3190 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3191 }
3192
3193 endOffscreenPass ()
3194 {
3195 const gl = this.gl;
3196 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3197 }
3198
3199 /**
3200 * @param {Array} passes
3201 * @param {Object} builtins
3202 * @param {{ toCanvas?: boolean }} options - toCanvas true writes the last pass to the canvas.
3203 * @returns {WebGLTexture|null} final color texture when not drawing to canvas
3204 */
3205 applyPostShaders (passes, builtins = {}, options = {})
3206 {
3207 if (!passes || !passes.length)
3208 { return this.colorTextures[0]; }
3209
3210 const gl = this.gl;
3211 const toCanvas = !!options.toCanvas;
3212 const sceneTexture = this.colorTextures[0];
3213 let read = 0;
3214 let readIsHalf = false;
3215
3216 gl.disable(gl.BLEND);
3217
3218 for (let i = 0; i < passes.length; i++)
3219 {
3220 const pass = passes[i];
3221 const isLast = i === passes.length - 1;
3222 const wantHalf = pass.scale != null && pass.scale < 1;
3223
3224 let write;
3225 let writeW;
3226 let writeH;
3227
3228 if (wantHalf)
3229 {
3230 // Half-res ping-pong on indices 3/4.
3231 if (readIsHalf)
3232 { write = (read === 3) ? 4 : 3; }
3233 else
3234 { write = 3; }
3235
3236 writeW = this._halfWidth;
3237 writeH = this._halfHeight;
3238 }
3239 else
3240 {
3241 // Full-res ping-pong on 1/2 (never overwrite scene buffer 0).
3242 // When leaving half-res, read half texture into a full write target.
3243 if (read === 1)
3244 { write = 2; }
3245 else if (read === 2)
3246 { write = 1; }
3247 else
3248 { write = 1; }
3249
3250 writeW = this._lastWidth;
3251 writeH = this._lastHeight;
3252 }
3253
3254 if (isLast && toCanvas)
3255 {
3256 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3257 writeW = this._lastWidth;
3258 writeH = this._lastHeight;
3259 }
3260 else
3261 {
3262 gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffers[write]);
3263 }
3264
3265 gl.viewport(0, 0, writeW, writeH);
3266 gl.clearColor(0, 0, 0, 0);
3267 gl.clear(gl.COLOR_BUFFER_BIT);
3268
3269 const uniforms = this._postUniforms;
3270 for (const key in uniforms)
3271 {
3272 if (Object.prototype.hasOwnProperty.call(uniforms, key))
3273 { delete uniforms[key]; }
3274 }
3275 if (builtins)
3276 {
3277 for (const key in builtins)
3278 {
3279 if (Object.prototype.hasOwnProperty.call(builtins, key))
3280 { uniforms[key] = builtins[key]; }
3281 }
3282 }
3283 const passUniforms = pass.uniforms;
3284 if (passUniforms)
3285 {
3286 for (const key in passUniforms)
3287 {
3288 if (Object.prototype.hasOwnProperty.call(passUniforms, key))
3289 { uniforms[key] = passUniforms[key]; }
3290 }
3291 }
3292 this._resUniform[0] = writeW;
3293 this._resUniform[1] = writeH;
3294 uniforms.u_resolution = this._resUniform;
3295 this.drawFullscreen(pass.shader, this.colorTextures[read], uniforms, sceneTexture);
3296
3297 if (!isLast || !toCanvas)
3298 {
3299 read = write;
3300 readIsHalf = wantHalf && !(isLast && toCanvas);
3301 }
3302 }
3303
3304 this._offscreenIndex = read;
3305 gl.enable(gl.BLEND);
3306 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3307 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3308
3309 return toCanvas ? null : this.colorTextures[read];
3310 }
3311
3312 blitToCanvas (texture, composite = "alpha")
3313 {
3314 if (!texture)
3315 { return; }
3316
3317 const gl = this.gl;
3318 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3319 gl.viewport(0, 0, this._lastWidth, this._lastHeight);
3320 gl.enable(gl.BLEND);
3321
3322 if (composite === "add")
3323 { gl.blendFunc(gl.ONE, gl.ONE); }
3324 else
3325 { gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA); }
3326
3327 this.drawFullscreen(this.screenCopyShader, texture, null, null);
3328
3329 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3330 }
3331
3332 drawFullscreen (shader, texture, uniforms, sceneTexture)
3333 {
3334 const gl = this.gl;
3335 const info = shader.getProgramInfo(gl);
3336 if (!info || !texture)
3337 { return; }
3338
3339 gl.useProgram(info.program);
3340
3341 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenPositionBuffer);
3342 if (info.attribs.position >= 0)
3343 {
3344 gl.enableVertexAttribArray(info.attribs.position);
3345 gl.vertexAttribPointer(info.attribs.position, 2, gl.FLOAT, false, 0, 0);
3346 }
3347
3348 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenTexCoordBuffer);
3349 if (info.attribs.texCoord >= 0)
3350 {
3351 gl.enableVertexAttribArray(info.attribs.texCoord);
3352 gl.vertexAttribPointer(info.attribs.texCoord, 2, gl.FLOAT, false, 0, 0);
3353 }
3354
3355 gl.activeTexture(gl.TEXTURE0);
3356 gl.bindTexture(gl.TEXTURE_2D, texture);
3357 this._setUniform(info, "u_texture", 0);
3358 this._setUniform(info, "u_alpha", 1);
3359
3360 if (sceneTexture && info.uniforms.u_scene)
3361 {
3362 gl.activeTexture(gl.TEXTURE1);
3363 gl.bindTexture(gl.TEXTURE_2D, sceneTexture);
3364 this._setUniform(info, "u_scene", 1);
3365 }
3366
3367 if (uniforms)
3368 {
3369 for (const name in uniforms)
3370 {
3371 if (!Object.prototype.hasOwnProperty.call(uniforms, name))
3372 { continue; }
3373
3374 this._setUniform(info, name, uniforms[name]);
3375 }
3376 }
3377
3378 gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
3379 }
3380
3381 /**
3382 * Default min/mag filter applied when creating textures in {@link getTexture}.
3383 * Does not rewrite textures that were already uploaded.
3384 */
3385 setDefaultTextureFilter (minFilter, magFilter)
3386 {
3387 const gl = this.gl;
3388 this.textureMinFilter = minFilter ?? gl.LINEAR;
3389 this.textureMagFilter = magFilter ?? gl.LINEAR;
3390 }
3391
3392 getTexture (htmlImage)
3393 {
3394 if (!htmlImage)
3395 { return null; }
3396
3397 let texture = this.textures.get(htmlImage);
3398 if (texture)
3399 { return texture; }
3400
3401 const gl = this.gl;
3402 texture = gl.createTexture();
3403 gl.bindTexture(gl.TEXTURE_2D, texture);
3404 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
3405 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
3406 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.textureMinFilter);
3407 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.textureMagFilter);
3408 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, htmlImage);
3409
3410 this.textures.set(htmlImage, texture);
3411 return texture;
3412 }
3413
3414 drawSprite (options)
3415 {
3416 const gl = this.gl;
3417 const width = this._lastWidth;
3418 const height = this._lastHeight;
3419 if (width <= 0 || height <= 0)
3420 { return; }
3421
3422 const shader = options.shader || this.defaultShader;
3423 const info = shader.getProgramInfo(gl);
3424 if (!info)
3425 { return; }
3426
3427 const texture = options.texture;
3428 if (!texture)
3429 { return; }
3430
3431 gl.useProgram(info.program);
3432
3433 gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);
3434 if (info.attribs.position >= 0)
3435 {
3436 gl.enableVertexAttribArray(info.attribs.position);
3437 gl.vertexAttribPointer(info.attribs.position, 2, gl.FLOAT, false, 0, 0);
3438 }
3439
3440 const uv = options.uvRect || { u0: 0, v0: 0, u1: 1, v1: 1 };
3441 const uvData = this._uvData;
3442 uvData[0] = uv.u0; uvData[1] = uv.v0;
3443 uvData[2] = uv.u1; uvData[3] = uv.v0;
3444 uvData[4] = uv.u0; uvData[5] = uv.v1;
3445 uvData[6] = uv.u1; uvData[7] = uv.v1;
3446 gl.bindBuffer(gl.ARRAY_BUFFER, this.texCoordBuffer);
3447 gl.bufferSubData(gl.ARRAY_BUFFER, 0, uvData);
3448
3449 if (info.attribs.texCoord >= 0)
3450 {
3451 gl.enableVertexAttribArray(info.attribs.texCoord);
3452 gl.vertexAttribPointer(info.attribs.texCoord, 2, gl.FLOAT, false, 0, 0);
3453 }
3454
3455 const matrix = GLContext._buildSpriteMatrix(
3456 options.x, options.y,
3457 options.w, options.h,
3458 options.rotationDeg || 0,
3459 options.mirrorX, options.mirrorY,
3460 width, height,
3461 this._matrixData
3462 );
3463
3464 this._setUniform(info, "u_matrix", matrix);
3465 this._setUniform(info, "u_alpha", options.alpha == null ? 1 : options.alpha);
3466 this._setUniform(info, "u_worldCenter", [options.x, options.y]);
3467 this._setUniform(info, "u_worldSize", [options.w, options.h]);
3468 this._setUniform(info, "u_rotationRad", (options.rotationDeg || 0) * Math.PI / 180);
3469
3470 gl.activeTexture(gl.TEXTURE0);
3471 gl.bindTexture(gl.TEXTURE_2D, texture);
3472 this._setUniform(info, "u_texture", 0);
3473
3474 let nextUnit = 1;
3475 if (options.textures)
3476 {
3477 for (const name in options.textures)
3478 {
3479 if (!Object.prototype.hasOwnProperty.call(options.textures, name))
3480 { continue; }
3481
3482 const extra = options.textures[name];
3483 if (!extra)
3484 { continue; }
3485
3486 gl.activeTexture(gl.TEXTURE0 + nextUnit);
3487 gl.bindTexture(gl.TEXTURE_2D, extra);
3488 this._setUniform(info, name, nextUnit);
3489 nextUnit++;
3490 }
3491 }
3492
3493 if (options.lights)
3494 { this._setLights(info, options.lights); }
3495 else if (info.uniforms.u_lightCount)
3496 { this._setUniform(info, "u_lightCount", 0); }
3497
3498 // Sensible bump defaults when the shader asks for them.
3499 if (info.uniforms.u_ambient && (!options.uniforms || options.uniforms.u_ambient == null))
3500 { this._setUniform(info, "u_ambient", 0.35); }
3501 if (info.uniforms.u_specular && (!options.uniforms || options.uniforms.u_specular == null))
3502 { this._setUniform(info, "u_specular", 0.25); }
3503 if (info.uniforms.u_bumpMode && (!options.uniforms || options.uniforms.u_bumpMode == null))
3504 { this._setUniform(info, "u_bumpMode", 1); }
3505
3506 if (options.uniforms)
3507 {
3508 for (const name in options.uniforms)
3509 {
3510 if (!Object.prototype.hasOwnProperty.call(options.uniforms, name))
3511 { continue; }
3512
3513 this._setUniform(info, name, options.uniforms[name]);
3514 }
3515 }
3516
3517 gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
3518 }
3519
3520 _setLights (info, lights)
3521 {
3522 const gl = this.gl;
3523 const max = GLContext.MAX_LIGHTS;
3524 const count = Math.max(0, Math.min(lights.length, max));
3525 this._setUniform(info, "u_lightCount", count);
3526
3527 const posEntry = info.uniforms["u_lightPos[0]"] || info.uniforms.u_lightPos;
3528 const colEntry = info.uniforms["u_lightColor[0]"] || info.uniforms.u_lightColor;
3529 if (!posEntry || !colEntry || count === 0)
3530 {
3531 if (count === 0)
3532 { this._setUniform(info, "u_lightCount", 0); }
3533 return;
3534 }
3535
3536 const pos = new Float32Array(max * 2);
3537 const col = new Float32Array(max * 3);
3538
3539 for (let i = 0; i < count; i++)
3540 {
3541 const light = lights[i] || {};
3542 pos[i * 2] = light.x != null ? light.x : (light.position ? light.position.x : 0);
3543 pos[i * 2 + 1] = light.y != null ? light.y : (light.position ? light.position.y : 0);
3544
3545 const c = light.color != null ? light.color : [1, 1, 1];
3546 if (Array.isArray(c))
3547 {
3548 col[i * 3] = c[0] != null ? c[0] : 0;
3549 col[i * 3 + 1] = c[1] != null ? c[1] : 0;
3550 col[i * 3 + 2] = c[2] != null ? c[2] : 0;
3551 }
3552 else
3553 {
3554 col[i * 3] = (c.r != null ? c.r : 1);
3555 col[i * 3 + 1] = (c.g != null ? c.g : 1);
3556 col[i * 3 + 2] = (c.b != null ? c.b : 1);
3557 }
3558
3559 // Allow 0–255 style colors.
3560 if (col[i * 3] > 1 || col[i * 3 + 1] > 1 || col[i * 3 + 2] > 1)
3561 {
3562 col[i * 3] /= 255;
3563 col[i * 3 + 1] /= 255;
3564 col[i * 3 + 2] /= 255;
3565 }
3566 }
3567
3568 gl.uniform2fv(posEntry.location, pos);
3569 gl.uniform3fv(colEntry.location, col);
3570 }
3571
3572 _setUniform (info, name, value)
3573 {
3574 const entry = info.uniforms[name];
3575 if (!entry || entry.location == null)
3576 { return; }
3577
3578 const gl = this.gl;
3579 const loc = entry.location;
3580
3581 if (typeof value === "number")
3582 {
3583 if (entry.type === gl.INT || entry.type === gl.SAMPLER_2D)
3584 { gl.uniform1i(loc, value); }
3585 else
3586 { gl.uniform1f(loc, value); }
3587 return;
3588 }
3589
3590 if (value instanceof Float32Array)
3591 {
3592 if (value.length === 16)
3593 { gl.uniformMatrix4fv(loc, false, value); }
3594 else if (value.length === 9)
3595 { gl.uniformMatrix3fv(loc, false, value); }
3596 else if (value.length === 4)
3597 { gl.uniform4fv(loc, value); }
3598 else if (value.length === 3)
3599 { gl.uniform3fv(loc, value); }
3600 else if (value.length === 2)
3601 { gl.uniform2fv(loc, value); }
3602 return;
3603 }
3604
3605 if (Array.isArray(value))
3606 {
3607 if (value.length === 4)
3608 { gl.uniform4fv(loc, value); }
3609 else if (value.length === 3)
3610 { gl.uniform3fv(loc, value); }
3611 else if (value.length === 2)
3612 { gl.uniform2fv(loc, value); }
3613 else if (value.length === 1)
3614 { gl.uniform1f(loc, value[0]); }
3615 }
3616 }
3617
3618 // Column-major mat4: projection (canvas Y-down) * T * R * S
3619 static _buildSpriteMatrix (x, y, w, h, rotationDeg, mirrorX, mirrorY, canvasW, canvasH, out)
3620 {
3621 const sx = (mirrorX ? -1 : 1) * w;
3622 const sy = (mirrorY ? -1 : 1) * h;
3623 const rad = rotationDeg * Math.PI / 180;
3624 const c = Math.cos(rad);
3625 const s = Math.sin(rad);
3626
3627 // Model maps unit quad [-0.5,0.5] into pixel space.
3628 const m00 = c * sx;
3629 const m01 = -s * sy;
3630 const m10 = s * sx;
3631 const m11 = c * sy;
3632 const m30 = x;
3633 const m31 = y;
3634
3635 const pr0 = 2 / canvasW;
3636 const pr5 = -2 / canvasH;
3637 const pr12 = -1;
3638 const pr13 = 1;
3639
3640 const matrix = out || new Float32Array(16);
3641 // P * M (only 2D affine terms matter)
3642 matrix[0] = pr0 * m00;
3643 matrix[1] = pr5 * m10;
3644 matrix[2] = 0;
3645 matrix[3] = 0;
3646 matrix[4] = pr0 * m01;
3647 matrix[5] = pr5 * m11;
3648 matrix[6] = 0;
3649 matrix[7] = 0;
3650 matrix[8] = 0;
3651 matrix[9] = 0;
3652 matrix[10] = -1;
3653 matrix[11] = 0;
3654 matrix[12] = pr0 * m30 + pr12;
3655 matrix[13] = pr5 * m31 + pr13;
3656 matrix[14] = 0;
3657 matrix[15] = 1;
3658 return matrix;
3659 }
3660 }
3661
3662 /*
3663 * End File:
3664 * framework/engine/gl/glContext.js
3665 */
3666
3667 /*
3668 * Start File:
3669 * framework/engine/renderLayer.js
3670 */
3671 class RenderLayer
3672 {
3673 static DEFAULT_NAME = "default";
3674
3675 constructor (name, options)
3676 {
3677 options = options || {};
3678 this.name = name || RenderLayer.DEFAULT_NAME;
3679 this.postShaders = options.postShaders || [];
3680 // "alpha" (source-over) or "add" (additive)
3681 this.composite = options.composite || "alpha";
3682 }
3683 }
3684
3685 /*
3686 * End File:
3687 * framework/engine/renderLayer.js
3688 */
3689
3690 /*
3691 * Start File:
3692 * framework/engine/objectComponents/transform.js
3693 */
3694 class Transform
3695 {
3696 get position ()
3697 {
3698 if (!this.g_position)
3699 {this.g_position = new vector(0, 0);}
3700
3701 return this.g_position;
3702 }
3703
3704 set position (v)
3705 {
3706 if (!this.g_position)
3707 {this.g_position = new vector(v.x, v.y);}
3708
3709 this.g_position.x = v.x;
3710 this.g_position.y = v.y;
3711 }
3712
3713 get scale ()
3714 {
3715 if (!this.g_scale)
3716 {this.g_scale = new vector(0, 0);}
3717
3718 return this.g_scale;
3719 }
3720
3721 set scale (v)
3722 {
3723 if (!this.g_scale)
3724 {this.g_scale = new vector(v.x, v.y);}
3725
3726 this.g_scale.x = v.x;
3727 this.g_scale.y = v.y;
3728 }
3729
3730 get velocity ()
3731 {
3732 if (!this.g_velocity)
3733 {this.g_velocity = new vector(0, 0);}
3734
3735 return this.g_velocity;
3736 }
3737
3738 set velocity (v)
3739 {
3740 if (!this.g_velocity)
3741 {this.g_velocity = new vector(v.x, v.y);}
3742
3743 this.g_velocity.x = v.x;
3744 this.g_velocity.y = v.y;
3745 }
3746
3747 g_position = null;
3748
3749 g_scale = null;
3750 rotation = 0;
3751 gameObject = null;
3752
3753 g_velocity = null;
3754 angularVelocity = 0;
3755
3756 get size ()
3757 {
3758 const sprite = this.gameObject.renderer && this.gameObject.renderer.sprite;
3759 const width = sprite ? sprite.width : 0;
3760 const height = sprite ? sprite.height : 0;
3761
3762 if (!this.g_size)
3763 { this.g_size = new vector(0, 0); }
3764
3765 this.g_size.x = this.scale.x * width;
3766 this.g_size.y = this.scale.y * height;
3767 return this.g_size;
3768 }
3769
3770 set size (v)
3771 {
3772 const sprite = this.gameObject.renderer && this.gameObject.renderer.sprite;
3773 const width = sprite && sprite.width ? sprite.width : 1;
3774 const height = sprite && sprite.height ? sprite.height : 1;
3775
3776 this.scale.x = v.x / width;
3777 this.scale.y = v.y / height;
3778 }
3779
3780 constructor (gameObject, x, y, w, h, r)
3781 {
3782 this.gameObject = gameObject;
3783 this.position = new vector(x, y);
3784 this.scale = new vector(w, h);
3785 this.rotation = r;
3786
3787 this.velocity = new vector(0, 0);
3788 }
3789
3790 update (deltaTime)
3791 {
3792 const vel = this.velocity;
3793 if (vel.x !== 0 || vel.y !== 0)
3794 {
3795 this.position.x += vel.x * deltaTime;
3796 this.position.y += vel.y * deltaTime;
3797 }
3798
3799 if (this.angularVelocity !== 0)
3800 { this.rotation += this.angularVelocity * deltaTime; }
3801 }
3802
3803 pointTowards (point)
3804 {
3805 var delta = point.subtract(this.position);
3806
3807 this.rotation = delta.toAngle();
3808 }
3809
3810 get left ()
3811 {
3812 return this.g_dir(0);
3813 }
3814
3815 get right ()
3816 {
3817 return this.g_dir(180);
3818 }
3819
3820 get forward ()
3821 {
3822 return this.g_dir(90);
3823 }
3824
3825 get back ()
3826 {
3827 return this.g_dir(270);
3828 }
3829
3830 g_dir (offset)
3831 {
3832 var myAngleInRadians = (this.rotation + offset) * (Math.PI / 180);
3833
3834 return new vector(-Math.cos(myAngleInRadians), -Math.sin(myAngleInRadians));
3835 }
3836 }
3837 /*
3838 * End File:
3839 * framework/engine/objectComponents/transform.js
3840 */
3841
3842 /*
3843 * Start File:
3844 * framework/engine/objectComponents/collider.js
3845 */
3846 class Collider
3847 {
3848 gameObject = null;
3849 enabled = false;
3850
3851 constructor (gameObject)
3852 {
3853 this.gameObject = gameObject;
3854 }
3855
3856 get widestDiagonal ()
3857 {
3858 return Math.sqrt((this.gameObject.transform.size.x * this.gameObject.transform.size.x) + (this.gameObject.transform.size.y * this.gameObject.transform.size.y));
3859 }
3860
3861 update (deltaTime)
3862 {
3863 if (this.enabled)
3864 {
3865 this.checkCollisions();
3866 }
3867
3868 // Bullets/FX have no click handlers — skip per-object mouse work entirely.
3869 const obj = this.gameObject;
3870 if (!obj.onClick && !obj.onMouseHeld)
3871 { return; }
3872
3873 const pressed = GameInput.mousePressed();
3874 const held = GameInput.mouseHeld();
3875
3876 if (pressed.left || pressed.middle || pressed.right)
3877 {
3878 this.checkClick(true, pressed);
3879 }
3880
3881 if (held.left || held.middle || held.right)
3882 {
3883 this.checkClick(false, held);
3884 }
3885 }
3886
3887 checkClick (thisFrame, btns)
3888 {
3889 if (!GameInput.mousePosition || !this.gameObject.scene)
3890 { return; }
3891
3892 var hit = false;
3893 var clickPos = GameInput.mousePosition
3894 .subtract(this.gameObject.scene.real_position)
3895 .subtract(this.gameObject.scene.cameraPosition);
3896
3897 var hw = this.gameObject.transform.size.x / 2;
3898 var hh = this.gameObject.transform.size.y / 2;
3899
3900 if (clickPos.x > this.gameObject.transform.position.x - hw && clickPos.x < this.gameObject.transform.position.x + hw)
3901 {
3902 if (clickPos.y > this.gameObject.transform.position.y - hh && clickPos.y < this.gameObject.transform.position.y + hh)
3903 {
3904 hit = true;
3905 }
3906 }
3907
3908 if (hit)
3909 {
3910 if (thisFrame)
3911 {
3912 this.gameObject.onClick && this.gameObject.onClick(btns);
3913 }
3914 else
3915 {
3916 this.gameObject.onMouseHeld && this.gameObject.onMouseHeld(btns);
3917 }
3918 }
3919 }
3920
3921 isInBounds (point)
3922 {
3923 var hw = this.gameObject.transform.size.x / 2;
3924 var hh = this.gameObject.transform.size.y / 2;
3925
3926 if (point.x > this.gameObject.transform.position.x - hw && point.x < this.gameObject.transform.position.x + hw)
3927 {
3928 if (point.y > this.gameObject.transform.position.y - hh && point.y < this.gameObject.transform.position.y + hh)
3929 {
3930 return true;
3931 }
3932 }
3933
3934 return false;
3935 }
3936
3937 checkCollisions ()
3938 {
3939 if (this.enabled && !this.gameObject.destroyed)
3940 {
3941 const activeObjects = this.gameObject.scene.activeObjects;
3942 const offset = activeObjects.indexOf(this.gameObject) + 1;
3943
3944 for (var i = offset; i < activeObjects.length; i++)
3945 {
3946 var o2 = activeObjects[i];
3947 if (o2 === this.gameObject || !o2.collider.enabled || o2.destroyed)
3948 { continue; }
3949
3950 if (this.widestDiagonal + o2.collider.widestDiagonal < this.gameObject.transform.position.distanceTo(o2.transform.position))
3951 { continue; }
3952
3953 var hit = false;
3954
3955 //hw = halfWidth, hh = halfHeight
3956 var hw = this.gameObject.transform.size.x / 2;
3957 var hh = this.gameObject.transform.size.y / 2;
3958
3959 var ohw = o2.transform.size.x / 2;
3960 var ohh = o2.transform.size.y / 2;
3961
3962 //CHECK FROM OBJ PERSPECTIVE
3963 var points =
3964 [
3965 this.gameObject.transform.position.x - hw,
3966 this.gameObject.transform.position.x + hw,
3967 this.gameObject.transform.position.y - hh,
3968 this.gameObject.transform.position.y + hh
3969 ];
3970
3971 if (points[1] >= o2.transform.position.x - ohw && points[0] <= o2.transform.position.x + ohw)
3972 {
3973 if (points[3] >= o2.transform.position.y - ohh && points[2] <= o2.transform.position.y + ohh)
3974 {
3975 hit = true;
3976 }
3977 }
3978
3979 if (hit)
3980 {
3981 if (!this.gameObject.destroyed && typeof this.gameObject.onCollision == 'function')
3982 { this.gameObject.onCollision(o2); }
3983
3984 if (!o2.destroyed && typeof o2.onCollision == 'function')
3985 { o2.onCollision(this.gameObject); }
3986 }
3987 }
3988 }
3989 }
3990 }
3991 /*
3992 * End File:
3993 * framework/engine/objectComponents/collider.js
3994 */
3995
3996 /*
3997 * Start File:
3998 * framework/engine/objectComponents/renderer.js
3999 */
4000 class Renderer
4001 {
4002 sprite = null;
4003 gameObject = null;
4004 subImage = 0;
4005 alpha = 1;
4006 mirrorX = false;
4007 mirrorY = false;
4008
4009 defaultAnimationSpeed = 1;
4010
4011 cycle = null;
4012
4013 visible = true;
4014
4015 shader = null;
4016 shaderUniforms = null;
4017
4018 // Optional maps for builtin sprite effects (framework `image` instances).
4019 bumpMap = null;
4020 secondaryMap = null;
4021
4022 // Dynamic lights for bumpmap: [{ x, y, color: [r,g,b]|{r,g,b} }, ...]
4023 lights = null;
4024
4025 // RenderLayer name; null uses RenderLayer.DEFAULT_NAME ("default").
4026 layer = null;
4027
4028 constructor (parentObject, sprite)
4029 {
4030 this.gameObject = parentObject;
4031 this.sprite = sprite;
4032 this.shader = null;
4033 this.shaderUniforms = null;
4034 this.bumpMap = null;
4035 this.secondaryMap = null;
4036 this.lights = null;
4037 this.layer = null;
4038 }
4039
4040 get layerName ()
4041 {
4042 return this.layer || RenderLayer.DEFAULT_NAME;
4043 }
4044
4045 update (deltaTime)
4046 {
4047 if (this.cycle)
4048 {
4049 if (!this.cycle.cycleSpeed || this.cycle.cycleSpeed == -1)
4050 {
4051 this.subImage = this.cycle.cycleArray[this.cycle.default];
4052 this.cycle.current = this.cycle.default;
4053 return;
4054 }
4055 this.cycle.timer += deltaTime;
4056
4057 if (this.cycle.timer > this.cycle.cycleSpeed)
4058 {
4059 this.cycle.timer -= this.cycle.cycleSpeed;
4060 let next;
4061
4062 if (this.cycle.loop)
4063 {
4064 next = (this.cycle.current + 1) % this.cycle.cycleArray.length;
4065 }
4066 else
4067 {
4068 if (this.cycle.current + 1 >= this.cycle.cycleArray.length)
4069 {
4070 if (this.cycle.chain)
4071 {
4072 this.cycle.chainDefaultIndex = this.cycle.chainDefaultIndex || this.cycle.default;
4073 this.cycle.chainSpeed = this.cycle.chainSpeed || this.cycle.cycleSpeed;
4074 this.setAnimation(this.cycle.chain, this.cycle.chainDefaultIndex, this.cycle.chainSpeed);
4075 }
4076
4077 return;
4078 }
4079 else
4080 {
4081 next = this.cycle.current + 1;
4082 }
4083 }
4084
4085 this.updateCycleSprite(next);
4086 }
4087 }
4088 }
4089
4090 updateCycleSprite (index)
4091 {
4092 this.subImage = this.cycle.cycleArray[index];
4093 this.cycle.current = index;
4094 }
4095
4096 draw ()
4097 {
4098 if (this.sprite)
4099 {
4100 var offX = this.gameObject.scene.cameraPosition.x;
4101 var offY = this.gameObject.scene.cameraPosition.y;
4102
4103 this.drawSprite(this.gameObject.transform.position.x + offX,
4104 this.gameObject.transform.position.y + offY,
4105 this.gameObject.transform.size.x,
4106 this.gameObject.transform.size.y,
4107 this.gameObject.transform.rotation);
4108 }
4109 }
4110
4111 drawSprite (dx, dy, dw, dh, rotation)
4112 {
4113 if (isNaN(this.subImage))
4114 {
4115 this.subImage = this.g_subImgOld;
4116 }
4117 else
4118 {
4119 this.g_subImgOld = this.subImage;
4120 }
4121
4122 let textures = null;
4123 if (this.bumpMap || this.secondaryMap)
4124 {
4125 textures = {};
4126 if (this.bumpMap)
4127 { textures.u_bump = this.bumpMap; }
4128 if (this.secondaryMap)
4129 { textures.u_secondary = this.secondaryMap; }
4130 }
4131
4132 this.sprite.draw(
4133 this.gameObject.scene,
4134 Math.round(dx),
4135 Math.round(dy),
4136 dw,
4137 dh,
4138 rotation,
4139 this.mirrorX,
4140 this.mirrorY,
4141 this.alpha,
4142 this.subImage,
4143 this.shader,
4144 this.shaderUniforms,
4145 textures,
4146 this.lights
4147 );
4148 }
4149
4150 get currentAnimationName ()
4151 {
4152 return this.cycle ? this.cycle.label : null;
4153 }
4154
4155 setAnimation (label, defaultIndex = 0, cycleSpeed = -1)
4156 {
4157 if (cycleSpeed < 0)
4158 {
4159 cycleSpeed = this.defaultAnimationSpeed;
4160 }
4161
4162 if (!this.sprite || !this.sprite.animationCycles || !this.sprite.animationCycles[label])
4163 {
4164 console.warn("Renderer.setAnimation: unknown animation '" + label + "'");
4165 return;
4166 }
4167
4168 if (this.cycle)
4169 {
4170 if (this.cycle.label == label)
4171 {
4172 this.cycle.default = defaultIndex;
4173 this.cycle.cycleSpeed = cycleSpeed;
4174 return;
4175 }
4176 }
4177
4178 const cycleData = this.sprite.animationCycles[label];
4179
4180 this.cycle = {
4181 label: label,
4182 cycleArray: cycleData.frames,
4183 default: defaultIndex,
4184 current: defaultIndex,
4185 cycleSpeed: cycleSpeed,
4186 loop: cycleData.loop,
4187 chain: cycleData.chain,
4188 chainDefaultIndex: cycleData.chainDefaultIndex,
4189 chainSpeed: cycleData.chainSpeed,
4190 timer: 0
4191 };
4192
4193 this.subImage = this.cycle.cycleArray[this.cycle.current];
4194 }
4195
4196 setAnimationCycleSpeed (cycleSpeed)
4197 {
4198 if (this.cycle)
4199 {
4200 this.cycle.cycleSpeed = cycleSpeed;
4201 }
4202 }
4203
4204 setSubImage (subImage)
4205 {
4206 this.subImage = subImage;
4207 this.cycle = null;
4208 }
4209 }
4210 /*
4211 * End File:
4212 * framework/engine/objectComponents/renderer.js
4213 */
4214
4215 /*
4216 * Start File:
4217 * framework/engine/image.js
4218 */
4219 class image
4220 {
4221 subImages = null;
4222 subImagesPerRow = null;
4223 loop = false;
4224 chain = null;
4225
4226 g_image = null;
4227
4228 animationCycles = {};
4229
4230 constructor (image, subImgTotal = 1, perRow = 1, loop = false, chain = null)
4231 {
4232 subImgTotal = subImgTotal || 1;
4233 perRow = perRow || 1;
4234
4235 this.subImages = subImgTotal;
4236 this.subImagesPerRow = perRow;
4237 this.g_image = image;
4238 this.loop = loop;
4239 this.chain = chain;
4240
4241 this.cacheWidth = -1;
4242 this.cacheHeight = -1;
4243
4244 // Keep the Image out of the DOM — canvas can draw from it directly.
4245 if (image && image.style)
4246 { image.style.display = "none"; }
4247 }
4248
4249 draw (scene, dx, dy, dw, dh, rotation, mirrorX, mirrorY, alpha, subImage, shader, uniforms, textures, lights)
4250 {
4251 if (!scene.glContext || !this.g_image)
4252 { return; }
4253
4254 // One hypot for frustum pad (was computed 4× per sprite).
4255 const pad = Math.sqrt(dw * dw + dh * dh);
4256 if (dx < -pad || dy < -pad || dx > scene.real_size.x + pad || dy > scene.real_size.y + pad)
4257 { return; }
4258
4259 let glTextures = null;
4260
4261 if (textures)
4262 {
4263 for (const name in textures)
4264 {
4265 if (!Object.prototype.hasOwnProperty.call(textures, name))
4266 { continue; }
4267
4268 const src = textures[name];
4269 if (!src)
4270 { continue; }
4271
4272 if (!glTextures)
4273 { glTextures = {}; }
4274
4275 const htmlImage = src.g_image || src;
4276 glTextures[name] = scene.glContext.getTexture(htmlImage);
4277 }
4278 }
4279
4280 const opts = this._drawOpts || (this._drawOpts = {});
4281 opts.texture = scene.glContext.getTexture(this.g_image);
4282 opts.x = dx;
4283 opts.y = dy;
4284 opts.w = dw;
4285 opts.h = dh;
4286 opts.rotationDeg = rotation;
4287 opts.mirrorX = mirrorX;
4288 opts.mirrorY = mirrorY;
4289 opts.alpha = alpha;
4290 opts.uvRect = this.getUvRect(subImage);
4291 opts.shader = shader || scene.glContext.defaultShader;
4292 opts.uniforms = uniforms;
4293 opts.textures = glTextures;
4294 opts.lights = lights;
4295 scene.glContext.drawSprite(opts);
4296 }
4297
4298 getUvRect (subImage)
4299 {
4300 if (!this._uvRects)
4301 { this._uvRects = []; }
4302
4303 const index = subImage | 0;
4304 let rect = this._uvRects[index];
4305 if (rect)
4306 { return rect; }
4307
4308 const subImageData = this.getSubImage(index);
4309 const imgW = this.g_image.width;
4310 const imgH = this.g_image.height;
4311 rect = {
4312 u0: subImageData.sx / imgW,
4313 v0: subImageData.sy / imgH,
4314 u1: (subImageData.sx + subImageData.sw) / imgW,
4315 v1: (subImageData.sy + subImageData.sh) / imgH
4316 };
4317 this._uvRects[index] = rect;
4318 return rect;
4319 }
4320
4321 hasAnimationCycle (label)
4322 {
4323 return this.animationCycles[label] != null;
4324 }
4325
4326 addAnimationCycle (label, cycle, loop, chain, chainDefaultIndex, chainSpeed)
4327 {
4328 this.animationCycles[label] =
4329 {
4330 frames: cycle,
4331 loop: loop,
4332 chain: chain,
4333 chainDefaultIndex: chainDefaultIndex,
4334 chainSpeed: chainSpeed
4335 };
4336 }
4337
4338 get width ()
4339 {
4340 if (this.cacheWidth < 0)
4341 { this.cacheWidth = this.g_image.width / this.subImagesPerRow; }
4342
4343 return this.cacheWidth;
4344 }
4345
4346 get height ()
4347 {
4348 if (this.cacheHeight < 0)
4349 { this.cacheHeight = this.g_image.height / (Math.ceil(this.subImages / this.subImagesPerRow) + 0); }
4350
4351 return this.cacheHeight;
4352 }
4353
4354 cacheWidth = -1;
4355 cacheHeight = -1;
4356
4357 getSubImage (subImageIndex)
4358 {
4359 var subImage = Math.round(subImageIndex);
4360 subImage %= this.subImages;
4361
4362 var c = subImage % this.subImagesPerRow;
4363 var r = Math.floor(subImage / this.subImagesPerRow);
4364 var sw = (this.g_image.width / this.subImagesPerRow);
4365 var sh = (this.g_image.height / Math.ceil(this.subImages / this.subImagesPerRow));
4366 var sx = sw * c;
4367 var sy = sh * r;
4368
4369 return { sw: sw, sh: sh, sx: sx, sy: sy };
4370 }
4371 }
4372
4373 /*
4374 * End File:
4375 * framework/engine/image.js
4376 */
4377
4378 /*
4379 * Start File:
4380 * framework/engine/gameobject.js
4381 */
4382 class GameObject
4383 {
4384 transform = null;
4385 renderer = null;
4386 collider = null;
4387 scene = null;
4388 _layer = 0;
4389 tags = [];
4390
4391 destroyed = false;
4392
4393 constructor (x, y, sprite, layer = 0)
4394 {
4395 this.transform = new Transform(this, x, y, 1, 1, 0);
4396 this.renderer = new Renderer(this, sprite);
4397 this.collider = new Collider(this);
4398 this._layer = layer;
4399 }
4400
4401 get layer ()
4402 {
4403 return this._layer;
4404 }
4405
4406 set layer (value)
4407 {
4408 if (this._layer === value)
4409 { return; }
4410 this._layer = value;
4411 if (this.scene)
4412 { this.scene.objectLayerChanged(this); }
4413 }
4414
4415 initQuadtree (quadTree)
4416 {
4417 this.quadTree = quadTree;
4418 }
4419
4420 checkQuadtree ()
4421 {
4422 if (!this.quadTree)
4423 { return; }
4424
4425 const x = this.transform.position.x;
4426 const y = this.transform.position.y;
4427 // Skip reinsert when the object has not moved since the last check.
4428 if (this.node && this._qtX === x && this._qtY === y)
4429 { return; }
4430 this._qtX = x;
4431 this._qtY = y;
4432
4433 if (this.node)
4434 {
4435 if (x < this.node.x1
4436 || x > this.node.x2
4437 || y < this.node.y1
4438 || y > this.node.y2)
4439 {
4440 this.quadTree.remove(this);
4441 this.quadTree.add(this);
4442 }
4443 }
4444 else
4445 {
4446 this.quadTree.add(this);
4447 }
4448 }
4449
4450 update (deltaTime)
4451 {
4452 if (this.destroyed)
4453 { return; }
4454
4455 this.transform.update(deltaTime);
4456 this.collider.update(deltaTime);
4457 this.renderer.update(deltaTime);
4458
4459 this.checkQuadtree();
4460 }
4461
4462 destroy ()
4463 {
4464 if (!this.destroyed)
4465 {
4466 this.onDestroy && this.onDestroy();
4467 this.quadTree && this.quadTree.remove(this);
4468 this.scene && this.scene.removeObject(this);
4469 this.destroyed = true;
4470 }
4471 }
4472
4473 draw ()
4474 {
4475 if (this.destroyed)
4476 { return; }
4477
4478 this.renderer.draw();
4479 }
4480 }
4481
4482 /*
4483 * End File:
4484 * framework/engine/gameobject.js
4485 */
4486
4487 /*
4488 * Start File:
4489 * framework/engine/scene.js
4490 */
4491 class Scene
4492 {
4493 static idCount = 0;
4494 id = null;
4495 activeObjects = [];
4496 position = null;
4497 size = null;
4498 real_position = null;
4499 px = 0; py = 0;
4500 real_size = null;
4501 cameraPosition = null;
4502 parentScene = null;
4503 renderBackground = true;
4504 quadTree = null;
4505
4506 pendingRemoval = [];
4507 _sortedActiveObjects = null;
4508 _sortDirty = true;
4509 /** Objects whose `layer` changed since the last draw-order rebuild. */
4510 _layerChanged = [];
4511 /**
4512 * If more than this many objects change layer between draws, fall back to a
4513 * full in-place sort (cheaper than many splice reinserts on large lists).
4514 */
4515 _layerChangeFullSortThreshold = 64;
4516 /** Reused per-draw-layer object lists (cleared + refilled each draw). */
4517 _byLayer = null;
4518 _byLayerNames = null;
4519
4520 g_primary = false;
4521
4522 static DisplayModes = { absolute: 0, relativeToParent: 1 };
4523
4524 displayMode = Scene.DisplayModes.absolute;
4525
4526 cv_canvas = null;
4527 glContext = null;
4528 destroyed = false;
4529
4530 // Legacy: posts applied to the "default" layer when that layer has none of its own.
4531 postShaders = [];
4532 postTime = 0;
4533
4534 // Ordered list of RenderLayer. Index 0 is drawn first (back).
4535 renderLayers = null;
4536
4537 game = null;
4538
4539 get primary ()
4540 {
4541 return this.g_primary;
4542 }
4543
4544 constructor (x, y, width, height, displayMode = 0)
4545 {
4546 Scene.idCount++;
4547 this.id = 'canvas_' + Scene.idCount;
4548
4549 this.position = new vector(x, y);
4550 this.size = new vector(width, height);
4551 this.real_position = new vector(x, y);
4552 this.real_size = new vector(width, height);
4553 this.cameraPosition = new vector(0, 0);
4554 this.displayMode = displayMode;
4555
4556
4557 const body = document.body;
4558
4559 body.insertAdjacentHTML('beforeend', '<canvas id="' + this.id + '" style="position: absolute; left: ' + x + 'px; top: ' + y + 'px;" width="' + width + '" height="' + height + '"></canvas>');
4560
4561 this.cv_canvas = document.getElementById(this.id);
4562 this.glContext = new GLContext(this.cv_canvas);
4563 this.postShaders = [];
4564 this.postTime = 0;
4565 this.renderLayers = [new RenderLayer(RenderLayer.DEFAULT_NAME)];
4566
4567 this.g_fixSize();
4568 this.quadTree = new QuadTree(this.real_size.x, this.real_size.y);
4569 }
4570
4571 /**
4572 * Replace the layer stack. Order in the array is draw order (first = back).
4573 * Each entry: RenderLayer, or { name, postShaders?, composite? }.
4574 */
4575 setLayers (layerConfigs)
4576 {
4577 if (!layerConfigs || !layerConfigs.length)
4578 {
4579 this.renderLayers = [new RenderLayer(RenderLayer.DEFAULT_NAME)];
4580 return this.renderLayers;
4581 }
4582
4583 const layers = [];
4584 for (let i = 0; i < layerConfigs.length; i++)
4585 {
4586 const cfg = layerConfigs[i];
4587 if (!cfg)
4588 { continue; }
4589
4590 if (cfg instanceof RenderLayer)
4591 { layers.push(cfg); }
4592 else
4593 { layers.push(new RenderLayer(cfg.name, cfg)); }
4594 }
4595
4596 if (!layers.length)
4597 { layers.push(new RenderLayer(RenderLayer.DEFAULT_NAME)); }
4598
4599 this.renderLayers = layers;
4600 return this.renderLayers;
4601 }
4602
4603 getLayer (name)
4604 {
4605 const layers = this.renderLayers || [];
4606 for (let i = 0; i < layers.length; i++)
4607 {
4608 if (layers[i].name === name)
4609 { return layers[i]; }
4610 }
4611
4612 return null;
4613 }
4614
4615 setPrimary ()
4616 {
4617 this.game.setPrimaryScene(this);
4618 }
4619
4620 onLoad ()
4621 {
4622
4623 }
4624
4625 loadChildScene (scene)
4626 {
4627 scene.parentScene = this;
4628 this.game.loadScene(scene);
4629 }
4630
4631 destroy ()
4632 {
4633 if (this.destroyed)
4634 { return; }
4635
4636 for (var i = 0; i < this.activeObjects.length; i++)
4637 {
4638 this.activeObjects[i].destroy();
4639 }
4640
4641 this.destroyed = true;
4642
4643 if (this.game)
4644 { this.game.removeScene(this); }
4645
4646 this.removeCanvas();
4647
4648 if (this.primary)
4649 {
4650 if (this.parentScene && !this.parentScene.destroyed)
4651 {
4652 this.parentScene.setPrimary();
4653 }
4654 else if (this.game)
4655 {
4656 let promoted = null;
4657 for (let i = 0; i < this.game.activeScenes.length; i++)
4658 {
4659 const candidate = this.game.activeScenes[i];
4660 if (candidate !== this && !candidate.destroyed)
4661 {
4662 promoted = candidate;
4663 break;
4664 }
4665 }
4666
4667 if (promoted)
4668 { this.game.setPrimaryScene(promoted); }
4669 else
4670 { this.g_primary = false; }
4671 }
4672 else
4673 {
4674 this.g_primary = false;
4675 }
4676 }
4677 }
4678
4679 removeCanvas ()
4680 {
4681 var elem = this.cv_canvas || document.getElementById(this.id);
4682 if (elem && elem.parentNode)
4683 {
4684 elem.parentNode.removeChild(elem);
4685 }
4686
4687 this.cv_canvas = null;
4688 this.glContext = null;
4689 }
4690
4691 backgroundColor =
4692 {
4693 r: 255,
4694 g: 255,
4695 b: 255
4696 };
4697
4698 get canvas ()
4699 {
4700 return this.cv_canvas;
4701 }
4702
4703 get context ()
4704 {
4705 return this.glContext ? this.glContext.gl : null;
4706 }
4707
4708 addObject (obj)
4709 {
4710 if (this.destroyed)
4711 { return; }
4712
4713 this.activeObjects.push(obj);
4714 obj.scene = this;
4715 obj.initQuadtree(this.quadTree);
4716 obj.checkQuadtree();
4717
4718 if (this._sortedActiveObjects && !this._sortDirty && !this._layerChanged.length)
4719 { this.#insertSortedByLayer(this._sortedActiveObjects, obj); }
4720 else
4721 { this._sortDirty = true; }
4722
4723 obj.addedToScene && obj.addedToScene();
4724
4725 return obj;
4726 }
4727
4728 removeObject (obj)
4729 {
4730 if (this.activeObjects.indexOf(obj) >= 0)
4731 {
4732 if (!this.pendingRemoval.contains(obj))
4733 { this.pendingRemoval.push(obj); }
4734
4735 this._sortDirty = true;
4736 }
4737
4738 if (this.quadTree === obj.quadTree)
4739 { this.quadTree.remove(obj); }
4740 }
4741
4742 /**
4743 * Called when an object's draw-priority `layer` changes.
4744 * Batches small moves for splice-reinsert; floods into a full sort when many change.
4745 */
4746 objectLayerChanged (obj)
4747 {
4748 if (!obj || this._sortDirty)
4749 {
4750 this._sortDirty = true;
4751 return;
4752 }
4753 this._layerChanged.push(obj);
4754 if (this._layerChanged.length > this._layerChangeFullSortThreshold)
4755 {
4756 this._sortDirty = true;
4757 this._layerChanged.length = 0;
4758 }
4759 }
4760
4761 /** Force a full draw-order rebuild on the next draw (e.g. bulk external edits). */
4762 markSortDirty ()
4763 {
4764 this._sortDirty = true;
4765 this._layerChanged.length = 0;
4766 }
4767
4768 /** First index with layer strictly greater than `layer` (insert after equal layers). */
4769 #upperBoundByLayer (sorted, layer)
4770 {
4771 let lo = 0;
4772 let hi = sorted.length;
4773 while (lo < hi)
4774 {
4775 const mid = (lo + hi) >> 1;
4776 if (sorted[mid].layer <= layer)
4777 { lo = mid + 1; }
4778 else
4779 { hi = mid; }
4780 }
4781 return lo;
4782 }
4783
4784 #insertSortedByLayer (sorted, obj)
4785 {
4786 // New objects and layer moves land after existing equal layers so a
4787 // recently updated sprite draws on top of older ties (stable-with-recency).
4788 const at = this.#upperBoundByLayer(sorted, obj.layer);
4789 sorted.splice(at, 0, obj);
4790 }
4791
4792 #reinsertSortedByLayer (sorted, obj)
4793 {
4794 const from = sorted.indexOf(obj);
4795 if (from >= 0)
4796 { sorted.splice(from, 1); }
4797 this.#insertSortedByLayer(sorted, obj);
4798 }
4799
4800 /**
4801 * Ensure `_sortedActiveObjects` matches `activeObjects` ordered by `layer`.
4802 * Avoids allocating a fresh array every frame (no `slice().sort()`).
4803 */
4804 #ensureDrawOrder ()
4805 {
4806 const active = this.activeObjects;
4807 if (this._sortDirty || !this._sortedActiveObjects)
4808 {
4809 let sorted = this._sortedActiveObjects;
4810 if (!sorted)
4811 {
4812 sorted = new Array(active.length);
4813 this._sortedActiveObjects = sorted;
4814 }
4815 else if (sorted.length !== active.length)
4816 { sorted.length = active.length; }
4817
4818 for (let i = 0; i < active.length; i++)
4819 { sorted[i] = active[i]; }
4820
4821 sorted.sort((a, b) => a.layer - b.layer);
4822 this._sortDirty = false;
4823 this._layerChanged.length = 0;
4824 return;
4825 }
4826
4827 if (!this._layerChanged.length)
4828 { return; }
4829
4830 const changed = this._layerChanged;
4831 const sorted = this._sortedActiveObjects;
4832 for (let i = 0; i < changed.length; i++)
4833 { this.#reinsertSortedByLayer(sorted, changed[i]); }
4834 changed.length = 0;
4835 }
4836
4837 update (deltaTime)
4838 {
4839 if (this.destroyed)
4840 { return; }
4841
4842 this.postTime += deltaTime;
4843
4844 for (let i = 0; i < this.activeObjects.length; i++)
4845 {
4846 this.activeObjects[i].update(deltaTime);
4847 }
4848
4849 if (this.pendingRemoval.length)
4850 {
4851 for (let i = 0; i < this.pendingRemoval.length; i++)
4852 {
4853 const obj = this.pendingRemoval[i];
4854 const index = this.activeObjects.indexOf(obj);
4855 if (index >= 0 && obj.destroyed)
4856 { this.activeObjects.removeAt(index); }
4857 }
4858
4859 this.pendingRemoval.length = 0;
4860 this._sortDirty = true;
4861 this._layerChanged.length = 0;
4862 }
4863
4864 this.quadTree.update(deltaTime);
4865 }
4866
4867 g_fixSize ()
4868 {
4869 if (this.displayMode == Scene.DisplayModes.relativeToParent)
4870 {
4871 if (this.parentScene)
4872 {
4873 this.real_position.x = this.parentScene.real_position.x + (this.position.x * this.parentScene.real_size.x);
4874 this.real_position.y = this.parentScene.real_position.y + (this.position.y * this.parentScene.real_size.y);
4875
4876 this.real_size.x = this.parentScene.real_size.x * this.size.x;
4877 this.real_size.y = this.parentScene.real_size.y * this.size.y;
4878 }
4879 else
4880 {
4881 this.real_position.x = window.innerWidth * this.position.x;
4882 this.real_position.y = window.innerHeight * this.position.y;
4883
4884 this.real_size.x = window.innerWidth * this.size.x;
4885 this.real_size.y = window.innerHeight * this.size.y;
4886 }
4887 }
4888 else if (this.displayMode == Scene.DisplayModes.absolute)
4889 {
4890 this.real_position.x = this.position.x;
4891 this.real_position.y = this.position.y;
4892
4893 this.real_size.x = this.size.x;
4894 this.real_size.y = this.size.y;
4895 }
4896
4897 const canvasW = Math.max(1, Math.round(this.real_size.x));
4898 const canvasH = Math.max(1, Math.round(this.real_size.y));
4899 let resized = false;
4900
4901 if (this.canvas.width != canvasW)
4902 {
4903 this.canvas.width = canvasW;
4904 resized = true;
4905 }
4906
4907 if (this.canvas.height != canvasH)
4908 {
4909 this.canvas.height = canvasH;
4910 resized = true;
4911 }
4912
4913 // Changing canvas dimensions resets WebGL — rebuild helper/buffers/programs.
4914 if (resized || !this.glContext)
4915 { this.glContext = new GLContext(this.cv_canvas); }
4916 else
4917 { this.glContext.setSize(this.canvas.width, this.canvas.height); }
4918
4919 if (this.px != this.real_position.x)
4920 {
4921 this.px = this.real_position.x;
4922 this.canvas.style.left = this.real_position.x + "px";
4923 }
4924
4925 if (this.py != this.real_position.y)
4926 {
4927 this.py = this.real_position.y;
4928 this.canvas.style.top = this.real_position.y + "px";
4929 }
4930 }
4931
4932 normalizePostShaderList (list)
4933 {
4934 if (!list || !list.length)
4935 { return []; }
4936
4937 const passes = [];
4938 for (let i = 0; i < list.length; i++)
4939 {
4940 const entry = list[i];
4941 if (!entry)
4942 { continue; }
4943
4944 if (entry instanceof Shader || (entry.vertSource && entry.fragSource && entry.getProgramInfo))
4945 {
4946 passes.push({ shader: entry, uniforms: null });
4947 }
4948 else if (entry.shader)
4949 {
4950 const pass = { shader: entry.shader, uniforms: entry.uniforms || null };
4951 if (entry.scale != null)
4952 { pass.scale = entry.scale; }
4953 passes.push(pass);
4954 }
4955 }
4956
4957 return passes;
4958 }
4959
4960 normalizePostShaders ()
4961 {
4962 return this.normalizePostShaderList(this.postShaders);
4963 }
4964
4965 getPostPassesForLayer (layer)
4966 {
4967 const fromLayer = this.normalizePostShaderList(layer.postShaders);
4968 if (fromLayer.length)
4969 { return fromLayer; }
4970
4971 // Back-compat: scene.postShaders apply to the default layer only.
4972 if (layer.name === RenderLayer.DEFAULT_NAME)
4973 { return this.normalizePostShaders(); }
4974
4975 return [];
4976 }
4977
4978 draw ()
4979 {
4980 if (this.destroyed || !this.glContext)
4981 { return; }
4982
4983 this.g_fixSize();
4984
4985 const gl = this.glContext;
4986 const layers = this.renderLayers && this.renderLayers.length
4987 ? this.renderLayers
4988 : [new RenderLayer(RenderLayer.DEFAULT_NAME)];
4989
4990 // Canvas clear (background behind all layers).
4991 gl.endOffscreenPass();
4992 if (this.renderBackground)
4993 {
4994 gl.clear(
4995 this.backgroundColor.r,
4996 this.backgroundColor.g,
4997 this.backgroundColor.b,
4998 1
4999 );
5000 }
5001 else
5002 {
5003 gl.clearTransparent();
5004 }
5005
5006 this.#ensureDrawOrder();
5007 const sortedActiveObjects = this._sortedActiveObjects;
5008
5009 // Reuse per-layer buckets so we do not allocate new arrays every frame.
5010 const byLayer = this._byLayer || (this._byLayer = Object.create(null));
5011 const byLayerNames = this._byLayerNames || (this._byLayerNames = []);
5012 for (let i = 0; i < byLayerNames.length; i++)
5013 { byLayer[byLayerNames[i]].length = 0; }
5014 byLayerNames.length = 0;
5015
5016 for (let i = 0; i < sortedActiveObjects.length; i++)
5017 {
5018 const obj = sortedActiveObjects[i];
5019 if (obj.destroyed || !obj.renderer || !obj.renderer.visible)
5020 { continue; }
5021
5022 const name = obj.renderer.layerName;
5023 let bucket = byLayer[name];
5024 if (!bucket)
5025 {
5026 bucket = [];
5027 byLayer[name] = bucket;
5028 }
5029 if (bucket.length === 0)
5030 { byLayerNames.push(name); }
5031 bucket.push(obj);
5032 }
5033
5034 const builtins = {
5035 u_resolution: [gl._lastWidth, gl._lastHeight],
5036 u_time: this.postTime
5037 };
5038
5039 for (let li = 0; li < layers.length; li++)
5040 {
5041 const renderLayer = layers[li];
5042 const layerObjects = byLayer[renderLayer.name];
5043 if (!layerObjects || !layerObjects.length)
5044 { continue; }
5045
5046 gl.beginOffscreenPass();
5047 gl.clearTransparent();
5048
5049 for (let i = 0; i < layerObjects.length; i++)
5050 { layerObjects[i].draw(this.context); }
5051
5052 const postPasses = this.getPostPassesForLayer(renderLayer);
5053 let texture = gl.colorTextures[0];
5054
5055 if (postPasses.length)
5056 {
5057 texture = gl.applyPostShaders(postPasses, builtins, { toCanvas: false });
5058 }
5059 else
5060 {
5061 gl.endOffscreenPass();
5062 }
5063
5064 gl.blitToCanvas(texture, renderLayer.composite || "alpha");
5065 }
5066 }
5067 }
5068 /*
5069 * End File:
5070 * framework/engine/scene.js
5071 */
5072
5073 /*
5074 * Start File:
5075 * framework/engine/game.js
5076 */
5077 class Game
5078 {
5079 activeScenes = [];
5080 pendingRemoval = [];
5081
5082 previousStep = 0; //used for calculating deltaTime
5083 isRunning = false;
5084 rafId = null;
5085
5086 images = {};
5087 shaders = {};
5088
5089 constructor ()
5090 {
5091 this.previousStep = 0;
5092 this.activeScenes = [];
5093 this.isRunning = false;
5094 this.rafId = null;
5095 this.shaders = {};
5096 this.update = this.update.bind(this);
5097 }
5098
5099 startGame ()
5100 {
5101 GameInput.g_init();
5102
5103 if (this.isRunning)
5104 { return; }
5105
5106 this.isRunning = true;
5107 this.previousStep = Date.now();
5108 this.update();
5109 }
5110
5111 stopGame ()
5112 {
5113 this.isRunning = false;
5114 if (this.rafId != null)
5115 {
5116 cancelAnimationFrame(this.rafId);
5117 this.rafId = null;
5118 }
5119 }
5120
5121 preloadImagesThenStart (imageData, onComplete, onError)
5122 {
5123 const cont = async () =>
5124 {
5125 try
5126 {
5127 await this.preloadImages(
5128 imageData
5129 );
5130
5131 this.startGame();
5132 onComplete && onComplete();
5133 }
5134 catch (err)
5135 {
5136 console.error("GAME: Image preload failed.", err);
5137 onError && onError(err);
5138 }
5139 };
5140
5141 cont();
5142 }
5143
5144 setPrimaryScene (scene)
5145 {
5146 if (this.activeScenes.contains(scene))
5147 {
5148 for (let i = 0; i < this.activeScenes.length; i++)
5149 { this.activeScenes[i].g_primary = false; }
5150
5151 scene.g_primary = true;
5152 }
5153 }
5154
5155 async preloadImages (imagesData)
5156 {
5157 const promises = [];
5158 const context = this;
5159
5160 for (var imageData of imagesData)
5161 {
5162 if (context.images[imageData.name])
5163 {
5164 console.warn("Image '" + imageData.name + "' is already loaded! (overwriting anyway)");
5165 }
5166
5167 promises.push(new Promise((resolve, reject) =>
5168 {
5169 var img = new Image();
5170 var imageContext = { name: imageData.name, subImgTotal: imageData.subImgTotal, perRow: imageData.perRow, loop: imageData.loop, chain: imageData.chain };
5171
5172 img.onload = function ()
5173 {
5174 var finalImage = new image(img, imageContext.subImgTotal, imageContext.perRow, imageContext.loop, imageContext.chain);
5175 finalImage.name = imageContext.name;
5176
5177 context.images[imageContext.name] = finalImage;
5178
5179 resolve();
5180 };
5181
5182 img.onerror = function ()
5183 {
5184 reject(new Error("Failed to load image '" + imageContext.name + "' from " + imageData.url));
5185 };
5186
5187 img.src = imageData.url;
5188 img.setAttribute("style", "display:none");
5189 }));
5190 }
5191 await Promise.all(promises);
5192
5193 console.log("all images loaded ", this.images);
5194
5195 return this.images;
5196 }
5197
5198 async preloadShaders (shadersData)
5199 {
5200 const context = this;
5201 const promises = [];
5202
5203 for (const shaderData of shadersData)
5204 {
5205 if (!shaderData || !shaderData.name)
5206 { throw new Error("preloadShaders: each entry needs a name"); }
5207
5208 if (!shaderData.frag)
5209 { throw new Error("preloadShaders: '" + shaderData.name + "' needs a frag path"); }
5210
5211 if (context.shaders[shaderData.name])
5212 { console.warn("Shader '" + shaderData.name + "' is already loaded! (overwriting anyway)"); }
5213
5214 promises.push((async () =>
5215 {
5216 let vertSource = shaderData.screen ? Shader.SCREEN_VERT : Shader.DEFAULT_VERT;
5217
5218 if (shaderData.vert)
5219 {
5220 const vertResponse = await fetch(shaderData.vert);
5221 if (!vertResponse.ok)
5222 {
5223 throw new Error("Failed to load vertex shader '" + shaderData.name + "' from " + shaderData.vert);
5224 }
5225
5226 vertSource = await vertResponse.text();
5227 }
5228
5229 const fragResponse = await fetch(shaderData.frag);
5230 if (!fragResponse.ok)
5231 {
5232 throw new Error("Failed to load fragment shader '" + shaderData.name + "' from " + shaderData.frag);
5233 }
5234
5235 const fragSource = await fragResponse.text();
5236 const shader = new Shader(vertSource, fragSource);
5237 shader.name = shaderData.name;
5238 shader.screen = !!shaderData.screen || vertSource === Shader.SCREEN_VERT;
5239 context.shaders[shaderData.name] = shader;
5240 })());
5241 }
5242
5243 await Promise.all(promises);
5244 console.log("all shaders loaded ", this.shaders);
5245 return this.shaders;
5246 }
5247
5248 loadScene (scene)
5249 {
5250 if (this.activeScenes.length == 0)
5251 { scene.g_primary = true; }
5252
5253 this.activeScenes.push(scene);
5254 scene.game = this;
5255 scene.onLoad();
5256 }
5257
5258 removeScene (scene)
5259 {
5260 if (this.activeScenes.indexOf(scene) >= 0)
5261 {
5262 if (!this.pendingRemoval.contains(scene))
5263 { this.pendingRemoval.push(scene); }
5264 }
5265 }
5266
5267 update ()
5268 {
5269 this.previousStep = this.previousStep || 0;
5270 const stepTime = Date.now();
5271 let stepTimeCurr = (stepTime - this.previousStep) * 0.001;
5272 stepTimeCurr = Math.min(stepTimeCurr, 0.1);
5273 if (isNaN(stepTimeCurr))
5274 { stepTimeCurr = 0; }
5275
5276 GameInput.g_updateKeys();
5277
5278 for (let i = 0; i < this.activeScenes.length; i++)
5279 {
5280 this.activeScenes[i].update(stepTimeCurr);
5281 this.activeScenes[i].draw();
5282 }
5283
5284 this.cleanActiveScenes();
5285
5286 this.previousStep = stepTime;
5287
5288 TWEEN.update();
5289
5290 if (this.isRunning)
5291 { this.rafId = requestAnimationFrame(this.update); }
5292 }
5293
5294 cleanActiveScenes ()
5295 {
5296 if (this.pendingRemoval.length > 0)
5297 {
5298 for (let i = 0; i < this.pendingRemoval.length; i++)
5299 {
5300 const scene = this.pendingRemoval[i];
5301 const index = this.activeScenes.indexOf(scene);
5302 if (index >= 0 && scene.destroyed)
5303 { this.activeScenes.removeAt(index); }
5304 }
5305
5306 this.pendingRemoval.length = 0;
5307 }
5308 }
5309 }
5310 /*
5311 * End File:
5312 * framework/engine/game.js
5313 */
@@ -0,0 +1,5313 @@
1/*
2 * AUTO-GENERATED FILE — DO NOT EDIT BY HAND.
3 *
4 * Built by glbuild.sh from the modular sources in this repository.
5 * Make changes in the framework/ source tree, then rebuild.
6 * Upstream: https://gitlab.com/Timfa/frameworkv3
7 */
8
9/*
10 * Start File:
11 * framework/extensions/polyfills.js
12 */
13if (!Math.sign)
14{
15 Math.sign = function (x)
16 {
17 x = +x; // convert to a number
18 if (x === 0 || isNaN(x))
19 {
20 return Number(x);
21 }
22 return x > 0 ? 1 : -1;
23 };
24}
25
26(function (e) { var t = function () { try { return !!Symbol.iterator; } catch (e) { return false; } }; var n = t(); var r = function (e) { var t = { next: function () { var t = e.shift(); return { done: t === void 0, value: t }; } }; if (n) { t[Symbol.iterator] = function () { return t; }; } return t; }; var i = function (e) { return encodeURIComponent(e).replace(/%20/g, "+"); }; var o = function (e) { return decodeURIComponent(e).replace(/\+/g, " "); }; var a = function () { var t = function (e) { Object.defineProperty(this, "_entries", { value: {} }); if (typeof e === "string") { if (e !== "") { e = e.replace(/^\?/, ""); var n = e.split("&"); var r; for (var i = 0; i < n.length; i++) { r = n[i].split("="); this.append(o(r[0]), r.length > 1 ? o(r[1]) : ""); } } } else if (e instanceof t) { var a = this; e.forEach(function (e, t) { a.append(e, t); }); } }; var a = t.prototype; a.append = function (e, t) { if (e in this._entries) { this._entries[e].push(t.toString()); } else { this._entries[e] = [t.toString()]; } }; a.delete = function (e) { delete this._entries[e]; }; a.get = function (e) { return e in this._entries ? this._entries[e][0] : null; }; a.getAll = function (e) { return e in this._entries ? this._entries[e].slice(0) : []; }; a.has = function (e) { return e in this._entries; }; a.set = function (e, t) { this._entries[e] = [t.toString()]; }; a.forEach = function (e, t) { var n; for (var r in this._entries) { if (this._entries.hasOwnProperty(r)) { n = this._entries[r]; for (var i = 0; i < n.length; i++) { e.call(t, n[i], r, this); } } } }; a.keys = function () { var e = []; this.forEach(function (t, n) { e.push(n); }); return r(e); }; a.values = function () { var e = []; this.forEach(function (t) { e.push(t); }); return r(e); }; a.entries = function () { var e = []; this.forEach(function (t, n) { e.push([n, t]); }); return r(e); }; if (n) { a[Symbol.iterator] = a.entries; } a.toString = function () { var e = []; this.forEach(function (t, n) { e.push(i(n) + "=" + i(t)); }); return e.join("&"); }; e.URLSearchParams = t; }; if (!("URLSearchParams" in e) || new URLSearchParams("?a=1").toString() !== "a=1") { a(); } })(typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : this); (function (e) { var t = function () { try { var e = new URL("b", "http://a"); e.pathname = "c%20d"; return e.href === "http://a/c%20d" && e.searchParams; } catch (e) { return false; } }; var n = function () { var t = e.URL; var n = function (e, t) { if (typeof e !== "string") {e = String(e);} var n = document.implementation.createHTMLDocument(""); window.doc = n; if (t) { var r = n.createElement("base"); r.href = t; n.head.appendChild(r); } var i = n.createElement("a"); i.href = e; n.body.appendChild(i); i.href = i.href; if (i.protocol === ":" || !/:/.test(i.href)) { throw new TypeError("Invalid URL"); } Object.defineProperty(this, "_anchorElement", { value: i }); }; var r = n.prototype; var i = function (e) { Object.defineProperty(r, e, { get: function () { return this._anchorElement[e]; }, set: function (t) { this._anchorElement[e] = t; }, enumerable: true }); };["hash", "host", "hostname", "port", "protocol", "search"].forEach(function (e) { i(e); }); Object.defineProperties(r, { toString: { get: function () { var e = this; return function () { return e.href; }; } }, href: { get: function () { return this._anchorElement.href.replace(/\?$/, ""); }, set: function (e) { this._anchorElement.href = e; }, enumerable: true }, pathname: { get: function () { return this._anchorElement.pathname.replace(/(^\/?)/, "/"); }, set: function (e) { this._anchorElement.pathname = e; }, enumerable: true }, origin: { get: function () { var e = { "http:": 80, "https:": 443, "ftp:": 21 }[this._anchorElement.protocol]; var t = this._anchorElement.port != e && this._anchorElement.port !== ""; return this._anchorElement.protocol + "//" + this._anchorElement.hostname + (t ? ":" + this._anchorElement.port : ""); }, enumerable: true }, password: { get: function () { return ""; }, set: function (e) { }, enumerable: true }, username: { get: function () { return ""; }, set: function (e) { }, enumerable: true }, searchParams: { get: function () { var e = new URLSearchParams(this.search); var t = this;["append", "delete", "set"].forEach(function (n) { var r = e[n]; e[n] = function () { r.apply(e, arguments); t.search = e.toString(); }; }); return e; }, enumerable: true } }); n.createObjectURL = function (e) { return t.createObjectURL.apply(t, arguments); }; n.revokeObjectURL = function (e) { return t.revokeObjectURL.apply(t, arguments); }; e.URL = n; }; if (!t()) { n(); } if (e.location !== void 0 && !("origin" in e.location)) { var r = function () { return e.location.protocol + "//" + e.location.hostname + (e.location.port ? ":" + e.location.port : ""); }; try { Object.defineProperty(e.location, "origin", { get: r, enumerable: true }); } catch (t) { setInterval(function () { e.location.origin = r(); }, 100); } } })(typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : this);
27/*
28 * End File:
29 * framework/extensions/polyfills.js
30 */
31
32/*
33 * Start File:
34 * framework/extensions/extentions.js
35 */
36/**
37 * Extending exising functionality
38 */
39
40Array.prototype.remove = function (element)
41{
42 var index = this.indexOf(element);
43
44 if (index > -1)
45 {
46 this.splice(index, 1);
47 }
48 else
49 {
50 console.error("Element not part of array!", this, element);
51 }
52};
53
54Array.prototype.removeAt = function (index)
55{
56 if (index > -1)
57 {
58 this.splice(index, 1);
59 }
60};
61
62Array.prototype.contains = function (element)
63{
64 var index = this.indexOf(element);
65
66 return index > -1;
67};
68
69Math.clamp = function (number, min, max)
70{
71 return Math.min(max, Math.max(min, number));
72};
73
74Math.randomRange = function (min, max)
75{
76 return min + (Math.random() * (max - min));
77};
78
79Math.lerp = function (a, b, t)
80{
81 return a + (b - a) * t;
82};
83
84Array.prototype.random = function ()
85{
86 return this[Math.floor((Math.random() * this.length))];
87};
88/*
89 * End File:
90 * framework/extensions/extentions.js
91 */
92
93/*
94 * Start File:
95 * framework/extensions/thirdparty.js
96 */
97//TWEENJS
98var TWEEN = TWEEN || function () { var n = []; return { getAll: function () { return n; }, removeAll: function () { n = []; }, add: function (t) { n.push(t); }, remove: function (t) { var r = n.indexOf(t); -1 !== r && n.splice(r, 1); }, update: function (t, r) { if (0 === n.length) {return !1;} var i = 0; for (t = void 0 !== t ? t : TWEEN.now(); i < n.length;){n[i].update(t) || r ? i++ : n.splice(i, 1);} return !0; } }; }(); !function () { void 0 === this.window && void 0 !== this.process ? TWEEN.now = function () { var n = process.hrtime(); return 1e3 * n[0] + n[1] / 1e3; } : void 0 !== this.window && void 0 !== window.performance && void 0 !== window.performance.now ? TWEEN.now = window.performance.now.bind(window.performance) : void 0 !== Date.now ? TWEEN.now = Date.now : TWEEN.now = function () { return (new Date).getTime(); }; }(), TWEEN.Tween = function (n) { var t = n, r = {}, i = {}, o = {}, u = 1e3, e = 0, a = !1, f = !1, c = !1, s = 0, h = null, l = TWEEN.Easing.Linear.None, E = TWEEN.Interpolation.Linear, p = [], d = null, v = !1, w = null, I = null, M = null, C = null, S = null, ST = null; for (var T in n) {r[T] = parseFloat(n[T], 10);} this.to = function (n, t) { return void 0 !== t && (u = t), i = n, this; }, this.start = function (n) { TWEEN.add(this), f = !0, v = !1, h = void 0 !== n ? n : TWEEN.now(), h += s; for (var u in i) { if (i[u] instanceof Array) { if (0 === i[u].length) {continue;} i[u] = [t[u]].concat(i[u]); } void 0 !== r[u] && (r[u] = t[u], r[u] instanceof Array == !1 && (r[u] *= 1), o[u] = r[u] || 0); } return this; }, this.stop = function () { return f ? (TWEEN.remove(this), f = !1, null !== M && M.call(S), this.stopChainedTweens(), this) : this; }, this.stopChainedTweens = function () { for (var n = 0, t = p.length; t > n; n++){p[n].stop();} }, this.delay = function (n) { return s = n, this; }, this.repeat = function (n) { return e = n, this; }, this.yoyo = function (n) { return a = n, this; }, this.easing = function (n) { return l = n, this; }, this.interpolation = function (n) { return E = n, this; }, this.chain = function () { return p = arguments, this; }, this.onStart = function (n, c) { return d = n, ST = c, this; }, this.onUpdate = function (n) { return w = n, this; }, this.onComplete = function (n, c) { return I = n, C = c, this; }, this.onStop = function (n, c) { return M = n, S = c, this; }, this.update = function (n) { var f, M, T; if (h > n) {return !0;} v === !1 && (null !== d && d.call(ST), v = !0), M = (n - h) / u, M = M > 1 ? 1 : M, T = l(M); for (f in i) {if (void 0 !== r[f]) { var N = r[f] || 0, W = i[f]; W instanceof Array ? t[f] = E(W, T) : ("string" == typeof W && (W = "+" === W.charAt(0) || "-" === W.charAt(0) ? N + parseFloat(W, 10) : parseFloat(W, 10)), "number" == typeof W && (t[f] = N + (W - N) * T)); }} if (null !== w && w.call(t, T), 1 === M) { if (e > 0) { isFinite(e) && e--; for (f in o) { if ("string" == typeof i[f] && (o[f] = o[f] + parseFloat(i[f], 10)), a) { var O = o[f]; o[f] = i[f], i[f] = O; } r[f] = o[f]; } return a && (c = !c), h = n + s, !0; } null !== I && I.call(C); for (var m = 0, g = p.length; g > m; m++){p[m].start(h + u);} return !1; } return !0; }; }, TWEEN.Easing = { Linear: { None: function (n) { return n; } }, Quadratic: { In: function (n) { return n * n; }, Out: function (n) { return n * (2 - n); }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n : -.5 * (--n * (n - 2) - 1); } }, Cubic: { In: function (n) { return n * n * n; }, Out: function (n) { return --n * n * n + 1; }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n * n : .5 * ((n -= 2) * n * n + 2); } }, Quartic: { In: function (n) { return n * n * n * n; }, Out: function (n) { return 1 - --n * n * n * n; }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n * n * n : -.5 * ((n -= 2) * n * n * n - 2); } }, Quintic: { In: function (n) { return n * n * n * n * n; }, Out: function (n) { return --n * n * n * n * n + 1; }, InOut: function (n) { return (n *= 2) < 1 ? .5 * n * n * n * n * n : .5 * ((n -= 2) * n * n * n * n + 2); } }, Sinusoidal: { In: function (n) { return 1 - Math.cos(n * Math.PI / 2); }, Out: function (n) { return Math.sin(n * Math.PI / 2); }, InOut: function (n) { return .5 * (1 - Math.cos(Math.PI * n)); } }, Exponential: { In: function (n) { return 0 === n ? 0 : Math.pow(1024, n - 1); }, Out: function (n) { return 1 === n ? 1 : 1 - Math.pow(2, -10 * n); }, InOut: function (n) { return 0 === n ? 0 : 1 === n ? 1 : (n *= 2) < 1 ? .5 * Math.pow(1024, n - 1) : .5 * (-Math.pow(2, -10 * (n - 1)) + 2); } }, Circular: { In: function (n) { return 1 - Math.sqrt(1 - n * n); }, Out: function (n) { return Math.sqrt(1 - --n * n); }, InOut: function (n) { return (n *= 2) < 1 ? -.5 * (Math.sqrt(1 - n * n) - 1) : .5 * (Math.sqrt(1 - (n -= 2) * n) + 1); } }, Elastic: { In: function (n) { return 0 === n ? 0 : 1 === n ? 1 : -Math.pow(2, 10 * (n - 1)) * Math.sin(5 * (n - 1.1) * Math.PI); }, Out: function (n) { return 0 === n ? 0 : 1 === n ? 1 : Math.pow(2, -10 * n) * Math.sin(5 * (n - .1) * Math.PI) + 1; }, InOut: function (n) { return 0 === n ? 0 : 1 === n ? 1 : (n *= 2, 1 > n ? -.5 * Math.pow(2, 10 * (n - 1)) * Math.sin(5 * (n - 1.1) * Math.PI) : .5 * Math.pow(2, -10 * (n - 1)) * Math.sin(5 * (n - 1.1) * Math.PI) + 1); } }, Back: { In: function (n) { var t = 1.70158; return n * n * ((t + 1) * n - t); }, Out: function (n) { var t = 1.70158; return --n * n * ((t + 1) * n + t) + 1; }, InOut: function (n) { var t = 2.5949095; return (n *= 2) < 1 ? .5 * (n * n * ((t + 1) * n - t)) : .5 * ((n -= 2) * n * ((t + 1) * n + t) + 2); } }, Bounce: { In: function (n) { return 1 - TWEEN.Easing.Bounce.Out(1 - n); }, Out: function (n) { return 1 / 2.75 > n ? 7.5625 * n * n : 2 / 2.75 > n ? 7.5625 * (n -= 1.5 / 2.75) * n + .75 : 2.5 / 2.75 > n ? 7.5625 * (n -= 2.25 / 2.75) * n + .9375 : 7.5625 * (n -= 2.625 / 2.75) * n + .984375; }, InOut: function (n) { return .5 > n ? .5 * TWEEN.Easing.Bounce.In(2 * n) : .5 * TWEEN.Easing.Bounce.Out(2 * n - 1) + .5; } } }, TWEEN.Interpolation = { Linear: function (n, t) { var r = n.length - 1, i = r * t, o = Math.floor(i), u = TWEEN.Interpolation.Utils.Linear; return 0 > t ? u(n[0], n[1], i) : t > 1 ? u(n[r], n[r - 1], r - i) : u(n[o], n[o + 1 > r ? r : o + 1], i - o); }, Bezier: function (n, t) { for (var r = 0, i = n.length - 1, o = Math.pow, u = TWEEN.Interpolation.Utils.Bernstein, e = 0; i >= e; e++){r += o(1 - t, i - e) * o(t, e) * n[e] * u(i, e);} return r; }, CatmullRom: function (n, t) { var r = n.length - 1, i = r * t, o = Math.floor(i), u = TWEEN.Interpolation.Utils.CatmullRom; return n[0] === n[r] ? (0 > t && (o = Math.floor(i = r * (1 + t))), u(n[(o - 1 + r) % r], n[o], n[(o + 1) % r], n[(o + 2) % r], i - o)) : 0 > t ? n[0] - (u(n[0], n[0], n[1], n[1], -i) - n[0]) : t > 1 ? n[r] - (u(n[r], n[r], n[r - 1], n[r - 1], i - r) - n[r]) : u(n[o ? o - 1 : 0], n[o], n[o + 1 > r ? r : o + 1], n[o + 2 > r ? r : o + 2], i - o); }, Utils: { Linear: function (n, t, r) { return (t - n) * r + n; }, Bernstein: function (n, t) { var r = TWEEN.Interpolation.Utils.Factorial; return r(n) / r(t) / r(n - t); }, Factorial: function () { var n = [1]; return function (t) { var r = 1; if (n[t]) {return n[t];} for (var i = t; i > 1; i--){r *= i;} return n[t] = r, r; }; }(), CatmullRom: function (n, t, r, i, o) { var u = .5 * (r - n), e = .5 * (i - t), a = o * o, f = o * a; return (2 * t - 2 * r + u + e) * f + (-3 * t + 3 * r - 2 * u - e) * a + u * o + t; } } }, function (n) { "function" == typeof define && define.amd ? define([], function () { return TWEEN; }) : "undefined" != typeof module && "object" == typeof exports ? module.exports = TWEEN : void 0 !== n && (n.TWEEN = TWEEN); }(this);
99/*
100 * End File:
101 * framework/extensions/thirdparty.js
102 */
103
104/*
105 * Start File:
106 * framework/util/vector.js
107 */
108class vector
109{
110 x = 0;
111 y = 0;
112
113 constructor (x, y)
114 {
115 this.x = x;
116
117 this.y = y;
118 }
119
120 get length ()
121 {
122 return Math.sqrt((this.x * this.x) + (this.y * this.y));
123 }
124
125 get lengthSq ()
126 {
127 return (this.x * this.x) + (this.y * this.y);
128 }
129
130 getLength ()
131 {
132 return Math.sqrt((this.x * this.x) + (this.y * this.y));
133 }
134
135
136 toAngle ()
137 {
138 let angle = (Math.atan2(this.y, this.x) * 180 / Math.PI) + 90;
139 if (angle < 0)
140 {angle += 360;}
141 return angle;
142 }
143
144 static fromAngle (angle)
145 {
146 angle = 360 - ((angle + 180) % 360);
147 angle = (angle / 180) * Math.PI;
148 return new vector(Math.sin(angle), Math.cos(angle));
149 }
150
151 normalize ()
152 {
153 var newVector = this.getCopy();
154 var length = newVector.length;
155
156 if (length != 0)
157 {
158 newVector.x /= length;
159 newVector.y /= length;
160 }
161
162 return newVector;
163 }
164
165
166 lerpTo (otherVector, t)
167 {
168 var delta = otherVector.subtract(this);
169
170 return this.add(delta.stretch(t));
171 }
172
173 lerpToInto (otherVector, t, out)
174 {
175 out.x = this.x + (otherVector.x - this.x) * t;
176 out.y = this.y + (otherVector.y - this.y) * t;
177 return out;
178 }
179
180
181 distanceToSq (otherVector)
182 {
183 var dX = this.x - otherVector.x;
184 var dY = this.y - otherVector.y;
185 return (dX * dX) + (dY * dY);
186 }
187
188 distanceTo (otherVector)
189 {
190 return Math.sqrt(this.distanceToSq(otherVector));
191 }
192
193
194 add (otherVector)
195 {
196 var newVector = this.getCopy();
197
198 newVector.x += otherVector.x;
199 newVector.y += otherVector.y;
200
201 return newVector;
202 }
203
204
205 subtract (otherVector)
206 {
207 var newVector = this.getCopy();
208
209 newVector.x -= otherVector.x;
210 newVector.y -= otherVector.y;
211
212 return newVector;
213 }
214
215
216 multiply (otherVector)
217 {
218 var newVector = this.getCopy();
219
220 newVector.x *= otherVector.x;
221 newVector.y *= otherVector.y;
222
223 return newVector;
224 }
225
226
227 divide (otherVector)
228 {
229 var newVector = this.getCopy();
230
231 newVector.x /= otherVector.x;
232 newVector.y /= otherVector.y;
233
234 return newVector;
235 }
236
237
238 stretch (length)
239 {
240 var newVector = this.getCopy();
241
242 newVector.x *= length;
243 newVector.y *= length;
244
245 return newVector;
246 }
247
248 rotate (degrees)
249 {
250 var ca = Math.cos(degrees * (Math.PI / 180));
251 var sa = Math.sin(degrees * (Math.PI / 180));
252 return new vector(ca * this.x - sa * this.y, sa * this.x + ca * this.y);
253 }
254
255 deltaAngle (otherVector)
256 {
257 var a = this.toAngle() * (Math.PI / 180);
258 var b = otherVector.toAngle() * (Math.PI / 180);
259
260 return Math.atan2(Math.sin(a - b), Math.cos(a - b)) * (180 / Math.PI);
261 }
262
263 cross (otherVector)
264 {
265 return this.x * otherVector.y - this.y * otherVector.x;
266 }
267
268
269 getCopy ()
270 {
271 return new vector(this.x, this.y);
272 }
273};
274/*
275 * End File:
276 * framework/util/vector.js
277 */
278
279/*
280 * Start File:
281 * framework/util/ease.js
282 */
283//ease functions
284
285var ease = {
286
287 //
288 // Basic ease functions
289 //
290
291 easeConstant: function (time, begin, change, duration)
292 {
293 "use strict";
294 return begin;
295 },
296
297 easeLinear: function (time, begin, change, duration)
298 {
299 "use strict";
300 var val = time / duration;
301 return begin + change * val;
302 },
303
304 easeInPower: function (time, begin, change, duration, power)
305 {
306 "use strict";
307 var val;
308 if (power === undefined) { power = 3; }
309 val = Math.pow(time / duration, power);
310 return begin + change * val;
311 },
312
313 easeOutPower: function (time, begin, change, duration, power)
314 {
315 "use strict";
316 var val = tbEase.easeInPower(duration - time, 1, -1, duration, power);
317 return begin + change * val;
318 },
319
320 easeInOutPower: function (time, begin, change, duration, power)
321 {
322 "use strict";
323 var val;
324 if (time < duration / 2)
325 {
326 val = tbEase.easeInPower(time, 0, 0.5, duration / 2, power);
327 } else
328 {
329 val = tbEase.easeInPower(duration - time, 1, -0.5, duration / 2, power);
330 }
331 return begin + change * val;
332 },
333
334 easeOutInPower: function (time, begin, change, duration, power)
335 {
336 "use strict";
337 var val;
338 if (time < duration / 2)
339 {
340 val = tbEase.easeInPower(duration / 2 - time, 0.5, -0.5, duration / 2, power);
341 } else
342 {
343 val = tbEase.easeInPower(time - duration / 2, 0.5, 0.5, duration / 2, power);
344 }
345 return begin + change * val;
346 },
347
348 easeInQuadratic: function (time, begin, change, duration)
349 {
350 "use strict";
351 return tbEase.easeInPower(time, begin, change, duration, 2);
352 },
353
354 easeOutQuadratic: function (time, begin, change, duration)
355 {
356 "use strict";
357 return tbEase.easeOutPower(time, begin, change, duration, 2);
358 },
359
360 easeInOutQuadratic: function (time, begin, change, duration)
361 {
362 "use strict";
363 return tbEase.easeInOutPower(time, begin, change, duration, 2);
364 },
365
366 easeOutInQuadratic: function (time, begin, change, duration)
367 {
368 "use strict";
369 return tbEase.easeOutInPower(time, begin, change, duration, 2);
370 },
371
372 easeInCubic: function (time, begin, change, duration)
373 {
374 "use strict";
375 return tbEase.easeInPower(time, begin, change, duration, 3);
376 },
377
378 easeOutCubic: function (time, begin, change, duration)
379 {
380 "use strict";
381 return tbEase.easeOutPower(time, begin, change, duration, 3);
382 },
383
384 easeInOutCubic: function (time, begin, change, duration)
385 {
386 "use strict";
387 return tbEase.easeInOutPower(time, begin, change, duration, 3);
388 },
389
390 easeOutInCubic: function (time, begin, change, duration)
391 {
392 "use strict";
393 return tbEase.easeOutInPower(time, begin, change, duration, 3);
394 },
395
396 easeInQuartic: function (time, begin, change, duration)
397 {
398 "use strict";
399 return tbEase.easeInPower(time, begin, change, duration, 4);
400 },
401
402 easeOutQuartic: function (time, begin, change, duration)
403 {
404 "use strict";
405 return tbEase.easeOutPower(time, begin, change, duration, 4);
406 },
407
408 easeInOutQuartic: function (time, begin, change, duration)
409 {
410 "use strict";
411 return tbEase.easeInOutPower(time, begin, change, duration, 4);
412 },
413
414 easeOutInQuartic: function (time, begin, change, duration)
415 {
416 "use strict";
417 return tbEase.easeOutInPower(time, begin, change, duration, 4);
418 },
419
420 easeInQuintic: function (time, begin, change, duration)
421 {
422 "use strict";
423 return tbEase.easeInPower(time, begin, change, duration, 5);
424 },
425
426 easeOutQuintic: function (time, begin, change, duration)
427 {
428 "use strict";
429 return tbEase.easeOutPower(time, begin, change, duration, 5);
430 },
431
432 easeInOutQuintic: function (time, begin, change, duration)
433 {
434 "use strict";
435 return tbEase.easeInOutPower(time, begin, change, duration, 5);
436 },
437
438 easeOutInQuintic: function (time, begin, change, duration)
439 {
440 "use strict";
441 return tbEase.easeOutInPower(time, begin, change, duration, 5);
442 },
443
444 easeInExponential: function (time, begin, change, duration, power)
445 {
446 "use strict";
447 var val, base;
448 if (power === undefined) { power = 8; }
449 base = Math.pow(2, -power); // The exponential function will not cover the whole range from 0-1 so we must correct it
450 val = (Math.pow(2, power * time / duration - power) - base) / (1 - base);
451 return begin + change * val;
452 },
453
454 easeOutExponential: function (time, begin, change, duration, power)
455 {
456 "use strict";
457 var val = tbEase.easeInExponential(duration - time, 1, -1, duration, power);
458 return begin + change * val;
459 },
460
461 easeInOutExponential: function (time, begin, change, duration, power)
462 {
463 "use strict";
464 var val;
465 if (time < duration / 2)
466 {
467 val = tbEase.easeInExponential(time, 0, 0.5, duration / 2, power);
468 } else
469 {
470 val = tbEase.easeInExponential(duration - time, 1, -0.5, duration / 2, power);
471 }
472 return begin + change * val;
473 },
474
475 easeOutInExponential: function (time, begin, change, duration, power)
476 {
477 "use strict";
478 var val;
479 if (time < duration / 2)
480 {
481 val = tbEase.easeInExponential(duration / 2 - time, 0.5, -0.5, duration / 2, power);
482 } else
483 {
484 val = tbEase.easeInExponential(time - duration / 2, 0.5, 0.5, duration / 2, power);
485 }
486 return begin + change * val;
487 },
488
489 easeInSine: function (time, begin, change, duration)
490 {
491 "use strict";
492 var val = 1 - Math.cos(time / duration * Math.PI / 2);
493 return begin + change * val;
494 },
495
496 easeOutSine: function (time, begin, change, duration)
497 {
498 "use strict";
499 var val = tbEase.easeInSine(duration - time, 1, -1, duration);
500 return begin + change * val;
501 },
502
503 easeInOutSine: function (time, begin, change, duration)
504 {
505 "use strict";
506 var val;
507 if (time < duration / 2)
508 {
509 val = tbEase.easeInSine(time, 0, 0.5, duration / 2);
510 } else
511 {
512 val = tbEase.easeInSine(duration - time, 1, -0.5, duration / 2);
513 }
514 return begin + change * val;
515 },
516
517 easeOutInSine: function (time, begin, change, duration)
518 {
519 "use strict";
520 var val;
521 if (time < duration / 2)
522 {
523 val = tbEase.easeInSine(duration / 2 - time, 0.5, -0.5, duration / 2);
524 } else
525 {
526 val = tbEase.easeInSine(time - duration / 2, 0.5, 0.5, duration / 2);
527 }
528 return begin + change * val;
529 },
530
531 easeInCircular: function (time, begin, change, duration)
532 {
533 "use strict";
534 var val = 1 - Math.sqrt(1 - Math.pow(time / duration, 2));
535 return begin + change * val;
536 },
537
538 easeOutCircular: function (time, begin, change, duration)
539 {
540 "use strict";
541 var val = tbEase.easeInCircular(duration - time, 1, -1, duration);
542 return begin + change * val;
543 },
544
545 easeInOutCircular: function (time, begin, change, duration)
546 {
547 "use strict";
548 var val;
549 if (time < duration / 2)
550 {
551 val = tbEase.easeInCircular(time, 0, 0.5, duration / 2);
552 } else
553 {
554 val = tbEase.easeInCircular(duration - time, 1, -0.5, duration / 2);
555 }
556 return begin + change * val;
557 },
558
559 easeOutInCircular: function (time, begin, change, duration)
560 {
561 "use strict";
562 var val;
563 if (time < duration / 2)
564 {
565 val = tbEase.easeInCircular(duration / 2 - time, 0.5, -0.5, duration / 2);
566 } else
567 {
568 val = tbEase.easeInCircular(time - duration / 2, 0.5, 0.5, duration / 2);
569 }
570 return begin + change * val;
571 },
572
573 easeInElastic: function (time, begin, change, duration, oscillations, stiffness)
574 {
575 "use strict";
576 var val;
577 if (oscillations === undefined) { oscillations = 3; }
578 if (stiffness === undefined) { stiffness = 8; }
579 val = Math.sin((1 - time / duration) * 2 * Math.PI * oscillations + Math.PI / 2); // Create the correct sign
580 val *= tbEase.easeInExponential(time, 0, 1, duration, stiffness); // Multiply with an exponential ease in
581 return begin + change * val;
582 },
583
584 easeOutElastic: function (time, begin, change, duration, oscillations, stiffness)
585 {
586 "use strict";
587 var val = tbEase.easeInElastic(duration - time, 1, -1, duration, oscillations, stiffness);
588 return begin + change * val;
589 },
590
591 easeInOutElastic: function (time, begin, change, duration, oscillations, stiffness)
592 {
593 "use strict";
594 var val;
595 if (time < duration / 2)
596 {
597 val = tbEase.easeInElastic(time, 0, 0.5, duration / 2, oscillations, stiffness);
598 } else
599 {
600 val = tbEase.easeInElastic(duration - time, 1, -0.5, duration / 2, oscillations, stiffness);
601 }
602 return begin + change * val;
603 },
604
605 easeOutInElastic: function (time, begin, change, duration, oscillations, stiffness)
606 {
607 "use strict";
608 var val;
609 if (time < duration / 2)
610 {
611 val = tbEase.easeInElastic(duration / 2 - time, 0.5, -0.5, duration / 2, oscillations, stiffness);
612 } else
613 {
614 val = tbEase.easeInElastic(time - duration / 2, 0.5, 0.5, duration / 2, oscillations, stiffness);
615 }
616 return begin + change * val;
617 },
618
619 easeInOvershoot: function (time, begin, change, duration, overshoot)
620 {
621 "use strict";
622 var val;
623 if (overshoot === undefined) { overshoot = 1.70158; }
624 val = (1 + overshoot) * Math.pow(time / duration, 3) - overshoot * Math.pow(time / duration, 2);
625 return begin + change * val;
626
627 },
628
629 easeOutOvershoot: function (time, begin, change, duration, overshoot)
630 {
631 "use strict";
632 var val = tbEase.easeInOvershoot(duration - time, 1, -1, duration, overshoot);
633 return begin + change * val;
634 },
635
636 easeInOutOvershoot: function (time, begin, change, duration, overshoot)
637 {
638 "use strict";
639 var val;
640 if (time < duration / 2)
641 {
642 val = tbEase.easeInOvershoot(time, 0, 0.5, duration / 2, overshoot);
643 } else
644 {
645 val = tbEase.easeInOvershoot(duration - time, 1, -0.5, duration / 2, overshoot);
646 }
647 return begin + change * val;
648 },
649
650 easeOutInOvershoot: function (time, begin, change, duration, overshoot)
651 {
652 "use strict";
653 var val;
654 if (time < duration / 2)
655 {
656 val = tbEase.easeInOvershoot(duration / 2 - time, 0.5, -0.5, duration / 2, overshoot);
657 } else
658 {
659 val = tbEase.easeInOvershoot(time - duration / 2, 0.5, 0.5, duration / 2, overshoot);
660 }
661 return begin + change * val;
662 },
663
664 easeInBounce: function (time, begin, change, duration, number, factor)
665 {
666 "use strict";
667 var bounces, i, w, width, height, val;
668 // Correct the arguments
669 if (number === undefined) { number = 4; }
670 if (factor === undefined) { factor = 2; } else { factor = Math.sqrt(factor); }
671 // Create the list of bounces
672 bounces = [1];
673 width = 1;
674 for (i = 1; i < number; i += 1)
675 {
676 bounces.push(bounces[i - 1] * factor);
677 width += bounces[i];
678 }
679 // Compute total size
680 width -= bounces[number - 1] / 2; // We don't use the last half bounce
681 height = Math.pow(bounces[number - 1], 2);
682 time = time / duration * width;
683 // Find the correct bounce
684 w = 0;
685 for (i = 0; i < number; i += 1)
686 {
687 if (time > bounces[i]) { time -= bounces[i]; } else { w = bounces[i]; break; }
688 }
689 // Now compute the value
690 val = -4 * Math.pow(time - w / 2, 2) + w * w;
691 return begin + change * val / height;
692 },
693
694 easeOutBounce: function (time, begin, change, duration, number, factor)
695 {
696 "use strict";
697 var val = tbEase.easeInBounce(duration - time, 1, -1, duration, number, factor);
698 return begin + change * val;
699 },
700
701 easeInOutBounce: function (time, begin, change, duration, number, factor)
702 {
703 "use strict";
704 var val;
705 if (time < duration / 2)
706 {
707 val = tbEase.easeInBounce(time, 0, 0.5, duration / 2, number, factor);
708 } else
709 {
710 val = tbEase.easeInBounce(duration - time, 1, -0.5, duration / 2, number, factor);
711 }
712 return begin + change * val;
713 },
714
715 easeOutInBounce: function (time, begin, change, duration, number, factor)
716 {
717 "use strict";
718 var val;
719 if (time < duration / 2)
720 {
721 val = tbEase.easeInBounce(duration / 2 - time, 0.5, -0.5, duration / 2, number, factor);
722 } else
723 {
724 val = tbEase.easeInBounce(time - duration / 2, 0.5, 0.5, duration / 2, number, factor);
725 }
726 return begin + change * val;
727 }
728};
729
730// Methods above call tbEase.*; alias so composed easings resolve at runtime.
731var tbEase = ease;
732/*
733 * End File:
734 * framework/util/ease.js
735 */
736
737/*
738 * Start File:
739 * framework/util/timingUtil.js
740 */
741/**
742 /* Timing utility
743 /*/
744
745var timingUtil =
746{
747 delayUntilCondition: function (conditionFunction, conditionContext, callback, context, interval)
748 {
749 interval = interval || 1;
750
751 if (conditionFunction.call(conditionContext))
752 {
753 callback.call(context);
754 }
755 else
756 {
757 setTimeout(function ()
758 {
759 timingUtil.delayUntilCondition(conditionFunction, conditionContext, callback, context, interval);
760 }, interval);
761 }
762 },
763
764 delayUntilNextFrame: function (callback, context)
765 {
766 requestAnimationFrame(function ()
767 {
768 callback.call(context);
769 });
770 },
771
772 delay: function (milliseconds, callback, context)
773 {
774 return setTimeout(function ()
775 {
776 callback.call(context);
777 }, milliseconds);
778 },
779
780 stop: function (timer)
781 {
782 clearTimeout(timer);
783 },
784
785 repeat: function (milliseconds, callback, context)
786 {
787 return setInterval(function ()
788 {
789 callback.call(context);
790 }, milliseconds);
791 }
792};
793
794// Historical alias — some call sites used TimingUtil casing.
795var TimingUtil = timingUtil;
796
797/*
798 * End File:
799 * framework/util/timingUtil.js
800 */
801
802/*
803 * Start File:
804 * framework/util/signal.js
805 */
806// Basic event listeners, modeled after Phaser Signals
807
808class Signal
809{
810 listeners = [];
811
812 dispatch ()
813 {
814 for (var i = 0; i < this.listeners.length; i++)
815 {
816 this.listeners[i].callback.apply(this.listeners[i].context, arguments);
817 }
818
819 for (var i = this.listeners.length - 1; i >= 0; i--)
820 {
821 if (this.listeners[i].once)
822 {
823 this.listeners.splice(i, 1);
824 }
825 }
826 }
827
828 add (callback, context, once)
829 {
830 if (!this.contains(callback, context))
831 {
832 this.listeners.push({ callback: callback, context: context, once: once });
833 }
834 }
835
836 addOnce (callback, context)
837 {
838 this.add(callback, context, true);
839 }
840
841 contains (callback, context)
842 {
843 for (var i = this.listeners.length - 1; i >= 0; i--)
844 {
845 if (this.listeners[i].callback === callback && this.listeners[i].context === context)
846 {
847 return true;
848 }
849 }
850
851 return false;
852 }
853
854 remove (callback, context)
855 {
856 for (var i = this.listeners.length - 1; i >= 0; i--)
857 {
858 if (this.listeners[i].callback === callback && this.listeners[i].context === context)
859 {
860 this.listeners.splice(i, 1);
861 break;
862 }
863 }
864 }
865
866 removeAll ()
867 {
868 this.listeners = [];
869 }
870}
871
872/*
873 * End File:
874 * framework/util/signal.js
875 */
876
877/*
878 * Start File:
879 * framework/util/cookie.js
880 */
881var CookieManager =
882{
883 setCookie: function (cname, cvalue, exdays = 365)
884 {
885 const d = new Date();
886
887 d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));
888 const expires = "expires=" + d.toUTCString();
889 const name = encodeURIComponent(cname);
890 const value = encodeURIComponent(cvalue);
891
892 document.cookie = name + "=" + value + ";" + expires + ";path=/;SameSite=Lax";
893 },
894
895 getCookie: function (cname)
896 {
897 const name = encodeURIComponent(cname) + "=";
898 const ca = document.cookie.split(';');
899
900 for (let i = 0; i < ca.length; i++)
901 {
902 let c = ca[i];
903
904 while (c.charAt(0) == ' ')
905 {
906 c = c.substring(1);
907 }
908
909 if (c.indexOf(name) == 0)
910 {
911 return decodeURIComponent(c.substring(name.length, c.length));
912 }
913 }
914
915 return "";
916 },
917
918 deleteCookie: function (cname)
919 {
920 document.cookie = encodeURIComponent(cname) + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/;SameSite=Lax";
921 }
922};
923
924/*
925 * End File:
926 * framework/util/cookie.js
927 */
928
929/*
930 * Start File:
931 * framework/util/urlParams.js
932 */
933var UrlParams =
934{
935 get: function (key)
936 {
937 var url_string = window.location.href;
938 var url = new URL(url_string);
939 var c = url.searchParams.get(key);
940
941 return c;
942 },
943
944 set: function (key, value)
945 {
946 var url_string = window.location.href;
947 var url = new URL(url_string);
948 url.searchParams.set(key, value);
949
950 // replaceState avoids flooding history when params change often.
951 window.history.replaceState(null, "", url);
952 }
953};
954
955/*
956 * End File:
957 * framework/util/urlParams.js
958 */
959
960/*
961 * Start File:
962 * framework/util/input.js
963 */
964
965
966var GameInput =
967{
968 keys: {},
969 g_keyStatus: [],
970 g_pKeyStatus: [],
971
972 g_pressKeyStatus: [],
973 g_ppressKeyStatus: [],
974
975 g_pressBlacklist: [],
976
977 g_mouseDown: false,
978 g_mouseDownThisFrame: false,
979
980 g_altMouseDown: false,
981 g_altMouseDownThisFrame: false,
982
983 g_middleMouseDown: false,
984 g_middleMouseDownThisFrame: false,
985
986 trueMousePosition: null,
987 mousePosition: null,
988
989 MouseButtons: {
990 Left: 0,
991 Middle: 1,
992 Right: 2
993 },
994
995 g_init: function ()
996 {
997 GameInput.trueMousePosition = new vector(0, 0);
998 GameInput.mousePosition = new vector(0, 0);
999
1000 document.onkeydown = GameInput.g_setKeyStatus;
1001 document.onkeyup = GameInput.g_setKeyStatus;
1002
1003 document.oncontextmenu = function () { return false; };
1004
1005 document.onmousedown = function (e)
1006 {
1007 switch (e.button)
1008 {
1009 case GameInput.MouseButtons.Left: GameInput.g_mouseDownThisFrame = true; break;
1010 case GameInput.MouseButtons.Middle: GameInput.g_middleMouseDownThisFrame = true; break;
1011 case GameInput.MouseButtons.Right: GameInput.g_altMouseDownThisFrame = true; break;
1012 }
1013 };
1014
1015 document.onmouseup = function (e)
1016 {
1017 switch (e.button)
1018 {
1019 case GameInput.MouseButtons.Left:
1020 GameInput.g_mouseDownThisFrame = false;
1021 GameInput.g_mouseDown = false;
1022 break;
1023 case GameInput.MouseButtons.Middle:
1024 GameInput.g_middleMouseDownThisFrame = false;
1025 GameInput.g_middleMouseDown = false;
1026 break;
1027 case GameInput.MouseButtons.Right:
1028 GameInput.g_altMouseDownThisFrame = false;
1029 GameInput.g_altMouseDown = false;
1030 break;
1031 }
1032 };
1033
1034 document.onmousemove = function (e)
1035 {
1036 if (!GameInput.trueMousePosition)
1037 { GameInput.trueMousePosition = new vector(); }
1038
1039 GameInput.trueMousePosition.x = e.x;
1040 GameInput.trueMousePosition.y = e.y;
1041 };
1042
1043 var el = document.getElementsByTagName("body")[0];
1044 el.addEventListener("touchstart", function () { GameInput.g_mouseDownThisFrame = true; }, false);
1045 el.addEventListener("touchend", function () { GameInput.g_mouseDownThisFrame = false; GameInput.g_mouseDown = false; }, false);
1046 el.addEventListener("touchcancel", function () { GameInput.g_mouseDownThisFrame = false; GameInput.g_mouseDown = false; }, false);
1047 el.addEventListener("touchmove", function () { return false; }, false);
1048 },
1049
1050 g_setKeyStatus: function (e)
1051 {
1052 GameInput.keys[e.key] = e.which;
1053 GameInput.g_keyStatus[e.which] = (e.type == "keydown");
1054
1055 if (!GameInput.g_pressBlacklist[e.which])
1056 { GameInput.g_pressKeyStatus[e.which] = (e.type == "keydown"); }
1057
1058 GameInput.g_pressBlacklist[e.which] = (e.type == "keydown"); //only allow single presses if key has been released once
1059 },
1060
1061 g_updateKeys: function ()
1062 {
1063 GameInput.mousePosition = GameInput.trueMousePosition;
1064
1065 // Snapshot previous frame — a bare assignment aliases the live array.
1066 GameInput.g_pKeyStatus = GameInput.g_keyStatus.slice();
1067 GameInput.g_ppressKeyStatus = GameInput.g_pressKeyStatus;
1068 GameInput.g_pressKeyStatus = [];
1069
1070 if (GameInput.g_mouseDown && GameInput.g_mouseDownThisFrame)
1071 {
1072 GameInput.g_mouseDownThisFrame = false;
1073 }
1074
1075 if (GameInput.g_mouseDownThisFrame && !GameInput.g_mouseDown)
1076 {
1077 GameInput.g_mouseDown = true;
1078 }
1079
1080 if (GameInput.g_altMouseDown && GameInput.g_altMouseDownThisFrame)
1081 {
1082 GameInput.g_altMouseDownThisFrame = false;
1083 }
1084
1085 if (GameInput.g_altMouseDownThisFrame && !GameInput.g_altMouseDown)
1086 {
1087 GameInput.g_altMouseDown = true;
1088 }
1089
1090 if (GameInput.g_middleMouseDown && GameInput.g_middleMouseDownThisFrame)
1091 {
1092 GameInput.g_middleMouseDownThisFrame = false;
1093 }
1094
1095 if (GameInput.g_middleMouseDownThisFrame && !GameInput.g_middleMouseDown)
1096 {
1097 GameInput.g_middleMouseDown = true;
1098 }
1099 },
1100
1101
1102 isPressed: function (keyCode)
1103 {
1104 if (GameInput.g_ppressKeyStatus[keyCode] == null)
1105 { return false; }
1106 else
1107 { return GameInput.g_ppressKeyStatus[keyCode]; }
1108 },
1109
1110
1111 isHeld: function (keyCode)
1112 {
1113 if (GameInput.g_pKeyStatus[keyCode] == null)
1114 { return false; }
1115 else
1116 { return GameInput.g_pKeyStatus[keyCode]; }
1117 },
1118
1119 _pressedState: { left: false, middle: false, right: false },
1120 _heldState: { left: false, middle: false, right: false },
1121
1122 mousePressed: function (btn)
1123 {
1124 switch (btn)
1125 {
1126 case GameInput.MouseButtons.Left: return GameInput.g_mouseDownThisFrame;
1127 case GameInput.MouseButtons.Middle: return GameInput.g_middleMouseDownThisFrame;
1128 case GameInput.MouseButtons.Right: return GameInput.g_altMouseDownThisFrame;
1129 }
1130
1131 const state = GameInput._pressedState;
1132 state.left = GameInput.g_mouseDownThisFrame;
1133 state.middle = GameInput.g_middleMouseDownThisFrame;
1134 state.right = GameInput.g_altMouseDownThisFrame;
1135 return state;
1136 },
1137
1138 mouseHeld: function (btn)
1139 {
1140 switch (btn)
1141 {
1142 case GameInput.MouseButtons.Left: return GameInput.g_mouseDown;
1143 case GameInput.MouseButtons.Middle: return GameInput.g_middleMouseDown;
1144 case GameInput.MouseButtons.Right: return GameInput.g_altMouseDown;
1145 }
1146
1147 const state = GameInput._heldState;
1148 state.left = GameInput.g_mouseDown;
1149 state.middle = GameInput.g_middleMouseDown;
1150 state.right = GameInput.g_altMouseDown;
1151 return state;
1152 }
1153};//
1154/*
1155 * End File:
1156 * framework/util/input.js
1157 */
1158
1159/*
1160 * Start File:
1161 * framework/util/audio.js
1162 */
1163var GameAudio =
1164{
1165 active: false,
1166 sounds: {},
1167 path: "",
1168 volume: 1,
1169 multiplay: true,
1170 supported: ["mp3", "ogg", "wav", "mp4", "aac"],
1171
1172 init: function (collection, containingFolder)
1173 {
1174 console.log("GAME: Loading sounds. (Note: Only supported from online-source, will fail when executed on local files.)");
1175
1176 try
1177 {
1178 if (typeof Audio !== "function" && typeof Audio !== "object")
1179 {
1180 throw new Error("HTML5 Audio is not supported in this browser");
1181 }
1182
1183 if (containingFolder == null)
1184 { containingFolder = ""; }
1185
1186 if (containingFolder != "")
1187 { containingFolder += "/"; }
1188
1189 this.path = containingFolder;
1190 this.sounds = {};
1191
1192 for (var i = 0; i < collection.length; i++)
1193 {
1194 var entry = collection[i];
1195 var name = entry.name;
1196 if (!name)
1197 { continue; }
1198
1199 var audio = new Audio();
1200 audio.preload = "auto";
1201 audio.volume = entry.volume != null ? entry.volume : this.volume;
1202 audio.src = this.resolveUrl(entry);
1203
1204 // Kick off preload without blocking init.
1205 audio.load();
1206
1207 this.sounds[name] = audio;
1208 }
1209
1210 this.active = true;
1211 }
1212 catch (err)
1213 {
1214 this.active = false;
1215 console.log("GAME: ERROR: Sounds could not be loaded. Sound will not be available.");
1216 }
1217 },
1218
1219 resolveUrl: function (entry)
1220 {
1221 if (entry.url)
1222 { return entry.url; }
1223
1224 var ext = entry.ext || this.pickExtension();
1225 if (ext.charAt(0) === ".")
1226 { ext = ext.substring(1); }
1227
1228 return this.path + entry.name + "." + ext;
1229 },
1230
1231 pickExtension: function ()
1232 {
1233 var probe = new Audio();
1234
1235 for (var i = 0; i < this.supported.length; i++)
1236 {
1237 var ext = this.supported[i];
1238 var mime = this.mimeFor(ext);
1239 if (mime && probe.canPlayType(mime))
1240 { return ext; }
1241 }
1242
1243 return "mp3";
1244 },
1245
1246 mimeFor: function (ext)
1247 {
1248 switch (ext)
1249 {
1250 case "mp3": return "audio/mpeg";
1251 case "ogg": return "audio/ogg";
1252 case "wav": return "audio/wav";
1253 case "mp4":
1254 case "aac": return 'audio/mp4; codecs="mp4a.40.2"';
1255 default: return "";
1256 }
1257 },
1258
1259 play: function (name)
1260 {
1261 if (!this.active)
1262 { return; }
1263
1264 var source = this.sounds[name];
1265 if (!source)
1266 {
1267 console.warn("GAME: Sound '" + name + "' was not loaded.");
1268 return;
1269 }
1270
1271 var clip = this.multiplay ? source.cloneNode() : source;
1272 clip.volume = source.volume;
1273
1274 if (!this.multiplay)
1275 {
1276 try { clip.currentTime = 0; }
1277 catch (err) { /* ignore seek errors before load */ }
1278 }
1279
1280 var playPromise = clip.play();
1281 if (playPromise && typeof playPromise.catch === "function")
1282 {
1283 playPromise.catch(function ()
1284 {
1285 // Autoplay policies can reject until a user gesture; ignore.
1286 });
1287 }
1288 }
1289};
1290
1291/*
1292 * End File:
1293 * framework/util/audio.js
1294 */
1295
1296/*
1297 * Start File:
1298 * framework/util/ray.js
1299 */
1300class Ray
1301{
1302 static Cast (scene, origin, direction, maxLength = -1)
1303 {
1304 direction = direction.normalize();
1305 const hits = []; // {hitObj, hitPoint}
1306 for (var i = 0; i < scene.activeObjects.length; i++)
1307 {
1308 let castAngle = direction.toAngle();
1309
1310 if (scene.activeObjects[i] != this && scene.activeObjects[i].collider.enabled)
1311 {
1312 var hw = scene.activeObjects[i].transform.size.x / 2;
1313 var hh = scene.activeObjects[i].transform.size.y / 2;
1314
1315 const points =
1316 [
1317 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y - hh),
1318 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y - hh),
1319 new vector(scene.activeObjects[i].transform.position.x - hw, scene.activeObjects[i].transform.position.y + hh),
1320 new vector(scene.activeObjects[i].transform.position.x + hw, scene.activeObjects[i].transform.position.y + hh)
1321 ];
1322
1323 points.sort((p1, p2) => p1.subtract(origin).length - p2.subtract(origin).length).pop();
1324
1325 for (let p = 0; p < points.length; p++)
1326 {
1327 const point = points[p];
1328 const deltaDistance = point.subtract(origin).length;
1329
1330 if (deltaDistance > maxLength && maxLength > 0)
1331 {
1332 continue;
1333 }
1334
1335 const stretched = direction.stretch(Math.min(deltaDistance, maxLength > 0 ? maxLength : deltaDistance));
1336
1337 const calcPoint = origin.add(stretched);
1338
1339 if (scene.activeObjects[i].collider.isInBounds(calcPoint))
1340 {
1341 //determine in between which vector angles ray is
1342 var angles = points.map(p => Ray.mapPointToPointAndAngle(p, origin));
1343
1344 pointLoop:
1345 for (let pa = 0; pa < angles.length; pa++)
1346 {
1347 for (let pb = 0; pb < angles.length; pb++)
1348 {
1349 if (angles[pa].angle - angles[pb].angle > 270 || angles[pb].angle - angles[pa].angle > 270)
1350 {
1351
1352 castAngle = (castAngle + 180) % 360;
1353 angles.forEach(pIn => pIn.angle = (pIn.angle + 180) % 360);
1354 break pointLoop;
1355 }
1356 }
1357 }
1358
1359 angles = angles.sort((a, b) => b.angle - a.angle);
1360
1361 if (angles[1].length > angles[0].length && angles[1].length > angles[2].length)
1362 {
1363 //only one face can be hit at this time, which is between angles[0] and angles[2]
1364 angles.removeAt(1); //remove the center, connecting to the un-hittable face
1365 }
1366 else
1367 {
1368 //one of two faces can be hit at this time, either angles[0]-angles[1] or angles[1]-angles[2]
1369 (castAngle > angles[1].angle) ? angles.pop() : angles.shift(); //figure out on which side we are, and remove the furthest
1370 }
1371
1372 //calc % of angle in relation to the angles it is between
1373 const smallAngle = Math.min(angles[1].angle, angles[0].angle);
1374 const percent = (castAngle - smallAngle) / (Math.max(angles[1].angle, angles[0].angle) - smallAngle);
1375
1376 const hitPoint = angles[1].point.lerpTo(angles[0].point, percent);
1377 hits.push({
1378 hitObj: scene.activeObjects[i],
1379 hitPoint: hitPoint,
1380 length: hitPoint.subtract(origin).length
1381 });
1382 break;
1383 }
1384 }
1385 }
1386 }
1387
1388 if (hits.length === 0)
1389 { return undefined; }
1390
1391 let shortest = hits[0];
1392
1393 for (let i = 1; i < hits.length; i++)
1394 {
1395 if (hits[i].length < shortest.length)
1396 {
1397 shortest = hits[i];
1398 }
1399 }
1400
1401 return shortest;
1402 }
1403
1404 static mapPointToPointAndAngle (point, origin)
1405 {
1406 const delta = point.subtract(origin);
1407
1408 return {
1409 point: point,
1410 angle: delta.toAngle(),
1411 length: delta.length
1412 };
1413 }
1414}
1415/*
1416 * End File:
1417 * framework/util/ray.js
1418 */
1419
1420/*
1421 * Start File:
1422 * framework/util/quadTree.js
1423 */
1424/**
1425 * Quadtree is a data-structure that contains a root node, and child nodes up to a defined depth. These nodes can be considered 'buckets' that can hold up to X objects.
1426 * When that number is exceeded (and the maximum depth is not yet reached), the node will split up into 4 separate nodes
1427 * (top left, top right, bottom left, bottom right),
1428 * dividing up the objects into the correct quadrant based on their location.
1429 *
1430 */
1431
1432class QuadTree
1433{
1434 constructor (width, height, maxDepth = 7, bucketSize = 30)
1435 {
1436 this.root = new Node(0, 0, width, height, 0, null, "", this);
1437
1438 this.maxDepth = maxDepth;
1439 this.bucketSize = bucketSize;
1440
1441 this.width = width;
1442 this.height = height;
1443
1444 // Reused across queries (results are valid until the next query).
1445 this._queryNodes = [];
1446 this._queryResult = [];
1447 this._queryScored = [];
1448 }
1449
1450 /**
1451 * Adds object to the quadtree. if the amount of objects in the target node is higher than
1452 * the permitted size, it divides up into 4 new nodes. Contents of this node is then divided up.
1453 * @param {GameObject} object
1454 * @returns {void}
1455 */
1456 add (object)
1457 {
1458 let dirOfOob = this.outOfBounds(object);
1459 while (dirOfOob)
1460 {
1461 this.embiggen(dirOfOob);
1462 dirOfOob = this.outOfBounds(object);
1463 }
1464
1465 // Node.add may split and move the object into a descendant leaf
1466 // (divide sets object.node). Otherwise assign the leaf we inserted into.
1467 const node = this.findNodeFromRoot(object);
1468 node.add(object);
1469 if (!object.node)
1470 { object.node = node; }
1471 }
1472
1473 /**
1474 * Removes object from quadtree. If the total amount of objects held by siblings is lower than the maximum size,
1475 * a cleanup phase is triggered to remove the objects from siblings, moved up to parent node
1476 * @param {GameObject} object
1477 * @returns {void}
1478 */
1479
1480 remove (object)
1481 {
1482 const node = object.node || (!this.root.hasChildren ? this.root : null);
1483
1484 if (node && node.remove(object))
1485 {
1486 object.node = null;
1487 }
1488 }
1489
1490 /**
1491 * Retrieves objects within range of a given position. Sorted by distance from position
1492 *
1493 * @param {vector} position
1494 * @param {number} range (radius)
1495 * @returns {GameObject[]} result
1496 */
1497
1498 getObjectsInRange (position, range)
1499 {
1500 return this.getObjectsOfTypesInRange(position, range, null);
1501 }
1502
1503 /**
1504 * Retrieves objects within range of a given position matching a type. Sorted by distance from position
1505 *
1506 * @param {vector} position
1507 * @param {number} range (radius)
1508 * @param {class[]} types
1509 * @returns {GameObject[]} result
1510 */
1511
1512 getObjectsOfTypesInRange (position, range, types, options)
1513 {
1514 const typeFilter = Array.isArray(types)
1515 ? types.filter(t => t != null)
1516 : (types != null ? [types] : []);
1517
1518 return this.collectInRange(position, range, (obj) =>
1519 {
1520 if (typeFilter.length === 0)
1521 { return true; }
1522
1523 for (let i = 0, len = typeFilter.length; i < len; i++)
1524 {
1525 if (obj instanceof typeFilter[i])
1526 { return true; }
1527 }
1528
1529 return false;
1530 }, options);
1531 }
1532
1533 getObjectsWithTagInRange (position, range, tags, options)
1534 {
1535 const tagFilter = Array.isArray(tags)
1536 ? tags.filter(t => t != null)
1537 : (tags != null ? [tags] : []);
1538
1539 return this.collectInRange(position, range, (obj) =>
1540 {
1541 if (tagFilter.length === 0)
1542 { return true; }
1543
1544 const objTags = obj.tags;
1545 if (!objTags || objTags.length === 0)
1546 { return false; }
1547
1548 for (let i = 0, len = tagFilter.length; i < len; i++)
1549 {
1550 const want = tagFilter[i];
1551 for (let j = 0, jl = objTags.length; j < jl; j++)
1552 {
1553 if (objTags[j] == want)
1554 { return true; }
1555 }
1556 }
1557
1558 return false;
1559 }, options);
1560 }
1561
1562 getClosestObjectWithTagInRange (position, range, tags)
1563 {
1564 const tagFilter = Array.isArray(tags)
1565 ? tags.filter(t => t != null)
1566 : (tags != null ? [tags] : []);
1567
1568 return this.getClosestObjectInRange(position, range, (obj) =>
1569 {
1570 if (tagFilter.length === 0)
1571 { return true; }
1572
1573 const objTags = obj.tags;
1574 if (!objTags || objTags.length === 0)
1575 { return false; }
1576
1577 for (let i = 0, len = tagFilter.length; i < len; i++)
1578 {
1579 const want = tagFilter[i];
1580 for (let j = 0, jl = objTags.length; j < jl; j++)
1581 {
1582 if (objTags[j] == want)
1583 { return true; }
1584 }
1585 }
1586
1587 return false;
1588 });
1589 }
1590
1591 /**
1592 * @param {vector} position
1593 * @param {number} range
1594 * @param {Function} predicate
1595 * @param {{ sort?: boolean }} [options] - sort defaults true (closest first)
1596 * @returns {GameObject[]} reused buffer — consume before the next query
1597 */
1598 collectInRange (position, range, predicate, options)
1599 {
1600 const sort = !options || options.sort !== false;
1601 const rangeSq = range * range;
1602 const result = this._queryResult;
1603 result.length = 0;
1604
1605 const nodes = this._queryNodes;
1606 nodes.length = 0;
1607 nodes.push(this.root);
1608
1609 if (!sort)
1610 {
1611 while (nodes.length > 0)
1612 {
1613 const node = nodes.pop();
1614
1615 if (!this.isInRange(position, range, node))
1616 { continue; }
1617
1618 if (node.hasChildren)
1619 {
1620 nodes.push(node.topleft, node.topright, node.bottomleft, node.bottomright);
1621 continue;
1622 }
1623
1624 const objects = node.objects;
1625 for (let i = 0, len = objects.length; i < len; i++)
1626 {
1627 const obj = objects[i];
1628 const distSq = obj.transform.position.distanceToSq(position);
1629 if (distSq > 0 && distSq < rangeSq && predicate(obj))
1630 { result.push(obj); }
1631 }
1632 }
1633
1634 return result;
1635 }
1636
1637 const scored = this._queryScored;
1638 scored.length = 0;
1639
1640 while (nodes.length > 0)
1641 {
1642 const node = nodes.pop();
1643
1644 if (!this.isInRange(position, range, node))
1645 { continue; }
1646
1647 if (node.hasChildren)
1648 {
1649 nodes.push(node.topleft, node.topright, node.bottomleft, node.bottomright);
1650 continue;
1651 }
1652
1653 const objects = node.objects;
1654 for (let i = 0, len = objects.length; i < len; i++)
1655 {
1656 const obj = objects[i];
1657 const distSq = obj.transform.position.distanceToSq(position);
1658 if (distSq > 0 && distSq < rangeSq && predicate(obj))
1659 { scored.push({ obj, dist: distSq }); }
1660 }
1661 }
1662
1663 if (scored.length > 1)
1664 { scored.sort((a, b) => a.dist - b.dist); }
1665
1666 for (let i = 0, len = scored.length; i < len; i++)
1667 { result.push(scored[i].obj); }
1668
1669 return result;
1670 }
1671
1672 getClosestObjectInRange (position, range, predicate)
1673 {
1674 const rangeSq = range * range;
1675 const nodes = this._queryNodes;
1676 nodes.length = 0;
1677 nodes.push(this.root);
1678 let closest = null;
1679 let closestDistSq = rangeSq;
1680
1681 while (nodes.length > 0)
1682 {
1683 const node = nodes.pop();
1684
1685 if (!this.isInRange(position, range, node))
1686 { continue; }
1687
1688 if (node.hasChildren)
1689 {
1690 nodes.push(node.topleft, node.topright, node.bottomleft, node.bottomright);
1691 continue;
1692 }
1693
1694 const objects = node.objects;
1695 for (let i = 0, len = objects.length; i < len; i++)
1696 {
1697 const obj = objects[i];
1698 const distSq = obj.transform.position.distanceToSq(position);
1699 if (distSq > 0 && distSq < closestDistSq && predicate(obj))
1700 {
1701 closestDistSq = distSq;
1702 closest = obj;
1703 }
1704 }
1705 }
1706
1707 return closest;
1708 }
1709
1710 isInRange (vector, range, node)
1711 {
1712 var points =
1713 [
1714 vector.x - range,
1715 vector.x + range,
1716 vector.y - range,
1717 vector.y + range
1718 ];
1719
1720 if (points[1] >= node.x1 && points[0] <= node.x2)
1721 {
1722 if (points[3] >= node.y1 && points[2] <= node.y2)
1723 {
1724 return true;
1725 }
1726 }
1727 return false;
1728 }
1729
1730 embiggen (dirOfOob)
1731 {
1732 // Place the current root as a child of a 2x parent that grows into the
1733 // out-of-bounds direction (L←, R→, U↑, D↓).
1734 if (dirOfOob == "L")
1735 {
1736 this.root = this.root.createParent("topright");
1737 }
1738 else if (dirOfOob == "R")
1739 {
1740 this.root = this.root.createParent("topleft");
1741 }
1742 else if (dirOfOob == "U")
1743 {
1744 this.root = this.root.createParent("bottomleft");
1745 }
1746 else if (dirOfOob == "D")
1747 {
1748 this.root = this.root.createParent("topleft");
1749 }
1750
1751 this.width = this.root.lengthX;
1752 this.height = this.root.lengthY;
1753 }
1754
1755 traverseTo (path)
1756 {
1757 let node = this.root;
1758
1759 for (let i = 0, len = path.length; i < len; i++)
1760 {
1761 if (!node.hasChildren)
1762 { return node; }
1763
1764 node = node.getChildren()[path[i]];
1765 }
1766
1767 return node;
1768 }
1769
1770 findNodeFromRoot (object)
1771 {
1772 return this.findNodeFromRootAtPosition(object.transform.position);
1773 }
1774
1775 findNodeFromRootAtPosition (position)
1776 {
1777 let node = this.root;
1778
1779 while (node && node.hasChildren)
1780 {
1781 node = node.findChildNode(position) || node.topleft;
1782 }
1783
1784 return node || this.root;
1785 }
1786
1787 show (ctx)
1788 {
1789 this.showAll(this.root, ctx);
1790 }
1791
1792 showAll (node, ctx)
1793 {
1794 node.show(ctx);
1795
1796 if (node.hasChildren)
1797 {
1798 node.getChildren().forEach((element) => this.showAll(element, ctx));
1799 }
1800 }
1801
1802 update (/* deltaTime */)
1803 {
1804 // Merge/split happen eagerly on add/remove; nothing to tick per frame.
1805 }
1806
1807 outOfBounds (object)
1808 {
1809 const pos = object.transform.position;
1810
1811 if (pos.x < this.root.x1)
1812 {
1813 return "L";
1814 }
1815
1816 if (pos.x > this.root.x2)
1817 {
1818 return "R";
1819 }
1820
1821 if (pos.y < this.root.y1)
1822 {
1823 return "U";
1824 }
1825
1826 if (pos.y > this.root.y2)
1827 {
1828 return "D";
1829 }
1830
1831 return false;
1832 }
1833}
1834
1835class Node
1836{
1837 get canBeMerged ()
1838 {
1839 // Leaf siblings may collapse into their parent when the parent's
1840 // whole subtree fits in one bucket again.
1841 return !this.hasChildren && this.parent && this.parent.recursiveCount <= this.quadTree.bucketSize;
1842 }
1843
1844 get shouldSplit ()
1845 {
1846 return !this.hasChildren
1847 && this.recursiveCount > this.quadTree.bucketSize
1848 && this.depth < this.quadTree.maxDepth;
1849 }
1850
1851 get hasChildren ()
1852 {
1853 return this.bottomright != null; //assume the rest is there too
1854 }
1855
1856 constructor (x1, y1, x2, y2, depth, parent, name, quadTree)
1857 {
1858 this.name = name;
1859
1860 this.x1 = x1;
1861 this.x2 = x2;
1862 this.y1 = y1;
1863 this.y2 = y2;
1864
1865 this.objects = [];
1866
1867 this.topleft = null;
1868 this.topright = null;
1869 this.bottomleft = null;
1870 this.bottomright = null;
1871
1872 this.parent = parent;
1873
1874 this.depth = depth;
1875 this.recursiveCount = 0;
1876
1877 this.lengthX = this.x2 - this.x1;
1878 this.lengthY = this.y2 - this.y1;
1879
1880 this.halfLengthX = this.lengthX / 2;
1881 this.halfLengthY = this.lengthY / 2;
1882
1883 this.quadTree = quadTree;
1884 }
1885
1886 addCount ()
1887 {
1888 this.recursiveCount++;
1889
1890 this.parent && this.parent.addCount();
1891
1892 if (this.shouldSplit)
1893 {
1894 this.divide();
1895 }
1896 }
1897
1898 removeCount ()
1899 {
1900 this.recursiveCount--;
1901
1902 // Merge before notifying the parent. If the parent is checked first,
1903 // it still sees this node as a branch and skips the collapse; after
1904 // this node merges into a leaf the parent never re-checks.
1905 if (this.hasChildren)
1906 {
1907 let merge = true;
1908 const children = this.getChildren();
1909 for (let i = 0, l = children.length; i < l; i++)
1910 {
1911 if (!children[i].canBeMerged)
1912 { merge = false; }
1913 }
1914
1915 if (merge)
1916 {
1917 this.merge();
1918 }
1919 }
1920
1921 this.parent && this.parent.removeCount();
1922 }
1923
1924 remove (obj)
1925 {
1926 const index = this.objects ? this.objects.indexOf(obj) : -1;
1927 if (index >= 0)
1928 {
1929 this.objects.splice(index, 1);
1930 this.removeCount();
1931 return true;
1932 }
1933
1934 return false;
1935 }
1936
1937 add (obj, ignoreCount)
1938 {
1939 if (this.objects.indexOf(obj) < 0)
1940 {
1941 this.objects.push(obj);
1942
1943 if (!ignoreCount)
1944 { this.addCount(); }
1945 }
1946 }
1947
1948 divide ()
1949 {
1950 this.createNodes();
1951 const center = new vector((this.x1 + this.x2) / 2, (this.y1 + this.y2) / 2);
1952
1953 this.objects.forEach(object =>
1954 {
1955 if (object.transform.position.y > center.y)
1956 {
1957 if (object.transform.position.x > center.x)
1958 {
1959 object.node = this.bottomright;
1960 this.bottomright.add(object, true);
1961 }
1962 else
1963 {
1964 object.node = this.bottomleft;
1965 this.bottomleft.add(object, true);
1966 }
1967 }
1968 else
1969 {
1970 if (object.transform.position.x > center.x)
1971 {
1972 object.node = this.topright;
1973 this.topright.add(object, true);
1974 }
1975 else
1976 {
1977 object.node = this.topleft;
1978 this.topleft.add(object, true);
1979 }
1980 }
1981 });
1982
1983 this.objects = [];
1984
1985 // add(..., true) skips counting so the parent is not double-counted.
1986 // Children still need a correct local recursiveCount, and may themselves
1987 // need to split when this redistribute dumps more than bucketSize in one cell.
1988 this.getChildren().forEach(child =>
1989 {
1990 child.recursiveCount = child.objects.length;
1991 if (child.shouldSplit)
1992 {
1993 child.divide();
1994 }
1995 });
1996 }
1997
1998 merge ()
1999 {
2000 this.getChildren().forEach(child =>
2001 {
2002 child.getObjects().forEach(object =>
2003 {
2004 this.add(object, true);
2005 object.node = this;
2006 });
2007 });
2008
2009 this.removeNodes();
2010 }
2011
2012 size ()
2013 {
2014 if (this.objects != null)
2015 {
2016 return this.objects.length;
2017 }
2018 return 0;
2019 }
2020
2021 getObjects ()
2022 {
2023 return this.objects;
2024 }
2025
2026 getChildren ()
2027 {
2028 if (!this.hasChildren)
2029 {
2030 return [];
2031 }
2032
2033 return [this.topleft, this.topright, this.bottomleft, this.bottomright];
2034 }
2035
2036 findChildNode (position)
2037 {
2038 if (!this.hasChildren)
2039 { return this; }
2040
2041 // Same midpoint rule as divide() so add/remove/query stay consistent,
2042 // and we never return undefined on shared edges.
2043 const midX = this.x1 + this.halfLengthX;
2044 const midY = this.y1 + this.halfLengthY;
2045
2046 if (position.y > midY)
2047 {
2048 return position.x > midX ? this.bottomright : this.bottomleft;
2049 }
2050
2051 return position.x > midX ? this.topright : this.topleft;
2052 }
2053
2054 createNodes ()
2055 {
2056 if (this.hasChildren)
2057 { return; }
2058
2059 const depth = this.depth + 1;
2060
2061 this.topleft = new Node(this.x1, this.y1, this.x1 + this.halfLengthX, this.y1 + this.halfLengthY, depth, this, this.name + 0, this.quadTree);
2062
2063 this.topright = new Node(this.x1 + this.halfLengthX, this.y1, this.x2, this.y1 + this.halfLengthY, depth, this, this.name + 1, this.quadTree);
2064
2065 this.bottomleft = new Node(this.x1, this.y1 + this.halfLengthY, this.x1 + this.halfLengthX, this.y2, depth, this, this.name + 2, this.quadTree);
2066
2067 this.bottomright = new Node(this.x1 + this.halfLengthX, this.y1 + this.halfLengthY, this.x2, this.y2, depth, this, this.name + 3, this.quadTree);
2068
2069 return this.getChildren();
2070 }
2071
2072 createParent (nodePosition)
2073 {
2074 let parentNode;
2075
2076 if (nodePosition == "topleft")
2077 {
2078 parentNode = new Node(this.x1, this.y1, this.x1 + (this.lengthX * 2), this.y1 + (this.lengthY * 2), this.depth - 1, null, "", this.quadTree);
2079
2080 parentNode.topleft = this;
2081 }
2082
2083 if (nodePosition == "topright")
2084 {
2085 parentNode = new Node(this.x1 - this.lengthX, this.y1, this.x1 + this.lengthX, this.y1 + (this.lengthY * 2), this.depth - 1, null, "", this.quadTree);
2086
2087 parentNode.topright = this;
2088 }
2089
2090 if (nodePosition == "bottomleft")
2091 {
2092 parentNode = new Node(this.x1, this.y1 - this.lengthY, this.x1 + (this.lengthX * 2), this.y1 + this.lengthY, this.depth - 1, null, "", this.quadTree);
2093
2094 parentNode.bottomleft = this;
2095 }
2096
2097 if (nodePosition == "bottomright")
2098 {
2099 parentNode = new Node(this.x1 - this.lengthX, this.y1 - this.lengthY, this.x1 + this.lengthX, this.y1 + this.lengthY, this.depth - 1, null, "", this.quadTree);
2100
2101 parentNode.bottomright = this;
2102 }
2103
2104 this.parent = parentNode;
2105 parentNode.recursiveCount = this.recursiveCount;
2106
2107 if (!parentNode.topleft)
2108 {
2109 parentNode.topleft = new Node(parentNode.x1, parentNode.y1, parentNode.x1 + parentNode.halfLengthX, parentNode.y1 + parentNode.halfLengthY, this.depth, parentNode, parentNode.name + 0, this.quadTree);
2110 }
2111
2112 if (!parentNode.topright)
2113 {
2114 parentNode.topright = new Node(parentNode.x1 + parentNode.halfLengthX, parentNode.y1, parentNode.x2, parentNode.y1 + parentNode.halfLengthY, this.depth, parentNode, parentNode.name + 1, this.quadTree);
2115 }
2116
2117 if (!parentNode.bottomleft)
2118 {
2119 parentNode.bottomleft = new Node(parentNode.x1, parentNode.y1 + parentNode.halfLengthY, parentNode.x1 + parentNode.halfLengthX, parentNode.y2, this.depth, parentNode, parentNode.name + 2, this.quadTree);
2120 }
2121
2122 if (!parentNode.bottomright)
2123 {
2124 parentNode.bottomright = new Node(parentNode.x1 + parentNode.halfLengthX, parentNode.y1 + parentNode.halfLengthY, parentNode.x2, parentNode.y2, this.depth, parentNode, parentNode.name + 3, this.quadTree);
2125 }
2126
2127 parentNode.reconfigureNames("");
2128 return parentNode;
2129 }
2130
2131 startReconfigureNames ()
2132 {
2133 let parent = this;
2134 while (parent.parent)
2135 {
2136 parent = parent.parent;
2137 }
2138
2139 parent.reconfigureNames("");
2140 }
2141
2142 reconfigureNames (name)
2143 {
2144 this.name = name;
2145 const children = this.getChildren();
2146 for (let i = 0, l = children.length; i < l; i++)
2147 {
2148 children[i].reconfigureNames(name + i);
2149 }
2150 }
2151
2152 removeNodes ()
2153 {
2154 this.topleft = null;
2155 this.topright = null;
2156 this.bottomleft = null;
2157 this.bottomright = null;
2158 }
2159
2160 show (ctx)
2161 {
2162 ctx.strokeStyle = "white";
2163 ctx.strokeRect(this.x1, this.y1, this.lengthX, this.lengthY);
2164 }
2165}
2166/*
2167 * End File:
2168 * framework/util/quadTree.js
2169 */
2170
2171/*
2172 * Start File:
2173 * framework/util/particleEmitter.js
2174 */
2175class ParticleEmitter
2176{
2177 static pool = [];
2178 enabled = false;
2179 mine = [];
2180 position = null;
2181
2182 emissionRate = 0;
2183 emissionTimer = 0;
2184 emissionAngle = 0;
2185
2186 startRotation = 0;
2187 startVelocity = 0;
2188 startAngularVelocity = 0;
2189 acceleration = null;
2190 angularAcceleration = 0;
2191 sprite = null;
2192 startSize = null;
2193 endSize = null;
2194 lifetimeMin = 0;
2195 lifetimeMax = 0;
2196 fadeIn = 0;
2197 fadeOut = 0;
2198 animationSpeed = 0;
2199 startFrame = 0;
2200
2201 friction = null;
2202 angularFriction = 0;
2203
2204 constructor (position, sprite, emissionRate, emissionAngle,
2205 startRotation, startVelocity, startAngularVelocity, acceleration,
2206 angularAcceleration, startSize, endSize, lifetimeMin,
2207 lifetimeMax = -1, fadeIn = 0, fadeOut = 0, startFrame = 0, animationSpeed = 0)
2208 {
2209 if (lifetimeMax < 0)
2210 { lifetimeMax = lifetimeMin; }
2211
2212 this.position = position;
2213 this.sprite = sprite;
2214
2215 this.emissionRate = emissionRate;
2216 this.emissionTimer = emissionRate;
2217 this.emissionAngle = emissionAngle;
2218
2219 this.startRotation = startRotation;
2220 this.startVelocity = startVelocity * 10;
2221 this.startAngularVelocity = startAngularVelocity * 10;
2222 this.acceleration = acceleration.stretch(10);
2223 this.angularAcceleration = angularAcceleration * 10;
2224 this.startSize = startSize;
2225 this.endSize = endSize;
2226 this.lifetimeMin = lifetimeMin;
2227 this.lifetimeMax = lifetimeMax;
2228 this.fadeIn = fadeIn;
2229 this.fadeOut = fadeOut;
2230 this.startFrame = startFrame;
2231 this.animationSpeed = animationSpeed;
2232
2233 this.friction = new vector(0, 0);
2234 }
2235
2236 start ()
2237 {
2238 this.enabled = true;
2239 }
2240
2241 stop ()
2242 {
2243 this.enabled = false;
2244 }
2245
2246 emit (amount = 1)
2247 {
2248 for (let i = 0; i < amount; i++)
2249 {
2250 const newParticle = ParticleEmitter.unPool();
2251 this.mine.push(newParticle);
2252
2253 const velocity = vector.fromAngle(this.emissionAngle).stretch(this.startVelocity);
2254 newParticle.emit(this, this.position.x, this.position.y, this.startRotation,
2255 velocity.x, velocity.y, this.startAngularVelocity, this.acceleration.x,
2256 this.acceleration.y, this.angularAcceleration, this.sprite, this.startSize.x,
2257 this.startSize.y, this.endSize.x, this.endSize.y, this.lifetimeMin,
2258 this.lifetimeMax, this.fadeIn, this.fadeOut, this.startFrame, this.animationSpeed,
2259 this.friction.getCopy(), this.angularFriction);
2260 }
2261 }
2262
2263 update (deltaTime)
2264 {
2265 if (this.enabled)
2266 { this.emissionTimer -= deltaTime; }
2267
2268 if (this.emissionTimer <= 0)
2269 {
2270 this.emissionTimer = this.emissionRate;
2271 this.emit();
2272 }
2273
2274 // Backwards so dispose()/remove during update cannot skip particles.
2275 for (let i = this.mine.length - 1; i >= 0; i--)
2276 {
2277 this.mine[i].update(deltaTime);
2278 }
2279 }
2280
2281 draw (scene)
2282 {
2283 for (let i = 0; i < this.mine.length; i++)
2284 {
2285 this.mine[i].draw(scene);
2286 }
2287 }
2288
2289 dispose (particle)
2290 {
2291 this.mine.remove(particle);
2292 ParticleEmitter.returnToPool(particle);
2293 }
2294
2295 static unPool () //get a particle from the static pool
2296 {
2297 if (ParticleEmitter.pool.length > 0)
2298 {
2299 return ParticleEmitter.pool.pop();
2300 }
2301
2302 return new Particle();
2303 }
2304
2305 static returnToPool (particle)
2306 {
2307 if (!ParticleEmitter.pool.contains(particle))
2308 {
2309 ParticleEmitter.pool.push(particle);
2310 }
2311 }
2312}
2313
2314class Particle
2315{
2316 parent = null;
2317 position = null;
2318 rotation = 0;
2319 velocity = null;
2320 angularVelocity = 0;
2321 acceleration = null;
2322 angularAcceleration = 0;
2323 sprite = null;
2324 animTimer = 0;
2325 animationSpeed = 0;
2326 subImage = 0;
2327 startSize = null;
2328 endSize = null;
2329 fadeInTime = 0;
2330 fadeInStart = 0;
2331 fadeOutTime = 0;
2332 lifeTime = 0;
2333 lifeTimeStart = 0;
2334 friction = null;
2335 angularfriction = 0;
2336
2337 constructor ()
2338 {
2339 this.position = new vector(0, 0);
2340 this.velocity = new vector(0, 0);
2341 this.acceleration = new vector(0, 0);
2342 this.startSize = new vector(0, 0);
2343 this.endSize = new vector(0, 0);
2344 }
2345
2346 emit (parent, x, y, r, vx, vy, va, ax, ay, ar, spr, ssx, ssy, esx, esy, lmin, lmax, fi = 0, fo = 0, sf = 0, as = 0, fric, anfric)
2347 {
2348 this.parent = parent;
2349 this.position.x = x;
2350 this.position.y = y;
2351 this.rotation = r;
2352 this.velocity.x = vx;
2353 this.velocity.y = vy;
2354 this.angularVelocity = va;
2355 this.acceleration.x = ax;
2356 this.acceleration.y = ay;
2357 this.angularAcceleration = ar;
2358 this.sprite = spr;
2359 this.startSize.x = ssx;
2360 this.startSize.y = ssy;
2361 this.endSize.x = esx;
2362 this.endSize.y = esy;
2363 this.lifeTime = Math.randomRange(lmin, lmax);
2364 this.lifeTimeStart = this.lifeTime;
2365 this.fadeInTime = fi;
2366 this.fadeInStart = fi;
2367 this.fadeOutTime = fo;
2368 this.animationSpeed = as;
2369 this.animTimer = as;
2370 this.subImage = sf;
2371 this.friction = fric ? fric.getCopy() : new vector(0, 0);
2372 this.angularFriction = anfric;
2373 }
2374
2375 update (deltaTime)
2376 {
2377 this.position.x += this.velocity.x * deltaTime;
2378 this.position.y += this.velocity.y * deltaTime;
2379 this.velocity.x += this.acceleration.x * deltaTime;
2380 this.velocity.y += this.acceleration.y * deltaTime;
2381
2382 this.velocity.x += this.friction.x * deltaTime * -Math.sign(this.velocity.x * 10);
2383 this.velocity.y += this.friction.y * deltaTime * -Math.sign(this.velocity.y * 10);
2384
2385 this.rotation += this.angularVelocity * deltaTime;
2386 this.angularVelocity += this.angularAcceleration * deltaTime;
2387
2388 this.angularVelocity += this.angularFriction * deltaTime * -Math.sign(this.angularVelocity * 10);
2389
2390 this.lifeTime -= deltaTime;
2391
2392 if (this.fadeInTime > 0)
2393 { this.fadeInTime -= deltaTime; }
2394
2395 if (this.animationSpeed > 0)
2396 {
2397 this.animTimer -= deltaTime;
2398
2399 if (this.animTimer <= 0)
2400 {
2401 this.animTimer = this.animationSpeed;
2402 this.subImage = (this.subImage + 1) % this.sprite.subImages;
2403 }
2404 }
2405
2406 if (this.lifeTime <= 0)
2407 { this.parent.dispose(this); }
2408 }
2409
2410 draw (scene)
2411 {
2412 const foAlpha = this.fadeOutTime > 0
2413 ? Math.min(1, this.lifeTime / this.fadeOutTime)
2414 : 1;
2415
2416 const fiAlpha = this.fadeInStart > 0
2417 ? 1 - (this.fadeInTime / this.fadeInStart)
2418 : 1;
2419
2420 this.sprite.draw(
2421 scene,
2422 Math.round(this.position.x),
2423 Math.round(this.position.y),
2424 Math.lerp(this.endSize.x, this.startSize.x, this.lifeTime / this.lifeTimeStart),
2425 Math.lerp(this.endSize.y, this.startSize.y, this.lifeTime / this.lifeTimeStart),
2426 this.rotation,
2427 false,
2428 false,
2429 Math.min(fiAlpha, foAlpha),
2430 this.subImage
2431 );
2432 }
2433}
2434/*
2435 * End File:
2436 * framework/util/particleEmitter.js
2437 */
2438
2439/*
2440 * Start File:
2441 * framework/engine/gl/shader.js
2442 */
2443class Shader
2444{
2445 static DEFAULT_VERT = [
2446 "attribute vec2 a_position;",
2447 "attribute vec2 a_texCoord;",
2448 "uniform mat4 u_matrix;",
2449 "varying vec2 v_texCoord;",
2450 "void main() {",
2451 " gl_Position = u_matrix * vec4(a_position, 0.0, 1.0);",
2452 " v_texCoord = a_texCoord;",
2453 "}"
2454 ].join("\n");
2455
2456 static DEFAULT_FRAG = [
2457 "precision mediump float;",
2458 "uniform sampler2D u_texture;",
2459 "uniform float u_alpha;",
2460 "varying vec2 v_texCoord;",
2461 "void main() {",
2462 " vec4 color = texture2D(u_texture, v_texCoord);",
2463 " gl_FragColor = vec4(color.rgb, color.a * u_alpha);",
2464 "}"
2465 ].join("\n");
2466
2467 // Fullscreen NDC quad for screen-space / post-process passes.
2468 static SCREEN_VERT = [
2469 "attribute vec2 a_position;",
2470 "attribute vec2 a_texCoord;",
2471 "varying vec2 v_texCoord;",
2472 "void main() {",
2473 " gl_Position = vec4(a_position, 0.0, 1.0);",
2474 " v_texCoord = a_texCoord;",
2475 "}"
2476 ].join("\n");
2477
2478 static SCREEN_COPY_FRAG = [
2479 "precision mediump float;",
2480 "uniform sampler2D u_texture;",
2481 "varying vec2 v_texCoord;",
2482 "void main() {",
2483 " gl_FragColor = texture2D(u_texture, v_texCoord);",
2484 "}"
2485 ].join("\n");
2486
2487 constructor (vertSource, fragSource)
2488 {
2489 this.vertSource = vertSource || Shader.DEFAULT_VERT;
2490 this.fragSource = fragSource || Shader.DEFAULT_FRAG;
2491 this._programs = new WeakMap();
2492 }
2493
2494 static fragment (fragSource)
2495 {
2496 return new Shader(Shader.DEFAULT_VERT, fragSource);
2497 }
2498
2499 static screenFragment (fragSource)
2500 {
2501 return new Shader(Shader.SCREEN_VERT, fragSource);
2502 }
2503
2504 getProgramInfo (gl)
2505 {
2506 let info = this._programs.get(gl);
2507 if (info)
2508 { return info; }
2509
2510 const program = Shader._createProgram(gl, this.vertSource, this.fragSource);
2511 if (!program)
2512 { return null; }
2513
2514 info = {
2515 program: program,
2516 attribs: {
2517 position: gl.getAttribLocation(program, "a_position"),
2518 texCoord: gl.getAttribLocation(program, "a_texCoord")
2519 },
2520 uniforms: {}
2521 };
2522
2523 const numUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
2524 for (let i = 0; i < numUniforms; i++)
2525 {
2526 const uniformInfo = gl.getActiveUniform(program, i);
2527 if (!uniformInfo)
2528 { continue; }
2529
2530 info.uniforms[uniformInfo.name] = {
2531 location: gl.getUniformLocation(program, uniformInfo.name),
2532 type: uniformInfo.type,
2533 size: uniformInfo.size
2534 };
2535 }
2536
2537 this._programs.set(gl, info);
2538 return info;
2539 }
2540
2541 static _createShader (gl, type, source)
2542 {
2543 const shader = gl.createShader(type);
2544 gl.shaderSource(shader, source);
2545 gl.compileShader(shader);
2546
2547 if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))
2548 {
2549 console.error("Shader compile error:", gl.getShaderInfoLog(shader));
2550 console.error(source);
2551 gl.deleteShader(shader);
2552 return null;
2553 }
2554
2555 return shader;
2556 }
2557
2558 static _createProgram (gl, vertSource, fragSource)
2559 {
2560 const vertexShader = Shader._createShader(gl, gl.VERTEX_SHADER, vertSource);
2561 const fragmentShader = Shader._createShader(gl, gl.FRAGMENT_SHADER, fragSource);
2562 if (!vertexShader || !fragmentShader)
2563 { return null; }
2564
2565 const program = gl.createProgram();
2566 gl.attachShader(program, vertexShader);
2567 gl.attachShader(program, fragmentShader);
2568 gl.linkProgram(program);
2569
2570 gl.deleteShader(vertexShader);
2571 gl.deleteShader(fragmentShader);
2572
2573 if (!gl.getProgramParameter(program, gl.LINK_STATUS))
2574 {
2575 console.error("Shader link error:", gl.getProgramInfoLog(program));
2576 gl.deleteProgram(program);
2577 return null;
2578 }
2579
2580 return program;
2581 }
2582}
2583
2584/*
2585 * End File:
2586 * framework/engine/gl/shader.js
2587 */
2588
2589/*
2590 * Start File:
2591 * framework/engine/gl/builtinShaders.js
2592 */
2593// Built-in screen-space / effect shaders. Games can use these without fetching files.
2594// Expand this set over time into the default framework shader bundle.
2595
2596Shader.Builtin = Shader.Builtin || {};
2597
2598Shader.Builtin.BLOOM_BRIGHT_FRAG = [
2599 "precision mediump float;",
2600 "uniform sampler2D u_texture;",
2601 "uniform float u_threshold;",
2602 "uniform float u_softKnee;",
2603 "varying vec2 v_texCoord;",
2604 "void main() {",
2605 " vec4 color = texture2D(u_texture, v_texCoord);",
2606 // Peak channel (not Rec.709 luma) so reds are not weaker than greens/blues.
2607 " float peak = max(color.r, max(color.g, color.b)) * color.a;",
2608 " float knee = max(u_softKnee, 0.001);",
2609 " float soft = smoothstep(u_threshold, u_threshold + knee, peak);",
2610 // Normalize by peak so saturated colors contribute similar bloom energy.
2611 " float invPeak = 1.0 / max(peak, 0.001);",
2612 " vec3 balanced = color.rgb * invPeak * soft;",
2613 " gl_FragColor = vec4(balanced, 1.0);",
2614 "}"
2615].join("\n");
2616
2617// Max-filter dilate: fattens 1–4px hotspots so later blur has something to spread.
2618Shader.Builtin.BLOOM_DILATE_FRAG = [
2619 "precision mediump float;",
2620 "uniform sampler2D u_texture;",
2621 "uniform vec2 u_resolution;",
2622 "uniform float u_radius;",
2623 "varying vec2 v_texCoord;",
2624 "void main() {",
2625 " vec2 px = u_radius / max(u_resolution, vec2(1.0));",
2626 " vec4 c = texture2D(u_texture, v_texCoord);",
2627 " c = max(c, texture2D(u_texture, v_texCoord + vec2(px.x, 0.0)));",
2628 " c = max(c, texture2D(u_texture, v_texCoord - vec2(px.x, 0.0)));",
2629 " c = max(c, texture2D(u_texture, v_texCoord + vec2(0.0, px.y)));",
2630 " c = max(c, texture2D(u_texture, v_texCoord - vec2(0.0, px.y)));",
2631 " c = max(c, texture2D(u_texture, v_texCoord + px));",
2632 " c = max(c, texture2D(u_texture, v_texCoord - px));",
2633 " c = max(c, texture2D(u_texture, v_texCoord + vec2(px.x, -px.y)));",
2634 " c = max(c, texture2D(u_texture, v_texCoord + vec2(-px.x, px.y)));",
2635 " vec2 px2 = px * 2.0;",
2636 " c = max(c, texture2D(u_texture, v_texCoord + vec2(px2.x, 0.0)));",
2637 " c = max(c, texture2D(u_texture, v_texCoord - vec2(px2.x, 0.0)));",
2638 " c = max(c, texture2D(u_texture, v_texCoord + vec2(0.0, px2.y)));",
2639 " c = max(c, texture2D(u_texture, v_texCoord - vec2(0.0, px2.y)));",
2640 " gl_FragColor = c;",
2641 "}"
2642].join("\n");
2643
2644// Wider separable blur (13-tap). u_direction (1,0)/(0,1); u_blurSize in texels.
2645Shader.Builtin.BLOOM_BLUR_FRAG = [
2646 "precision mediump float;",
2647 "uniform sampler2D u_texture;",
2648 "uniform vec2 u_resolution;",
2649 "uniform vec2 u_direction;",
2650 "uniform float u_blurSize;",
2651 "varying vec2 v_texCoord;",
2652 "void main() {",
2653 " vec2 step = u_direction * u_blurSize / max(u_resolution, vec2(1.0));",
2654 " vec4 c = vec4(0.0);",
2655 " c += texture2D(u_texture, v_texCoord - step * 6.0) * 0.009;",
2656 " c += texture2D(u_texture, v_texCoord - step * 5.0) * 0.019;",
2657 " c += texture2D(u_texture, v_texCoord - step * 4.0) * 0.038;",
2658 " c += texture2D(u_texture, v_texCoord - step * 3.0) * 0.071;",
2659 " c += texture2D(u_texture, v_texCoord - step * 2.0) * 0.111;",
2660 " c += texture2D(u_texture, v_texCoord - step) * 0.147;",
2661 " c += texture2D(u_texture, v_texCoord) * 0.160;",
2662 " c += texture2D(u_texture, v_texCoord + step) * 0.147;",
2663 " c += texture2D(u_texture, v_texCoord + step * 2.0) * 0.111;",
2664 " c += texture2D(u_texture, v_texCoord + step * 3.0) * 0.071;",
2665 " c += texture2D(u_texture, v_texCoord + step * 4.0) * 0.038;",
2666 " c += texture2D(u_texture, v_texCoord + step * 5.0) * 0.019;",
2667 " c += texture2D(u_texture, v_texCoord + step * 6.0) * 0.009;",
2668 " gl_FragColor = c;",
2669 "}"
2670].join("\n");
2671
2672// Combine: add bloom while keeping / boosting chroma (avoids gray wash at high intensity).
2673Shader.Builtin.BLOOM_COMBINE_FRAG = [
2674 "precision mediump float;",
2675 "uniform sampler2D u_texture;",
2676 "uniform sampler2D u_scene;",
2677 "uniform float u_intensity;",
2678 "uniform float u_saturation;",
2679 "uniform float u_colorPreserve;",
2680 "varying vec2 v_texCoord;",
2681 "void main() {",
2682 " vec4 scene = texture2D(u_scene, v_texCoord);",
2683 " vec4 bloom = texture2D(u_texture, v_texCoord);",
2684 " vec3 bloomCol = bloom.rgb;",
2685 " float bloomPeak = max(bloomCol.r, max(bloomCol.g, bloomCol.b));",
2686 " bloomCol = mix(vec3(bloomPeak), bloomCol, u_saturation);",
2687 // Hue from scene peak (not luma) so red bullets keep chroma under colorPreserve.
2688 " float scenePeak = max(scene.r, max(scene.g, scene.b));",
2689 " vec3 sceneHue = scene.rgb / max(scenePeak, 0.04);",
2690 " bloomCol *= mix(vec3(1.0), sceneHue, clamp(u_colorPreserve, 0.0, 1.0));",
2691 " bloomCol *= u_intensity;",
2692 // Soft add: keeps punchy color instead of clipping hard to white/gray.
2693 " vec3 rgb = scene.rgb + bloomCol * (1.0 - scene.rgb * 0.35);",
2694 " float bloomA = max(bloomCol.r, max(bloomCol.g, bloomCol.b));",
2695 " float a = max(scene.a, min(bloomA, 1.0));",
2696 " gl_FragColor = vec4(rgb, a);",
2697 "}"
2698].join("\n");
2699
2700/**
2701 * Multi-pass bloom for a RenderLayer / scene.postShaders.
2702 *
2703 * options:
2704 * - threshold, softKnee, intensity, blurSize
2705 * - saturation: bloom chroma boost (1 = neutral, >1 = juicier)
2706 * - colorPreserve: 0–1 tint bloom with the original sprite hue
2707 * - smallSources: dilate tiny bright pixels before blur (good for 3–4px bullets)
2708 * - dilate: explicit dilate radius in texels (overrides smallSources default)
2709 * - scales: number of H/V blur scale pairs (default 2 with smallSources, else 1)
2710 * - halfRes: run dilate + blur at half resolution when true (default true)
2711 */
2712Shader.getBloomPostChain = function (options)
2713{
2714 options = options || {};
2715 const threshold = options.threshold != null ? options.threshold : 0.4;
2716 const softKnee = options.softKnee != null ? options.softKnee : 0.3;
2717 const intensity = options.intensity != null ? options.intensity : 1.25;
2718 const blurSize = options.blurSize != null ? options.blurSize : 3.0;
2719 const saturation = options.saturation != null ? options.saturation : 1.0;
2720 const colorPreserve = options.colorPreserve != null ? options.colorPreserve : 0.0;
2721 const smallSources = !!options.smallSources;
2722
2723 let dilateRadius = 0;
2724 if (options.dilate != null)
2725 { dilateRadius = options.dilate; }
2726 else if (smallSources)
2727 { dilateRadius = 4.5; } // fatter hotspots so tiny bullets bloom closer to large ones
2728
2729 const scales = options.scales != null
2730 ? options.scales
2731 : (smallSources ? 2 : 1);
2732
2733 // Dilate + blur at half-res (~4× less fill). Bright extract + combine stay full-res.
2734 const halfResBlur = options.halfRes !== false;
2735 const halfPass = halfResBlur ? { scale: 0.5 } : {};
2736 // At half-res, texel-sized kernels cover ~2× world space — keep visual width similar.
2737 const resScale = halfResBlur ? 0.5 : 1;
2738
2739 if (!Shader._bloomBright || Shader._bloomBright.fragSource !== Shader.Builtin.BLOOM_BRIGHT_FRAG)
2740 {
2741 Shader._bloomBright = Shader.screenFragment(Shader.Builtin.BLOOM_BRIGHT_FRAG);
2742 Shader._bloomDilate = Shader.screenFragment(Shader.Builtin.BLOOM_DILATE_FRAG);
2743 Shader._bloomBlur = Shader.screenFragment(Shader.Builtin.BLOOM_BLUR_FRAG);
2744 Shader._bloomCombine = Shader.screenFragment(Shader.Builtin.BLOOM_COMBINE_FRAG);
2745 }
2746
2747 const chain = [
2748 { shader: Shader._bloomBright, uniforms: { u_threshold: threshold, u_softKnee: softKnee } }
2749 ];
2750
2751 if (dilateRadius > 0)
2752 {
2753 chain.push(Object.assign({
2754 shader: Shader._bloomDilate,
2755 uniforms: { u_radius: dilateRadius * resScale }
2756 }, halfPass));
2757 }
2758
2759 const scaleFactors = [1, 2.2, 4.5, 8];
2760 for (let i = 0; i < scales; i++)
2761 {
2762 const size = blurSize * scaleFactors[Math.min(i, scaleFactors.length - 1)] * resScale;
2763 chain.push(Object.assign({
2764 shader: Shader._bloomBlur,
2765 uniforms: { u_direction: [1, 0], u_blurSize: size }
2766 }, halfPass));
2767 chain.push(Object.assign({
2768 shader: Shader._bloomBlur,
2769 uniforms: { u_direction: [0, 1], u_blurSize: size }
2770 }, halfPass));
2771 }
2772
2773 chain.push({
2774 shader: Shader._bloomCombine,
2775 uniforms: {
2776 u_intensity: intensity,
2777 u_saturation: saturation,
2778 u_colorPreserve: colorPreserve
2779 }
2780 });
2781 return chain;
2782};
2783
2784// --- Sprite effect builtins -------------------------------------------------
2785
2786Shader.Builtin.BUMPMAP_FRAG = [
2787 "precision mediump float;",
2788 "uniform sampler2D u_texture;",
2789 "uniform sampler2D u_bump;",
2790 "uniform float u_alpha;",
2791 "uniform vec2 u_worldCenter;",
2792 "uniform vec2 u_worldSize;",
2793 "uniform float u_rotationRad;",
2794 "uniform int u_lightCount;",
2795 "uniform vec2 u_lightPos[16];",
2796 "uniform vec3 u_lightColor[16];",
2797 "uniform float u_ambient;",
2798 "uniform float u_specular;",
2799 // 0 = height map (R), 1 = tangent-space normal map (RGB)
2800 "uniform float u_bumpMode;",
2801 "varying vec2 v_texCoord;",
2802 "void main() {",
2803 " vec4 albedo = texture2D(u_texture, v_texCoord);",
2804 " vec3 normal;",
2805 " if (u_bumpMode < 0.5) {",
2806 " float hL = texture2D(u_bump, v_texCoord + vec2(-0.01, 0.0)).r;",
2807 " float hR = texture2D(u_bump, v_texCoord + vec2(0.01, 0.0)).r;",
2808 " float hU = texture2D(u_bump, v_texCoord + vec2(0.0, -0.01)).r;",
2809 " float hD = texture2D(u_bump, v_texCoord + vec2(0.0, 0.01)).r;",
2810 " normal = normalize(vec3(hL - hR, hU - hD, 0.35));",
2811 " } else {",
2812 " vec3 nSample = texture2D(u_bump, v_texCoord).xyz * 2.0 - 1.0;",
2813 " normal = normalize(nSample);",
2814 " }",
2815 " float c = cos(u_rotationRad);",
2816 " float s = sin(u_rotationRad);",
2817 " normal = normalize(vec3(c * normal.x - s * normal.y, s * normal.x + c * normal.y, normal.z));",
2818 " vec2 local = (v_texCoord - vec2(0.5)) * u_worldSize;",
2819 " vec2 world = u_worldCenter + vec2(c * local.x - s * local.y, s * local.x + c * local.y);",
2820 " vec3 lighting = vec3(u_ambient);",
2821 " for (int i = 0; i < 16; i++) {",
2822 " if (i >= u_lightCount) { break; }",
2823 " vec2 toLight = u_lightPos[i] - world;",
2824 " float dist = max(length(toLight), 0.001);",
2825 " vec3 lightDir = normalize(vec3(toLight / dist, 0.75));",
2826 " float diff = max(dot(normal, lightDir), 0.0);",
2827 " float atten = 1.0 / (1.0 + dist * 0.006 + dist * dist * 0.00004);",
2828 " float spec = pow(diff, 24.0) * u_specular;",
2829 " lighting += u_lightColor[i] * (diff + spec) * atten;",
2830 " }",
2831 " gl_FragColor = vec4(albedo.rgb * lighting, albedo.a * u_alpha);",
2832 "}"
2833].join("\n");
2834
2835// Replace pure R/G/B paint channel with u_replaceColor.
2836Shader.Builtin.COLOUR_REPLACE_FRAG = [
2837 "precision mediump float;",
2838 "uniform sampler2D u_texture;",
2839 "uniform float u_alpha;",
2840 "uniform float u_channel;",
2841 "uniform vec3 u_replaceColor;",
2842 "varying vec2 v_texCoord;",
2843 "void main() {",
2844 " vec4 color = texture2D(u_texture, v_texCoord);",
2845 " float ch = color.r;",
2846 " float other = max(color.g, color.b);",
2847 " if (u_channel > 0.5 && u_channel < 1.5) { ch = color.g; other = max(color.r, color.b); }",
2848 " if (u_channel >= 1.5) { ch = color.b; other = max(color.r, color.g); }",
2849 " float mask = clamp((ch - other) * 1.75, 0.0, 1.0);",
2850 " vec3 rgb = mix(color.rgb, u_replaceColor, mask);",
2851 " gl_FragColor = vec4(rgb, color.a * u_alpha);",
2852 "}"
2853].join("\n");
2854
2855// Clip sprite where secondary map luminance < u_amount (0 = full, 1 = gone).
2856Shader.Builtin.DISINTEGRATE_FRAG = [
2857 "precision mediump float;",
2858 "uniform sampler2D u_texture;",
2859 "uniform sampler2D u_secondary;",
2860 "uniform float u_alpha;",
2861 "uniform float u_amount;",
2862 "varying vec2 v_texCoord;",
2863 "void main() {",
2864 " vec4 color = texture2D(u_texture, v_texCoord);",
2865 " float ref = texture2D(u_secondary, v_texCoord).r;",
2866 " if (ref < u_amount) { discard; }",
2867 " float edge = smoothstep(u_amount, u_amount + 0.08, ref);",
2868 " gl_FragColor = vec4(color.rgb, color.a * u_alpha * edge);",
2869 "}"
2870].join("\n");
2871
2872Shader.getBumpmapShader = function ()
2873{
2874 if (!Shader._bumpmap || Shader._bumpmap.fragSource !== Shader.Builtin.BUMPMAP_FRAG)
2875 { Shader._bumpmap = Shader.fragment(Shader.Builtin.BUMPMAP_FRAG); }
2876 return Shader._bumpmap;
2877};
2878
2879Shader.getColourReplaceShader = function ()
2880{
2881 if (!Shader._colourReplace)
2882 { Shader._colourReplace = Shader.fragment(Shader.Builtin.COLOUR_REPLACE_FRAG); }
2883 return Shader._colourReplace;
2884};
2885
2886Shader.getDisintegrateShader = function ()
2887{
2888 if (!Shader._disintegrate)
2889 { Shader._disintegrate = Shader.fragment(Shader.Builtin.DISINTEGRATE_FRAG); }
2890 return Shader._disintegrate;
2891};
2892
2893// --- Screen-space effect builtins ------------------------------------------
2894
2895Shader.Builtin.DIRECTIONAL_BLUR_FRAG = [
2896 "precision mediump float;",
2897 "uniform sampler2D u_texture;",
2898 "uniform vec2 u_resolution;",
2899 "uniform vec2 u_direction;",
2900 "uniform float u_length;",
2901 "varying vec2 v_texCoord;",
2902 "void main() {",
2903 " vec2 dir = u_direction;",
2904 " float len = length(dir);",
2905 " if (len > 0.0001) { dir /= len; } else { dir = vec2(1.0, 0.0); }",
2906 " vec2 step = dir * u_length / max(u_resolution, vec2(1.0));",
2907 " vec4 c = vec4(0.0);",
2908 " c += texture2D(u_texture, v_texCoord - step * 2.0) * 0.12;",
2909 " c += texture2D(u_texture, v_texCoord - step) * 0.23;",
2910 " c += texture2D(u_texture, v_texCoord) * 0.30;",
2911 " c += texture2D(u_texture, v_texCoord + step) * 0.23;",
2912 " c += texture2D(u_texture, v_texCoord + step * 2.0) * 0.12;",
2913 " gl_FragColor = c;",
2914 "}"
2915].join("\n");
2916
2917Shader.Builtin.RADIAL_BLUR_FRAG = [
2918 "precision mediump float;",
2919 "uniform sampler2D u_texture;",
2920 "uniform vec2 u_center;",
2921 "uniform float u_amount;",
2922 "varying vec2 v_texCoord;",
2923 "void main() {",
2924 " vec2 toCenter = u_center - v_texCoord;",
2925 " vec4 c = vec4(0.0);",
2926 " for (int i = 0; i < 8; i++) {",
2927 " float t = float(i) / 7.0;",
2928 " vec2 uv = v_texCoord + toCenter * t * u_amount;",
2929 " c += texture2D(u_texture, uv);",
2930 " }",
2931 " gl_FragColor = c / 8.0;",
2932 "}"
2933].join("\n");
2934
2935Shader.Builtin.COLOR_ADJUST_FRAG = [
2936 "precision mediump float;",
2937 "uniform sampler2D u_texture;",
2938 "uniform float u_saturation;",
2939 "uniform float u_contrast;",
2940 "uniform float u_brightness;",
2941 "varying vec2 v_texCoord;",
2942 "void main() {",
2943 " vec4 color = texture2D(u_texture, v_texCoord);",
2944 " float lum = dot(color.rgb, vec3(0.299, 0.587, 0.114));",
2945 " vec3 rgb = mix(vec3(lum), color.rgb, u_saturation);",
2946 " rgb = (rgb - 0.5) * u_contrast + 0.5 + u_brightness;",
2947 " gl_FragColor = vec4(rgb, color.a);",
2948 "}"
2949].join("\n");
2950
2951Shader.getDirectionalBlurPostChain = function (options)
2952{
2953 options = options || {};
2954 const direction = options.direction || [1, 0];
2955 const length = options.length != null ? options.length : 8;
2956
2957 if (!Shader._directionalBlur)
2958 { Shader._directionalBlur = Shader.screenFragment(Shader.Builtin.DIRECTIONAL_BLUR_FRAG); }
2959
2960 return [{
2961 shader: Shader._directionalBlur,
2962 uniforms: {
2963 u_direction: [direction[0], direction[1]],
2964 u_length: length
2965 }
2966 }];
2967};
2968
2969Shader.getRadialBlurPostChain = function (options)
2970{
2971 options = options || {};
2972 const amount = options.amount != null ? options.amount : 0.15;
2973 const center = options.center || [0.5, 0.5];
2974
2975 if (!Shader._radialBlur)
2976 { Shader._radialBlur = Shader.screenFragment(Shader.Builtin.RADIAL_BLUR_FRAG); }
2977
2978 return [{
2979 shader: Shader._radialBlur,
2980 uniforms: {
2981 u_amount: amount,
2982 u_center: [center[0], center[1]]
2983 }
2984 }];
2985};
2986
2987Shader.getColorAdjustPostChain = function (options)
2988{
2989 options = options || {};
2990 const saturation = options.saturation != null ? options.saturation : 1.0;
2991 const contrast = options.contrast != null ? options.contrast : 1.0;
2992 const brightness = options.brightness != null ? options.brightness : 0.0;
2993
2994 if (!Shader._colorAdjust)
2995 { Shader._colorAdjust = Shader.screenFragment(Shader.Builtin.COLOR_ADJUST_FRAG); }
2996
2997 return [{
2998 shader: Shader._colorAdjust,
2999 uniforms: {
3000 u_saturation: saturation,
3001 u_contrast: contrast,
3002 u_brightness: brightness
3003 }
3004 }];
3005};
3006
3007/*
3008 * End File:
3009 * framework/engine/gl/builtinShaders.js
3010 */
3011
3012/*
3013 * Start File:
3014 * framework/engine/gl/glContext.js
3015 */
3016class GLContext
3017{
3018 static MAX_LIGHTS = 16;
3019
3020 constructor (canvas)
3021 {
3022 this.canvas = canvas;
3023
3024 // 2D sprites do not benefit from MSAA; disabling avoids extra GPU cost.
3025 const attrs = { alpha: true, premultipliedAlpha: false, antialias: false };
3026 this.gl = canvas.getContext("webgl", attrs) || canvas.getContext("experimental-webgl", attrs);
3027
3028 if (!this.gl)
3029 { throw new Error("WebGL is not supported in this browser."); }
3030
3031 const gl = this.gl;
3032 gl.enable(gl.BLEND);
3033 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3034 gl.disable(gl.DEPTH_TEST);
3035 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
3036
3037 this.defaultShader = new Shader(Shader.DEFAULT_VERT, Shader.DEFAULT_FRAG);
3038 this.screenCopyShader = new Shader(Shader.SCREEN_VERT, Shader.SCREEN_COPY_FRAG);
3039 this.textures = new WeakMap();
3040 // Defaults for getTexture uploads. Games can switch to NEAREST for pixel art.
3041 this.textureMinFilter = gl.LINEAR;
3042 this.textureMagFilter = gl.LINEAR;
3043
3044 // Reused per-sprite uploads (avoid allocating Float32Array every draw).
3045 this._uvData = new Float32Array(8);
3046 this._matrixData = new Float32Array(16);
3047
3048 this.positionBuffer = gl.createBuffer();
3049 gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);
3050 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
3051 -0.5, -0.5,
3052 0.5, -0.5,
3053 -0.5, 0.5,
3054 0.5, 0.5
3055 ]), gl.STATIC_DRAW);
3056
3057 this.texCoordBuffer = gl.createBuffer();
3058 gl.bindBuffer(gl.ARRAY_BUFFER, this.texCoordBuffer);
3059 gl.bufferData(gl.ARRAY_BUFFER, this._uvData, gl.DYNAMIC_DRAW);
3060
3061 // Fullscreen NDC quad (triangle strip) + UVs (v=0 at bottom, matches FBO sampling).
3062 this.screenPositionBuffer = gl.createBuffer();
3063 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenPositionBuffer);
3064 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
3065 -1, -1,
3066 1, -1,
3067 -1, 1,
3068 1, 1
3069 ]), gl.STATIC_DRAW);
3070
3071 this.screenTexCoordBuffer = gl.createBuffer();
3072 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenTexCoordBuffer);
3073 gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
3074 0, 0,
3075 1, 0,
3076 0, 1,
3077 1, 1
3078 ]), gl.STATIC_DRAW);
3079
3080 // [0] = scene (stable during post), [1]/[2] = full-res ping-pong,
3081 // [3]/[4] = half-res ping-pong for pass.scale < 1 blur.
3082 this.framebuffers = [null, null, null, null, null];
3083 this.colorTextures = [null, null, null, null, null];
3084 this._offscreenIndex = 0;
3085 this._lastWidth = 0;
3086 this._lastHeight = 0;
3087 this._halfWidth = 0;
3088 this._halfHeight = 0;
3089 this._postUniforms = {};
3090 this._resUniform = [0, 0];
3091 this.setSize(canvas.width, canvas.height);
3092 }
3093
3094 setSize (width, height)
3095 {
3096 const gl = this.gl;
3097 width = Math.max(1, width | 0);
3098 height = Math.max(1, height | 0);
3099
3100 if (width !== this._lastWidth || height !== this._lastHeight)
3101 {
3102 this._lastWidth = width;
3103 this._lastHeight = height;
3104 this._halfWidth = Math.max(1, width >> 1);
3105 this._halfHeight = Math.max(1, height >> 1);
3106 gl.viewport(0, 0, width, height);
3107 this._rebuildFramebuffers(width, height);
3108 }
3109 }
3110
3111 _destroyFramebuffers ()
3112 {
3113 const gl = this.gl;
3114 for (let i = 0; i < this.framebuffers.length; i++)
3115 {
3116 if (this.framebuffers[i])
3117 {
3118 gl.deleteFramebuffer(this.framebuffers[i]);
3119 this.framebuffers[i] = null;
3120 }
3121
3122 if (this.colorTextures[i])
3123 {
3124 gl.deleteTexture(this.colorTextures[i]);
3125 this.colorTextures[i] = null;
3126 }
3127 }
3128 }
3129
3130 _rebuildFramebuffers (width, height)
3131 {
3132 const gl = this.gl;
3133 this._destroyFramebuffers();
3134
3135 this._halfWidth = Math.max(1, width >> 1);
3136 this._halfHeight = Math.max(1, height >> 1);
3137
3138 for (let i = 0; i < 5; i++)
3139 {
3140 const texW = i < 3 ? width : this._halfWidth;
3141 const texH = i < 3 ? height : this._halfHeight;
3142
3143 const texture = gl.createTexture();
3144 gl.bindTexture(gl.TEXTURE_2D, texture);
3145 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
3146 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
3147 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
3148 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
3149 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texW, texH, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
3150
3151 const fb = gl.createFramebuffer();
3152 gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
3153 gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
3154
3155 const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
3156 if (status !== gl.FRAMEBUFFER_COMPLETE)
3157 {
3158 console.error("Framebuffer incomplete:", status);
3159 }
3160
3161 this.framebuffers[i] = fb;
3162 this.colorTextures[i] = texture;
3163 }
3164
3165 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3166 gl.bindTexture(gl.TEXTURE_2D, null);
3167 }
3168
3169 clear (r, g, b, a = 1)
3170 {
3171 const gl = this.gl;
3172 gl.clearColor(r / 255, g / 255, b / 255, a);
3173 gl.clear(gl.COLOR_BUFFER_BIT);
3174 }
3175
3176 clearTransparent ()
3177 {
3178 const gl = this.gl;
3179 gl.clearColor(0, 0, 0, 0);
3180 gl.clear(gl.COLOR_BUFFER_BIT);
3181 }
3182
3183 beginOffscreenPass ()
3184 {
3185 const gl = this.gl;
3186 this._offscreenIndex = 0;
3187 gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffers[0]);
3188 gl.viewport(0, 0, this._lastWidth, this._lastHeight);
3189 gl.enable(gl.BLEND);
3190 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3191 }
3192
3193 endOffscreenPass ()
3194 {
3195 const gl = this.gl;
3196 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3197 }
3198
3199 /**
3200 * @param {Array} passes
3201 * @param {Object} builtins
3202 * @param {{ toCanvas?: boolean }} options - toCanvas true writes the last pass to the canvas.
3203 * @returns {WebGLTexture|null} final color texture when not drawing to canvas
3204 */
3205 applyPostShaders (passes, builtins = {}, options = {})
3206 {
3207 if (!passes || !passes.length)
3208 { return this.colorTextures[0]; }
3209
3210 const gl = this.gl;
3211 const toCanvas = !!options.toCanvas;
3212 const sceneTexture = this.colorTextures[0];
3213 let read = 0;
3214 let readIsHalf = false;
3215
3216 gl.disable(gl.BLEND);
3217
3218 for (let i = 0; i < passes.length; i++)
3219 {
3220 const pass = passes[i];
3221 const isLast = i === passes.length - 1;
3222 const wantHalf = pass.scale != null && pass.scale < 1;
3223
3224 let write;
3225 let writeW;
3226 let writeH;
3227
3228 if (wantHalf)
3229 {
3230 // Half-res ping-pong on indices 3/4.
3231 if (readIsHalf)
3232 { write = (read === 3) ? 4 : 3; }
3233 else
3234 { write = 3; }
3235
3236 writeW = this._halfWidth;
3237 writeH = this._halfHeight;
3238 }
3239 else
3240 {
3241 // Full-res ping-pong on 1/2 (never overwrite scene buffer 0).
3242 // When leaving half-res, read half texture into a full write target.
3243 if (read === 1)
3244 { write = 2; }
3245 else if (read === 2)
3246 { write = 1; }
3247 else
3248 { write = 1; }
3249
3250 writeW = this._lastWidth;
3251 writeH = this._lastHeight;
3252 }
3253
3254 if (isLast && toCanvas)
3255 {
3256 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3257 writeW = this._lastWidth;
3258 writeH = this._lastHeight;
3259 }
3260 else
3261 {
3262 gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffers[write]);
3263 }
3264
3265 gl.viewport(0, 0, writeW, writeH);
3266 gl.clearColor(0, 0, 0, 0);
3267 gl.clear(gl.COLOR_BUFFER_BIT);
3268
3269 const uniforms = this._postUniforms;
3270 for (const key in uniforms)
3271 {
3272 if (Object.prototype.hasOwnProperty.call(uniforms, key))
3273 { delete uniforms[key]; }
3274 }
3275 if (builtins)
3276 {
3277 for (const key in builtins)
3278 {
3279 if (Object.prototype.hasOwnProperty.call(builtins, key))
3280 { uniforms[key] = builtins[key]; }
3281 }
3282 }
3283 const passUniforms = pass.uniforms;
3284 if (passUniforms)
3285 {
3286 for (const key in passUniforms)
3287 {
3288 if (Object.prototype.hasOwnProperty.call(passUniforms, key))
3289 { uniforms[key] = passUniforms[key]; }
3290 }
3291 }
3292 this._resUniform[0] = writeW;
3293 this._resUniform[1] = writeH;
3294 uniforms.u_resolution = this._resUniform;
3295 this.drawFullscreen(pass.shader, this.colorTextures[read], uniforms, sceneTexture);
3296
3297 if (!isLast || !toCanvas)
3298 {
3299 read = write;
3300 readIsHalf = wantHalf && !(isLast && toCanvas);
3301 }
3302 }
3303
3304 this._offscreenIndex = read;
3305 gl.enable(gl.BLEND);
3306 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3307 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3308
3309 return toCanvas ? null : this.colorTextures[read];
3310 }
3311
3312 blitToCanvas (texture, composite = "alpha")
3313 {
3314 if (!texture)
3315 { return; }
3316
3317 const gl = this.gl;
3318 gl.bindFramebuffer(gl.FRAMEBUFFER, null);
3319 gl.viewport(0, 0, this._lastWidth, this._lastHeight);
3320 gl.enable(gl.BLEND);
3321
3322 if (composite === "add")
3323 { gl.blendFunc(gl.ONE, gl.ONE); }
3324 else
3325 { gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA); }
3326
3327 this.drawFullscreen(this.screenCopyShader, texture, null, null);
3328
3329 gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
3330 }
3331
3332 drawFullscreen (shader, texture, uniforms, sceneTexture)
3333 {
3334 const gl = this.gl;
3335 const info = shader.getProgramInfo(gl);
3336 if (!info || !texture)
3337 { return; }
3338
3339 gl.useProgram(info.program);
3340
3341 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenPositionBuffer);
3342 if (info.attribs.position >= 0)
3343 {
3344 gl.enableVertexAttribArray(info.attribs.position);
3345 gl.vertexAttribPointer(info.attribs.position, 2, gl.FLOAT, false, 0, 0);
3346 }
3347
3348 gl.bindBuffer(gl.ARRAY_BUFFER, this.screenTexCoordBuffer);
3349 if (info.attribs.texCoord >= 0)
3350 {
3351 gl.enableVertexAttribArray(info.attribs.texCoord);
3352 gl.vertexAttribPointer(info.attribs.texCoord, 2, gl.FLOAT, false, 0, 0);
3353 }
3354
3355 gl.activeTexture(gl.TEXTURE0);
3356 gl.bindTexture(gl.TEXTURE_2D, texture);
3357 this._setUniform(info, "u_texture", 0);
3358 this._setUniform(info, "u_alpha", 1);
3359
3360 if (sceneTexture && info.uniforms.u_scene)
3361 {
3362 gl.activeTexture(gl.TEXTURE1);
3363 gl.bindTexture(gl.TEXTURE_2D, sceneTexture);
3364 this._setUniform(info, "u_scene", 1);
3365 }
3366
3367 if (uniforms)
3368 {
3369 for (const name in uniforms)
3370 {
3371 if (!Object.prototype.hasOwnProperty.call(uniforms, name))
3372 { continue; }
3373
3374 this._setUniform(info, name, uniforms[name]);
3375 }
3376 }
3377
3378 gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
3379 }
3380
3381 /**
3382 * Default min/mag filter applied when creating textures in {@link getTexture}.
3383 * Does not rewrite textures that were already uploaded.
3384 */
3385 setDefaultTextureFilter (minFilter, magFilter)
3386 {
3387 const gl = this.gl;
3388 this.textureMinFilter = minFilter ?? gl.LINEAR;
3389 this.textureMagFilter = magFilter ?? gl.LINEAR;
3390 }
3391
3392 getTexture (htmlImage)
3393 {
3394 if (!htmlImage)
3395 { return null; }
3396
3397 let texture = this.textures.get(htmlImage);
3398 if (texture)
3399 { return texture; }
3400
3401 const gl = this.gl;
3402 texture = gl.createTexture();
3403 gl.bindTexture(gl.TEXTURE_2D, texture);
3404 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
3405 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
3406 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.textureMinFilter);
3407 gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.textureMagFilter);
3408 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, htmlImage);
3409
3410 this.textures.set(htmlImage, texture);
3411 return texture;
3412 }
3413
3414 drawSprite (options)
3415 {
3416 const gl = this.gl;
3417 const width = this._lastWidth;
3418 const height = this._lastHeight;
3419 if (width <= 0 || height <= 0)
3420 { return; }
3421
3422 const shader = options.shader || this.defaultShader;
3423 const info = shader.getProgramInfo(gl);
3424 if (!info)
3425 { return; }
3426
3427 const texture = options.texture;
3428 if (!texture)
3429 { return; }
3430
3431 gl.useProgram(info.program);
3432
3433 gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);
3434 if (info.attribs.position >= 0)
3435 {
3436 gl.enableVertexAttribArray(info.attribs.position);
3437 gl.vertexAttribPointer(info.attribs.position, 2, gl.FLOAT, false, 0, 0);
3438 }
3439
3440 const uv = options.uvRect || { u0: 0, v0: 0, u1: 1, v1: 1 };
3441 const uvData = this._uvData;
3442 uvData[0] = uv.u0; uvData[1] = uv.v0;
3443 uvData[2] = uv.u1; uvData[3] = uv.v0;
3444 uvData[4] = uv.u0; uvData[5] = uv.v1;
3445 uvData[6] = uv.u1; uvData[7] = uv.v1;
3446 gl.bindBuffer(gl.ARRAY_BUFFER, this.texCoordBuffer);
3447 gl.bufferSubData(gl.ARRAY_BUFFER, 0, uvData);
3448
3449 if (info.attribs.texCoord >= 0)
3450 {
3451 gl.enableVertexAttribArray(info.attribs.texCoord);
3452 gl.vertexAttribPointer(info.attribs.texCoord, 2, gl.FLOAT, false, 0, 0);
3453 }
3454
3455 const matrix = GLContext._buildSpriteMatrix(
3456 options.x, options.y,
3457 options.w, options.h,
3458 options.rotationDeg || 0,
3459 options.mirrorX, options.mirrorY,
3460 width, height,
3461 this._matrixData
3462 );
3463
3464 this._setUniform(info, "u_matrix", matrix);
3465 this._setUniform(info, "u_alpha", options.alpha == null ? 1 : options.alpha);
3466 this._setUniform(info, "u_worldCenter", [options.x, options.y]);
3467 this._setUniform(info, "u_worldSize", [options.w, options.h]);
3468 this._setUniform(info, "u_rotationRad", (options.rotationDeg || 0) * Math.PI / 180);
3469
3470 gl.activeTexture(gl.TEXTURE0);
3471 gl.bindTexture(gl.TEXTURE_2D, texture);
3472 this._setUniform(info, "u_texture", 0);
3473
3474 let nextUnit = 1;
3475 if (options.textures)
3476 {
3477 for (const name in options.textures)
3478 {
3479 if (!Object.prototype.hasOwnProperty.call(options.textures, name))
3480 { continue; }
3481
3482 const extra = options.textures[name];
3483 if (!extra)
3484 { continue; }
3485
3486 gl.activeTexture(gl.TEXTURE0 + nextUnit);
3487 gl.bindTexture(gl.TEXTURE_2D, extra);
3488 this._setUniform(info, name, nextUnit);
3489 nextUnit++;
3490 }
3491 }
3492
3493 if (options.lights)
3494 { this._setLights(info, options.lights); }
3495 else if (info.uniforms.u_lightCount)
3496 { this._setUniform(info, "u_lightCount", 0); }
3497
3498 // Sensible bump defaults when the shader asks for them.
3499 if (info.uniforms.u_ambient && (!options.uniforms || options.uniforms.u_ambient == null))
3500 { this._setUniform(info, "u_ambient", 0.35); }
3501 if (info.uniforms.u_specular && (!options.uniforms || options.uniforms.u_specular == null))
3502 { this._setUniform(info, "u_specular", 0.25); }
3503 if (info.uniforms.u_bumpMode && (!options.uniforms || options.uniforms.u_bumpMode == null))
3504 { this._setUniform(info, "u_bumpMode", 1); }
3505
3506 if (options.uniforms)
3507 {
3508 for (const name in options.uniforms)
3509 {
3510 if (!Object.prototype.hasOwnProperty.call(options.uniforms, name))
3511 { continue; }
3512
3513 this._setUniform(info, name, options.uniforms[name]);
3514 }
3515 }
3516
3517 gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
3518 }
3519
3520 _setLights (info, lights)
3521 {
3522 const gl = this.gl;
3523 const max = GLContext.MAX_LIGHTS;
3524 const count = Math.max(0, Math.min(lights.length, max));
3525 this._setUniform(info, "u_lightCount", count);
3526
3527 const posEntry = info.uniforms["u_lightPos[0]"] || info.uniforms.u_lightPos;
3528 const colEntry = info.uniforms["u_lightColor[0]"] || info.uniforms.u_lightColor;
3529 if (!posEntry || !colEntry || count === 0)
3530 {
3531 if (count === 0)
3532 { this._setUniform(info, "u_lightCount", 0); }
3533 return;
3534 }
3535
3536 const pos = new Float32Array(max * 2);
3537 const col = new Float32Array(max * 3);
3538
3539 for (let i = 0; i < count; i++)
3540 {
3541 const light = lights[i] || {};
3542 pos[i * 2] = light.x != null ? light.x : (light.position ? light.position.x : 0);
3543 pos[i * 2 + 1] = light.y != null ? light.y : (light.position ? light.position.y : 0);
3544
3545 const c = light.color != null ? light.color : [1, 1, 1];
3546 if (Array.isArray(c))
3547 {
3548 col[i * 3] = c[0] != null ? c[0] : 0;
3549 col[i * 3 + 1] = c[1] != null ? c[1] : 0;
3550 col[i * 3 + 2] = c[2] != null ? c[2] : 0;
3551 }
3552 else
3553 {
3554 col[i * 3] = (c.r != null ? c.r : 1);
3555 col[i * 3 + 1] = (c.g != null ? c.g : 1);
3556 col[i * 3 + 2] = (c.b != null ? c.b : 1);
3557 }
3558
3559 // Allow 0–255 style colors.
3560 if (col[i * 3] > 1 || col[i * 3 + 1] > 1 || col[i * 3 + 2] > 1)
3561 {
3562 col[i * 3] /= 255;
3563 col[i * 3 + 1] /= 255;
3564 col[i * 3 + 2] /= 255;
3565 }
3566 }
3567
3568 gl.uniform2fv(posEntry.location, pos);
3569 gl.uniform3fv(colEntry.location, col);
3570 }
3571
3572 _setUniform (info, name, value)
3573 {
3574 const entry = info.uniforms[name];
3575 if (!entry || entry.location == null)
3576 { return; }
3577
3578 const gl = this.gl;
3579 const loc = entry.location;
3580
3581 if (typeof value === "number")
3582 {
3583 if (entry.type === gl.INT || entry.type === gl.SAMPLER_2D)
3584 { gl.uniform1i(loc, value); }
3585 else
3586 { gl.uniform1f(loc, value); }
3587 return;
3588 }
3589
3590 if (value instanceof Float32Array)
3591 {
3592 if (value.length === 16)
3593 { gl.uniformMatrix4fv(loc, false, value); }
3594 else if (value.length === 9)
3595 { gl.uniformMatrix3fv(loc, false, value); }
3596 else if (value.length === 4)
3597 { gl.uniform4fv(loc, value); }
3598 else if (value.length === 3)
3599 { gl.uniform3fv(loc, value); }
3600 else if (value.length === 2)
3601 { gl.uniform2fv(loc, value); }
3602 return;
3603 }
3604
3605 if (Array.isArray(value))
3606 {
3607 if (value.length === 4)
3608 { gl.uniform4fv(loc, value); }
3609 else if (value.length === 3)
3610 { gl.uniform3fv(loc, value); }
3611 else if (value.length === 2)
3612 { gl.uniform2fv(loc, value); }
3613 else if (value.length === 1)
3614 { gl.uniform1f(loc, value[0]); }
3615 }
3616 }
3617
3618 // Column-major mat4: projection (canvas Y-down) * T * R * S
3619 static _buildSpriteMatrix (x, y, w, h, rotationDeg, mirrorX, mirrorY, canvasW, canvasH, out)
3620 {
3621 const sx = (mirrorX ? -1 : 1) * w;
3622 const sy = (mirrorY ? -1 : 1) * h;
3623 const rad = rotationDeg * Math.PI / 180;
3624 const c = Math.cos(rad);
3625 const s = Math.sin(rad);
3626
3627 // Model maps unit quad [-0.5,0.5] into pixel space.
3628 const m00 = c * sx;
3629 const m01 = -s * sy;
3630 const m10 = s * sx;
3631 const m11 = c * sy;
3632 const m30 = x;
3633 const m31 = y;
3634
3635 const pr0 = 2 / canvasW;
3636 const pr5 = -2 / canvasH;
3637 const pr12 = -1;
3638 const pr13 = 1;
3639
3640 const matrix = out || new Float32Array(16);
3641 // P * M (only 2D affine terms matter)
3642 matrix[0] = pr0 * m00;
3643 matrix[1] = pr5 * m10;
3644 matrix[2] = 0;
3645 matrix[3] = 0;
3646 matrix[4] = pr0 * m01;
3647 matrix[5] = pr5 * m11;
3648 matrix[6] = 0;
3649 matrix[7] = 0;
3650 matrix[8] = 0;
3651 matrix[9] = 0;
3652 matrix[10] = -1;
3653 matrix[11] = 0;
3654 matrix[12] = pr0 * m30 + pr12;
3655 matrix[13] = pr5 * m31 + pr13;
3656 matrix[14] = 0;
3657 matrix[15] = 1;
3658 return matrix;
3659 }
3660}
3661
3662/*
3663 * End File:
3664 * framework/engine/gl/glContext.js
3665 */
3666
3667/*
3668 * Start File:
3669 * framework/engine/renderLayer.js
3670 */
3671class RenderLayer
3672{
3673 static DEFAULT_NAME = "default";
3674
3675 constructor (name, options)
3676 {
3677 options = options || {};
3678 this.name = name || RenderLayer.DEFAULT_NAME;
3679 this.postShaders = options.postShaders || [];
3680 // "alpha" (source-over) or "add" (additive)
3681 this.composite = options.composite || "alpha";
3682 }
3683}
3684
3685/*
3686 * End File:
3687 * framework/engine/renderLayer.js
3688 */
3689
3690/*
3691 * Start File:
3692 * framework/engine/objectComponents/transform.js
3693 */
3694class Transform
3695{
3696 get position ()
3697 {
3698 if (!this.g_position)
3699 {this.g_position = new vector(0, 0);}
3700
3701 return this.g_position;
3702 }
3703
3704 set position (v)
3705 {
3706 if (!this.g_position)
3707 {this.g_position = new vector(v.x, v.y);}
3708
3709 this.g_position.x = v.x;
3710 this.g_position.y = v.y;
3711 }
3712
3713 get scale ()
3714 {
3715 if (!this.g_scale)
3716 {this.g_scale = new vector(0, 0);}
3717
3718 return this.g_scale;
3719 }
3720
3721 set scale (v)
3722 {
3723 if (!this.g_scale)
3724 {this.g_scale = new vector(v.x, v.y);}
3725
3726 this.g_scale.x = v.x;
3727 this.g_scale.y = v.y;
3728 }
3729
3730 get velocity ()
3731 {
3732 if (!this.g_velocity)
3733 {this.g_velocity = new vector(0, 0);}
3734
3735 return this.g_velocity;
3736 }
3737
3738 set velocity (v)
3739 {
3740 if (!this.g_velocity)
3741 {this.g_velocity = new vector(v.x, v.y);}
3742
3743 this.g_velocity.x = v.x;
3744 this.g_velocity.y = v.y;
3745 }
3746
3747 g_position = null;
3748
3749 g_scale = null;
3750 rotation = 0;
3751 gameObject = null;
3752
3753 g_velocity = null;
3754 angularVelocity = 0;
3755
3756 get size ()
3757 {
3758 const sprite = this.gameObject.renderer && this.gameObject.renderer.sprite;
3759 const width = sprite ? sprite.width : 0;
3760 const height = sprite ? sprite.height : 0;
3761
3762 if (!this.g_size)
3763 { this.g_size = new vector(0, 0); }
3764
3765 this.g_size.x = this.scale.x * width;
3766 this.g_size.y = this.scale.y * height;
3767 return this.g_size;
3768 }
3769
3770 set size (v)
3771 {
3772 const sprite = this.gameObject.renderer && this.gameObject.renderer.sprite;
3773 const width = sprite && sprite.width ? sprite.width : 1;
3774 const height = sprite && sprite.height ? sprite.height : 1;
3775
3776 this.scale.x = v.x / width;
3777 this.scale.y = v.y / height;
3778 }
3779
3780 constructor (gameObject, x, y, w, h, r)
3781 {
3782 this.gameObject = gameObject;
3783 this.position = new vector(x, y);
3784 this.scale = new vector(w, h);
3785 this.rotation = r;
3786
3787 this.velocity = new vector(0, 0);
3788 }
3789
3790 update (deltaTime)
3791 {
3792 const vel = this.velocity;
3793 if (vel.x !== 0 || vel.y !== 0)
3794 {
3795 this.position.x += vel.x * deltaTime;
3796 this.position.y += vel.y * deltaTime;
3797 }
3798
3799 if (this.angularVelocity !== 0)
3800 { this.rotation += this.angularVelocity * deltaTime; }
3801 }
3802
3803 pointTowards (point)
3804 {
3805 var delta = point.subtract(this.position);
3806
3807 this.rotation = delta.toAngle();
3808 }
3809
3810 get left ()
3811 {
3812 return this.g_dir(0);
3813 }
3814
3815 get right ()
3816 {
3817 return this.g_dir(180);
3818 }
3819
3820 get forward ()
3821 {
3822 return this.g_dir(90);
3823 }
3824
3825 get back ()
3826 {
3827 return this.g_dir(270);
3828 }
3829
3830 g_dir (offset)
3831 {
3832 var myAngleInRadians = (this.rotation + offset) * (Math.PI / 180);
3833
3834 return new vector(-Math.cos(myAngleInRadians), -Math.sin(myAngleInRadians));
3835 }
3836}
3837/*
3838 * End File:
3839 * framework/engine/objectComponents/transform.js
3840 */
3841
3842/*
3843 * Start File:
3844 * framework/engine/objectComponents/collider.js
3845 */
3846class Collider
3847{
3848 gameObject = null;
3849 enabled = false;
3850
3851 constructor (gameObject)
3852 {
3853 this.gameObject = gameObject;
3854 }
3855
3856 get widestDiagonal ()
3857 {
3858 return Math.sqrt((this.gameObject.transform.size.x * this.gameObject.transform.size.x) + (this.gameObject.transform.size.y * this.gameObject.transform.size.y));
3859 }
3860
3861 update (deltaTime)
3862 {
3863 if (this.enabled)
3864 {
3865 this.checkCollisions();
3866 }
3867
3868 // Bullets/FX have no click handlers — skip per-object mouse work entirely.
3869 const obj = this.gameObject;
3870 if (!obj.onClick && !obj.onMouseHeld)
3871 { return; }
3872
3873 const pressed = GameInput.mousePressed();
3874 const held = GameInput.mouseHeld();
3875
3876 if (pressed.left || pressed.middle || pressed.right)
3877 {
3878 this.checkClick(true, pressed);
3879 }
3880
3881 if (held.left || held.middle || held.right)
3882 {
3883 this.checkClick(false, held);
3884 }
3885 }
3886
3887 checkClick (thisFrame, btns)
3888 {
3889 if (!GameInput.mousePosition || !this.gameObject.scene)
3890 { return; }
3891
3892 var hit = false;
3893 var clickPos = GameInput.mousePosition
3894 .subtract(this.gameObject.scene.real_position)
3895 .subtract(this.gameObject.scene.cameraPosition);
3896
3897 var hw = this.gameObject.transform.size.x / 2;
3898 var hh = this.gameObject.transform.size.y / 2;
3899
3900 if (clickPos.x > this.gameObject.transform.position.x - hw && clickPos.x < this.gameObject.transform.position.x + hw)
3901 {
3902 if (clickPos.y > this.gameObject.transform.position.y - hh && clickPos.y < this.gameObject.transform.position.y + hh)
3903 {
3904 hit = true;
3905 }
3906 }
3907
3908 if (hit)
3909 {
3910 if (thisFrame)
3911 {
3912 this.gameObject.onClick && this.gameObject.onClick(btns);
3913 }
3914 else
3915 {
3916 this.gameObject.onMouseHeld && this.gameObject.onMouseHeld(btns);
3917 }
3918 }
3919 }
3920
3921 isInBounds (point)
3922 {
3923 var hw = this.gameObject.transform.size.x / 2;
3924 var hh = this.gameObject.transform.size.y / 2;
3925
3926 if (point.x > this.gameObject.transform.position.x - hw && point.x < this.gameObject.transform.position.x + hw)
3927 {
3928 if (point.y > this.gameObject.transform.position.y - hh && point.y < this.gameObject.transform.position.y + hh)
3929 {
3930 return true;
3931 }
3932 }
3933
3934 return false;
3935 }
3936
3937 checkCollisions ()
3938 {
3939 if (this.enabled && !this.gameObject.destroyed)
3940 {
3941 const activeObjects = this.gameObject.scene.activeObjects;
3942 const offset = activeObjects.indexOf(this.gameObject) + 1;
3943
3944 for (var i = offset; i < activeObjects.length; i++)
3945 {
3946 var o2 = activeObjects[i];
3947 if (o2 === this.gameObject || !o2.collider.enabled || o2.destroyed)
3948 { continue; }
3949
3950 if (this.widestDiagonal + o2.collider.widestDiagonal < this.gameObject.transform.position.distanceTo(o2.transform.position))
3951 { continue; }
3952
3953 var hit = false;
3954
3955 //hw = halfWidth, hh = halfHeight
3956 var hw = this.gameObject.transform.size.x / 2;
3957 var hh = this.gameObject.transform.size.y / 2;
3958
3959 var ohw = o2.transform.size.x / 2;
3960 var ohh = o2.transform.size.y / 2;
3961
3962 //CHECK FROM OBJ PERSPECTIVE
3963 var points =
3964 [
3965 this.gameObject.transform.position.x - hw,
3966 this.gameObject.transform.position.x + hw,
3967 this.gameObject.transform.position.y - hh,
3968 this.gameObject.transform.position.y + hh
3969 ];
3970
3971 if (points[1] >= o2.transform.position.x - ohw && points[0] <= o2.transform.position.x + ohw)
3972 {
3973 if (points[3] >= o2.transform.position.y - ohh && points[2] <= o2.transform.position.y + ohh)
3974 {
3975 hit = true;
3976 }
3977 }
3978
3979 if (hit)
3980 {
3981 if (!this.gameObject.destroyed && typeof this.gameObject.onCollision == 'function')
3982 { this.gameObject.onCollision(o2); }
3983
3984 if (!o2.destroyed && typeof o2.onCollision == 'function')
3985 { o2.onCollision(this.gameObject); }
3986 }
3987 }
3988 }
3989 }
3990}
3991/*
3992 * End File:
3993 * framework/engine/objectComponents/collider.js
3994 */
3995
3996/*
3997 * Start File:
3998 * framework/engine/objectComponents/renderer.js
3999 */
4000class Renderer
4001{
4002 sprite = null;
4003 gameObject = null;
4004 subImage = 0;
4005 alpha = 1;
4006 mirrorX = false;
4007 mirrorY = false;
4008
4009 defaultAnimationSpeed = 1;
4010
4011 cycle = null;
4012
4013 visible = true;
4014
4015 shader = null;
4016 shaderUniforms = null;
4017
4018 // Optional maps for builtin sprite effects (framework `image` instances).
4019 bumpMap = null;
4020 secondaryMap = null;
4021
4022 // Dynamic lights for bumpmap: [{ x, y, color: [r,g,b]|{r,g,b} }, ...]
4023 lights = null;
4024
4025 // RenderLayer name; null uses RenderLayer.DEFAULT_NAME ("default").
4026 layer = null;
4027
4028 constructor (parentObject, sprite)
4029 {
4030 this.gameObject = parentObject;
4031 this.sprite = sprite;
4032 this.shader = null;
4033 this.shaderUniforms = null;
4034 this.bumpMap = null;
4035 this.secondaryMap = null;
4036 this.lights = null;
4037 this.layer = null;
4038 }
4039
4040 get layerName ()
4041 {
4042 return this.layer || RenderLayer.DEFAULT_NAME;
4043 }
4044
4045 update (deltaTime)
4046 {
4047 if (this.cycle)
4048 {
4049 if (!this.cycle.cycleSpeed || this.cycle.cycleSpeed == -1)
4050 {
4051 this.subImage = this.cycle.cycleArray[this.cycle.default];
4052 this.cycle.current = this.cycle.default;
4053 return;
4054 }
4055 this.cycle.timer += deltaTime;
4056
4057 if (this.cycle.timer > this.cycle.cycleSpeed)
4058 {
4059 this.cycle.timer -= this.cycle.cycleSpeed;
4060 let next;
4061
4062 if (this.cycle.loop)
4063 {
4064 next = (this.cycle.current + 1) % this.cycle.cycleArray.length;
4065 }
4066 else
4067 {
4068 if (this.cycle.current + 1 >= this.cycle.cycleArray.length)
4069 {
4070 if (this.cycle.chain)
4071 {
4072 this.cycle.chainDefaultIndex = this.cycle.chainDefaultIndex || this.cycle.default;
4073 this.cycle.chainSpeed = this.cycle.chainSpeed || this.cycle.cycleSpeed;
4074 this.setAnimation(this.cycle.chain, this.cycle.chainDefaultIndex, this.cycle.chainSpeed);
4075 }
4076
4077 return;
4078 }
4079 else
4080 {
4081 next = this.cycle.current + 1;
4082 }
4083 }
4084
4085 this.updateCycleSprite(next);
4086 }
4087 }
4088 }
4089
4090 updateCycleSprite (index)
4091 {
4092 this.subImage = this.cycle.cycleArray[index];
4093 this.cycle.current = index;
4094 }
4095
4096 draw ()
4097 {
4098 if (this.sprite)
4099 {
4100 var offX = this.gameObject.scene.cameraPosition.x;
4101 var offY = this.gameObject.scene.cameraPosition.y;
4102
4103 this.drawSprite(this.gameObject.transform.position.x + offX,
4104 this.gameObject.transform.position.y + offY,
4105 this.gameObject.transform.size.x,
4106 this.gameObject.transform.size.y,
4107 this.gameObject.transform.rotation);
4108 }
4109 }
4110
4111 drawSprite (dx, dy, dw, dh, rotation)
4112 {
4113 if (isNaN(this.subImage))
4114 {
4115 this.subImage = this.g_subImgOld;
4116 }
4117 else
4118 {
4119 this.g_subImgOld = this.subImage;
4120 }
4121
4122 let textures = null;
4123 if (this.bumpMap || this.secondaryMap)
4124 {
4125 textures = {};
4126 if (this.bumpMap)
4127 { textures.u_bump = this.bumpMap; }
4128 if (this.secondaryMap)
4129 { textures.u_secondary = this.secondaryMap; }
4130 }
4131
4132 this.sprite.draw(
4133 this.gameObject.scene,
4134 Math.round(dx),
4135 Math.round(dy),
4136 dw,
4137 dh,
4138 rotation,
4139 this.mirrorX,
4140 this.mirrorY,
4141 this.alpha,
4142 this.subImage,
4143 this.shader,
4144 this.shaderUniforms,
4145 textures,
4146 this.lights
4147 );
4148 }
4149
4150 get currentAnimationName ()
4151 {
4152 return this.cycle ? this.cycle.label : null;
4153 }
4154
4155 setAnimation (label, defaultIndex = 0, cycleSpeed = -1)
4156 {
4157 if (cycleSpeed < 0)
4158 {
4159 cycleSpeed = this.defaultAnimationSpeed;
4160 }
4161
4162 if (!this.sprite || !this.sprite.animationCycles || !this.sprite.animationCycles[label])
4163 {
4164 console.warn("Renderer.setAnimation: unknown animation '" + label + "'");
4165 return;
4166 }
4167
4168 if (this.cycle)
4169 {
4170 if (this.cycle.label == label)
4171 {
4172 this.cycle.default = defaultIndex;
4173 this.cycle.cycleSpeed = cycleSpeed;
4174 return;
4175 }
4176 }
4177
4178 const cycleData = this.sprite.animationCycles[label];
4179
4180 this.cycle = {
4181 label: label,
4182 cycleArray: cycleData.frames,
4183 default: defaultIndex,
4184 current: defaultIndex,
4185 cycleSpeed: cycleSpeed,
4186 loop: cycleData.loop,
4187 chain: cycleData.chain,
4188 chainDefaultIndex: cycleData.chainDefaultIndex,
4189 chainSpeed: cycleData.chainSpeed,
4190 timer: 0
4191 };
4192
4193 this.subImage = this.cycle.cycleArray[this.cycle.current];
4194 }
4195
4196 setAnimationCycleSpeed (cycleSpeed)
4197 {
4198 if (this.cycle)
4199 {
4200 this.cycle.cycleSpeed = cycleSpeed;
4201 }
4202 }
4203
4204 setSubImage (subImage)
4205 {
4206 this.subImage = subImage;
4207 this.cycle = null;
4208 }
4209}
4210/*
4211 * End File:
4212 * framework/engine/objectComponents/renderer.js
4213 */
4214
4215/*
4216 * Start File:
4217 * framework/engine/image.js
4218 */
4219class image
4220{
4221 subImages = null;
4222 subImagesPerRow = null;
4223 loop = false;
4224 chain = null;
4225
4226 g_image = null;
4227
4228 animationCycles = {};
4229
4230 constructor (image, subImgTotal = 1, perRow = 1, loop = false, chain = null)
4231 {
4232 subImgTotal = subImgTotal || 1;
4233 perRow = perRow || 1;
4234
4235 this.subImages = subImgTotal;
4236 this.subImagesPerRow = perRow;
4237 this.g_image = image;
4238 this.loop = loop;
4239 this.chain = chain;
4240
4241 this.cacheWidth = -1;
4242 this.cacheHeight = -1;
4243
4244 // Keep the Image out of the DOM — canvas can draw from it directly.
4245 if (image && image.style)
4246 { image.style.display = "none"; }
4247 }
4248
4249 draw (scene, dx, dy, dw, dh, rotation, mirrorX, mirrorY, alpha, subImage, shader, uniforms, textures, lights)
4250 {
4251 if (!scene.glContext || !this.g_image)
4252 { return; }
4253
4254 // One hypot for frustum pad (was computed 4× per sprite).
4255 const pad = Math.sqrt(dw * dw + dh * dh);
4256 if (dx < -pad || dy < -pad || dx > scene.real_size.x + pad || dy > scene.real_size.y + pad)
4257 { return; }
4258
4259 let glTextures = null;
4260
4261 if (textures)
4262 {
4263 for (const name in textures)
4264 {
4265 if (!Object.prototype.hasOwnProperty.call(textures, name))
4266 { continue; }
4267
4268 const src = textures[name];
4269 if (!src)
4270 { continue; }
4271
4272 if (!glTextures)
4273 { glTextures = {}; }
4274
4275 const htmlImage = src.g_image || src;
4276 glTextures[name] = scene.glContext.getTexture(htmlImage);
4277 }
4278 }
4279
4280 const opts = this._drawOpts || (this._drawOpts = {});
4281 opts.texture = scene.glContext.getTexture(this.g_image);
4282 opts.x = dx;
4283 opts.y = dy;
4284 opts.w = dw;
4285 opts.h = dh;
4286 opts.rotationDeg = rotation;
4287 opts.mirrorX = mirrorX;
4288 opts.mirrorY = mirrorY;
4289 opts.alpha = alpha;
4290 opts.uvRect = this.getUvRect(subImage);
4291 opts.shader = shader || scene.glContext.defaultShader;
4292 opts.uniforms = uniforms;
4293 opts.textures = glTextures;
4294 opts.lights = lights;
4295 scene.glContext.drawSprite(opts);
4296 }
4297
4298 getUvRect (subImage)
4299 {
4300 if (!this._uvRects)
4301 { this._uvRects = []; }
4302
4303 const index = subImage | 0;
4304 let rect = this._uvRects[index];
4305 if (rect)
4306 { return rect; }
4307
4308 const subImageData = this.getSubImage(index);
4309 const imgW = this.g_image.width;
4310 const imgH = this.g_image.height;
4311 rect = {
4312 u0: subImageData.sx / imgW,
4313 v0: subImageData.sy / imgH,
4314 u1: (subImageData.sx + subImageData.sw) / imgW,
4315 v1: (subImageData.sy + subImageData.sh) / imgH
4316 };
4317 this._uvRects[index] = rect;
4318 return rect;
4319 }
4320
4321 hasAnimationCycle (label)
4322 {
4323 return this.animationCycles[label] != null;
4324 }
4325
4326 addAnimationCycle (label, cycle, loop, chain, chainDefaultIndex, chainSpeed)
4327 {
4328 this.animationCycles[label] =
4329 {
4330 frames: cycle,
4331 loop: loop,
4332 chain: chain,
4333 chainDefaultIndex: chainDefaultIndex,
4334 chainSpeed: chainSpeed
4335 };
4336 }
4337
4338 get width ()
4339 {
4340 if (this.cacheWidth < 0)
4341 { this.cacheWidth = this.g_image.width / this.subImagesPerRow; }
4342
4343 return this.cacheWidth;
4344 }
4345
4346 get height ()
4347 {
4348 if (this.cacheHeight < 0)
4349 { this.cacheHeight = this.g_image.height / (Math.ceil(this.subImages / this.subImagesPerRow) + 0); }
4350
4351 return this.cacheHeight;
4352 }
4353
4354 cacheWidth = -1;
4355 cacheHeight = -1;
4356
4357 getSubImage (subImageIndex)
4358 {
4359 var subImage = Math.round(subImageIndex);
4360 subImage %= this.subImages;
4361
4362 var c = subImage % this.subImagesPerRow;
4363 var r = Math.floor(subImage / this.subImagesPerRow);
4364 var sw = (this.g_image.width / this.subImagesPerRow);
4365 var sh = (this.g_image.height / Math.ceil(this.subImages / this.subImagesPerRow));
4366 var sx = sw * c;
4367 var sy = sh * r;
4368
4369 return { sw: sw, sh: sh, sx: sx, sy: sy };
4370 }
4371}
4372
4373/*
4374 * End File:
4375 * framework/engine/image.js
4376 */
4377
4378/*
4379 * Start File:
4380 * framework/engine/gameobject.js
4381 */
4382class GameObject
4383{
4384 transform = null;
4385 renderer = null;
4386 collider = null;
4387 scene = null;
4388 _layer = 0;
4389 tags = [];
4390
4391 destroyed = false;
4392
4393 constructor (x, y, sprite, layer = 0)
4394 {
4395 this.transform = new Transform(this, x, y, 1, 1, 0);
4396 this.renderer = new Renderer(this, sprite);
4397 this.collider = new Collider(this);
4398 this._layer = layer;
4399 }
4400
4401 get layer ()
4402 {
4403 return this._layer;
4404 }
4405
4406 set layer (value)
4407 {
4408 if (this._layer === value)
4409 { return; }
4410 this._layer = value;
4411 if (this.scene)
4412 { this.scene.objectLayerChanged(this); }
4413 }
4414
4415 initQuadtree (quadTree)
4416 {
4417 this.quadTree = quadTree;
4418 }
4419
4420 checkQuadtree ()
4421 {
4422 if (!this.quadTree)
4423 { return; }
4424
4425 const x = this.transform.position.x;
4426 const y = this.transform.position.y;
4427 // Skip reinsert when the object has not moved since the last check.
4428 if (this.node && this._qtX === x && this._qtY === y)
4429 { return; }
4430 this._qtX = x;
4431 this._qtY = y;
4432
4433 if (this.node)
4434 {
4435 if (x < this.node.x1
4436 || x > this.node.x2
4437 || y < this.node.y1
4438 || y > this.node.y2)
4439 {
4440 this.quadTree.remove(this);
4441 this.quadTree.add(this);
4442 }
4443 }
4444 else
4445 {
4446 this.quadTree.add(this);
4447 }
4448 }
4449
4450 update (deltaTime)
4451 {
4452 if (this.destroyed)
4453 { return; }
4454
4455 this.transform.update(deltaTime);
4456 this.collider.update(deltaTime);
4457 this.renderer.update(deltaTime);
4458
4459 this.checkQuadtree();
4460 }
4461
4462 destroy ()
4463 {
4464 if (!this.destroyed)
4465 {
4466 this.onDestroy && this.onDestroy();
4467 this.quadTree && this.quadTree.remove(this);
4468 this.scene && this.scene.removeObject(this);
4469 this.destroyed = true;
4470 }
4471 }
4472
4473 draw ()
4474 {
4475 if (this.destroyed)
4476 { return; }
4477
4478 this.renderer.draw();
4479 }
4480}
4481
4482/*
4483 * End File:
4484 * framework/engine/gameobject.js
4485 */
4486
4487/*
4488 * Start File:
4489 * framework/engine/scene.js
4490 */
4491class Scene
4492{
4493 static idCount = 0;
4494 id = null;
4495 activeObjects = [];
4496 position = null;
4497 size = null;
4498 real_position = null;
4499 px = 0; py = 0;
4500 real_size = null;
4501 cameraPosition = null;
4502 parentScene = null;
4503 renderBackground = true;
4504 quadTree = null;
4505
4506 pendingRemoval = [];
4507 _sortedActiveObjects = null;
4508 _sortDirty = true;
4509 /** Objects whose `layer` changed since the last draw-order rebuild. */
4510 _layerChanged = [];
4511 /**
4512 * If more than this many objects change layer between draws, fall back to a
4513 * full in-place sort (cheaper than many splice reinserts on large lists).
4514 */
4515 _layerChangeFullSortThreshold = 64;
4516 /** Reused per-draw-layer object lists (cleared + refilled each draw). */
4517 _byLayer = null;
4518 _byLayerNames = null;
4519
4520 g_primary = false;
4521
4522 static DisplayModes = { absolute: 0, relativeToParent: 1 };
4523
4524 displayMode = Scene.DisplayModes.absolute;
4525
4526 cv_canvas = null;
4527 glContext = null;
4528 destroyed = false;
4529
4530 // Legacy: posts applied to the "default" layer when that layer has none of its own.
4531 postShaders = [];
4532 postTime = 0;
4533
4534 // Ordered list of RenderLayer. Index 0 is drawn first (back).
4535 renderLayers = null;
4536
4537 game = null;
4538
4539 get primary ()
4540 {
4541 return this.g_primary;
4542 }
4543
4544 constructor (x, y, width, height, displayMode = 0)
4545 {
4546 Scene.idCount++;
4547 this.id = 'canvas_' + Scene.idCount;
4548
4549 this.position = new vector(x, y);
4550 this.size = new vector(width, height);
4551 this.real_position = new vector(x, y);
4552 this.real_size = new vector(width, height);
4553 this.cameraPosition = new vector(0, 0);
4554 this.displayMode = displayMode;
4555
4556
4557 const body = document.body;
4558
4559 body.insertAdjacentHTML('beforeend', '<canvas id="' + this.id + '" style="position: absolute; left: ' + x + 'px; top: ' + y + 'px;" width="' + width + '" height="' + height + '"></canvas>');
4560
4561 this.cv_canvas = document.getElementById(this.id);
4562 this.glContext = new GLContext(this.cv_canvas);
4563 this.postShaders = [];
4564 this.postTime = 0;
4565 this.renderLayers = [new RenderLayer(RenderLayer.DEFAULT_NAME)];
4566
4567 this.g_fixSize();
4568 this.quadTree = new QuadTree(this.real_size.x, this.real_size.y);
4569 }
4570
4571 /**
4572 * Replace the layer stack. Order in the array is draw order (first = back).
4573 * Each entry: RenderLayer, or { name, postShaders?, composite? }.
4574 */
4575 setLayers (layerConfigs)
4576 {
4577 if (!layerConfigs || !layerConfigs.length)
4578 {
4579 this.renderLayers = [new RenderLayer(RenderLayer.DEFAULT_NAME)];
4580 return this.renderLayers;
4581 }
4582
4583 const layers = [];
4584 for (let i = 0; i < layerConfigs.length; i++)
4585 {
4586 const cfg = layerConfigs[i];
4587 if (!cfg)
4588 { continue; }
4589
4590 if (cfg instanceof RenderLayer)
4591 { layers.push(cfg); }
4592 else
4593 { layers.push(new RenderLayer(cfg.name, cfg)); }
4594 }
4595
4596 if (!layers.length)
4597 { layers.push(new RenderLayer(RenderLayer.DEFAULT_NAME)); }
4598
4599 this.renderLayers = layers;
4600 return this.renderLayers;
4601 }
4602
4603 getLayer (name)
4604 {
4605 const layers = this.renderLayers || [];
4606 for (let i = 0; i < layers.length; i++)
4607 {
4608 if (layers[i].name === name)
4609 { return layers[i]; }
4610 }
4611
4612 return null;
4613 }
4614
4615 setPrimary ()
4616 {
4617 this.game.setPrimaryScene(this);
4618 }
4619
4620 onLoad ()
4621 {
4622
4623 }
4624
4625 loadChildScene (scene)
4626 {
4627 scene.parentScene = this;
4628 this.game.loadScene(scene);
4629 }
4630
4631 destroy ()
4632 {
4633 if (this.destroyed)
4634 { return; }
4635
4636 for (var i = 0; i < this.activeObjects.length; i++)
4637 {
4638 this.activeObjects[i].destroy();
4639 }
4640
4641 this.destroyed = true;
4642
4643 if (this.game)
4644 { this.game.removeScene(this); }
4645
4646 this.removeCanvas();
4647
4648 if (this.primary)
4649 {
4650 if (this.parentScene && !this.parentScene.destroyed)
4651 {
4652 this.parentScene.setPrimary();
4653 }
4654 else if (this.game)
4655 {
4656 let promoted = null;
4657 for (let i = 0; i < this.game.activeScenes.length; i++)
4658 {
4659 const candidate = this.game.activeScenes[i];
4660 if (candidate !== this && !candidate.destroyed)
4661 {
4662 promoted = candidate;
4663 break;
4664 }
4665 }
4666
4667 if (promoted)
4668 { this.game.setPrimaryScene(promoted); }
4669 else
4670 { this.g_primary = false; }
4671 }
4672 else
4673 {
4674 this.g_primary = false;
4675 }
4676 }
4677 }
4678
4679 removeCanvas ()
4680 {
4681 var elem = this.cv_canvas || document.getElementById(this.id);
4682 if (elem && elem.parentNode)
4683 {
4684 elem.parentNode.removeChild(elem);
4685 }
4686
4687 this.cv_canvas = null;
4688 this.glContext = null;
4689 }
4690
4691 backgroundColor =
4692 {
4693 r: 255,
4694 g: 255,
4695 b: 255
4696 };
4697
4698 get canvas ()
4699 {
4700 return this.cv_canvas;
4701 }
4702
4703 get context ()
4704 {
4705 return this.glContext ? this.glContext.gl : null;
4706 }
4707
4708 addObject (obj)
4709 {
4710 if (this.destroyed)
4711 { return; }
4712
4713 this.activeObjects.push(obj);
4714 obj.scene = this;
4715 obj.initQuadtree(this.quadTree);
4716 obj.checkQuadtree();
4717
4718 if (this._sortedActiveObjects && !this._sortDirty && !this._layerChanged.length)
4719 { this.#insertSortedByLayer(this._sortedActiveObjects, obj); }
4720 else
4721 { this._sortDirty = true; }
4722
4723 obj.addedToScene && obj.addedToScene();
4724
4725 return obj;
4726 }
4727
4728 removeObject (obj)
4729 {
4730 if (this.activeObjects.indexOf(obj) >= 0)
4731 {
4732 if (!this.pendingRemoval.contains(obj))
4733 { this.pendingRemoval.push(obj); }
4734
4735 this._sortDirty = true;
4736 }
4737
4738 if (this.quadTree === obj.quadTree)
4739 { this.quadTree.remove(obj); }
4740 }
4741
4742 /**
4743 * Called when an object's draw-priority `layer` changes.
4744 * Batches small moves for splice-reinsert; floods into a full sort when many change.
4745 */
4746 objectLayerChanged (obj)
4747 {
4748 if (!obj || this._sortDirty)
4749 {
4750 this._sortDirty = true;
4751 return;
4752 }
4753 this._layerChanged.push(obj);
4754 if (this._layerChanged.length > this._layerChangeFullSortThreshold)
4755 {
4756 this._sortDirty = true;
4757 this._layerChanged.length = 0;
4758 }
4759 }
4760
4761 /** Force a full draw-order rebuild on the next draw (e.g. bulk external edits). */
4762 markSortDirty ()
4763 {
4764 this._sortDirty = true;
4765 this._layerChanged.length = 0;
4766 }
4767
4768 /** First index with layer strictly greater than `layer` (insert after equal layers). */
4769 #upperBoundByLayer (sorted, layer)
4770 {
4771 let lo = 0;
4772 let hi = sorted.length;
4773 while (lo < hi)
4774 {
4775 const mid = (lo + hi) >> 1;
4776 if (sorted[mid].layer <= layer)
4777 { lo = mid + 1; }
4778 else
4779 { hi = mid; }
4780 }
4781 return lo;
4782 }
4783
4784 #insertSortedByLayer (sorted, obj)
4785 {
4786 // New objects and layer moves land after existing equal layers so a
4787 // recently updated sprite draws on top of older ties (stable-with-recency).
4788 const at = this.#upperBoundByLayer(sorted, obj.layer);
4789 sorted.splice(at, 0, obj);
4790 }
4791
4792 #reinsertSortedByLayer (sorted, obj)
4793 {
4794 const from = sorted.indexOf(obj);
4795 if (from >= 0)
4796 { sorted.splice(from, 1); }
4797 this.#insertSortedByLayer(sorted, obj);
4798 }
4799
4800 /**
4801 * Ensure `_sortedActiveObjects` matches `activeObjects` ordered by `layer`.
4802 * Avoids allocating a fresh array every frame (no `slice().sort()`).
4803 */
4804 #ensureDrawOrder ()
4805 {
4806 const active = this.activeObjects;
4807 if (this._sortDirty || !this._sortedActiveObjects)
4808 {
4809 let sorted = this._sortedActiveObjects;
4810 if (!sorted)
4811 {
4812 sorted = new Array(active.length);
4813 this._sortedActiveObjects = sorted;
4814 }
4815 else if (sorted.length !== active.length)
4816 { sorted.length = active.length; }
4817
4818 for (let i = 0; i < active.length; i++)
4819 { sorted[i] = active[i]; }
4820
4821 sorted.sort((a, b) => a.layer - b.layer);
4822 this._sortDirty = false;
4823 this._layerChanged.length = 0;
4824 return;
4825 }
4826
4827 if (!this._layerChanged.length)
4828 { return; }
4829
4830 const changed = this._layerChanged;
4831 const sorted = this._sortedActiveObjects;
4832 for (let i = 0; i < changed.length; i++)
4833 { this.#reinsertSortedByLayer(sorted, changed[i]); }
4834 changed.length = 0;
4835 }
4836
4837 update (deltaTime)
4838 {
4839 if (this.destroyed)
4840 { return; }
4841
4842 this.postTime += deltaTime;
4843
4844 for (let i = 0; i < this.activeObjects.length; i++)
4845 {
4846 this.activeObjects[i].update(deltaTime);
4847 }
4848
4849 if (this.pendingRemoval.length)
4850 {
4851 for (let i = 0; i < this.pendingRemoval.length; i++)
4852 {
4853 const obj = this.pendingRemoval[i];
4854 const index = this.activeObjects.indexOf(obj);
4855 if (index >= 0 && obj.destroyed)
4856 { this.activeObjects.removeAt(index); }
4857 }
4858
4859 this.pendingRemoval.length = 0;
4860 this._sortDirty = true;
4861 this._layerChanged.length = 0;
4862 }
4863
4864 this.quadTree.update(deltaTime);
4865 }
4866
4867 g_fixSize ()
4868 {
4869 if (this.displayMode == Scene.DisplayModes.relativeToParent)
4870 {
4871 if (this.parentScene)
4872 {
4873 this.real_position.x = this.parentScene.real_position.x + (this.position.x * this.parentScene.real_size.x);
4874 this.real_position.y = this.parentScene.real_position.y + (this.position.y * this.parentScene.real_size.y);
4875
4876 this.real_size.x = this.parentScene.real_size.x * this.size.x;
4877 this.real_size.y = this.parentScene.real_size.y * this.size.y;
4878 }
4879 else
4880 {
4881 this.real_position.x = window.innerWidth * this.position.x;
4882 this.real_position.y = window.innerHeight * this.position.y;
4883
4884 this.real_size.x = window.innerWidth * this.size.x;
4885 this.real_size.y = window.innerHeight * this.size.y;
4886 }
4887 }
4888 else if (this.displayMode == Scene.DisplayModes.absolute)
4889 {
4890 this.real_position.x = this.position.x;
4891 this.real_position.y = this.position.y;
4892
4893 this.real_size.x = this.size.x;
4894 this.real_size.y = this.size.y;
4895 }
4896
4897 const canvasW = Math.max(1, Math.round(this.real_size.x));
4898 const canvasH = Math.max(1, Math.round(this.real_size.y));
4899 let resized = false;
4900
4901 if (this.canvas.width != canvasW)
4902 {
4903 this.canvas.width = canvasW;
4904 resized = true;
4905 }
4906
4907 if (this.canvas.height != canvasH)
4908 {
4909 this.canvas.height = canvasH;
4910 resized = true;
4911 }
4912
4913 // Changing canvas dimensions resets WebGL — rebuild helper/buffers/programs.
4914 if (resized || !this.glContext)
4915 { this.glContext = new GLContext(this.cv_canvas); }
4916 else
4917 { this.glContext.setSize(this.canvas.width, this.canvas.height); }
4918
4919 if (this.px != this.real_position.x)
4920 {
4921 this.px = this.real_position.x;
4922 this.canvas.style.left = this.real_position.x + "px";
4923 }
4924
4925 if (this.py != this.real_position.y)
4926 {
4927 this.py = this.real_position.y;
4928 this.canvas.style.top = this.real_position.y + "px";
4929 }
4930 }
4931
4932 normalizePostShaderList (list)
4933 {
4934 if (!list || !list.length)
4935 { return []; }
4936
4937 const passes = [];
4938 for (let i = 0; i < list.length; i++)
4939 {
4940 const entry = list[i];
4941 if (!entry)
4942 { continue; }
4943
4944 if (entry instanceof Shader || (entry.vertSource && entry.fragSource && entry.getProgramInfo))
4945 {
4946 passes.push({ shader: entry, uniforms: null });
4947 }
4948 else if (entry.shader)
4949 {
4950 const pass = { shader: entry.shader, uniforms: entry.uniforms || null };
4951 if (entry.scale != null)
4952 { pass.scale = entry.scale; }
4953 passes.push(pass);
4954 }
4955 }
4956
4957 return passes;
4958 }
4959
4960 normalizePostShaders ()
4961 {
4962 return this.normalizePostShaderList(this.postShaders);
4963 }
4964
4965 getPostPassesForLayer (layer)
4966 {
4967 const fromLayer = this.normalizePostShaderList(layer.postShaders);
4968 if (fromLayer.length)
4969 { return fromLayer; }
4970
4971 // Back-compat: scene.postShaders apply to the default layer only.
4972 if (layer.name === RenderLayer.DEFAULT_NAME)
4973 { return this.normalizePostShaders(); }
4974
4975 return [];
4976 }
4977
4978 draw ()
4979 {
4980 if (this.destroyed || !this.glContext)
4981 { return; }
4982
4983 this.g_fixSize();
4984
4985 const gl = this.glContext;
4986 const layers = this.renderLayers && this.renderLayers.length
4987 ? this.renderLayers
4988 : [new RenderLayer(RenderLayer.DEFAULT_NAME)];
4989
4990 // Canvas clear (background behind all layers).
4991 gl.endOffscreenPass();
4992 if (this.renderBackground)
4993 {
4994 gl.clear(
4995 this.backgroundColor.r,
4996 this.backgroundColor.g,
4997 this.backgroundColor.b,
4998 1
4999 );
5000 }
5001 else
5002 {
5003 gl.clearTransparent();
5004 }
5005
5006 this.#ensureDrawOrder();
5007 const sortedActiveObjects = this._sortedActiveObjects;
5008
5009 // Reuse per-layer buckets so we do not allocate new arrays every frame.
5010 const byLayer = this._byLayer || (this._byLayer = Object.create(null));
5011 const byLayerNames = this._byLayerNames || (this._byLayerNames = []);
5012 for (let i = 0; i < byLayerNames.length; i++)
5013 { byLayer[byLayerNames[i]].length = 0; }
5014 byLayerNames.length = 0;
5015
5016 for (let i = 0; i < sortedActiveObjects.length; i++)
5017 {
5018 const obj = sortedActiveObjects[i];
5019 if (obj.destroyed || !obj.renderer || !obj.renderer.visible)
5020 { continue; }
5021
5022 const name = obj.renderer.layerName;
5023 let bucket = byLayer[name];
5024 if (!bucket)
5025 {
5026 bucket = [];
5027 byLayer[name] = bucket;
5028 }
5029 if (bucket.length === 0)
5030 { byLayerNames.push(name); }
5031 bucket.push(obj);
5032 }
5033
5034 const builtins = {
5035 u_resolution: [gl._lastWidth, gl._lastHeight],
5036 u_time: this.postTime
5037 };
5038
5039 for (let li = 0; li < layers.length; li++)
5040 {
5041 const renderLayer = layers[li];
5042 const layerObjects = byLayer[renderLayer.name];
5043 if (!layerObjects || !layerObjects.length)
5044 { continue; }
5045
5046 gl.beginOffscreenPass();
5047 gl.clearTransparent();
5048
5049 for (let i = 0; i < layerObjects.length; i++)
5050 { layerObjects[i].draw(this.context); }
5051
5052 const postPasses = this.getPostPassesForLayer(renderLayer);
5053 let texture = gl.colorTextures[0];
5054
5055 if (postPasses.length)
5056 {
5057 texture = gl.applyPostShaders(postPasses, builtins, { toCanvas: false });
5058 }
5059 else
5060 {
5061 gl.endOffscreenPass();
5062 }
5063
5064 gl.blitToCanvas(texture, renderLayer.composite || "alpha");
5065 }
5066 }
5067}
5068/*
5069 * End File:
5070 * framework/engine/scene.js
5071 */
5072
5073/*
5074 * Start File:
5075 * framework/engine/game.js
5076 */
5077class Game
5078{
5079 activeScenes = [];
5080 pendingRemoval = [];
5081
5082 previousStep = 0; //used for calculating deltaTime
5083 isRunning = false;
5084 rafId = null;
5085
5086 images = {};
5087 shaders = {};
5088
5089 constructor ()
5090 {
5091 this.previousStep = 0;
5092 this.activeScenes = [];
5093 this.isRunning = false;
5094 this.rafId = null;
5095 this.shaders = {};
5096 this.update = this.update.bind(this);
5097 }
5098
5099 startGame ()
5100 {
5101 GameInput.g_init();
5102
5103 if (this.isRunning)
5104 { return; }
5105
5106 this.isRunning = true;
5107 this.previousStep = Date.now();
5108 this.update();
5109 }
5110
5111 stopGame ()
5112 {
5113 this.isRunning = false;
5114 if (this.rafId != null)
5115 {
5116 cancelAnimationFrame(this.rafId);
5117 this.rafId = null;
5118 }
5119 }
5120
5121 preloadImagesThenStart (imageData, onComplete, onError)
5122 {
5123 const cont = async () =>
5124 {
5125 try
5126 {
5127 await this.preloadImages(
5128 imageData
5129 );
5130
5131 this.startGame();
5132 onComplete && onComplete();
5133 }
5134 catch (err)
5135 {
5136 console.error("GAME: Image preload failed.", err);
5137 onError && onError(err);
5138 }
5139 };
5140
5141 cont();
5142 }
5143
5144 setPrimaryScene (scene)
5145 {
5146 if (this.activeScenes.contains(scene))
5147 {
5148 for (let i = 0; i < this.activeScenes.length; i++)
5149 { this.activeScenes[i].g_primary = false; }
5150
5151 scene.g_primary = true;
5152 }
5153 }
5154
5155 async preloadImages (imagesData)
5156 {
5157 const promises = [];
5158 const context = this;
5159
5160 for (var imageData of imagesData)
5161 {
5162 if (context.images[imageData.name])
5163 {
5164 console.warn("Image '" + imageData.name + "' is already loaded! (overwriting anyway)");
5165 }
5166
5167 promises.push(new Promise((resolve, reject) =>
5168 {
5169 var img = new Image();
5170 var imageContext = { name: imageData.name, subImgTotal: imageData.subImgTotal, perRow: imageData.perRow, loop: imageData.loop, chain: imageData.chain };
5171
5172 img.onload = function ()
5173 {
5174 var finalImage = new image(img, imageContext.subImgTotal, imageContext.perRow, imageContext.loop, imageContext.chain);
5175 finalImage.name = imageContext.name;
5176
5177 context.images[imageContext.name] = finalImage;
5178
5179 resolve();
5180 };
5181
5182 img.onerror = function ()
5183 {
5184 reject(new Error("Failed to load image '" + imageContext.name + "' from " + imageData.url));
5185 };
5186
5187 img.src = imageData.url;
5188 img.setAttribute("style", "display:none");
5189 }));
5190 }
5191 await Promise.all(promises);
5192
5193 console.log("all images loaded ", this.images);
5194
5195 return this.images;
5196 }
5197
5198 async preloadShaders (shadersData)
5199 {
5200 const context = this;
5201 const promises = [];
5202
5203 for (const shaderData of shadersData)
5204 {
5205 if (!shaderData || !shaderData.name)
5206 { throw new Error("preloadShaders: each entry needs a name"); }
5207
5208 if (!shaderData.frag)
5209 { throw new Error("preloadShaders: '" + shaderData.name + "' needs a frag path"); }
5210
5211 if (context.shaders[shaderData.name])
5212 { console.warn("Shader '" + shaderData.name + "' is already loaded! (overwriting anyway)"); }
5213
5214 promises.push((async () =>
5215 {
5216 let vertSource = shaderData.screen ? Shader.SCREEN_VERT : Shader.DEFAULT_VERT;
5217
5218 if (shaderData.vert)
5219 {
5220 const vertResponse = await fetch(shaderData.vert);
5221 if (!vertResponse.ok)
5222 {
5223 throw new Error("Failed to load vertex shader '" + shaderData.name + "' from " + shaderData.vert);
5224 }
5225
5226 vertSource = await vertResponse.text();
5227 }
5228
5229 const fragResponse = await fetch(shaderData.frag);
5230 if (!fragResponse.ok)
5231 {
5232 throw new Error("Failed to load fragment shader '" + shaderData.name + "' from " + shaderData.frag);
5233 }
5234
5235 const fragSource = await fragResponse.text();
5236 const shader = new Shader(vertSource, fragSource);
5237 shader.name = shaderData.name;
5238 shader.screen = !!shaderData.screen || vertSource === Shader.SCREEN_VERT;
5239 context.shaders[shaderData.name] = shader;
5240 })());
5241 }
5242
5243 await Promise.all(promises);
5244 console.log("all shaders loaded ", this.shaders);
5245 return this.shaders;
5246 }
5247
5248 loadScene (scene)
5249 {
5250 if (this.activeScenes.length == 0)
5251 { scene.g_primary = true; }
5252
5253 this.activeScenes.push(scene);
5254 scene.game = this;
5255 scene.onLoad();
5256 }
5257
5258 removeScene (scene)
5259 {
5260 if (this.activeScenes.indexOf(scene) >= 0)
5261 {
5262 if (!this.pendingRemoval.contains(scene))
5263 { this.pendingRemoval.push(scene); }
5264 }
5265 }
5266
5267 update ()
5268 {
5269 this.previousStep = this.previousStep || 0;
5270 const stepTime = Date.now();
5271 let stepTimeCurr = (stepTime - this.previousStep) * 0.001;
5272 stepTimeCurr = Math.min(stepTimeCurr, 0.1);
5273 if (isNaN(stepTimeCurr))
5274 { stepTimeCurr = 0; }
5275
5276 GameInput.g_updateKeys();
5277
5278 for (let i = 0; i < this.activeScenes.length; i++)
5279 {
5280 this.activeScenes[i].update(stepTimeCurr);
5281 this.activeScenes[i].draw();
5282 }
5283
5284 this.cleanActiveScenes();
5285
5286 this.previousStep = stepTime;
5287
5288 TWEEN.update();
5289
5290 if (this.isRunning)
5291 { this.rafId = requestAnimationFrame(this.update); }
5292 }
5293
5294 cleanActiveScenes ()
5295 {
5296 if (this.pendingRemoval.length > 0)
5297 {
5298 for (let i = 0; i < this.pendingRemoval.length; i++)
5299 {
5300 const scene = this.pendingRemoval[i];
5301 const index = this.activeScenes.indexOf(scene);
5302 if (index >= 0 && scene.destroyed)
5303 { this.activeScenes.removeAt(index); }
5304 }
5305
5306 this.pendingRemoval.length = 0;
5307 }
5308 }
5309}
5310/*
5311 * End File:
5312 * framework/engine/game.js
5313 */
package.json added +12 −0
@@ -0,0 +1,12 @@
1 {
2 "name": "meteors",
3 "private": true,
4 "version": "0.1.0",
5 "description": "Meteos-inspired puzzle game on Tim's frameworkv3 (WebGL)",
6 "scripts": {
7 "build": "bash src/build.sh",
8 "test": "node --test test/*.test.js",
9 "start": "python3 -m http.server 8080 --directory build",
10 "images": "python3 scripts/make-placeholders.py"
11 }
12 }
@@ -0,0 +1,12 @@
1{
2 "name": "meteors",
3 "private": true,
4 "version": "0.1.0",
5 "description": "Meteos-inspired puzzle game on Tim's frameworkv3 (WebGL)",
6 "scripts": {
7 "build": "bash src/build.sh",
8 "test": "node --test test/*.test.js",
9 "start": "python3 -m http.server 8080 --directory build",
10 "images": "python3 scripts/make-placeholders.py"
11 }
12}
src/build.sh added +40 −0
@@ -0,0 +1,40 @@
1 #!/usr/bin/env bash
2 # Concatenate game sources into build/game.js, same pattern as raytracer / frameworkv3.
3 set -euo pipefail
4 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
5 BUILD_FILE="$ROOT/build/game.js"
6 SRC_DIR="$ROOT/src"
7
8 mkdir -p "$ROOT/build"
9
10 printf "Build started, output file: %s\n" "$BUILD_FILE"
11 rm -f "$BUILD_FILE"
12
13 FILES=(
14 "$SRC_DIR/rng.js"
15 "$SRC_DIR/planet.js"
16 "$SRC_DIR/gameCore.js"
17 "$SRC_DIR/main.js"
18 )
19
20 {
21 printf '%s\n' "/*"
22 printf '%s\n' " * AUTO-GENERATED FILE — DO NOT EDIT BY HAND."
23 printf '%s\n' " * Built by src/build.sh from the sources in src/."
24 printf '%s\n' " */"
25 } >> "$BUILD_FILE"
26
27 for file in "${FILES[@]}"
28 do
29 if [[ ! -f "$file" ]]
30 then
31 printf "Missing source file: %s\n" "$file" >&2
32 exit 1
33 fi
34 printf "\n/*\n * Start File:\n * %s\n */ \n" "$file" >> "$BUILD_FILE"
35 printf "Building %s\n" "$file"
36 cat "$file" >> "$BUILD_FILE"
37 printf "\n/*\n * End File:\n * %s\n */ \n" "$file" >> "$BUILD_FILE"
38 done
39
40 printf "DONE\n"
@@ -0,0 +1,40 @@
1#!/usr/bin/env bash
2# Concatenate game sources into build/game.js, same pattern as raytracer / frameworkv3.
3set -euo pipefail
4ROOT="$(cd "$(dirname "$0")/.." && pwd)"
5BUILD_FILE="$ROOT/build/game.js"
6SRC_DIR="$ROOT/src"
7
8mkdir -p "$ROOT/build"
9
10printf "Build started, output file: %s\n" "$BUILD_FILE"
11rm -f "$BUILD_FILE"
12
13FILES=(
14 "$SRC_DIR/rng.js"
15 "$SRC_DIR/planet.js"
16 "$SRC_DIR/gameCore.js"
17 "$SRC_DIR/main.js"
18)
19
20{
21 printf '%s\n' "/*"
22 printf '%s\n' " * AUTO-GENERATED FILE — DO NOT EDIT BY HAND."
23 printf '%s\n' " * Built by src/build.sh from the sources in src/."
24 printf '%s\n' " */"
25} >> "$BUILD_FILE"
26
27for file in "${FILES[@]}"
28do
29 if [[ ! -f "$file" ]]
30 then
31 printf "Missing source file: %s\n" "$file" >&2
32 exit 1
33 fi
34 printf "\n/*\n * Start File:\n * %s\n */ \n" "$file" >> "$BUILD_FILE"
35 printf "Building %s\n" "$file"
36 cat "$file" >> "$BUILD_FILE"
37 printf "\n/*\n * End File:\n * %s\n */ \n" "$file" >> "$BUILD_FILE"
38done
39
40printf "DONE\n"