@codexo/exojs 0.6.2 → 0.6.3

package/README.md

@@ -1,156 +1,156 @@
-# ExoJS
-
-ExoJS is a TypeScript-first 2D runtime for browser games and interactive apps. It is designed around explicit scene flow, practical rendering features, and predictable runtime behavior.
-
-## Project status
-
-ExoJS is **pre-1.0**. The public API is still under active design — scene graph, rendering pipeline, and resource lifecycle boundaries may change between minor versions. Pin exact versions in downstream experiments. `1.0.0` will mark the first stable API contract.
-
-## Why ExoJS
-
-- TypeScript-first API surface with strong runtime contracts
-- Scene and asset workflows built for real game loops
-- Modern rendering stack: WebGPU-first with WebGL2 fallback
-- Practical visuals: filters, masks, render passes, cache-as-bitmap
-- Gameplay tools: animated sprites, scene stacking, camera helpers, audio sprites
-- Performance visibility with built-in render stats and benchmark harness
-- Optional Rapier physics integration without forcing physics on every app
-
-## What Is Shipped Today
-
-- `Application`, `Scene`, and scene-manager lifecycle
-- Typed `Loader` with manifest/bundle workflow (`defineAssetManifest`, `registerManifest`, `loadBundle`)
-- Drawables: `Sprite`, `AnimatedSprite`, `Graphics`, `ParticleSystem`, `Text`, `Video`
-- Scene stacking (`overlay` / `modal` / `opaque`) with input routing and fade transitions
-- View/camera helpers (`follow`, bounds clamp, shake, zoom)
-- Rendering composition primitives (`RenderTexture`, `RenderTargetPass`, filter chains, visual masks, cache-as-bitmap)
-- Render stats (`submittedNodes`, `culledNodes`, `drawCalls`, `batches`, `renderPasses`, ...)
-- Optional Rapier adapter (`createRapierPhysicsWorld`)
-
-## Installation
-
-```bash
-npm install @codexo/exojs
-```
-
-ExoJS currently publishes an ESM-first package shape. Use `import` syntax with modern bundlers/runtime tooling.
-CommonJS `require()` usage is not part of the supported contract for this pre-1.0 line.
-
-## Quickstart
-
-```ts
-import { Application, Scene, Graphics, Color, type RenderBackend } from '@codexo/exojs';
-
-class HelloScene extends Scene {
-    private readonly box = new Graphics();
-
-    public constructor() {
-        super();
-
-        this.box.fillColor = Color.white;
-        this.box.drawRectangle(-32, -32, 64, 64);
-        this.box.setPosition(400, 300);
-
-        this.addChild(this.box);
-    }
-
-    public override update(delta: import('@codexo/exojs').Time): void {
-        this.box.rotation += delta.seconds * 45;
-    }
-
-    public override draw(backend: RenderBackend): void {
-        this.root.render(backend);
-    }
-}
-
-const canvas = document.querySelector('canvas');
-
-if (!canvas) {
-    throw new Error('Missing <canvas> element.');
-}
-
-const app = new Application({
-    canvas,
-    width: 800,
-    height: 600,
-    clearColor: Color.cornflowerBlue,
-});
-
-await app.start(new HelloScene());
-```
-
-## Next Steps
-
-- In-repo examples: [examples/README.md](examples/README.md)
-
-## WebGPU and WebGL2
-
-`Application` defaults to backend auto-selection:
-
-- prefers WebGPU when available
-- falls back to WebGL2 if WebGPU is unavailable or initialization fails
-
-You can force backend selection when needed:
-
-```ts
-new Application({ backend: { type: 'webgpu' } });
-new Application({ backend: { type: 'webgl2' } });
-new Application({ backend: { type: 'auto' } });
-```
-
-## Optional Rapier Physics
-
-Rapier integration is opt-in and loaded only when you use it.
-
-```ts
-import { createRapierPhysicsWorld } from '@codexo/exojs';
-
-const physics = await createRapierPhysicsWorld({ gravityY: 9.81 });
-```
-
-If Rapier is unavailable, creation fails with a clear setup error.
-
-### Physics scope policy
-
-ExoJS ships **one** physics adapter: Rapier. The integration is intentionally
-narrow:
-
-- Physics is **optional**. `@dimforge/rapier2d-compat` is a peer dependency
-  marked `optional`. Apps that do not call `createRapierPhysicsWorld` never
-  load it and never pay for it at runtime.
-- Rendering, application, and core scene code **do not** depend on physics.
-  The adapter binds Rapier bodies to scene nodes from the outside; the core
-  has no knowledge of physics.
-- ExoJS is **not** a physics-engine abstraction layer. There is no
-  `PhysicsWorld` interface that spans multiple backends, and no plan to
-  add one. If you need a different physics library, integrate it directly
-  in your app code without library involvement.
-- A second physics adapter (Box2D, Matter.js, Planck, etc.) is **not** on
-  the 1.0 roadmap and will not be accepted as a contribution. The honesty
-  rule that applies to rendering backends applies here too: one chosen
-  physics, not a fake-universal physics layer.
-
-For full integration details see [docs/physics/rapier-integration.md](docs/physics/rapier-integration.md).
-
-## Examples
-
-The runnable live site (Astro + Lit + Monaco preview) lives in [`examples/`](examples/README.md) and is deployed as the repository's GitHub Pages site at <https://exoridus.github.io/ExoJS/>.
-
-## Development
-
-```bash
-npm run typecheck
-npm run lint
-npm test
-npm run build
-npm run verify:package
-npm run perf:benchmark
-```
-
-Internal imports use the `@/*` path alias (mapped to `src/*`) — the same convention used by Vite, Next.js, and other modern TypeScript setups. Building the library requires TypeScript 6.
-
-## Links
-
-- Repository: <https://github.com/Exoridus/ExoJS>
-- Issues: <https://github.com/Exoridus/ExoJS/issues>
-- Changelog: [CHANGELOG.md](CHANGELOG.md)
+# ExoJS
+
+ExoJS is a TypeScript-first 2D runtime for browser games and interactive apps. It is designed around explicit scene flow, practical rendering features, and predictable runtime behavior.
+
+## Project status
+
+ExoJS is **pre-1.0**. The public API is still under active design — scene graph, rendering pipeline, and resource lifecycle boundaries may change between minor versions. Pin exact versions in downstream experiments. `1.0.0` will mark the first stable API contract.
+
+## Why ExoJS
+
+- TypeScript-first API surface with strong runtime contracts
+- Scene and asset workflows built for real game loops
+- Modern rendering stack: WebGPU-first with WebGL2 fallback
+- Practical visuals: filters, masks, render passes, cache-as-bitmap
+- Gameplay tools: animated sprites, scene stacking, camera helpers, audio sprites
+- Performance visibility with built-in render stats and benchmark harness
+- Optional Rapier physics integration without forcing physics on every app
+
+## What Is Shipped Today
+
+- `Application`, `Scene`, and scene-manager lifecycle
+- Typed `Loader` with manifest/bundle workflow (`defineAssetManifest`, `registerManifest`, `loadBundle`)
+- Drawables: `Sprite`, `AnimatedSprite`, `Graphics`, `ParticleSystem`, `Text`, `Video`
+- Scene stacking (`overlay` / `modal` / `opaque`) with input routing and fade transitions
+- View/camera helpers (`follow`, bounds clamp, shake, zoom)
+- Rendering composition primitives (`RenderTexture`, `RenderTargetPass`, filter chains, visual masks, cache-as-bitmap)
+- Render stats (`submittedNodes`, `culledNodes`, `drawCalls`, `batches`, `renderPasses`, ...)
+- Optional Rapier adapter (`createRapierPhysicsWorld`)
+
+## Installation
+
+```bash
+npm install @codexo/exojs
+```
+
+ExoJS currently publishes an ESM-first package shape. Use `import` syntax with modern bundlers/runtime tooling.
+CommonJS `require()` usage is not part of the supported contract for this pre-1.0 line.
+
+## Quickstart
+
+```ts
+import { Application, Scene, Graphics, Color, type RenderBackend } from '@codexo/exojs';
+
+class HelloScene extends Scene {
+    private readonly box = new Graphics();
+
+    public constructor() {
+        super();
+
+        this.box.fillColor = Color.white;
+        this.box.drawRectangle(-32, -32, 64, 64);
+        this.box.setPosition(400, 300);
+
+        this.addChild(this.box);
+    }
+
+    public override update(delta: import('@codexo/exojs').Time): void {
+        this.box.rotation += delta.seconds * 45;
+    }
+
+    public override draw(backend: RenderBackend): void {
+        this.root.render(backend);
+    }
+}
+
+const canvas = document.querySelector('canvas');
+
+if (!canvas) {
+    throw new Error('Missing <canvas> element.');
+}
+
+const app = new Application({
+    canvas,
+    width: 800,
+    height: 600,
+    clearColor: Color.cornflowerBlue,
+});
+
+await app.start(new HelloScene());
+```
+
+## Next Steps
+
+- In-repo examples: [examples/README.md](examples/README.md)
+
+## WebGPU and WebGL2
+
+`Application` defaults to backend auto-selection:
+
+- prefers WebGPU when available
+- falls back to WebGL2 if WebGPU is unavailable or initialization fails
+
+You can force backend selection when needed:
+
+```ts
+new Application({ backend: { type: 'webgpu' } });
+new Application({ backend: { type: 'webgl2' } });
+new Application({ backend: { type: 'auto' } });
+```
+
+## Optional Rapier Physics
+
+Rapier integration is opt-in and loaded only when you use it.
+
+```ts
+import { createRapierPhysicsWorld } from '@codexo/exojs';
+
+const physics = await createRapierPhysicsWorld({ gravityY: 9.81 });
+```
+
+If Rapier is unavailable, creation fails with a clear setup error.
+
+### Physics scope policy
+
+ExoJS ships **one** physics adapter: Rapier. The integration is intentionally
+narrow:
+
+- Physics is **optional**. `@dimforge/rapier2d-compat` is a peer dependency
+  marked `optional`. Apps that do not call `createRapierPhysicsWorld` never
+  load it and never pay for it at runtime.
+- Rendering, application, and core scene code **do not** depend on physics.
+  The adapter binds Rapier bodies to scene nodes from the outside; the core
+  has no knowledge of physics.
+- ExoJS is **not** a physics-engine abstraction layer. There is no
+  `PhysicsWorld` interface that spans multiple backends, and no plan to
+  add one. If you need a different physics library, integrate it directly
+  in your app code without library involvement.
+- A second physics adapter (Box2D, Matter.js, Planck, etc.) is **not** on
+  the 1.0 roadmap and will not be accepted as a contribution. The honesty
+  rule that applies to rendering backends applies here too: one chosen
+  physics, not a fake-universal physics layer.
+
+For full integration details see [docs/physics/rapier-integration.md](docs/physics/rapier-integration.md).
+
+## Examples
+
+The runnable live site (Astro + Lit + Monaco preview) lives in [`examples/`](examples/README.md) and is deployed as the repository's GitHub Pages site at <https://exoridus.github.io/ExoJS/>.
+
+## Development
+
+```bash
+npm run typecheck
+npm run lint
+npm test
+npm run build
+npm run verify:package
+npm run perf:benchmark
+```
+
+Internal imports use the `@/*` path alias (mapped to `src/*`) — the same convention used by Vite, Next.js, and other modern TypeScript setups. Building the library requires TypeScript 6.
+
+## Links
+
+- Repository: <https://github.com/Exoridus/ExoJS>
+- Issues: <https://github.com/Exoridus/ExoJS/issues>
+- Changelog: [CHANGELOG.md](CHANGELOG.md)

