melonjs 20.10.0 → 20.10.1

package/build/camera/camera2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../src/camera/camera2d.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../src/camera/camera2d.ts"],"names":[],"mappings":"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"}

package/build/index.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - 20.10.0
+ * melonJS Game Engine - 20.10.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -16940,6 +16940,29 @@ var Camera2d = class extends Renderable {
       fx.draw(renderer, this.width, this.height);
     }
   }
+  /**
+   * The built-in {@link Camera2d#colorMatrix} as the effect that applies it,
+   * made on first need and kept, and set to the current matrix.
+   *
+   * `draw` appends it last in the camera's chain for the frame. The
+   * renderer's warm-up calls this too, once a stage has been built, so the
+   * effect exists, and is warmed where `draw` will run it, before the frame
+   * that first needs it rather than inside that frame.
+   * @param renderer - the renderer the camera draws with
+   * @returns the effect, or null while the matrix is identity
+   * @ignore
+   * @internal
+   */
+  _syncColorMatrixEffect(renderer) {
+    if (this.colorMatrix.isIdentity()) {
+      return null;
+    }
+    if (!this._colorMatrixEffect) {
+      this._colorMatrixEffect = new ColorMatrixEffect(renderer);
+    }
+    this._colorMatrixEffect.reset().multiply(this.colorMatrix);
+    return this._colorMatrixEffect;
+  }
   /**
    * draw all objects visible in this viewport
    * @ignore
@@ -16955,12 +16978,9 @@ var Camera2d = class extends Renderable {
     const containerOffsetY = isNonDefault ? container.pos.y : 0;
     const translateX = this.pos.x + this.offset.x + containerOffsetX;
     const translateY = this.pos.y + this.offset.y + containerOffsetY;
-    if (!this.colorMatrix.isIdentity()) {
-      if (!this._colorMatrixEffect) {
-        this._colorMatrixEffect = new ColorMatrixEffect(renderer);
-      }
-      this._colorMatrixEffect.reset().multiply(this.colorMatrix);
-      this.postEffects.push(this._colorMatrixEffect);
+    const colorMatrixEffect = this._syncColorMatrixEffect(renderer);
+    if (colorMatrixEffect !== null) {
+      this.postEffects.push(colorMatrixEffect);
     }
     const usePostEffect = r.beginPostEffect(this);
     this._applyContainerViewTransform(container, translateX, translateY);
@@ -23341,19 +23361,157 @@ var Renderer = class _Renderer {
   }
   /**
    * Run the warm-ups queued by {@link Renderer#_queueWarm}.
+   * @param {boolean} [stage=false] - true when a stage is being entered,
+   *   which warms its cameras' grading as well
+   * @returns {Promise<void>[]} what they started that is still being built
+   * @ignore
+   * @internal
+   */
+  _flushWarm(stage = false) {
+    const hosts = this._warmHosts === void 0 ? [] : [...this._warmHosts];
+    if (hosts.length === 0 && !stage) {
+      return [];
+    }
+    this._warmHosts?.clear();
+    const cameras = stage || hosts.some((host) => {
+      return host?._postEffectManaged === true;
+    });
+    this._warmFog = this._warmFogStates();
+    try {
+      return this._collectWarms(() => {
+        for (const host of hosts) {
+          try {
+            this._warmRenderable(host);
+          } catch {
+          }
+        }
+        if (cameras) {
+          try {
+            this._warmCameraColorMatrices();
+          } catch {
+          }
+        }
+      });
+    } finally {
+      this._warmFog = void 0;
+    }
+  }
+  /**
+   * Run `warm` and hand back what it started that is still being built,
+   * as one promise each. Every warm-up on this base is done by the time it
+   * returns, so nothing.
+   * @param {Function} warm - issues the warm-ups
+   * @returns {Promise<void>[]} the warm-ups still on their way
    * @ignore
    * @internal
    */
