melonjs 19.5.0 → 19.6.0

package/build/index.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - 19.5.0
+ * melonJS Game Engine - 19.6.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -24177,13 +24177,38 @@ var GLShader = class {
    */
   constructor(gl, vertex, fragment, precision) {
     this.gl = gl;
+    this.destroyed = false;
+    this.suspended = false;
+    this._sourceVertex = vertex;
+    this._sourceFragment = fragment;
+    this._precision = precision;
+    this._uniformCache = /* @__PURE__ */ Object.create(null);
+    if (gl.isContextLost()) {
+      this.suspended = true;
+      this.program = null;
+      this.uniforms = null;
+      this.attributes = null;
+    } else {
+      this._compile();
+    }
+    on(ONCONTEXT_LOST, this._onContextLost, this);
+    on(ONCONTEXT_RESTORED, this._onContextRestored, this);
+  }
+  /**
+   * (Re)compile the shader program against `this.gl` from the
+   * preserved source. Called from the constructor and from
+   * {@link _onContextRestored}. Replays any cached uniform values
+   * against the freshly-extracted uniforms proxy.
+   * @private
+   */
+  _compile() {
     this.vertex = setPrecision(
-      minify(vertex),
-      precision || getMaxShaderPrecision(this.gl)
+      minify(this._sourceVertex),
+      this._precision || getMaxShaderPrecision(this.gl)
     );
     this.fragment = setPrecision(
-      minify(fragment),
-      precision || getMaxShaderPrecision(this.gl)
+      minify(this._sourceFragment),
+      this._precision || getMaxShaderPrecision(this.gl)
     );
     this.attributes = extractAttributes(this.gl, this);
     this.program = compileProgram(
@@ -24193,12 +24218,54 @@ var GLShader = class {
       this.attributes
     );
     this.uniforms = extractUniforms(this.gl, this);
-    on(ONCONTEXT_LOST, this.destroy, this);
+    this.suspended = false;
+    for (const name of Object.keys(this._uniformCache)) {
+      if (typeof this.uniforms[name] !== "undefined") {
+        this.bind();
+        this.uniforms[name] = this._uniformCache[name];
+      }
+    }
+  }
+  /**
+   * Handler for {@link ONCONTEXT_LOST}. Tears down the GL program
+   * but preserves the shader source + cached uniform values so the
+   * shader can be transparently rebuilt on context restore.
+   * @private
+   */
+  _onContextLost() {
+    if (this.destroyed || this.suspended) {
+      return;
+    }
+    this.suspended = true;
+    this.uniforms = null;
+    this.attributes = null;
+    if (this.program !== null) {
+      try {
+        this.gl.deleteProgram(this.program);
+      } catch {
+      }
+      this.program = null;
+    }
+  }
+  /**
+   * Handler for {@link ONCONTEXT_RESTORED}. Re-compiles and
+   * re-links the shader against the new GL context, then replays
+   * any cached uniform values via {@link _compile}.
+   * @private
+   */
+  _onContextRestored() {
+    if (this.destroyed) {
+      return;
+    }
+    this._compile();
   }
   /**
    * Installs this shader program as part of current rendering state
    */
   bind() {
+    if (this.destroyed || this.suspended) {
+      return;
+    }
     this.gl.useProgram(this.program);
   }
   /**
@@ -24207,6 +24274,9 @@ var GLShader = class {
    * @returns {GLint} number indicating the location of the variable name if found. Returns -1 otherwise
    */
   getAttribLocation(name) {
+    if (this.destroyed || this.suspended) {
+      return -1;
+    }
     const attr = this.attributes[name];
     if (typeof attr !== "undefined") {
       return attr;
@@ -24222,14 +24292,35 @@ var GLShader = class {
    * myShader.setUniform("uProjectionMatrix", this.projectionMatrix);
    */
   setUniform(name, value) {
+    if (this.destroyed) {
+      return;
+    }
+    let cached;
+    let glValue;
+    if (typeof value === "object" && value !== null) {
+      if (typeof value.toArray === "function") {
+        const arr = value.toArray();
+        cached = captureValue(this._uniformCache[name], arr);
+        glValue = arr;
+      } else if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+        cached = captureValue(this._uniformCache[name], value);
+        glValue = value;
+      } else {
+        cached = value;
+        glValue = value;
+      }
+    } else {
+      cached = value;
+      glValue = value;
+    }
+    this._uniformCache[name] = cached;
+    if (this.suspended) {
+      return;
+    }
     const uniforms = this.uniforms;
     if (typeof uniforms[name] !== "undefined") {
       this.bind();
-      if (typeof value === "object" && typeof value.toArray === "function") {
-        uniforms[name] = value.toArray();
-      } else {
-        uniforms[name] = value;
-      }
+      uniforms[name] = glValue;
     } else {
       throw new Error("undefined (" + name + ") uniform for shader " + this);
     }
@@ -24258,14 +24349,32 @@ var GLShader = class {
     }
   }
   /**
-   * destroy this shader objects resources (program, attributes, uniforms)
+   * destroy this shader objects resources (program, attributes, uniforms).
+   * Idempotent — calling destroy twice (or after a context-lost suspend)
+   * is safe. Unsubscribes from the renderer's context lost / restored
+   * events so a destroyed shader is never automatically resurrected.
    */
   destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    off(ONCONTEXT_LOST, this._onContextLost, this);
+    off(ONCONTEXT_RESTORED, this._onContextRestored, this);
     this.uniforms = null;
     this.attributes = null;
-    this.gl.deleteProgram(this.program);
+    if (this.program !== null) {
+      try {
+        this.gl.deleteProgram(this.program);
+      } catch {
+      }
+      this.program = null;
+    }
     this.vertex = null;
     this.fragment = null;
+    this._sourceVertex = null;
+    this._sourceFragment = null;
+    this._uniformCache = null;
   }
 };
 
@@ -24275,10 +24384,22 @@ var quad_default = "// Current vertex point\nattribute vec2 aVertex;\nattribute
 // src/video/webgl/shadereffect.js
 var ShaderEffect = class {
   /**
-   * whether this effect is active (false in Canvas mode)
+   * whether this effect is active (false in Canvas mode, false after
+   * {@link destroy}, and false while the WebGL context is suspended
+   * between an `ONCONTEXT_LOST` and the matching `ONCONTEXT_RESTORED`
+   * event).
    * @type {boolean}
    */
   enabled = false;
+  /**
+   * `true` once {@link destroy} has been called. Distinct from
+   * `enabled` — which also toggles transiently across a context
+   * lost / restored cycle — to give callers a stable signal for
+   * "this effect has been explicitly released."
+   * @type {boolean}
+   * @readonly
+   */
+  destroyed = false;
   /**
    * @param {WebGLRenderer|CanvasRenderer} renderer - the current renderer instance
    * @param {string} fragmentBody - GLSL code containing a `vec4 apply(vec4 color, vec2 uv)` function
@@ -24297,7 +24418,6 @@ var ShaderEffect = class {
       "uniform sampler2D uSampler;",
       "varying vec4 vColor;",
       "varying vec2 vRegion;",
-      // user-provided fragment body (uniforms + apply function)
       fragmentBody,
       "void main(void) {",
       "    vec4 texColor = texture2D(uSampler, vRegion) * vColor;",
@@ -24311,6 +24431,24 @@ var ShaderEffect = class {
       precision || renderer2.shaderPrecision
     );
     this.enabled = true;
+    on(ONCONTEXT_LOST, this._onContextLost, this);
+    on(ONCONTEXT_RESTORED, this._onContextRestored, this);
+  }
+  /** @private */
+  _onContextLost() {
+    if (this.destroyed) {
+      return;
+    }
+    this._enabledBeforeSuspend = this.enabled;
+    this.enabled = false;
+  }
+  /** @private */
+  _onContextRestored() {
+    if (this.destroyed) {
+      return;
+    }
+    this.enabled = this._enabledBeforeSuspend !== false;
+    this._enabledBeforeSuspend = void 0;
   }
   /**
    * Set the uniform to the given value
@@ -24359,12 +24497,20 @@ var ShaderEffect = class {
     return this.enabled ? this._shader.uniforms : {};
   }
   /**
-   * destroy this shader effect
+   * destroy this shader effect. Idempotent — calling destroy twice
+   * is safe. Unsubscribes from the renderer's context-lost / restored
+   * events so a destroyed effect is not auto-reactivated.
    */
   destroy() {
-    if (this.enabled) {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.enabled = false;
+    off(ONCONTEXT_LOST, this._onContextLost, this);
+    off(ONCONTEXT_RESTORED, this._onContextRestored, this);
+    if (this._shader) {
       this._shader.destroy();
-      this.enabled = false;
     }
   }
 };
@@ -29440,7 +29586,7 @@ var Trigger = class extends Renderable {
 };
 
 // src/version.ts
-var version = "19.5.0";
+var version = "19.6.0";
 
 // src/system/bootstrap.ts
 var initialized = false;
@@ -34828,6 +34974,7 @@ var WebGLRenderer = class extends Renderer {
       (e) => {
         e.preventDefault();
         this.isContextValid = false;
+        this.vertexBuffer = null;
         emit(ONCONTEXT_LOST, this);
       },
       false
@@ -34835,7 +34982,17 @@ var WebGLRenderer = class extends Renderer {
     this.getCanvas().addEventListener(
       "webglcontextrestored",
       () => {
+        this.vertexBuffer = this.gl.createBuffer();
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+        this.gl.disable(this.gl.DEPTH_TEST);
+        this.gl.depthMask(false);
+        this.gl.disable(this.gl.SCISSOR_TEST);
+        this._scissorActive = false;
+        this.gl.enable(this.gl.BLEND);
+        this.setBlendMode(this.settings.blendMode);
         this.reset();
+        this.cache.units.clear();
+        this.cache.usedUnits.clear();
         this.isContextValid = true;
         emit(ONCONTEXT_RESTORED, this);
       },