package/dist/esm/core/capabilities.d.ts

@@ -0,0 +1,37 @@
+interface CapabilitiesShape {
+    /** A real WebGL2 context can be created on a probe canvas. */
+    readonly webgl2: boolean;
+    /** `navigator.gpu` is present. Does NOT guarantee adapter availability. */
+    readonly webgpu: boolean;
+    /** `AudioContext` (standard or `webkit`-prefixed) is constructable. */
+    readonly audio: boolean;
+    /** `PointerEvent` is supported. */
+    readonly pointer: boolean;
+    /** Touch input is exposed via `ontouchstart` or `maxTouchPoints > 0`. */
+    readonly touch: boolean;
+    /** `navigator.getGamepads` is available. */
+    readonly gamepad: boolean;
+    /** `KeyboardEvent` is supported. */
+    readonly keyboard: boolean;
+    /** The Fullscreen API is exposed on the document element. */
+    readonly fullscreen: boolean;
+    /** `navigator.vibrate` is available. */
+    readonly vibration: boolean;
+    /** `OffscreenCanvas` constructor is on the global. */
+    readonly offscreenCanvas: boolean;
+}
+export type Capabilities = CapabilitiesShape;
+export type CapabilityName = keyof CapabilitiesShape;
+/**
+ * Synchronous, one-shot feature-detection results. Computed once at
+ * module load and frozen. Use either as a property bag (`capabilities.touch`)
+ * or via {@link isSupported} for typed lookup.
+ */
+export declare const capabilities: Capabilities;
+/**
+ * Typed lookup over {@link capabilities}. Identical to
+ * `capabilities[name]` but the function form gives clearer call-sites
+ * when the name is computed.
+ */
+export declare function isSupported(name: CapabilityName): boolean;
+export {};