-  _flushWarm() {
-    const hosts = [...this._warmHosts];
-    this._warmHosts.clear();
-    for (const host of hosts) {
+  _collectWarms(warm) {
+    warm();
+    return [];
+  }
+  /**
+   * Run the queued warm-ups now, and say when they are built.
+   *
+   * What a state change waits on before drawing the stage it has just built
+   * (see `state.change`). A warm-up on its own does not keep the first
+   * frame from compiling: the frame comes some milliseconds after the stage
+   * is built, and a pipeline still compiling then is compiled again, on the
+   * spot, by the draw that needs it. Holding the frame until they land is
+   * what lets them do their job.
+   *
+   * Only what this flush asked for is waited on, not every warm-up in
+   * flight: one a game started for later (an effect attached ahead of
+   * time, a level's own preload) is not this stage's to wait for.
+   * @returns {Promise<void>|undefined} settles once they are built, or
+   *   `undefined` when nothing is being built and the frame can draw now
+   * @ignore
+   * @internal
+   */
+  _whenWarmed() {
+    let waits;
+    try {
+      waits = this._flushWarm(true);
+    } catch {
+      return void 0;
+    }
+    if (waits.length === 0) {
+      return void 0;
+    }
+    return Promise.all(waits).then(() => {
+    });
+  }
+  /**
+   * Warm each of the current stage's cameras for its built-in colour
+   * matrix.
+   *
+   * A camera applies `colorMatrix` as one more effect at the end of its
+   * chain, but it built that effect inside its own `draw`, on the first
+   * frame the matrix was not identity, and appends it for that frame only.
+   * Nothing ever attached it, so nothing warmed it: its program (WebGL) or
+   * its pipelines (WebGPU) were built in the first frame of a stage that
+   * grades its camera. Made here instead, once the stage has been built,
+   * and warmed where `draw` runs it, last in the camera's chain.
+   * @ignore
+   * @internal
+   */
+  _warmCameraColorMatrices() {
+    const cameras = state_default.current()?.cameras;
+    if (cameras === void 0) {
+      return;
+    }
+    for (const camera of cameras.values()) {
+      const effect = camera._syncColorMatrixEffect?.(this);
+      if (effect == null) {
+        continue;
+      }
+      const effects = camera.postEffects;
+      effects.push(effect);
       try {
-        this._warmRenderable(host);
-      } catch {
+        this._warmPostEffects(camera);
+      } finally {
+        effects.splice(effects.indexOf(effect), 1);
       }
     }
   }
+  /**
+   * Whether the meshes being warmed will draw with fog, without it, or both.
+   *
+   * Fog is a pipeline variant, and which one a mesh draws with is decided by
+   * the camera drawing it: each camera installs its own fog on the renderer
+   * as it starts drawing ({@link Renderer#setFog}), and the frame clears it.
+   * So the renderer's own value is no answer here. A warm-up runs between
+   * frames, while the renderer still holds the fog of whichever camera drew
+   * LAST, which after a state change is the previous screen's: a loading
+   * screen has none, so every mesh of a fogged scene was warmed without it
+   * and then compiled with it, synchronously, on its first frame.
+   *
+   * Asked of the current stage's cameras instead, through the same
+   * `_fog3dState` the draw installs, so the warm-up and the draw cannot
+   * disagree. A stage with a fogged camera and a clear one (a minimap, say)
+   * warms both variants. Fog switched on in a later frame than the scene was
+   * built in is not seen here, and is built on that frame as before.
+   * @returns {boolean[]} the fog states to warm, each `true` for fogged
+   * @ignore
+   * @internal
+   */
+  _warmFogStates() {
+    let fogged = false;
+    let clear = false;
+    const cameras = state_default.current()?.cameras;
+    if (cameras !== void 0) {
+      for (const camera of cameras.values()) {
+        if (camera._fog3dState?.(this) != null) {
+          fogged = true;
+        } else {
+          clear = true;
+        }
+      }
+    }
+    if (!fogged && !clear) {
+      return [this._fog3d != null];
+    }
+    return clear && fogged ? [false, true] : [fogged];
+  }
   /**
    * Warm one renderable, and everything under it when it is a container:
    * adding a container to the world brings its whole subtree in with it,
@@ -40204,6 +40362,8 @@ var _transitionConfig = {
   duration: 0
 };
 var _onSwitchComplete = null;
+var MAX_WARM_HOLD = 1500;
+var _heldSwitch = null;
 var _extraArgs = null;
 var _pauseTime = 0;
 var _freezeTimer = null;
@@ -40257,9 +40417,17 @@ function _renderFrame(time) {
   }
 }
 function _stopRunLoop() {
+  _endHeldSwitches();
   globalThis.cancelAnimationFrame(_animFrameId);
   _animFrameId = -1;
 }
+function _endHeldSwitches() {
+  while (_heldSwitch !== null) {
+    const finish = _heldSwitch;
+    _heldSwitch = null;
+    finish();
+  }
+}
 function _switchState(stateId) {
   _stopRunLoop();
   if (_stages[_state]) {
@@ -40267,17 +40435,45 @@ function _switchState(stateId) {
   }
   if (_stages[stateId]) {
     _state = stateId;
+    const onSwitchComplete = _onSwitchComplete;
+    _onSwitchComplete = null;
+    const finish = () => {
+      try {
+        emit(STATE_CHANGE);
+      } finally {
+        onSwitchComplete?.();
+      }
+    };
     if (_extraArgs) {
       _stages[_state].stage.reset(_app2, ..._extraArgs);
     } else {
       _stages[_state].stage.reset(_app2);
     }
-    _startRunLoop();
-    emit(STATE_CHANGE);
-    if (_onSwitchComplete) {
-      _onSwitchComplete();
-      _onSwitchComplete = null;
+    const renderer = _app2?.renderer;
+    const warmed = renderer?._whenWarmed?.();
+    _endHeldSwitches();
+    if (warmed === void 0) {
+      _startRunLoop();
+      finish();
+      return;
     }
+    _heldSwitch = finish;
+    let cap;
+    const start = () => {
+      clearTimeout(cap);
+      if (_heldSwitch !== finish) {
+        return;
+      }
+      _heldSwitch = null;
+      _startRunLoop();
+      finish();
+    };
+    void Promise.race([
+      warmed,
+      new Promise((resolve) => {
+        cap = setTimeout(resolve, MAX_WARM_HOLD);
+      })
+    ]).then(start, start);
   }
 }
 var _app2;
@@ -40461,7 +40657,7 @@ var state3 = {
    * @returns true if a "process is running"
    */
   isRunning() {
-    return _animFrameId !== -1;
+    return _animFrameId !== -1 || _heldSwitch !== null;
   },
   /**
    * Return the pause state of the state manager
@@ -48910,16 +49106,36 @@ var WebGLRenderer = class _WebGLRenderer extends Renderer {
       return;
     }
     this._meshEffectWarmQueue ??= [];
-    for (const fx of effects) {
-      this._meshEffectWarmQueue.push(batcher, fx);
+    for (const fog of this._warmFog ?? [this._fog3d != null]) {
+      const fogDefine = fog ? "#define FOG\n" : "";
+      for (const fx of effects) {
+        this._meshEffectWarmQueue.push(batcher, fx, fogDefine);
+      }
     }
     if (this._meshEffectWarmScheduled !== true) {
       this._meshEffectWarmScheduled = true;
+      this._meshEffectWarmDone = new Promise((resolve) => {
+        this._meshEffectWarmSettle = resolve;
+      });
       queueMicrotask(() => {
         this._linkQueuedMeshEffects();
       });
     }
   }
+  /**
+   * Run `warm` and hand back what is still to be built once it returns:
+   * the spliced mesh programs it queued, which are linked over the next
+   * tasks rather than all at once.
+   * @param {Function} warm - issues the warm-ups
+   * @returns {Promise<void>[]} the queued links, as one promise, or nothing
+   * @override
+   * @ignore
+   * @internal
+   */
+  _collectWarms(warm) {
+    warm();
+    return this._meshEffectWarmScheduled === true ? [this._meshEffectWarmDone] : [];
+  }
   /**
    * Link the spliced mesh programs queued by `_warmPostEffects`, a few
    * milliseconds' worth per task, so a pool's worth spreads over the next
@@ -48933,7 +49149,7 @@ var WebGLRenderer = class _WebGLRenderer extends Renderer {
     const gl = this.gl;
     if (gl === null || gl.isContextLost?.() === true) {
       queue.length = 0;
-      this._meshEffectWarmScheduled = false;
+      this._settleMeshEffectWarm();
       return;
     }
     const start = globalThis.performance.now();
@@ -48942,15 +49158,16 @@ var WebGLRenderer = class _WebGLRenderer extends Renderer {
       while (queue.length > 0 && globalThis.performance.now() - start < MESH_EFFECT_LINK_BUDGET) {
         const batcher = queue.shift();
         const fx = queue.shift();
+        const fogDefine = queue.shift();
         if (fx.destroyed !== true && batcher.canHostEffect?.(fx) === true) {
-          batcher.effectShaderFor(fx);
+          batcher._effectShader(fx, fogDefine);
         }
       }
     } finally {
       this._restoreProgram(previous);
     }
     if (queue.length === 0) {
-      this._meshEffectWarmScheduled = false;
+      this._settleMeshEffectWarm();
     } else if (globalThis.document?.hidden === true) {
       this._linkQueuedMeshEffects();
     } else {
@@ -48959,6 +49176,17 @@ var WebGLRenderer = class _WebGLRenderer extends Renderer {
       }, 0);
     }
   }
+  /**
+   * The link queue is empty: let the next warm-up schedule a new one, and
+   * release whatever is waiting on this one.
+   * @ignore
+   * @internal
+   */
+  _settleMeshEffectWarm() {
+    this._meshEffectWarmScheduled = false;
+    this._meshEffectWarmSettle?.();
+    this._meshEffectWarmSettle = void 0;
+  }
   /**
    * Build the advanced blend shader and its offscreen target before the
    * first draw in one of those modes, which otherwise compiles the shader
@@ -50042,8 +50270,16 @@ var WebGLRenderer = class _WebGLRenderer extends Renderer {
    * @see WebGLRenderer#createPattern
    */
   drawPattern(pattern, x, y, width, height) {
+    if (this.customShader?._screenTextureUniforms?.length > 0) {
+      this.toFrameTexture();
+    }
     const uvs = pattern.getUVs("0,0," + width + "," + height);
     this.setBatcher("quad");
+    const shader = this.customShader;
+    if (shader != null) {
+      this.currentBatcher.useShader(shader);
+      shader._prepareTextures?.(this.currentBatcher);
+    }
     this.currentBatcher.addQuad(
       pattern,
       x,
@@ -56651,7 +56887,7 @@ var Trigger = class extends Renderable {
 };
 
 // src/version.ts
-var version = "20.10.0";
+var version = "20.10.1";
 
 // src/system/bootstrap.ts
 var initialized = false;
@@ -59176,6 +59412,7 @@ var WebGPUPipelineCache = class _WebGPUPipelineCache {
     this.inFrameMisses = 0;
     this.inFrameMissKeys = [];
     this.pending = /* @__PURE__ */ new Map();
+    this.collecting = void 0;
     this.warmQueue = [];
     this.warmInFlight = 0;
     this.touchQueue = /* @__PURE__ */ new Map();
@@ -59537,6 +59774,7 @@ var WebGPUPipelineCache = class _WebGPUPipelineCache {
     }
     const inFlight = this.pending.get(key);
     if (inFlight !== void 0) {
+      this.collecting?.push(inFlight);
       return inFlight;
     }
     const descriptor = this._descriptor(
@@ -59554,6 +59792,9 @@ var WebGPUPipelineCache = class _WebGPUPipelineCache {
     const promise = new Promise((resolve) => {
       this.warmQueue.push({
         run: () => {
+          if (this.pipelines.has(key)) {
+            return void 0;
+          }
           return typeof this.device.createRenderPipelineAsync === "function" ? this.device.createRenderPipelineAsync(descriptor) : this.device.createRenderPipeline(descriptor);
         },
         resolve: (pipeline) => {
@@ -59567,9 +59808,29 @@ var WebGPUPipelineCache = class _WebGPUPipelineCache {
       });
     });
     this.pending.set(key, promise);
+    this.collecting?.push(promise);
     this._pumpWarmQueue();
     return promise;
   }
+  /**
+   * Run `ask` and hand back the warm-ups it asked for that are not built
+   * yet: the ones it started, and the ones already compiling that it asked
+   * for again. A pipeline already in the cache is not waited on, so a scene
+   * entered a second time hands back nothing.
+   * @param {Function} ask - asks for warm-ups, through {@link WebGPUPipelineCache#warm}
+   * @returns {Promise<void>[]} one promise per pipeline still on its way
+   */
+  collect(ask) {
+    const outer = this.collecting;
+    const asked = [];
+    this.collecting = asked;
+    try {
+      ask();
+    } finally {
+      this.collecting = outer;
+    }
+    return asked;
+  }
   /**
    * Start queued warm-ups until {@link MAX_WARM_IN_FLIGHT} are compiling.
    * @ignore
@@ -62880,6 +63141,21 @@ var WebGPURenderer = class _WebGPURenderer extends Renderer {
     }
     return realization.gpu.key;
   }
+  /**
+   * Run `warm` and hand back the pipelines it asked for that are still
+   * compiling, which on this backend is every one not already cached.
+   * @param {Function} warm - issues the warm-ups
+   * @returns {Promise<void>[]} one promise per pipeline on its way
+   * @override
+   * @ignore
+   * @internal
+   */
+  _collectWarms(warm) {
+    if (this.pipelineCache == null) {
+      return super._collectWarms(warm);
+    }
+    return this.pipelineCache.collect(warm);
+  }
   /**
    * Build, off the frame, every pipeline a renderable's post effects can
    * draw with, and the render targets its chain will composite through.
@@ -63052,6 +63328,20 @@ var WebGPURenderer = class _WebGPURenderer extends Renderer {
    * @internal
    */
   _warmMeshDraw(mesh, family, scene) {
+    for (const fog of this._warmFog ?? [this._fog3d != null]) {
+      this._warmMeshDrawFog(mesh, family, scene, fog);
+    }
+  }
+  /**
+   * {@link WebGPURenderer#_warmMeshDraw} for one fog state.
+   * @param {object} mesh - the mesh
+   * @param {string} family - the pipeline family it draws with
+   * @param {Array<Array<string|number>>} scene - the targets it can land on
+   * @param {boolean} fog - whether it draws fogged
+   * @ignore
+   * @internal
+   */
+  _warmMeshDrawFog(mesh, family, scene, fog) {
     const culling = mesh.cullBackFaces === true;
     const state4 = {
       cullMode: culling ? "back" : "none",
@@ -63059,7 +63349,9 @@ var WebGPURenderer = class _WebGPURenderer extends Renderer {
       frontFace: culling && this.supportsRetainedMesh === true && mesh.rightHanded !== true ? "cw" : "ccw",
       depthWrite: void 0,
       depthTest: mesh.depthTest === false ? false : void 0,
-      fog: this._fog3d != null ? true : void 0
+      // `undefined` rather than `false`, as the draw sets it: the key only
+      // grows a fog suffix for `true`
+      fog: fog ? true : void 0
     };
     const blendedOnly = mesh.transparent === true || mesh._blendedDraw === true;
     const blended = mesh.transparent !== false || mesh._blendedDraw === true;
@@ -63113,6 +63405,7 @@ var WebGPURenderer = class _WebGPURenderer extends Renderer {
       return;
     }
     if (renderable.instanceLayout !== void 0) {
+      this._warmInstancedDraw(renderable, scene);
       return;
     }
     const blendMode = renderable.blendMode ?? "normal";
@@ -63129,6 +63422,61 @@ var WebGPURenderer = class _WebGPURenderer extends Renderer {
       );
     }
   }
+  /**
+   * Warm what an `InstancedMesh` draws with: its instanced family, and the
+   * instanced ground-shadow family when it casts one.
+   *
+   * Both families are registered per instance record layout, on first use,
+   * which the warm-up used to leave to the first draw. Nothing about them
+   * needs the draw, though: the layout is the mesh's own, so registering
+   * them here builds the same module and vertex layout the draw would, and
+   * the keys follow the same rules as an ordinary mesh's. A scatter of
+   * props is one of these, and it is exactly the kind of thing a stage
+   * builds when it starts and draws on its next frame.
+   * @param {object} mesh - the instanced mesh
+   * @param {Array<Array<string|number>>} scene - the targets it can land on
+   * @ignore
+   * @internal
+   */
+  _warmInstancedDraw(mesh, scene) {
+    if (this.supportsInstancing !== true) {
+      return;
+    }
+    const batcher = this._meshBatcherFor(mesh);
+    if (typeof batcher?.instancedFamilyFor !== "function") {
+      return;
+    }
+    this._warmMeshDraw(
+      mesh,
+      batcher.instancedFamilyFor(mesh.instanceLayout),
+      scene
+    );
+    if (mesh._castsGroundShadow?.(this) !== true || typeof batcher.instancedShadowFamily !== "function") {
+      return;
+    }
+    const family = batcher.instancedShadowFamily(mesh.instanceLayout);
+    for (const fog of this._warmFog ?? [this._fog3d != null]) {
+      const state4 = {
+        cullMode: "none",
+        frontFace: "ccw",
+        depthWrite: false,
+        depthTest: mesh.depthTest === false ? false : void 0,
+        fog: fog ? true : void 0
+      };
+      for (const [format, sampleCount] of scene) {
+        void this.pipelineCache.warm(
+          family,
+          "triangle-list",
+          "normal",
+          true,
+          "none",
+          state4,
+          format,
+          sampleCount
+        );
+      }
+    }
+  }
   /**
    * Build the advanced blend shader and its offscreen target before the
    * first draw in one of those modes, and warm the two pipelines a bracket
@@ -63516,20 +63864,25 @@ var WebGPURenderer = class _WebGPURenderer extends Renderer {
       if (this.getDefaultTextureFilter() === "linear") {
         this.textureStore.warmMipmaps();
       }
+      const warms = [];
       if (this._canWarm()) {
         for (const [format, sampleCount] of this._sceneTargets()) {
-          void this.pipelineCache.warm(
-            "clear",
-            "triangle-list",
-            "none",
-            true,
-            "none",
-            void 0,
-            format,
-            sampleCount
+          warms.push(
+            this.pipelineCache.warm(
+              "clear",
+              "triangle-list",
+              "none",
+              true,
+              "none",
+              void 0,
+              format,
+              sampleCount
+            )
           );
         }
       }
+      return Promise.all(warms).then(() => {
+      });
     });
   }
   /**