| 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 | */ |