package/dist/esm/core/capabilities.js

@@ -0,0 +1,96 @@
+// Browser feature-detection probes evaluated once at module load. The
+// resulting `capabilities` object is a `Readonly<Record<CapabilityName,
+// boolean>>` and can be inspected directly or queried via `isSupported`.
+//
+// All probes are synchronous. Async questions ("can I actually acquire a
+// WebGPU adapter?", "can the audio decoder play this OGG file?") are
+// outside this module's scope — they're owned by the Application's
+// backend selection and the Loader respectively. `capabilities.webgpu`
+// returning `true` only guarantees that the browser advertises WebGPU,
+// not that an adapter request will succeed.
+const hasWindow = typeof window !== 'undefined';
+const hasDocument = typeof document !== 'undefined';
+const hasNavigator = typeof navigator !== 'undefined';
+const probeWebGl2 = () => {
+    if (!hasDocument)
+        return false;
+    try {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl2');
+        return gl !== null;
+    }
+    catch {
+        return false;
+    }
+};
+const probeWebGpu = () => {
+    return hasNavigator && 'gpu' in navigator;
+};
+const probeAudio = () => {
+    if (!hasWindow)
+        return false;
+    const w = window;
+    return typeof w.AudioContext !== 'undefined' || typeof w.webkitAudioContext !== 'undefined';
+};
+const probePointer = () => {
+    return hasWindow && 'PointerEvent' in window;
+};
+const probeTouch = () => {
+    if (!hasWindow)
+        return false;
+    if ('ontouchstart' in window)
+        return true;
+    if (hasNavigator && typeof navigator.maxTouchPoints === 'number' && navigator.maxTouchPoints > 0)
+        return true;
+    return false;
+};
+const probeGamepad = () => {
+    return hasNavigator && typeof navigator.getGamepads === 'function';
+};
+const probeKeyboard = () => {
+    return hasWindow && 'KeyboardEvent' in window;
+};
+const probeFullscreen = () => {
+    if (!hasDocument)
+        return false;
+    const el = document.documentElement;
+    return typeof el.requestFullscreen === 'function' || typeof el.webkitRequestFullscreen === 'function';
+};
+const probeVibration = () => {
+    return hasNavigator && typeof navigator.vibrate === 'function';
+};
+const probeOffscreenCanvas = () => {
+    // The browser global is verbatim `OffscreenCanvas`; eslint's
+    // strict-camelCase rule rejects the property name even though we
+    // can't rename a web standard.
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    return hasWindow && typeof window.OffscreenCanvas !== 'undefined';
+};
+/**
+ * Synchronous, one-shot feature-detection results. Computed once at
+ * module load and frozen. Use either as a property bag (`capabilities.touch`)
+ * or via {@link isSupported} for typed lookup.
+ */
+const capabilities = Object.freeze({
+    webgl2: probeWebGl2(),
+    webgpu: probeWebGpu(),
+    audio: probeAudio(),
+    pointer: probePointer(),
+    touch: probeTouch(),
+    gamepad: probeGamepad(),
+    keyboard: probeKeyboard(),
+    fullscreen: probeFullscreen(),
+    vibration: probeVibration(),
+    offscreenCanvas: probeOffscreenCanvas(),
+});
+/**
+ * Typed lookup over {@link capabilities}. Identical to
+ * `capabilities[name]` but the function form gives clearer call-sites
+ * when the name is computed.
+ */
+function isSupported(name) {
+    return capabilities[name];
+}
+
+export { capabilities, isSupported };
+//# sourceMappingURL=capabilities.js.map

