melonjs 20.5.0 → 20.6.0

package/build/application/defaultApplicationSettings.d.ts

@@ -5,6 +5,7 @@ export declare const defaultApplicationSettings: {
     powerPreference: "default";
     transparent: false;
     antiAlias: false;
+    prewarm: true;
     textureFilter: "auto";
     maxTextures: "auto";
     castGroundShadow: true;

package/build/application/defaultApplicationSettings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultApplicationSettings.d.ts","sourceRoot":"","sources":["../../src/application/defaultApplicationSettings.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;CAmBC,CAAC"}
+{"version":3,"file":"defaultApplicationSettings.d.ts","sourceRoot":"","sources":["../../src/application/defaultApplicationSettings.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;CAoBC,CAAC"}

package/build/application/settings.d.ts

@@ -100,6 +100,43 @@ export type ApplicationSettings = {
      * @default false
      */
     antiAlias: boolean;
+    /**
+     * Warm the renderer up during `loader.preload()`, behind the loading
+     * screen, instead of paying for it on the frame that first draws (GPU
+     * backends — the Canvas renderer has nothing to warm and ignores this).
+     *
+     * Today that means the built-in shader programs, which is all
+     * {@link Renderer#prewarm} does. Named for the intent rather than the
+     * current contents: anything else worth doing before the first frame
+     * belongs behind the same switch, and should not need a second setting.
+     *
+     * A GPU backend does not finish a shader when handed the source; it
+     * finishes it the first time something is drawn with it. That puts the
+     * whole cost on the frame a scene first appears, which is the moment a
+     * level or stage comes up and its geometry arrives a beat late. Warming
+     * up moves it to where a progress bar is already on screen.
+     *
+     * **On by default.** The cost is small and it is paid where nothing is
+     * waiting on a frame: a purely 2D game links the mesh-tier programs
+     * it will never bind — both the unlit tier and the lit one that inherits
+     * from it — measured at about 60ms on a fast desktop GPU, inside a preload
+     * that is already showing a progress bar. A tiny 2D game with a near-empty
+     * preload is the one case that pays without any possible benefit. Set it to
+     * `false` for a target where linking is slow enough that the preload
+     * itself would suffer.
+     *
+     * The warm-up is run by `loader.preload()` — every call, not just the
+     * first — so a game that preloads gets it automatically and a game that
+     * never calls `preload()` never gets it at all. Call
+     * {@link Renderer#prewarm} directly in that case.
+     *
+     * Shaders declared as assets (`{type: "shader"}`) are covered too, so a
+     * level's own effects are warmed by declaring them alongside that level's
+     * assets rather than building them inline when the level starts.
+     * @default true
+     * @see {@link Renderer#prewarm}
+     */
+    prewarm: boolean;
     /**
      * Default texture magnification/minification filter, **decoupled from
      * `antiAlias`** (GPU backends — WebGL and WebGPU; the 2D Canvas

package/build/application/settings.d.ts.map

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

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.5.0
+ * melonJS Game Engine - 20.6.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -6891,6 +6891,52 @@ var Renderer = class _Renderer {
    */
   flush() {
   }
+  /**
+   * Compile the backend's built-in shader programs up front, so the first
+   * frame that draws them does not stall while the driver builds them.
+   *
+   * A GPU backend does not finish a shader when you hand it the source. It
+   * finishes it the first time something is actually drawn with it, which
+   * puts the whole cost on the frame a scene first appears — the moment a
+   * level or stage comes up and its geometry arrives a beat late. Calling
+   * this while a loading screen is still on screen moves that cost to where
+   * nobody is waiting on a frame.
+   *
+   * Resolves immediately on a backend with nothing to compile (Canvas).
+   * What "ready" means is backend-specific and worth knowing: WebGL's link
+   * blocks, so a resolved promise there means the programs are genuinely
+   * built; WebGPU's `createShaderModule` returns before its compilation
+   * finishes, so a resolved promise there means the modules have been
+   * requested and validation is under way.
+   *
+   * **You normally do not call this.** `loader.preload()` calls it for you,
+   * once the assets are in and before `LOADER_COMPLETE` fires — so it runs
+   * while the loading screen is still up — whenever the application's
+   * `prewarm` setting is on, which it is by default. Every `preload()` warms,
+   * not just the first, so a per-level preload warms whatever that level
+   * brought with it.
+   *
+   * Two consequences worth knowing:
+   *
+   * - **A game that never calls `loader.preload()` is never warmed.** There
+   *   is no other hook. Call this yourself if you load assets some other way
+   *   and still want the warm-up.
+   * - It is deliberately NOT called from `Application.init()`. That runs
+   *   before anything is on screen, so warming there would only lengthen a
+   *   blank page instead of hiding behind a progress bar.
+   * @returns {Promise<void>} settles when the built-in programs are ready
+   * @example
+   * // the usual case: nothing to write. `preload()` warms on the way through
+   * await loader.preload(resources);
+   * @example
+   * // only needed if you do not use the preloader, or want a second warm-up
+   * // at a point of your own choosing
+   * await app.renderer.prewarm();
+   * state.change(state.PLAY);
+   */
+  prewarm() {
+    return Promise.resolve();
+  }
   /**
    * Mark the start of a screen-space (`floating`) draw, during which the
    * camera's screen projection is installed and world-space geometry cannot
@@ -13429,7 +13475,7 @@ var input_exports = {};
 __export(input_exports, {
   GAMEPAD: () => GAMEPAD,
   KEY: () => KEY,
-  _app: () => _app2,
+  _app: () => _app3,
   bindGamepad: () => bindGamepad,
   bindKey: () => bindKey,
   bindPointer: () => bindPointer,
@@ -20798,7 +20844,16 @@ var Camera2d = class extends Renderable {
       container.draw(r, this);
     }
     renderer.flushTransparent();
+    const hasCameraEffects = this.cameraEffects.length > 0;
+    if (hasCameraEffects) {
+      renderer.setProjection(this.screenProjection);
+    }
     this.drawFX(renderer);
+    if (hasCameraEffects) {
+      renderer.setProjection(
+        isNonDefault ? this.worldProjection : this.projectionMatrix
+      );
+    }
     container.postDraw(r);
     this.postDraw(r);
     if (stage) {
@@ -22291,6 +22346,13 @@ var DefaultLoadingScreen = class extends Stage {
    * @internal
    */
   #cleanedUp = false;
+  /**
+   * whether the preloader has reported done. Latched on LOADER_COMPLETE
+   * and read by the logo's own load callback — NOT a teardown signal.
+   * @ignore
+   * @internal
+   */
+  #loadingComplete = false;
   /**
    * Pin the loading screen to a Camera2d regardless of the
    * application's `cameraClass` setting. The loader must render
@@ -22310,13 +22372,14 @@ var DefaultLoadingScreen = class extends Stage {
     const barHeight = 8;
     this.#app = app;
     this.#cleanedUp = false;
+    this.#loadingComplete = false;
     app.world.backgroundColor.parseCSS("#202020");
     const { width, height } = app.renderer;
     this.progressBar = new ProgressBar(0, height / 2, width, barHeight);
     app.world.addChild(this.progressBar, 1);
-    once(LOADER_COMPLETE, this.#cleanup, this);
-    load2({ name: "melonjs_logo", type: "image", src: melonjs_logo_default }, () => {
-      if (this.#cleanedUp) {
+    once(LOADER_COMPLETE, this.#onLoaderComplete, this);
+    load2({ name: "melonjs_logo", type: "image", src: melonjs_logo_default }).then(() => {
+      if (this.#loadingComplete || this.#cleanedUp) {
         return;
       }
       this.logoSprite = new Sprite(width / 2, height / 2, {
@@ -22325,8 +22388,18 @@ var DefaultLoadingScreen = class extends Stage {
         frameheight: 256
       });
       app.world.addChild(this.logoSprite, 2);
+    }).catch(() => {
     });
   }
+  /**
+   * The preloader is done. Latched so a late-arriving logo is not added
+   * to a world that is about to be replaced; nothing is torn down here.
+   * @ignore
+   * @internal
+   */
+  #onLoaderComplete() {
+    this.#loadingComplete = true;
+  }
   /**
    * Remove loading screen children and unload the logo
    * @ignore
@@ -22354,8 +22427,8 @@ var DefaultLoadingScreen = class extends Stage {
    * @internal
    */
   onDestroyEvent() {
-    if (!this.#cleanedUp) {
-      off(LOADER_COMPLETE, this.#cleanup, this);
+    if (!this.#loadingComplete) {
+      off(LOADER_COMPLETE, this.#onLoaderComplete, this);
     }
     this.#cleanup();
   }
@@ -35128,6 +35201,21 @@ function initParsers() {
   setParser("shader", preloadShader);
   parserInitialized = true;
 }
+var _app2;
+on(GAME_INIT, (app) => {
+  _app2 = app;
+});
+function runShaderPrewarm() {
+  if (_app2 === void 0 || _app2.settings?.prewarm !== true) {
+    return Promise.resolve();
+  }
+  try {
+    return Promise.resolve(_app2.renderer?.prewarm?.()).catch(() => {
+    });
+  } catch {
+    return Promise.resolve();
+  }
+}
 function completeLoading(onloadcb) {
   const callback = onloadcb || onload;
   if (typeof callback === "function") {
@@ -35171,7 +35259,7 @@ function preload(assets, onloadcb, switchToLoadState = true) {
   if (switchToLoadState === true) {
     state_default.change(state_default.LOADING);
   }
-  return Promise.all(promises).then(() => {
+  return Promise.all(promises).then(runShaderPrewarm).then(() => {
     completeLoading(onload);
   });
 }
@@ -39017,6 +39105,18 @@ var WebGLBatcher = class extends Batcher {
       vertex.clear();
     }
   }
+  /**
+   * Build any shader variant this batcher compiles lazily.
+   *
+   * A batcher whose only program is the one built in its constructor has
+   * nothing to do here — which is every batcher but the mesh one.
+   * @returns {Promise<void>} settles once this batcher is warm
+   * @ignore
+   * @internal
+   */
+  prewarm() {
+    return Promise.resolve();
+  }
 };
 
 // src/video/gpu/primitives.ts
@@ -42070,6 +42170,71 @@ var MeshBatcher = class extends MaterialBatcher {
     }
     return shader;
   }
+  /**
+   * Build every shader variant this batcher can reach, so none of them is
+   * compiled on the frame a scene first draws.
+   *
+   * The set is enumerable because each variant is a source permutation, not
+   * a runtime branch: fog on or off, and the three instance-record slots.
+   * That is 1 fogged mesh + 8 instanced + 2 ground-shadow programs; the
+   * plain mesh program is built in the constructor and is already here.
+   *
+   * Yields between programs. Linking is synchronous in WebGL and a dozen
+   * links in one task is a dropped frame — which on a loading screen is a
+   * stuttering progress bar, trading one visible hitch for another.
+   * @returns {Promise<void>} settles once every variant is linked
+   * @ignore
+   * @internal
+   */
+  async prewarm() {
+    const yieldToFrame = () => {
+      if (globalThis.document?.hidden === true) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        setTimeout(resolve, 0);
+      });
+    };
+    const alive = () => {
+      return this.gl !== null && this.gl?.isContextLost?.() !== true;
+    };
+    const sources = this._shaderSources();
+    const instanced = this._instancedShaderSources();
+    for (const fogDefine of ["", "#define FOG\n"]) {
+      if (fogDefine !== "") {
+        this.shaderVariant("mesh|fog", sources, fogDefine, fogDefine);
+        await yieldToFrame();
+        if (!alive()) {
+          return;
+        }
+      }
+      for (const hasColor of [false, true]) {
+        for (const hasData of [false, true]) {
+          const key = (hasColor ? 1 : 0) | (hasData ? 2 : 0) | (fogDefine !== "" ? 4 : 0);
+          this.shaderVariant(
+            `instanced|${key}`,
+            instanced,
+            (hasColor ? "#define INSTANCE_COLORS\n" : "") + (hasData ? "#define INSTANCE_DATA\n" : "") + fogDefine,
+            (hasData ? "#define INSTANCE_DATA\n" : "") + fogDefine
+          );
+          await yieldToFrame();
+          if (!alive()) {
+            return;
+          }
+        }
+      }
+      this.shaderVariant(
+        fogDefine === "" ? "shadow" : "shadow|fog",
+        { vertex: mesh_shadow_instanced_default, fragment: mesh_default },
+        fogDefine,
+        fogDefine
+      );
+      await yieldToFrame();
+      if (!alive()) {
+        return;
+      }
+    }
+  }
   /**
    * Whether the bound program is one this batcher would pick for a plain
    * mesh — its own, or the fog variant of its own.
@@ -44343,6 +44508,7 @@ var WebGLRenderer = class _WebGLRenderer extends Renderer {
     this.onContextRestoredInvalidate = (renderer) => {
       if (renderer === this) {
         this.currentProgram = void 0;
+        this._prewarmed = void 0;
       }
     };
     this.onCanvasResize = (width, height) => {
@@ -44426,6 +44592,29 @@ var WebGLRenderer = class _WebGLRenderer extends Renderer {
       batcher.releaseRetained?.(mesh);
     });
   }
+  /**
+   * Compile every shader variant the built-in batchers can reach.
+   *
+   * A WebGL batcher builds its own program in its constructor, so the base
+   * programs are already linked by the time `init()` resolves. What is not
+   * is the mesh batcher's permutations — fog, and the three instance-record
+   * slots — which are built on first use and so land on the frame a 3D
+   * scene first draws.
+   * @returns {Promise<void>} settles once every variant is linked
+   * @see {@link Renderer#prewarm}
+   */
+  prewarm() {
+    if (this._prewarmed === void 0) {
+      this._prewarmed = Promise.all(
+        [...this.batchers.values()].map((batcher) => {
+          return batcher.prewarm();
+        })
+      ).then(() => {
+        this.setBatcher("quad");
+      });
+    }
+    return this._prewarmed;
+  }
   destroy() {
     off(GAME_RESET, this.onGameReset);
     off(ONCONTEXT_RESTORED, this.onContextRestoredInvalidate);
@@ -47315,8 +47504,8 @@ var Pointer = class extends Bounds {
     this.isPrimary = typeof event.isPrimary !== "undefined" ? event.isPrimary : true;
     this.button = event.button || 0;
     this.type = event.type;
-    if (typeof _app2?.viewport !== "undefined") {
-      _app2.viewport.localToWorld(this.gameScreenX, this.gameScreenY, tmpVec);
+    if (typeof _app3?.viewport !== "undefined") {
+      _app3.viewport.localToWorld(this.gameScreenX, this.gameScreenY, tmpVec);
     }
     this.gameWorldX = tmpVec.x;
     this.gameWorldY = tmpVec.y;
@@ -47337,9 +47526,9 @@ var pointer_default = Pointer;
 var T_POINTERS = [];
 var eventHandlers = /* @__PURE__ */ new Map();
 var currentPointer;
-var _app2;
+var _app3;
 on(GAME_INIT, (app) => {
-  _app2 = app;
+  _app3 = app;
 });
 var pointerInitialized = false;
 var lastTimeStamp = 0;
@@ -47403,7 +47592,7 @@ function registerEventListener(eventList, callback) {
 }
 function enablePointerEvent() {
   if (!pointerInitialized) {
-    if (!_app2) {
+    if (!_app3) {
       throw new Error("Pointer events require an initialized Application");
     }
     currentPointer = new Rect(0, 0, 1, 1);
@@ -47411,7 +47600,7 @@ function enablePointerEvent() {
       T_POINTERS.push(new pointer_default());
     }
     if (pointerEventTarget === null || pointerEventTarget === void 0) {
-      pointerEventTarget = _app2.renderer.getCanvas();
+      pointerEventTarget = _app3.renderer.getCanvas();
     }
     if (pointerEvent) {
       activeEventList = pointerEventList;
@@ -47465,7 +47654,7 @@ function enablePointerEvent() {
       globalThis.document.addEventListener(
         POINTERLOCKCHANGE,
         () => {
-          locked = globalThis.document.pointerLockElement === _app2.getParentElement();
+          locked = globalThis.document.pointerLockElement === _app3.getParentElement();
           emit(POINTERLOCKCHANGE, locked);
         },
         true
@@ -47515,7 +47704,7 @@ function dispatchEvent(normalizedEvents2) {
       }
       lastTimeStamp = pointer2.event.timeStamp;
     }
-    const worldOffset = _app2.world.pos;
+    const worldOffset = _app3.world.pos;
     const absoluteWorldX = pointer2.gameWorldX + worldOffset.x;
     const absoluteWorldY = pointer2.gameWorldY + worldOffset.y;
     currentPointer.pos.set(pointer2.gameWorldX, pointer2.gameWorldY);
@@ -47525,16 +47714,16 @@ function dispatchEvent(normalizedEvents2) {
       pointer2.gameY = pointer2.gameLocalY = pointer2.gameScreenY;
       emit(POINTERMOVE, pointer2);
     }
-    let candidates = _app2.world.broadphase.retrieve(
+    let candidates = _app3.world.broadphase.retrieve(
       currentPointer,
-      (a, b) => _app2.world._sortReverseZ(a, b),
+      (a, b) => _app3.world._sortReverseZ(a, b),
       void 0
     );
     if (worldOffset.x !== 0 || worldOffset.y !== 0) {
       currentPointer.pos.set(absoluteWorldX, absoluteWorldY);
-      const absoluteCandidates = _app2.world.broadphase.retrieve(
+      const absoluteCandidates = _app3.world.broadphase.retrieve(
         currentPointer,
-        (a, b) => _app2.world._sortReverseZ(a, b),
+        (a, b) => _app3.world._sortReverseZ(a, b),
         void 0
       );
       for (const candidate of candidates) {
@@ -47543,10 +47732,10 @@ function dispatchEvent(normalizedEvents2) {
         }
       }
       candidates = absoluteCandidates.sort(
-        (a, b) => _app2.world._sortReverseZ(a, b)
+        (a, b) => _app3.world._sortReverseZ(a, b)
       );
     }
-    candidates = candidates.concat([_app2.viewport]);
+    candidates = candidates.concat([_app3.viewport]);
     for (let c = candidates.length, candidate; c--, candidate = candidates[c]; ) {
       if (eventHandlers.has(candidate) && candidate.isKinematic !== true) {
         const handlers = eventHandlers.get(candidate);
@@ -47709,11 +47898,11 @@ function hasRegisteredEvents() {
 }
 function globalToLocal(x, y, v) {
   v = v || vector2dPool.get();
-  const rect = getElementBounds(_app2.renderer.getCanvas());
+  const rect = getElementBounds(_app3.renderer.getCanvas());
   const pixelRatio = globalThis.devicePixelRatio || 1;
   x -= rect.left + (globalThis.pageXOffset || 0);
   y -= rect.top + (globalThis.pageYOffset || 0);
-  const scale2 = _app2.renderer.scaleRatio;
+  const scale2 = _app3.renderer.scaleRatio;
   if (scale2.x !== 1 || scale2.y !== 1) {
     x /= scale2.x;
     y /= scale2.y;
@@ -47805,7 +47994,7 @@ function releaseAllPointerEvents(region) {
 }
 function requestPointerLock() {
   if (hasPointerLockSupport) {
-    const element = _app2.getParentElement();
+    const element = _app3.getParentElement();
     void element.requestPointerLock();
     return true;
   }
@@ -52489,7 +52678,7 @@ var Trigger = class extends Renderable {
 };
 
 // src/version.ts
-var version = "20.5.0";
+var version = "20.6.0";
 
 // src/system/bootstrap.ts
 var initialized = false;
@@ -55216,46 +55405,75 @@ var WebGPUPipelineCache = class _WebGPUPipelineCache {
         primitive.cullMode = meshState.cullMode;
         primitive.frontFace = meshState.frontFace;
       }
-      pipeline = this.device.createRenderPipeline({
-        label: `melonJS ${key}`,
-        layout: this.pipelineLayouts[shaderKey],
-        vertex: {
-          module: this.modules[shaderKey],
-          entryPoint: "vertex_main",
-          buffers: vertexLayout ?? [],
-          ...meshState ? { constants: { enable_fog: fogFlag } } : {}
-        },
-        fragment: {
-          module: this.modules[shaderKey],
-          entryPoint: "fragment_main",
-          ...meshState ? { constants: { enable_fog: fogFlag } } : {},
-          targets: [
-            {
-              format: this.format,
-              blend: shaderKey === "clear" ? void 0 : gpuBlendState(blend, pma),
-              writeMask: stencil.colorWriteMask
-            }
-          ]
-        },
-        primitive,
-        depthStencil: {
-          format: DEPTH_STENCIL_FORMAT,
-          // `!== false`, not `!!`: mesh draws that never set the field (and
-          // every bare `{cullMode, frontFace}` literal) must keep writing
-          // depth exactly as they did before the axis existed
-          depthWriteEnabled: meshState ? meshState.depthWrite !== false : false,
-          depthCompare: meshState ? "less-equal" : "always",
-          stencilFront: stencil.stencil,
-          stencilBack: stencil.stencil,
-          stencilReadMask: stencil.readMask,
-          stencilWriteMask: stencil.writeMask
-        },
-        multisample: { count: this.sampleCount }
-      });
+      pipeline = this.device.createRenderPipeline(
+        this._descriptor(key, shaderKey, blend, pma, stencil, primitive, {
+          vertexLayout,
+          meshState,
+          fogFlag
+        })
+      );
       this.pipelines.set(key, pipeline);
     }
     return pipeline;
   }
+  /**
+   * Assemble a pipeline descriptor.
+   *
+   * Split out of `get()` so the descriptor can be read on its own — it is
+   * long, and every field in it is load-bearing for cache correctness: a
+   * pipeline built from a descriptor that differs from the one a draw would
+   * have produced is worse than no cache entry at all, because the draw
+   * silently builds a second one under a key nothing will hit again.
+   * @param {string} key - the cache key, used as the label
+   * @param {string} shaderKey - the module family
+   * @param {string} blend - normalized blend mode
+   * @param {boolean} pma - premultiplied alpha
+   * @param {object} stencil - the resolved stencil state
+   * @param {object} primitive - the resolved primitive state
+   * @param {object} opts - `{vertexLayout, meshState, fogFlag}`
+   * @returns {GPURenderPipelineDescriptor} the descriptor
+   * @ignore
+   * @internal
+   */
+  _descriptor(key, shaderKey, blend, pma, stencil, primitive, opts) {
+    const { vertexLayout, meshState, fogFlag } = opts;
+    return {
+      label: `melonJS ${key}`,
+      layout: this.pipelineLayouts[shaderKey],
+      vertex: {
+        module: this.modules[shaderKey],
+        entryPoint: "vertex_main",
+        buffers: vertexLayout ?? [],
+        ...meshState ? { constants: { enable_fog: fogFlag } } : {}
+      },
+      fragment: {
+        module: this.modules[shaderKey],
+        entryPoint: "fragment_main",
+        ...meshState ? { constants: { enable_fog: fogFlag } } : {},
+        targets: [
+          {
+            format: this.format,
+            blend: shaderKey === "clear" ? void 0 : gpuBlendState(blend, pma),
+            writeMask: stencil.colorWriteMask
+          }
+        ]
+      },
+      primitive,
+      depthStencil: {
+        format: DEPTH_STENCIL_FORMAT,
+        // `!== false`, not `!!`: mesh draws that never set the field (and
+        // every bare `{cullMode, frontFace}` literal) must keep writing
+        // depth exactly as they did before the axis existed
+        depthWriteEnabled: meshState ? meshState.depthWrite !== false : false,
+        depthCompare: meshState ? "less-equal" : "always",
+        stencilFront: stencil.stencil,
+        stencilBack: stencil.stencil,
+        stencilReadMask: stencil.readMask,
+        stencilWriteMask: stencil.writeMask
+      },
+      multisample: { count: this.sampleCount }
+    };
+  }
   /**
    * drop every cached pipeline (device loss — the whole cache object is
    * rebuilt by the renderer's restore path, this exists for symmetry)
@@ -58450,6 +58668,45 @@ var WebGPURenderer = class _WebGPURenderer extends Renderer {
     }
     return this.renderPass;
   }
+  /**
+   * Compile the WGSL module of every shader asset the loader has, ahead of
+   * the frame that first draws it.
+   *
+   * WebGPU splits what WebGL fuses into one program. The **modules** for
+   * the engine's own families — quad, blit, primitive, clear, and the mesh
+   * tiers — are already created when the pipeline cache and the batchers
+   * are constructed, so there is nothing lazy there to warm. A **pipeline**
+   * is lazy, but it is keyed by draw state (blend, cull, depth-write) as
+   * well as by shader, so the set a scene will ask for cannot be known from
+   * here — and creating one costs almost nothing anyway, because WebGPU
+   * records the intent and leaves the work to first use.
+   *
+   * What IS both lazy and knowable is a `ShaderEffect`'s module:
+   * `prepareEffectBinding` builds it, and it is only ever called from
+   * inside the draw path. Every effect the loader compiled from a
+   * `{type: "shader"}` asset is already in `shaderList`, so those are
+   * exactly the ones that can be brought forward — which is what makes
+   * declaring a level's effects alongside that level's assets worth doing.
+   *
+   * Effects constructed inline when a stage builds are not here yet and
+   * cannot be warmed; that is a property of when they come into existence,
+   * not a limitation of this method.
+   * @returns {Promise<void>} settles once those modules are built
+   * @see {@link Renderer#prewarm}
+   */
+  prewarm() {
+    return Promise.resolve().then(() => {
+      for (const effect of Object.values(shaderList)) {
+        const realization = effect?.wgslRealization;
+        if (realization === void 0 || realization.valid !== true) {
+          continue;
+        }
+        if (realization.gpu === null || realization.gpu.epoch !== this.pipelineCache.epoch) {
+          buildEffectGPU(this, effect, realization);
+        }
+      }
+    });
+  }
   /**
    * end the open pass and submit the frame's command buffer
    * @override
@@ -60255,6 +60512,7 @@ var defaultApplicationSettings = {
   powerPreference: "default",
   transparent: false,
   antiAlias: false,
+  prewarm: true,
   textureFilter: "auto",
   maxTextures: "auto",
   castGroundShadow: true,