melonjs 19.9.1 → 20.0.0

package/build/renderable/mesh.d.ts

@@ -4,7 +4,21 @@
  * or from raw geometry data (vertices, uvs, indices).
  * Includes a built-in perspective projection and supports 3D transforms
  * through the standard Renderable API (`rotate`, `scale`, `translate`).
- * Works on both WebGL (hardware depth testing) and Canvas (painter's algorithm) renderers.
+ * Works on both GPU backends — WebGL 2 and WebGPU, with hardware depth
+ * testing — and on the Canvas renderer via the CPU-projected 2D-camera
+ * path (painter's algorithm, no depth buffer).
+ *
+ * **Retained rendering** — under a {@link Camera3d} on a GPU backend
+ * (`renderer.supportsRetainedMesh`), the mesh's model-space geometry is
+ * uploaded to GPU buffers **once** and every frame just draws it by
+ * reference: placement, camera, tint, alpha and emissive all ride
+ * per-draw uniforms, so moving, rotating, scaling or re-tinting a mesh
+ * never re-uploads geometry (near-zero per-frame allocation). Editing
+ * the geometry itself in place is still possible — signal it with
+ * {@link Mesh#needsUpdate} and the GPU copy refreshes on the next draw.
+ * Under a 2D camera (or on Canvas) the mesh instead re-projects its
+ * vertices on the CPU each frame — same API, the camera and backend
+ * decide the path.
  *
  * **Pivot — transforms are applied about the mesh's local origin `(0, 0, 0)`,
  * NOT a normalized anchor point.** Unlike a {@link Sprite} (whose
@@ -26,12 +40,12 @@ export default class Mesh extends Renderable {
      * @param {number} x - the x screen position of the mesh object
      * @param {number} y - the y screen position of the mesh object
      * @param {object} settings - Configuration parameters for the Mesh object
-     * @param {string} [settings.model] - name of a preloaded OBJ model (via loader.preload with type "obj")
+     * @param {string} [settings.model] - name of a preloaded OBJ model (via loader.preload with type "obj"). Vertex normals come with it — authored `vn` when the file has them, generated from face geometry when it does not — so an OBJ model can be `lit`.
      * @param {Float32Array|number[]} [settings.vertices] - vertex positions as x,y,z triplets (alternative to settings.model)
      * @param {Float32Array|number[]} [settings.uvs] - texture coordinates as u,v pairs (alternative to settings.model)
      * @param {Uint16Array|number[]} [settings.indices] - triangle vertex indices (alternative to settings.model)
-     * @param {HTMLImageElement|TextureAtlas|string} [settings.texture] - the texture to apply (image name, HTMLImageElement, or TextureAtlas). If omitted and settings.material is provided, the texture is resolved from the MTL material's map_Kd.
-     * @param {string} [settings.material] - name of a preloaded MTL material (via loader.preload with type "mtl"). When provided, the diffuse texture (map_Kd), tint color (Kd), and opacity (d) are automatically applied.
+     * @param {HTMLImageElement|TextureAtlas|string} [settings.texture] - the texture to apply (image name, HTMLImageElement, or TextureAtlas). If omitted and settings.material is provided, the texture is resolved from the MTL material's map_Kd. Passing this pins ONE binding over the whole model, which on a multi-material model suppresses the per-material texture split — see {@link Mesh#textureGroups}.
+     * @param {string} [settings.material] - name of a preloaded MTL material (via loader.preload with type "mtl"). When provided, the diffuse texture (map_Kd), tint color (Kd), and opacity (d) are automatically applied. On a multi-material model each material's own `map_Kd` is bound for its own slice of the geometry (#1573) and each `Kd` is baked per-vertex, so one `Mesh` renders the whole model.
      * @param {number} settings.width - display width in pixels. With normalization on (the default) the model is scaled to fit this size; with `normalize: false` this is the uniform pixels-per-unit scale applied to the raw geometry.
      * @param {number} [settings.height] - display height in pixels (normalized models only; ignored when `normalize: false`)
      * @param {boolean} [settings.cullBackFaces=true] - enable backface culling
@@ -39,9 +53,9 @@ export default class Mesh extends Renderable {
      * @param {number} [settings.scale] - world-space scale (pixels per source unit) for the Camera3d path; defaults to `width`. Set this when `width`/`height` describe the renderable's world bounds (frustum culling) rather than the geometry scale — see {@link Mesh#meshScale}.
      * @param {boolean} [settings.rightHanded=false] - treat the source as right-handed (Y-up, e.g. glTF) under the `Camera3d` world path. The default Y-up→Y-down bridge negates Y only (a reflection, which mirrors the scene left/right); `true` negates Y **and** Z (a rotation) so chirality is preserved and the result matches the authoring tool. See {@link Mesh#rightHanded}.
      * @param {string} [settings.textureRepeat] - texture wrap mode (`"repeat"` / `"repeat-x"` / `"repeat-y"` / `"no-repeat"`) this mesh samples its texture with (per-mesh — it does not modify the shared texture, so other meshes/sprites using the same image are unaffected). Use `"repeat"` when the geometry's UVs fall outside the `[0, 1]` range and rely on the texture tiling (e.g. glTF assets, whose default sampler wrap is REPEAT) — otherwise the texture clamps to its edge texels and looks flat. Ignored for the white-pixel fallback. Note: REPEAT on a non-power-of-two texture requires WebGL 2.
-     * @param {string} [settings.textureFilter] - texture magnification filter (`"nearest"` for crisp pixel-art upscaling, `"linear"` for smooth) applied to the resolved texture. Omit to keep the renderer's global `antiAlias` default. WebGL only (ignored by the Canvas renderer).
-     * @param {number} [settings.alphaCutoff=0] - alpha cutout threshold. Fragments whose final alpha is below this value are discarded (hard-edged cutout — foliage, fences, decals — with no blending or sorting). `0` disables the cutout. Set automatically by the glTF loader from a material's `alphaMode: "MASK"`. WebGL mesh path only.
-     * @param {number[]|Float32Array} [settings.emissive] - emissive (self-illumination) color `[r, g, b]` (0..1, may exceed 1 for HDR glow) added on top of the lit/unlit color so the surface glows regardless of scene lights (neon, lava, screens). Omit / all-zero for no emission. Set automatically by the glTF loader (`emissiveFactor`) and OBJ loader (MTL `Ke`). WebGL mesh path only.
+     * @param {string} [settings.textureFilter] - texture magnification filter (`"nearest"` for crisp pixel-art upscaling, `"linear"` for smooth) applied to the resolved texture. Omit to keep the renderer's global `antiAlias` default. On the mesh path, linear filtering also samples a generated mip chain with trilinear minification and 4× anisotropy (distant geometry stops shimmering) — `"nearest"` opts out, keeping crisp pixel-art models on hard level-0 sampling. GPU backends only (ignored by the Canvas renderer).
+     * @param {number} [settings.alphaCutoff=0] - alpha cutout threshold. Fragments whose final alpha is below this value are discarded (hard-edged cutout — foliage, fences, decals — with no blending or sorting). `0` disables the cutout. Set automatically by the glTF loader from a material's `alphaMode: "MASK"`. GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
+     * @param {number[]|Float32Array} [settings.emissive] - emissive (self-illumination) color `[r, g, b]` (0..1, may exceed 1 for HDR glow) added on top of the lit/unlit color so the surface glows regardless of scene lights (neon, lava, screens). Omit / all-zero for no emission. Set automatically by the glTF loader (`emissiveFactor`) and OBJ loader (MTL `Ke`). GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
      * @example
      * // create from OBJ + MTL (texture auto-resolved from material)
      * let mesh = new me.Mesh(0, 0, {
@@ -122,7 +136,18 @@ export default class Mesh extends Renderable {
     vertexCount: number;
     _indicesOriginal: number[];
     /**
-     * the projected vertex positions, updated each draw call
+     * the projected vertex positions.
+     *
+     * **Not refreshed on the retained `Camera3d` path.** There, geometry is
+     * uploaded once in model space and placed by the GPU, so nothing
+     * projects vertices per frame and this array holds whatever it last
+     * did. It is still maintained by the Canvas renderer and by the 2D
+     * camera path. Engine consumers that need current world positions —
+     * {@link Mesh#getBounds3d}, {@link Mesh#toPolygon} — derive them on
+     * demand instead of reading this; user code should do the same.
+     *
+     * To edit geometry, write to {@link Mesh#originalVertices} and set
+     * {@link Mesh#needsUpdate}.
      * @type {Float32Array}
      */
     vertices: Float32Array;
@@ -139,7 +164,7 @@ export default class Mesh extends Renderable {
      * from the scene's lights, using {@link Mesh#originalNormals}); when
      * `false` (the default) it uses the lean unlit path and pays no lighting
      * cost. The glTF loader sets this on scene meshes when the scene has
-     * lights. Only meaningful under a `Camera3d` + WebGL.
+     * lights. Only meaningful under a `Camera3d` on a GPU backend.
      * @type {boolean}
      * @default false
      */
@@ -150,7 +175,7 @@ export default class Mesh extends Renderable {
      * decals) that needs no blending or back-to-front sorting. `0` (the
      * default) disables the cutout and the mesh renders fully opaque. Set by
      * the glTF loader from a material's `alphaMode: "MASK"` / `alphaCutoff`.
-     * WebGL mesh path only (the Canvas renderer ignores it).
+     * GPU mesh path only (the Canvas renderer ignores it).
      * @type {number}
      * @default 0
      */
@@ -162,10 +187,107 @@ export default class Mesh extends Renderable {
      * screens, glowing eyes). `undefined` (the default) means no emission and
      * keeps the mesh on the lean path. Set by the glTF loader from a material's
      * `emissiveFactor` (× `KHR_materials_emissive_strength`) and by the OBJ
-     * loader from an MTL's `Ke`. WebGL mesh path only.
+     * loader from an MTL's `Ke`. GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
      * @type {Float32Array|undefined}
      */
     emissive: Float32Array | undefined;
+    /**
+     * Specular (highlight) color as an `[r, g, b]` `Float32Array`, or
+     * `undefined` for a purely diffuse surface — which is the default, and
+     * what every mesh rendered as before this existed.
+     *
+     * Drives a Blinn-Phong highlight on the **lit** mesh path, so it needs
+     * `lit: true`, a `Light3d`, and normals. Set by the OBJ loader from an
+     * MTL's `Ks`; paired with {@link Mesh#shininess}, which decides how
+     * tight the highlight is. A `Ks` with no `Ns` produces nothing — the
+     * exponent is what turns the term on.
+     * @type {Float32Array|undefined}
+     * @see Mesh#shininess
+     */
+    specular: Float32Array | undefined;
+    /**
+     * Specular exponent — how tight the highlight is. The MTL `Ns` range
+     * is 0..1000; higher is a smaller, harder highlight (polished metal),
+     * lower is a broad sheen (satin). `0` (the default) disables the
+     * specular term outright however bright {@link Mesh#specular} is, which
+     * is what keeps a material declaring neither on the diffuse-only path.
+     * @type {number}
+     * @default 0
+     */
+    shininess: number;
+    /**
+     * Per-texel opacity map (MTL `map_d`), or `undefined`. Its red channel
+     * multiplies the fragment's alpha before {@link Mesh#alphaCutoff} is
+     * applied, so a single material can cut out per pixel — the shape of
+     * a leaf, the holes in a chain-link fence — where `alphaCutoff` alone
+     * can only threshold uniformly across the whole material.
+     *
+     * Only meaningful alongside a non-zero `alphaCutoff`: without one there
+     * is nothing to discard against. GPU mesh path only.
+     * @type {TextureAtlas|undefined}
+     */
+    alphaMap: TextureAtlas | undefined;
+    /**
+     * Cast a soft dark ellipse — a "blob" shadow — on the ground beneath
+     * this mesh (#1515).
+     *
+     * Not a simulated shadow, deliberately: what a 2.5D scene needs from
+     * one is *contact* — where the object is standing, and how far off the
+     * ground it is mid-jump. It costs one extra draw per shadowed object,
+     * shares one geometry and one texture with every other shadow in the
+     * scene, and is inert while `false`.
+     *
+     * Requires a GPU backend and a {@link Camera3d}: the shadow rides the
+     * retained world-space path, so the Canvas renderer and the 2D-camera
+     * path draw none.
+     *
+     * Left **unset** (`undefined`, the default) this follows the
+     * application's `castGroundShadow` setting — with one safeguard: a
+     * scene-wide opt-in skips meshes with no vertical extent, because a
+     * flat plane lying on the floor is the floor, and shadowing it with
+     * itself smears the whole ground. Setting the property here is an
+     * explicit instruction and always obeyed, safeguard included.
+     * @type {boolean|undefined}
+     * @default undefined
+     * @see Mesh#shadowGroundY
+     */
+    castGroundShadow: boolean | undefined;
+    /**
+     * World Y of the floor the shadow lands on, or `undefined` (the
+     * default) to mean "this object is standing on the ground" — the
+     * shadow sits at the object's own base, at full strength, and does not
+     * shrink or fade.
+     *
+     * Set it, and the shadow shrinks and fades as the object rises above
+     * it: the readable part of a jump. The game already knows this value
+     * from collision, which is why it is not derived — deriving it from the
+     * object's live bounds would make the "ground" jump with the jumper,
+     * so the height could never be anything but zero.
+     *
+     * Render space is Y-DOWN, so the floor is a **greater** Y than the
+     * object above it.
+     * @type {number|undefined}
+     * @default undefined
+     */
+    shadowGroundY: number | undefined;
+    /**
+     * Opacity of the shadow directly beneath the object, before any
+     * height fade.
+     * @type {number}
+     * @default 0.45
+     */
+    shadowOpacity: number;
+    /**
+     * Cached horizontal half-extent used to size the shadow, resolved on
+     * first shadowed draw. Cached because the alternative is a
+     * `getBounds3d()` per frame per shadow, which re-bounds every source
+     * vertex through the model matrix.
+     * @ignore
+     */
+    _shadowHalfX: number;
+    _shadowHalfZ: number;
+    _shadowGeomVersion: number;
+    _shadowHasHeight: boolean;
     /**
      * whether to cull back-facing triangles
      * @type {boolean}
@@ -211,7 +333,8 @@ export default class Mesh extends Renderable {
      * runtime color multiplication, or rebuild the Mesh with
      * new material settings.
      * @type {Array<{materialName: string|null, start: number,
-     *   count: number, tint: Color, opacity: number}>}
+     *   count: number, tint: Color, opacity: number,
+     *   texture: TextureAtlas|undefined}>}
      */
     groups: Array<{
         materialName: string | null;
@@ -219,6 +342,7 @@ export default class Mesh extends Renderable {
         count: number;
         tint: Color;
         opacity: number;
+        texture: TextureAtlas | undefined;
     }>;
     /**
      * Per-vertex color buffer (one packed Uint32 per vertex)
@@ -241,6 +365,28 @@ export default class Mesh extends Renderable {
      */
     vertexColors: Uint32Array;
     texture: any;
+    /**
+     * Index ranges that each need their own diffuse texture bound, for a
+     * multi-material model whose materials carry different `map_Kd` maps
+     * (#1573) — `undefined` whenever one binding covers the whole mesh,
+     * which is every single-material model and every `Kd`-only one.
+     *
+     * The GPU backends draw one indexed range per entry instead of one
+     * range for the whole mesh; adjacent materials sharing a texture are
+     * already merged here, so the list is the minimum number of draws the
+     * model needs. An explicit `settings.texture` suppresses the split
+     * entirely — asking for one texture is asking for one texture.
+     *
+     * The Canvas renderer ignores this: a multi-material mesh takes its
+     * per-triangle solid-fill path there and never samples a texture at
+     * all.
+     * @type {Array<{texture: TextureAtlas, start: number, count: number}>|undefined}
+     */
+    textureGroups: Array<{
+        texture: TextureAtlas;
+        start: number;
+        count: number;
+    }> | undefined;
     /**
      * Per-mesh texture wrap mode (`"repeat"` / `"repeat-x"` / `"repeat-y"`
      * / `"no-repeat"`), or `undefined` to sample with the texture's own
@@ -274,6 +420,8 @@ export default class Mesh extends Renderable {
     _hullPoints: Vector2d[];
     /** @ignore */
     _hullPolygon: Polygon | null;
+    /** @ignore */
+    _geometryVersion: number;
     /**
      * Project all vertices through projectionMatrix × currentTransform
      * and store the results in `this.vertices`.
@@ -283,6 +431,40 @@ export default class Mesh extends Renderable {
      * @ignore
      */
     _projectVertices(offsetX?: number, offsetY?: number, zScale?: number): void;
+    /**
+     * Signal that this mesh's geometry itself has changed — its vertices, UVs,
+     * indices, normals or per-vertex colours were edited in place.
+     *
+     * Placement is *not* geometry: moving, rotating, scaling or re-tinting a
+     * mesh needs no signal, because those are applied when drawing rather than
+     * stored in the geometry. Only reach for this after writing into
+     * {@link Mesh#originalVertices} and friends directly.
+     * @type {boolean}
+     * @example
+     * // deform the mesh, then tell it the shape moved
+     * mesh.originalVertices[1] += 10;
+     * mesh.needsUpdate = true;
+     */
+    set needsUpdate(value: any);
+    /**
+     * Compose this mesh's placement into a single matrix: where its model-space
+     * geometry sits in the world.
+     *
+     * This is the matrix form of {@link Mesh#_projectVerticesWorld} — the same
+     * transform, scale and axis bridge, expressed once instead of applied to
+     * every vertex:
+     *
+     *   `translate(pos, depth) · scale(s, -s, ±s) · currentTransform`
+     *
+     * The Y negation bridges Y-up geometry to the engine's Y-down world; Z is
+     * negated too for right-handed (glTF) sources, which makes the bridge a
+     * rotation rather than a reflection and so preserves triangle winding.
+     * @returns {Matrix3d} the mesh's model matrix (reused instance)
+     * @ignore
+     */
+    _composeModelMatrix(): Matrix3d;
+    /** @ignore */
+    _modelMatrix: Matrix3d | undefined;
     /**
      * Project vertices into **world space** for the Camera3d render path.
      * Bypasses {@link Mesh#projectionMatrix} (the self-contained
@@ -332,23 +514,22 @@ export default class Mesh extends Renderable {
      * (e.g. a level transition into a 2D minigame) gets its original
      * winding back and stays correctly oriented under
      * `cullBackFaces: true`.
+     * @param {boolean} [needsReversedIndices=true] - build the winding-reversed index copy. `false` on the retained path, which corrects winding with `frontFace` and would otherwise duplicate the index array for nothing.
      * @ignore
      */
-    _setupWorldSpace(): void;
+    _setupWorldSpace(needsReversedIndices?: boolean): void;
     _indicesReversed: any;
     _worldSpace: boolean | undefined;
     _useWorldSpace: boolean | undefined;
     /**
-     * The mesh's world-space 3D axis-aligned bounding box, as projected by the
-     * most recent draw. This is the 3D analog of {@link Renderable#getBounds}
-     * (which returns a flat 2D box from `width`/`height` and so cannot describe
-     * a mesh's real extent).
+     * The mesh's world-space 3D axis-aligned bounding box. This is the 3D analog
+     * of {@link Renderable#getBounds} (which returns a flat 2D box from
+     * `width`/`height` and so cannot describe a mesh's real extent).
      *
-     * Under a `Camera3d` the mesh projects its vertices into world space every
-     * frame (see {@link Mesh#_projectVerticesWorld}), so the returned box tracks
-     * the live transform / animation. Under the 2D path the projected vertices
-     * are screen-space, so the box is only meaningful after a Camera3d draw —
-     * use {@link Renderable#getBounds} for the 2D case.
+     * Computed on demand by bounding the model-space geometry through the
+     * mesh's current placement, so it reflects the live transform and is valid
+     * before the mesh has ever been drawn. Meaningful for the `Camera3d` path;
+     * for the 2D path use {@link Renderable#getBounds}.
      *
      * The same {@link AABB3d} instance is returned each call (recomputed in
      * place), so copy it (`.clone()`) if you need to keep it.
@@ -357,6 +538,37 @@ export default class Mesh extends Renderable {
     getBounds3d(): AABB3d;
     /** @ignore */
     _bounds3d: AABB3d | undefined;
+    /**
+     * Whether this mesh casts a ground shadow on this draw (#1515).
+     *
+     * Precedence, most specific first: the mesh's own `castGroundShadow`, then
+     * the application's `castGroundShadow` setting. A per-mesh value is an
+     * explicit instruction and is obeyed as given; the application default is a
+     * blanket one, so it skips meshes with no vertical extent — which is what a
+     * ground plane is, and a flat plane lying on the floor has nothing to cast.
+     * Read off the renderer rather than the global application instance, the
+     * same way the `textureFilter` default is.
+     * @param {WebGLRenderer|WebGPURenderer} renderer - the active renderer
+     * @returns {boolean} true if a shadow should be drawn
+     * @ignore
+     */
+    _castsGroundShadow(renderer: WebGLRenderer | WebGPURenderer): boolean;
+    /**
+     * Measure the model-space footprint the blob is built from, and whether the
+     * geometry has any height at all — once per geometry version.
+     * @ignore
+     */
+    _measureShadowFootprint(): void;
+    /**
+     * Draw this mesh's ground shadow: the shared blob quad, flattened onto the
+     * ground plane beneath the object (#1515).
+     *
+     * The quad is shared by every shadow in the scene and its geometry is
+     * uploaded once, so this is one draw and no allocation.
+     * @param {WebGLRenderer} renderer - the active renderer
+     * @ignore
+     */
+    _drawGroundShadow(renderer: WebGLRenderer): void;
     /**
      * Render the mesh at its current state (transforms, projection, tint) to an offscreen canvas.
      * The returned canvas can be used with `renderer.drawImage()`, as a `Sprite` image source,
@@ -380,12 +592,19 @@ export default class Mesh extends Renderable {
      * const sprite = new me.Sprite(100, 100, { image: bitmap });
      */
     toImageBitmap(): Promise<ImageBitmap>;
+    /**
+     * Release this mesh's GPU-resident geometry, if a renderer is holding any,
+     * then destroy the renderable.
+     * @ignore
+     */
+    destroy(): void;
 }
 import Renderable from "./renderable.js";
+import { TextureAtlas } from "./../video/texture/atlas.js";
 import { Color } from "../math/color.ts";
 import { Matrix3d } from "../math/matrix3d.ts";
 import { Vector2d } from "../math/vector2d.ts";
 import { Polygon } from "../geometries/polygon.ts";
 import { AABB3d } from "../physics/broadphase/aabb3d.ts";
-import { TextureAtlas } from "./../video/texture/atlas.js";
+import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
 //# sourceMappingURL=mesh.d.ts.map

package/build/renderable/mesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/mesh.js"],"names":[],"mappings":"AAmHA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgEG;IACH,eAhEW,MAAM,KACN,MAAM,YAEd;QAA0B,KAAK;QACU,QAAQ;QACR,GAAG;QACJ,OAAO;QACS,OAAO;QACrC,QAAQ;QACT,KAAK,EAAtB,MAAM;QACY,MAAM;QACL,aAAa;QACb,SAAS;QACV,KAAK;QACJ,WAAW;QACZ,aAAa;QACb,aAAa;QACb,WAAW;QACI,QAAQ;KACjD,EAwbF;IAjYC;;;OAGG;IACH,kBAFU,YAAY,CAEkB;IAExC;;;OAGG;IACH,KAFU,YAAY,CAEA;IAQtB;;;OAGG;IACH,aAFU,MAAM,CAEsB;IAmCvC,2BAAoC;IAGpC;;;OAGG;IACH,UAFU,YAAY,CAEgC;IAEtD;;;;;OAKG;IACH,iBAFU,YAAY,GAAC,SAAS,CAOnB;IAUb;;;;;;;;;OASG;IACH,KAHU,OAAO,CAGe;IAEhC;;;;;;;;;OASG;IACH,aAHU,MAAM,CAIoD;IAEpE;;;;;;;;;OASG;IACH,UAFU,YAAY,GAAC,SAAS,CAEa;IAE7C;;;;OAIG;IACH,eAHU,OAAO,CAIoD;IAErE;;;;;;;;;;OAUG;IACH,aAHU,OAAO,CAG+B;IAEhD;;;;;;;;;OASG;IACH,WAHU,MAAM,CAIiD;IAsBhE;;;;;;;;;;;;;;;;;OAiBG;IACH,QAHU,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QACrD,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAIhD;IAsBF;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAFU,WAAW,CAEgC;IAuDtD,aAIC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,eAFU,MAAM,GAAC,SAAS,CAKb;IAsBb;;;;;;OAMG;IACH,kBAFU,QAAQ,CAEoB;IAqBtC,cAAc;IACd,sBAAyB;IAOzB,cAAc;IACd,wBAEE;IACF,cAAc;IACd,6BAAwB;IAGzB;;;;;;;OAOG;IACH,2BALW,MAAM,YACN,MAAM,WACN,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,+BALW,MAAM,WACN,MAAM,WACN,MAAM,QAqChB;IAED;;;;;;;;;;;;OAYG;IACH,6BA8BC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,yBAqBC;IAHC,sBAA2B;IAE5B,iCAAuB;IAoBvB,oCAAuD;IAGxD;;;;;;;;;;;;;;;OAeG;IACH,eAFa,MAAM,CAWlB;IAPC,cAAc;IACd,8BAA6B;IAkI/B;;;;;;;;;;;;OAYG;IACH,YATa,iBAAiB,CAoH7B;IAED;;;;;;;OAOG;IACH,iBALa,OAAO,CAAC,WAAW,CAAC,CAOhC;CACD;uBA3hCsB,iBAAiB;sBAZlB,kBAAkB;yBACf,qBAAqB;yBACrB,qBAAqB;wBAJtB,0BAA0B;uBAU3B,iCAAiC;6BAE3B,6BAA6B"}
+{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/mesh.js"],"names":[],"mappings":"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"}

package/build/renderable/renderable.d.ts

@@ -238,10 +238,12 @@ export default class Renderable extends Rect {
      */
     mask: Rect | RoundRect | Polygon | Line | Ellipse;
     /**
-     * the list of post-processing shader effects applied to this renderable (WebGL only).
-     * Effects are applied in order. Use {@link addPostEffect}, {@link getPostEffect},
-     * and {@link removePostEffect} to manage effects, or assign directly.
-     * In Canvas mode, this property is ignored.
+     * the list of post-processing shader effects applied to this renderable
+     * (GPU backends — WebGL and WebGPU). Effects are applied in order. Use
+     * {@link addPostEffect}, {@link getPostEffect}, and
+     * {@link removePostEffect} to manage effects, or assign directly.
+     * On the Canvas renderer effects stay inert (the scene keeps rendering
+     * un-effected).
      * @type {Array<GLShader|ShaderEffect>}
      * @default []
      * @example

package/build/renderable/renderable.d.ts.map

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

package/build/renderable/sprite3d.d.ts

@@ -319,12 +319,6 @@ export default class Sprite3d extends Mesh {
      * @ignore
      */
     _applyFrame(region: object): void;
-    /**
-     * Release resources (returns the engine's pooled `current.offset` to the
-     * pool), then defer to the standard mesh/renderable teardown.
-     * @ignore
-     */
-    destroy(): void;
     /**
      * Capture the rendering camera so {@link Sprite3d#_projectVerticesWorld} can
      * orient the billboard toward it. Read from the per-draw `viewport` (passed
@@ -342,6 +336,23 @@ export default class Sprite3d extends Mesh {
      * @ignore
      */
     _projectVerticesWorld(offsetX: any, offsetY: any, offsetZ: any): void;
+    /**
+     * Resolve the camera-facing basis this billboard should use, leaving it in
+     * the shared `_right` / `_up` scratch vectors.
+     *
+     * Shared by the CPU projection and the model-matrix composition so the two
+     * can never disagree about which way the card faces.
+     * @returns {boolean} `false` when this sprite is not billboarding
+     * @ignore
+     */
+    _billboardBasis(): boolean;
+    /**
+     * Emit the 4 corners as center ± right·localX ± up·localY (the local
+     * offsets are the baked ±hw / ±hh quad coordinates, already shifted by the
+     * anchor offset). Only used on renderers without retained geometry.
+     * @ignore
+     */
+    _projectBillboardCorners(offsetX: any, offsetY: any, offsetZ: any): void;
 }
 import Mesh from "./mesh.js";
 import FrameAnimation from "./frameAnimation.js";

package/build/renderable/sprite3d.d.ts.map

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

package/build/renderable/text/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,eAzCW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACW,SAAS;QACT,WAAW;QACjB,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACmB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACjB,aAAa;QACF,IAAI;KACzC,EAmGF;IApEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;OAGG;IACH,cAAe;IAMhB,cAAc;IACd,kDA8EC;IAdA,8CAEE;IAEF;;OAEG;IACH,wBAA4B;IAG5B,iCAAoC;IAMrC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAwChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CA4DhB;IAkBD,oCAZU,MAAM,EAiBf;IArBD;;;;;;;;;;;OAWG;IACH,gCARU,MAAM,CAUf;IAyBD,+BAZU,MAAM,EAsBf;IA1BD;;;;;OAKG;IACH,2BAFU,MAAM,CAUf;IAiED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QA2BtC;IAED;;OAEG;IACH,4EA6BC;IAED;;;OAGG;IACH,gBAUC;CACD;uBAnkBsB,kBAAkB;sBAJR,qBAAqB;+BAEvB,gDAAgD;wBAGvD,kBAAkB"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,eAzCW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACW,SAAS;QACT,WAAW;QACjB,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACmB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACjB,aAAa;QACF,IAAI;KACzC,EAmGF;IApEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;OAGG;IACH,cAAe;IAMhB,cAAc;IACd,kDA8EC;IAdA,8CAEE;IAEF;;OAEG;IACH,wBAA4B;IAG5B,iCAAoC;IAMrC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAwChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CAkEhB;IAkBD,oCAZU,MAAM,EAiBf;IArBD;;;;;;;;;;;OAWG;IACH,gCARU,MAAM,CAUf;IAyBD,+BAZU,MAAM,EAsBf;IA1BD;;;;;OAKG;IACH,2BAFU,MAAM,CAUf;IAiED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QA2BtC;IAED;;OAEG;IACH,4EA6BC;IAED;;;OAGG;IACH,gBAUC;CACD;uBAzkBsB,kBAAkB;sBAJR,qBAAqB;+BAEvB,gDAAgD;wBAGvD,kBAAkB"}

package/build/system/device.d.ts

@@ -153,43 +153,9 @@ export declare function setAutoFocus(enable: boolean): void;
  * specify a function to execute when the Device is fully loaded and ready
  * @param fn - the function to be executed
  * @example
- * // small game skeleton
- * let game = {
- *    // called by the me.device.onReady function
- *    onload = function () {
- *       // init video
- *       if (!me.video.init('screen', 640, 480, true)) {
- *          alert("Sorry but your browser does not support html 5 canvas.");
- *          return;
- *       }
- *
- *       // initialize the "audio"
- *       me.audio.init("mp3,ogg");
- *
- *       // set callback for resources loaded event
- *       me.loader.onload = this.loaded.bind(this);
- *
- *       // set all resources to be loaded
- *       me.loader.preload(game.assets);
- *
- *       // load everything & display a loading screen
- *       me.state.change(me.state.LOADING);
- *    };
- *
- *    // callback when everything is loaded
- *    loaded = function () {
- *       // define stuff
- *       // ....
- *
- *       // change to the menu screen
- *       me.state.change(me.state.PLAY);
- *    }
- * }; // game
- *
- * // "bootstrap"
- * me.device.onReady(function () {
- *    game.onload();
- * });
+ * // the modern equivalent is simply to await the Application
+ * const app = new Application(640, 480, { parent: "screen" });
+ * await app.init();
  * @deprecated since 18.3.0 — no longer needed when using {@link Application} as entry point.
  * @category Application
  */
@@ -284,10 +250,15 @@ export declare function getElementBounds(element: string | HTMLElement): DOMRect
  */
 export declare function getParentBounds(element: string | HTMLElement): DOMRect;
 /**
- * returns true if the device supports WebGL
+ * Returns true if the device supports WebGL 2 — the version the WebGL
+ * renderer requires since 20.0. This probes the same context type that
+ * renderer construction requests, so the two can never disagree.
+ *
+ * When it returns false, `renderer: video.AUTO` falls back to the Canvas
+ * renderer and `renderer: video.WEBGL` throws at construction time.
  * @param [options] - context creation options
- * @param [options.failIfMajorPerformanceCaveat=true] - If true, the renderer will switch to CANVAS mode if the performances of a WebGL context would be dramatically lower than that of a native application making equivalent OpenGL calls.
- * @returns true if WebGL is supported
+ * @param [options.failIfMajorPerformanceCaveat=true] - if true, report WebGL as unsupported when the browser warns that a context would perform dramatically worse than a native application (e.g. a software rasterizer). Set false to accept WebGL on blocklisted drivers or software renderers.
+ * @returns true if WebGL 2 is supported
  * @category Application
  */
 export declare function isWebGLSupported(options?: {

package/build/system/device.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../src/system/device.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,eAAe,MAAM,eAAe,CAAC;AA+FjD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,sBAAsB,QAIvD;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,wBAAkB,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,UAAU,SAA+B,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,YAAY,OAA4B,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,KAAK,SACsD,CAAC;AAEzE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,QAIvB,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,KAAK,SAEoC,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,qBAAqB,SAE4B,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,oBAAoB,OAAsC,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,SAC6C,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,gBAAgB,OAAiC,CAAC;AAO/D,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,WAAW,OAIvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,SAA0C,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,KAAK,OAA+B,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,QAAQ,SAEoC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,YAAY,SAAoB,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,eAAe,SAAuB,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,YAAY,SAAwC,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,QAAQ,QAMb,CAAC;AAET;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAmC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,QAAQ,SAAoB,CAAC;AAE1C;;;GAGG;AACH,eAAO,IAAI,aAAa,QAAI,CAAC;AAE7B;;;GAGG;AACH,eAAO,IAAI,aAAa,QAAI,CAAC;AAE7B;;;GAGG;AACH,eAAO,IAAI,aAAa,QAAI,CAAC;AAE7B;;;GAGG;AACH,eAAO,IAAI,KAAK,QAAI,CAAC;AAErB;;;GAGG;AACH,eAAO,IAAI,IAAI,QAAI,CAAC;AAEpB;;;;GAIG;AACH,eAAO,IAAI,KAAK,QAAI,CAAC;AAErB;;;;;;;;;;GAUG;AAEH,eAAO,IAAI,SAAS,SAAO,CAAC;AAE5B;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAElD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,QAErC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,SAoCnC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE,OAAO,QAiB3C;AAUD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1E;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAoC7C;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,WAY7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,YAYhC;AAED;;;GAGG;AACH,wBAAgB,UAAU,YAEzB;AAED;;;GAGG;AACH,wBAAgB,WAAW,YAE1B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,GAAE,MAAgB,2BAQhD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAO5C,WAAW,CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,WAAW,CAqBrE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAYvE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,WAE5D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE;IAC1C,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACvC,GAAG,OAAO,CAqBV;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,SAIpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,YAoBjC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,SAMnC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,YAsBrC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,SAKvC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,QAOjD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GACrE,OAAO,CAkCT"}
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../src/system/device.ts"],"names":[],"mappings":"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"}

package/build/system/platform.d.ts

@@ -18,22 +18,6 @@
  * webApp `true` if running as a standalone web app
  */
 export declare const ua: string;
-/**
- * iPad-on-Mac-UA predicate. Exported so the spec file can assert the
- * SAME function the module evaluates at load time (no drift between
- * docs and implementation), but marked `@internal` because it's a
- * test-seam, not a stable public API — the engine reserves the right
- * to change / inline / rename it without a breaking-change bump.
- *
- * Parameter shape is `Partial<Pick<Navigator, ...>>` rather than a
- * named alias so no engine-defined type leaks into the emitted
- * `.d.ts` (`tsconfig.build.json` doesn't currently set
- * `stripInternal`).
- * @param nav - a `navigator`-shaped object (or `undefined` for Node/SSR)
- * @returns `true` when `nav` looks like an iPad reporting under the iPadOS-13+ desktop Mac UA
- * @internal
- */
-export declare function isIPadOnMacUA(nav: Partial<Pick<Navigator, "platform" | "maxTouchPoints">> | undefined): boolean;
 export declare const iOS: boolean;
 export declare const android: boolean;
 /**

package/build/system/platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/system/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,EAAE,QAGT,CAAC;AAaP;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC5B,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,gBAAgB,CAAC,CAAC,GAAG,SAAS,GACtE,OAAO,CAET;AAOD,eAAO,MAAM,GAAG,SAAsD,CAAC;AACvE,eAAO,MAAM,OAAO,SAAsB,CAAC;AAC3C;;GAEG;AACH,eAAO,MAAM,QAAQ,SAAwB,CAAC;AAC9C,eAAO,MAAM,KAAK,SAAoB,CAAC;AACvC,eAAO,MAAM,QAAQ,SAAkB,CAAC;AACxC;;GAEG;AACH,eAAO,MAAM,EAAE,SAA4B,CAAC;AAC5C;;GAEG;AACH,eAAO,MAAM,UAAU,SAAyB,CAAC;AACjD;;GAEG;AACH,eAAO,MAAM,MAAM,SAAyC,CAAC;AAC7D,eAAO,MAAM,MAAM,SAAyB,CAAC;AAC7C,eAAO,MAAM,QAAQ,SAA6B,CAAC;AAOnD,eAAO,MAAM,MAAM,SAGW,CAAC;AAO/B,eAAO,MAAM,QAAQ,SAAqC,CAAC;AAC3D,eAAO,MAAM,MAAM,SAK2C,CAAC"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/system/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,EAAE,QAGT,CAAC;AAuCP,eAAO,MAAM,GAAG,SAAsD,CAAC;AACvE,eAAO,MAAM,OAAO,SAAsB,CAAC;AAC3C;;GAEG;AACH,eAAO,MAAM,QAAQ,SAAwB,CAAC;AAC9C,eAAO,MAAM,KAAK,SAAoB,CAAC;AACvC,eAAO,MAAM,QAAQ,SAAkB,CAAC;AACxC;;GAEG;AACH,eAAO,MAAM,EAAE,SAA4B,CAAC;AAC5C;;GAEG;AACH,eAAO,MAAM,UAAU,SAAyB,CAAC;AACjD;;GAEG;AACH,eAAO,MAAM,MAAM,SAAyC,CAAC;AAC7D,eAAO,MAAM,MAAM,SAAyB,CAAC;AAC7C,eAAO,MAAM,QAAQ,SAA6B,CAAC;AAOnD,eAAO,MAAM,MAAM,SAGW,CAAC;AAO/B,eAAO,MAAM,QAAQ,SAAqC,CAAC;AAC3D,eAAO,MAAM,MAAM,SAK2C,CAAC"}

package/build/utils/utils.d.ts

@@ -24,6 +24,8 @@ export declare function checkVersion(v1: string, v2: string): 0 | 1 | -1;
  * [velocity=false] draw the entities velocity in the debug panel (if enabled)
  * [quadtree=false] draw the quadtree in the debug panel (if enabled)
  * [webgl=false] force the renderer to WebGL
+ * [canvas=false] force the renderer to Canvas
+ * [webgpu=false] force the renderer to WebGPU (opt-in only; never selected by `video.AUTO`)
  * [debug=false] display the debug panel (if preloaded)
  * [debugToggleKey="s"] show/hide the debug panel (if preloaded)
  * @example

package/build/utils/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAWtC;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,cAalD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,GAAG,CAAC,EAAE,MAAM,oCA0C1C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAI,QAIhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAI,UAInC;AAED,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,EAO7D,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAWtC;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,cAalD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,GAAG,CAAC,EAAE,MAAM,oCA2C1C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAI,QAIhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAI,UAInC;AAED,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,EAO7D,CAAC"}