package/dist/esm/core/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sources":["../../../../src/core/capabilities.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/esm/core/index.d.ts

@@ -2,6 +2,7 @@ export * from './types';
 export * from './utils';
 export * from './Application';
 export * from './Bounds';
+export * from './capabilities';
 export * from './Clock';
 export * from './Color';
 export * from './Quadtree';

package/dist/esm/index.js

@@ -1,6 +1,7 @@
 export { canvasSourceToDataUrl, emptyArrayBuffer, getCanvasSourceSize, getPreciseTime, getTextureSourceSize, hours, milliseconds, minutes, noop, rand, removeArrayItems, seconds, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio } from './core/utils.js';
 export { Application, ApplicationStatus } from './core/Application.js';
 export { Bounds } from './core/Bounds.js';
+export { capabilities, isSupported } from './core/capabilities.js';
 export { Clock } from './core/Clock.js';
 export { Color } from './core/Color.js';
 export { Quadtree } from './core/Quadtree.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/rendering/webgl2/glsl/mask-compose.frag.js

@@ -1,4 +1,4 @@
-var fragmentSource = "#version 300 es\r\nprecision lowp float;\r\n\r\nuniform sampler2D u_content;\r\nuniform sampler2D u_mask;\r\n\r\nin vec2 v_texcoord;\r\n\r\nlayout(location = 0) out vec4 fragColor;\r\n\r\nvoid main(void) {\r\n    vec4 contentColor = texture(u_content, v_texcoord);\r\n    float maskAlpha = texture(u_mask, v_texcoord).a;\r\n\r\n    fragColor = vec4(contentColor.rgb * maskAlpha, contentColor.a * maskAlpha);\r\n}\r\n";
+var fragmentSource = "#version 300 es\nprecision lowp float;\n\nuniform sampler2D u_content;\nuniform sampler2D u_mask;\n\nin vec2 v_texcoord;\n\nlayout(location = 0) out vec4 fragColor;\n\nvoid main(void) {\n    vec4 contentColor = texture(u_content, v_texcoord);\n    float maskAlpha = texture(u_mask, v_texcoord).a;\n\n    fragColor = vec4(contentColor.rgb * maskAlpha, contentColor.a * maskAlpha);\n}\n";
 
 export { fragmentSource as default };
 //# sourceMappingURL=mask-compose.frag.js.map

