@codexo/exojs 0.6.1 → 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';
@@ -61,6 +62,7 @@ export { ParticleOptions } from './particles/emitters/ParticleOptions.js';
 export { UniversalEmitter } from './particles/emitters/UniversalEmitter.js';
 export { Particle } from './particles/Particle.js';
 export { ParticleSystem } from './particles/ParticleSystem.js';
+export { Mesh } from './rendering/mesh/Mesh.js';
 export { CircleGeometry } from './rendering/primitives/CircleGeometry.js';
 export { Geometry } from './rendering/primitives/Geometry.js';
 export { DrawableShape } from './rendering/primitives/DrawableShape.js';
@@ -83,6 +85,7 @@ export { WebGl2RenderBuffer } from './rendering/webgl2/WebGl2RenderBuffer.js';
 export { WebGl2ShaderBlock } from './rendering/webgl2/WebGl2ShaderBlock.js';
 export { webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames } from './rendering/webgl2/WebGl2ShaderMappings.js';
 export { WebGl2VertexArrayObject } from './rendering/webgl2/WebGl2VertexArrayObject.js';
+export { WebGl2MeshRenderer } from './rendering/webgl2/WebGl2MeshRenderer.js';
 export { WebGl2ParticleRenderer } from './rendering/webgl2/WebGl2ParticleRenderer.js';
 export { WebGl2PrimitiveRenderer } from './rendering/webgl2/WebGl2PrimitiveRenderer.js';
 export { WebGl2Backend } from './rendering/webgl2/WebGl2Backend.js';
@@ -90,6 +93,7 @@ export { createWebGl2ShaderProgram } from './rendering/webgl2/WebGl2ShaderProgra
 export { WebGl2SpriteRenderer } from './rendering/webgl2/WebGl2SpriteRenderer.js';
 export { AbstractWebGpuRenderer } from './rendering/webgpu/AbstractWebGpuRenderer.js';
 export { getWebGpuBlendState } from './rendering/webgpu/WebGpuBlendState.js';
+export { WebGpuMeshRenderer } from './rendering/webgpu/WebGpuMeshRenderer.js';
 export { WebGpuParticleRenderer } from './rendering/webgpu/WebGpuParticleRenderer.js';
 export { WebGpuPrimitiveRenderer } from './rendering/webgpu/WebGpuPrimitiveRenderer.js';
 export { WebGpuBackend } from './rendering/webgpu/WebGpuBackend.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/index.d.ts

@@ -1,3 +1,4 @@
+export * from './mesh/Mesh';
 export * from './primitives/CircleGeometry';
 export * from './primitives/Geometry';
 export * from './primitives/DrawableShape';
@@ -20,6 +21,7 @@ export * from './webgl2/WebGl2RenderBuffer';
 export * from './webgl2/WebGl2ShaderBlock';
 export * from './webgl2/WebGl2ShaderMappings';
 export * from './webgl2/WebGl2VertexArrayObject';
+export * from './webgl2/WebGl2MeshRenderer';
 export * from './webgl2/WebGl2ParticleRenderer';
 export * from './webgl2/WebGl2PrimitiveRenderer';
 export type { WebGl2Backend } from './webgl2/WebGl2Backend';
@@ -28,6 +30,7 @@ export * from './webgl2/WebGl2ShaderProgram';
 export * from './webgl2/WebGl2SpriteRenderer';
 export * from './webgpu/AbstractWebGpuRenderer';
 export * from './webgpu/WebGpuBlendState';
+export * from './webgpu/WebGpuMeshRenderer';
 export * from './webgpu/WebGpuParticleRenderer';
 export * from './webgpu/WebGpuPrimitiveRenderer';
 export type { WebGpuBackend } from './webgpu/WebGpuBackend';

package/dist/esm/rendering/mesh/Mesh.d.ts

@@ -0,0 +1,69 @@
+import { Drawable } from '@/rendering/Drawable';
+import type { Texture } from '@/rendering/texture/Texture';
+import type { RenderTexture } from '@/rendering/texture/RenderTexture';
+/**
+ * Construction-time options for a {@link Mesh}.
+ *
+ * Vertices are required and must be a flat sequence of (x, y) pairs in
+ * local space. UVs and per-vertex colors are optional but, when present,
+ * must match the vertex count (UVs as (u, v) pairs, colors as one
+ * packed-RGBA8 u32 per vertex). Indices are optional — if absent, the
+ * vertex stream is drawn as a flat triangle list (3*N vertices = N
+ * triangles). A texture is optional; a textured mesh samples it at the
+ * supplied UVs while an untextured mesh paints solid vertex colors only.
+ *
+ * Validation is enforced at construction; any mismatch throws.
+ */
+export interface MeshOptions {
+    readonly vertices: Float32Array;
+    readonly indices?: Uint16Array;
+    readonly uvs?: Float32Array;
+    readonly colors?: Uint32Array;
+    readonly texture?: Texture | RenderTexture | null;
+}
+/**
+ * Arbitrary 2D triangle-mesh primitive.
+ *
+ * `Mesh` lives alongside {@link Sprite} as a public Drawable: it has the
+ * same transform (position/rotation/scale/origin), tint, blendMode,
+ * filters, masks, and cacheAsBitmap — but the geometry it renders is
+ * user-supplied rather than implied by a texture frame. The intended use
+ * cases are:
+ *
+ * - Custom-shape sprites whose silhouette isn't a quad (badges, speech
+ *   bubbles, region overlays).
+ * - Deformable visuals (rope/ribbon, banner, water surface): mutate the
+ *   vertex array between frames and the GPU re-tessellates nothing —
+ *   only the transform changes per frame.
+ * - Particles or trails with custom geometry per emitter.
+ *
+ * The mesh data is **immutable after construction** in v1: vertex /
+ * index / UV / color arrays are exposed as readonly references. Mutate
+ * the underlying typed arrays in-place if you need per-frame updates,
+ * but the array lengths and topology cannot change. Texture is the only
+ * post-construction mutable property.
+ *
+ * The vertex stream is a flat `Float32Array` of (x, y) pairs in local
+ * space. The mesh's local bounds are computed once at construction from
+ * the AABB of those vertices and used by the cull pass. Re-computing
+ * after in-place mutation is the caller's responsibility (call
+ * `recomputeLocalBounds()`).
+ */
+export declare class Mesh extends Drawable {
+    readonly vertices: Float32Array;
+    readonly indices: Uint16Array | null;
+    readonly uvs: Float32Array | null;
+    readonly colors: Uint32Array | null;
+    private _texture;
+    constructor(options: MeshOptions);
+    get vertexCount(): number;
+    get indexCount(): number;
+    get texture(): Texture | RenderTexture | null;
+    set texture(texture: Texture | RenderTexture | null);
+    /**
+     * Recompute the local AABB from the current vertex array. Call after
+     * mutating `vertices` in place to keep culling correct; otherwise the
+     * bounds the cull pass sees will be the AABB at construction time.
+     */
+    recomputeLocalBounds(): this;
+}