Merge branch 'feature/scaffold'
@@ -0,0 +1,5 @@
1
node_modules/
2
*.log
3
.DS_Store
4
__pycache__/
5
*.pyc
@@ -0,0 +1,5 @@1
node_modules/2
*.log3
.DS_Store4
__pycache__/5
*.pyc@@ -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/frameworkv37
*/8
9
/*10
* Start File:11
* framework/extensions/polyfills.js12
*/ 13
if (!Math.sign)14
{15
Math.sign = function (x)16
{17
x = +x; // convert to a number18
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.js30
*/ 31
32
/*33
* Start File:34
* framework/extensions/extentions.js35
*/ 36
/**37
* Extending exising functionality38
*/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
else49
{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.js91
*/ 92
93
/*94
* Start File:95
* framework/extensions/thirdparty.js96
*/ 97
//TWEENJS98
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.js102
*/ 103
104
/*105
* Start File:106
* framework/util/vector.js107
*/ 108
class vector109
{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.js277
*/ 278
279
/*280
* Start File:281
* framework/util/ease.js282
*/ 283
//ease functions284
285
var ease = {286
287
//288
// Basic ease functions289
//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
} else328
{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
} else342
{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 it450
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
} else469
{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
} else483
{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
} else511
{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
} else525
{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
} else553
{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
} else567
{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 sign580
val *= tbEase.easeInExponential(time, 0, 1, duration, stiffness); // Multiply with an exponential ease in581
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
} else599
{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
} else613
{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
} else644
{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
} else658
{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 arguments669
if (number === undefined) { number = 4; }670
if (factor === undefined) { factor = 2; } else { factor = Math.sqrt(factor); }671
// Create the list of bounces672
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 size680
width -= bounces[number - 1] / 2; // We don't use the last half bounce681
height = Math.pow(bounces[number - 1], 2);682
time = time / duration * width;683
// Find the correct bounce684
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 value690
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
} else709
{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
} else723
{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.js735
*/ 736
737
/*738
* Start File:739
* framework/util/timingUtil.js740
*/ 741
/**742
/* Timing utility743
/*/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
else756
{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.js800
*/ 801
802
/*803
* Start File:804
* framework/util/signal.js805
*/ 806
// Basic event listeners, modeled after Phaser Signals807
808
class Signal809
{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.js875
*/ 876
877
/*878
* Start File:879
* framework/util/cookie.js880
*/ 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.js927
*/ 928
929
/*930
* Start File:931
* framework/util/urlParams.js932
*/ 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.js958
*/ 959
960
/*961
* Start File:962
* framework/util/input.js963
*/ 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: 2993
},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 once1059
},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
else1107
{ return GameInput.g_ppressKeyStatus[keyCode]; }1108
},1109
1110
1111
isHeld: function (keyCode)1112
{1113
if (GameInput.g_pKeyStatus[keyCode] == null)1114
{ return false; }1115
else1116
{ 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.js1157
*/ 1158
1159
/*1160
* Start File:1161
* framework/util/audio.js1162
*/ 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.js1294
*/ 1295
1296
/*1297
* Start File:1298
* framework/util/ray.js1299
*/ 1300
class Ray1301
{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 is1342
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 face1365
}1366
else1367
{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 furthest1370
}1371
1372
//calc % of angle in relation to the angles it is between1373
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).length1381
});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.length1412
};1413
}1414
}1415
/*1416
* End File:1417
* framework/util/ray.js1418
*/ 1419
1420
/*1421
* Start File:1422
* framework/util/quadTree.js1423
*/ 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 QuadTree1433
{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 leaf1466
// (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 position1492
* 1493
* @param {vector} position 1494
* @param {number} range (radius)1495
* @returns {GameObject[]} result1496
*/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 position1505
* 1506
* @param {vector} position 1507
* @param {number} range (radius)1508
* @param {class[]} types 1509
* @returns {GameObject[]} result1510
*/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} position1593
* @param {number} range1594
* @param {Function} predicate1595
* @param {{ sort?: boolean }} [options] - sort defaults true (closest first)1596
* @returns {GameObject[]} reused buffer — consume before the next query1597
*/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 + range1718
];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 the1733
// 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 Node1836
{1837
get canBeMerged ()1838
{1839
// Leaf siblings may collapse into their parent when the parent's1840
// 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.hasChildren1847
&& this.recursiveCount > this.quadTree.bucketSize1848
&& this.depth < this.quadTree.maxDepth;1849
}1850
1851
get hasChildren ()1852
{1853
return this.bottomright != null; //assume the rest is there too1854
}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; after1904
// 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
else1963
{1964
object.node = this.bottomleft;1965
this.bottomleft.add(object, true);1966
}1967
}1968
else1969
{1970
if (object.transform.position.x > center.x)1971
{1972
object.node = this.topright;1973
this.topright.add(object, true);1974
}1975
else1976
{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 themselves1987
// 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.js2169
*/ 2170
2171
/*2172
* Start File:2173
* framework/util/particleEmitter.js2174
*/ 2175
class ParticleEmitter2176
{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 pool2296
{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 Particle2315
{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 > 02413
? Math.min(1, this.lifeTime / this.fadeOutTime)2414
: 1;2415
2416
const fiAlpha = this.fadeInStart > 02417
? 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.subImage2431
);2432
}2433
}2434
/*2435
* End File:2436
* framework/util/particleEmitter.js2437
*/ 2438
2439
/*2440
* Start File:2441
* framework/engine/gl/shader.js2442
*/ 2443
class Shader2444
{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.size2534
};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.js2587
*/ 2588
2589
/*2590
* Start File:2591
* framework/engine/gl/builtinShaders.js2592
*/ 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, blurSize2705
* - saturation: bloom chroma boost (1 = neutral, >1 = juicier)2706
* - colorPreserve: 0–1 tint bloom with the original sprite hue2707
* - 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 ones2728
2729
const scales = options.scales != null2730
? options.scales2731
: (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: colorPreserve2779
}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: length2965
}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: brightness3003
}3004
}];3005
};3006
3007
/*3008
* End File:3009
* framework/engine/gl/builtinShaders.js3010
*/ 3011
3012
/*3013
* Start File:3014
* framework/engine/gl/glContext.js3015
*/ 3016
class GLContext3017
{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.53055
]), 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, 13069
]), 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, 13078
]), 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} passes3201
* @param {Object} builtins3202
* @param {{ toCanvas?: boolean }} options - toCanvas true writes the last pass to the canvas.3203
* @returns {WebGLTexture|null} final color texture when not drawing to canvas3204
*/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
else3234
{ write = 3; }3235
3236
writeW = this._halfWidth;3237
writeH = this._halfHeight;3238
}3239
else3240
{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
else3248
{ 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
else3261
{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
else3325
{ 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._matrixData3462
);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
else3553
{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
else3586
{ 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 * S3619
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.js3665
*/ 3666
3667
/*3668
* Start File:3669
* framework/engine/renderLayer.js3670
*/ 3671
class RenderLayer3672
{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.js3688
*/ 3689
3690
/*3691
* Start File:3692
* framework/engine/objectComponents/transform.js3693
*/ 3694
class Transform3695
{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.js3840
*/ 3841
3842
/*3843
* Start File:3844
* framework/engine/objectComponents/collider.js3845
*/ 3846
class Collider3847
{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.mousePosition3894
.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
else3915
{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 = halfHeight3956
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 PERSPECTIVE3963
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 + hh3969
];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.js3994
*/ 3995
3996
/*3997
* Start File:3998
* framework/engine/objectComponents/renderer.js3999
*/ 4000
class Renderer4001
{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
else4067
{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
else4080
{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
else4118
{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.lights4147
);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: 04191
};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.js4213
*/ 4214
4215
/*4216
* Start File:4217
* framework/engine/image.js4218
*/ 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.js4376
*/ 4377
4378
/*4379
* Start File:4380
* framework/engine/gameobject.js4381
*/ 4382
class GameObject4383
{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.x14436
|| x > this.node.x24437
|| y < this.node.y14438
|| y > this.node.y2)4439
{4440
this.quadTree.remove(this);4441
this.quadTree.add(this);4442
}4443
}4444
else4445
{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.js4485
*/ 4486
4487
/*4488
* Start File:4489
* framework/engine/scene.js4490
*/ 4491
class Scene4492
{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 a4513
* 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
else4593
{ 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
else4670
{ this.g_primary = false; }4671
}4672
else4673
{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: 2554696
};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
else4721
{ 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
else4779
{ 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 a4787
// 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
else4880
{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
else4917
{ 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.length4987
? this.renderLayers4988
: [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
14999
);5000
}5001
else5002
{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.postTime5037
};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
else5060
{5061
gl.endOffscreenPass();5062
}5063
5064
gl.blitToCanvas(texture, renderLayer.composite || "alpha");5065
}5066
}5067
}5068
/*5069
* End File:5070
* framework/engine/scene.js5071
*/ 5072
5073
/*5074
* Start File:5075
* framework/engine/game.js5076
*/ 5077
class Game5078
{5079
activeScenes = [];5080
pendingRemoval = [];5081
5082
previousStep = 0; //used for calculating deltaTime5083
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
try5126
{5127
await this.preloadImages(5128
imageData5129
);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.js5313
*/ @@ -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
}@@ -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 bash2
# Concatenate game sources into build/game.js, same pattern as raytracer / frameworkv3.3
set -euo pipefail4
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
do29
if [[ ! -f "$file" ]]30
then31
printf "Missing source file: %s\n" "$file" >&232
exit 133
fi34
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
done39
40
printf "DONE\n"