package/dist/esm/rendering/webgl2/glsl/mask-compose.vert.js

@@ -1,4 +1,4 @@
-var vertexSource = "#version 300 es\r\nprecision lowp float;\r\n\r\nlayout(location = 0) in vec2 a_position;\r\nlayout(location = 1) in vec2 a_texcoord;\r\n\r\nuniform mat3 u_projection;\r\n\r\nout vec2 v_texcoord;\r\n\r\nvoid main(void) {\r\n    gl_Position = vec4((u_projection * vec3(a_position, 1.0)).xy, 0.0, 1.0);\r\n    v_texcoord = a_texcoord;\r\n}\r\n";
+var vertexSource = "#version 300 es\nprecision lowp float;\n\nlayout(location = 0) in vec2 a_position;\nlayout(location = 1) in vec2 a_texcoord;\n\nuniform mat3 u_projection;\n\nout vec2 v_texcoord;\n\nvoid main(void) {\n    gl_Position = vec4((u_projection * vec3(a_position, 1.0)).xy, 0.0, 1.0);\n    v_texcoord = a_texcoord;\n}\n";
 
 export { vertexSource as default };
 //# sourceMappingURL=mask-compose.vert.js.map

package/dist/esm/rendering/webgl2/glsl/particle.frag.js

@@ -1,4 +1,4 @@
-var fragmentSource = "#version 300 es\r\nprecision lowp float;\r\n\r\nuniform sampler2D u_texture;\r\n\r\nin vec2 v_texcoord;\r\nin vec4 v_color;\r\n\r\nlayout(location = 0) out vec4 fragColor;\r\n\r\nvoid main(void) {\r\n    fragColor = texture(u_texture, v_texcoord) * v_color;\r\n}\r\n";
+var fragmentSource = "#version 300 es\nprecision lowp float;\n\nuniform sampler2D u_texture;\n\nin vec2 v_texcoord;\nin vec4 v_color;\n\nlayout(location = 0) out vec4 fragColor;\n\nvoid main(void) {\n    fragColor = texture(u_texture, v_texcoord) * v_color;\n}\n";
 
 export { fragmentSource as default };
 //# sourceMappingURL=particle.frag.js.map

package/dist/esm/rendering/webgl2/glsl/primitive.frag.js

@@ -1,4 +1,4 @@
-var fragmentSource = "#version 300 es\r\nprecision lowp float;\r\n\r\nlayout(location = 0) out vec4 fragColor;\r\n\r\nin vec4 v_color;\r\n\r\nvoid main(void) {\r\n    fragColor = v_color;\r\n}\r\n";
+var fragmentSource = "#version 300 es\nprecision lowp float;\n\nlayout(location = 0) out vec4 fragColor;\n\nin vec4 v_color;\n\nvoid main(void) {\n    fragColor = v_color;\n}\n";
 
 export { fragmentSource as default };
 //# sourceMappingURL=primitive.frag.js.map

package/dist/esm/rendering/webgl2/glsl/primitive.vert.js

@@ -1,4 +1,4 @@
-var vertexSource = "#version 300 es\r\nprecision lowp float;\r\n\r\nlayout(location = 0) in vec2 a_position;\r\nlayout(location = 1) in vec4 a_color;\r\n\r\nuniform mat3 u_projection;\r\nuniform mat3 u_translation;\r\n\r\nout vec4 v_color;\r\n\r\nvoid main(void) {\r\n    gl_Position = vec4((u_projection * u_translation * vec3(a_position, 1.0)).xy, 0.0, 1.0);\r\n    v_color = vec4(a_color.rgb * a_color.a, a_color.a);\r\n}\r\n";
+var vertexSource = "#version 300 es\nprecision lowp float;\n\nlayout(location = 0) in vec2 a_position;\nlayout(location = 1) in vec4 a_color;\n\nuniform mat3 u_projection;\nuniform mat3 u_translation;\n\nout vec4 v_color;\n\nvoid main(void) {\n    gl_Position = vec4((u_projection * u_translation * vec3(a_position, 1.0)).xy, 0.0, 1.0);\n    v_color = vec4(a_color.rgb * a_color.a, a_color.a);\n}\n";
 
 export { vertexSource as default };
 //# sourceMappingURL=primitive.vert.js.map

package/dist/esm/rendering/webgl2/glsl/sprite.frag.js

@@ -1,4 +1,4 @@
-var fragmentSource = "#version 300 es\r\nprecision lowp float;\r\nprecision lowp int;\r\n\r\n// Multi-texture sprite batching: up to 8 textures bound per draw call,\r\n// each fragment selects its source via a flat-interpolated slot index.\r\n//\r\n// GLSL ES 3.0 forbids non-constant array-of-sampler indexing unless the\r\n// expression is dynamically uniform — which a per-vertex slot is not\r\n// once different triangles in the same batch carry different slots. The\r\n// if/else chain below dispatches statically and dodges that constraint.\r\n\r\nuniform sampler2D u_texture0;\r\nuniform sampler2D u_texture1;\r\nuniform sampler2D u_texture2;\r\nuniform sampler2D u_texture3;\r\nuniform sampler2D u_texture4;\r\nuniform sampler2D u_texture5;\r\nuniform sampler2D u_texture6;\r\nuniform sampler2D u_texture7;\r\n\r\nin vec2 v_texcoord;\r\nin vec4 v_color;\r\nflat in uint v_textureSlot;\r\n\r\nlayout(location = 0) out vec4 fragColor;\r\n\r\nvoid main(void) {\r\n    vec4 sampleColor;\r\n\r\n    if (v_textureSlot == 0u) {\r\n        sampleColor = texture(u_texture0, v_texcoord);\r\n    } else if (v_textureSlot == 1u) {\r\n        sampleColor = texture(u_texture1, v_texcoord);\r\n    } else if (v_textureSlot == 2u) {\r\n        sampleColor = texture(u_texture2, v_texcoord);\r\n    } else if (v_textureSlot == 3u) {\r\n        sampleColor = texture(u_texture3, v_texcoord);\r\n    } else if (v_textureSlot == 4u) {\r\n        sampleColor = texture(u_texture4, v_texcoord);\r\n    } else if (v_textureSlot == 5u) {\r\n        sampleColor = texture(u_texture5, v_texcoord);\r\n    } else if (v_textureSlot == 6u) {\r\n        sampleColor = texture(u_texture6, v_texcoord);\r\n    } else {\r\n        sampleColor = texture(u_texture7, v_texcoord);\r\n    }\r\n\r\n    fragColor = sampleColor * v_color;\r\n}\r\n";
+var fragmentSource = "#version 300 es\nprecision lowp float;\nprecision lowp int;\n\n// Multi-texture sprite batching: up to 8 textures bound per draw call,\n// each fragment selects its source via a flat-interpolated slot index.\n//\n// GLSL ES 3.0 forbids non-constant array-of-sampler indexing unless the\n// expression is dynamically uniform — which a per-vertex slot is not\n// once different triangles in the same batch carry different slots. The\n// if/else chain below dispatches statically and dodges that constraint.\n\nuniform sampler2D u_texture0;\nuniform sampler2D u_texture1;\nuniform sampler2D u_texture2;\nuniform sampler2D u_texture3;\nuniform sampler2D u_texture4;\nuniform sampler2D u_texture5;\nuniform sampler2D u_texture6;\nuniform sampler2D u_texture7;\n\nin vec2 v_texcoord;\nin vec4 v_color;\nflat in uint v_textureSlot;\n\nlayout(location = 0) out vec4 fragColor;\n\nvoid main(void) {\n    vec4 sampleColor;\n\n    if (v_textureSlot == 0u) {\n        sampleColor = texture(u_texture0, v_texcoord);\n    } else if (v_textureSlot == 1u) {\n        sampleColor = texture(u_texture1, v_texcoord);\n    } else if (v_textureSlot == 2u) {\n        sampleColor = texture(u_texture2, v_texcoord);\n    } else if (v_textureSlot == 3u) {\n        sampleColor = texture(u_texture3, v_texcoord);\n    } else if (v_textureSlot == 4u) {\n        sampleColor = texture(u_texture4, v_texcoord);\n    } else if (v_textureSlot == 5u) {\n        sampleColor = texture(u_texture5, v_texcoord);\n    } else if (v_textureSlot == 6u) {\n        sampleColor = texture(u_texture6, v_texcoord);\n    } else {\n        sampleColor = texture(u_texture7, v_texcoord);\n    }\n\n    fragColor = sampleColor * v_color;\n}\n";
 
 export { fragmentSource as default };
 //# sourceMappingURL=sprite.frag.js.map

package/dist/esm/rendering/webgpu/WebGpuBackend.js

@@ -717,47 +717,47 @@ class WebGpuBackend {
     _getMipmapResources() {
         if (this._mipmapShaderModule === null || this._mipmapBindGroupLayout === null || this._mipmapPipelineLayout === null || this._mipmapPipeline === null || this._mipmapSampler === null) {
             this._mipmapShaderModule = this.device.createShaderModule({
-                code: `
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) texcoord: vec2<f32>,
-};
-
-@group(0) @binding(0)
-var sourceTexture: texture_2d<f32>;
-@group(0) @binding(1)
-var sourceSampler: sampler;
-
-@vertex
-fn vertexMain(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
-    var positions = array<vec2<f32>, 3>(
-        vec2<f32>(-1.0, -1.0),
-        vec2<f32>(3.0, -1.0),
-        vec2<f32>(-1.0, 3.0)
-    );
-    // Y is flipped vs the position array: NDC Y points up, but texture UV
-    // Y points down (UV (0,0) is the top-left of the source). Matching the
-    // two ensures that the output texture's top-left pixel samples from the
-    // source's top-left, so every mip level has the same orientation as the
-    // level above it. Prior to this, odd mip levels were rendered upside
-    // down, producing visible texture flips at view-size doublings.
-    var texcoords = array<vec2<f32>, 3>(
-        vec2<f32>(0.0, 1.0),
-        vec2<f32>(2.0, 1.0),
-        vec2<f32>(0.0, -1.0)
-    );
-    var output: VertexOutput;
-
-    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);
-    output.texcoord = texcoords[vertexIndex];
-
-    return output;
-}
-
-@fragment
-fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
-    return textureSample(sourceTexture, sourceSampler, input.texcoord);
-}
+                code: `
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texcoord: vec2<f32>,
+};
+
+@group(0) @binding(0)
+var sourceTexture: texture_2d<f32>;
+@group(0) @binding(1)
+var sourceSampler: sampler;
+
+@vertex
+fn vertexMain(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var positions = array<vec2<f32>, 3>(
+        vec2<f32>(-1.0, -1.0),
+        vec2<f32>(3.0, -1.0),
+        vec2<f32>(-1.0, 3.0)
+    );
+    // Y is flipped vs the position array: NDC Y points up, but texture UV
+    // Y points down (UV (0,0) is the top-left of the source). Matching the
+    // two ensures that the output texture's top-left pixel samples from the
+    // source's top-left, so every mip level has the same orientation as the
+    // level above it. Prior to this, odd mip levels were rendered upside
+    // down, producing visible texture flips at view-size doublings.
+    var texcoords = array<vec2<f32>, 3>(
+        vec2<f32>(0.0, 1.0),
+        vec2<f32>(2.0, 1.0),
+        vec2<f32>(0.0, -1.0)
+    );
+    var output: VertexOutput;
+
+    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);
+    output.texcoord = texcoords[vertexIndex];
+
+    return output;
+}
+
+@fragment
+fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
+    return textureSample(sourceTexture, sourceSampler, input.texcoord);
+}
 `,
             });
             this._mipmapBindGroupLayout = this.device.createBindGroupLayout({