@waica/engine 0.24.0 → 0.26.0

package/dist/components/animated-sprite.js

@@ -5,6 +5,7 @@ import { locateFrame, sheetCell } from '../animation/sheet.js';
 import { spritePlacement } from '../sprite-placement.js';
 import { reportRejection } from '../report-rejection.js';
 import { spriteBatchesOf, spriteInstanceOf } from '../sprite-batches.js';
+import { setEmissive, TRANSPARENT_TEXEL_ALPHA } from '../render-layers.js';
 /** Where a frame on a failed sheet draws: the flat (white) untextured quad. */
 const UNTEXTURED = { texture: null, pixelArt: false, shape: 'rectangle' };
 const clampAnchor = (value) => Math.min(1, Math.max(0, value));
@@ -20,6 +21,7 @@ const clampAnchor = (value) => Math.min(1, Math.max(0, value));
  */
 export class AnimatedSprite extends Component {
     static componentName = 'AnimatedSprite';
+    static space = '2d';
     static updateAfter = ['StateMachine'];
     static params = {
         offsetX: { label: 'x offset' },
@@ -27,6 +29,7 @@ export class AnimatedSprite extends Component {
         anchorX: { label: 'x anchor', min: 0, max: 1, step: 0.25 },
         anchorY: { label: 'y anchor', min: 0, max: 1, step: 0.25 },
         layer: { label: 'layer', min: -5, max: 5, step: 1 },
+        emissive: { label: 'emissive' },
     };
     static transient = [
         'current',
@@ -133,6 +136,17 @@ export class AnimatedSprite extends Component {
         this.flipX = value;
         this.syncQuad();
     }
+    // Emissive (issue #78 CA-10): never darkened by the light-map, drawn after
+    // it at full brightness. On its own render layer.
+    _emissive = false;
+    get emissive() {
+        return this._emissive;
+    }
+    set emissive(value) {
+        this._emissive = value === true;
+        if (this.mesh)
+            setEmissive(this.mesh, this._emissive);
+    }
     clips = {};
     initialClip;
     /** Clip currently playing. */
@@ -182,10 +196,11 @@ export class AnimatedSprite extends Component {
             this.mesh = instance.anchor;
         }
         else {
-            const material = new THREE.MeshBasicMaterial({ map: this.texs[0], transparent: true });
+            const material = new THREE.MeshBasicMaterial({ map: this.texs[0], transparent: true, alphaTest: TRANSPARENT_TEXEL_ALPHA });
             this.mesh = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), material);
         }
         this.mesh.position.z = this.layer * 0.01;
+        setEmissive(this.mesh, this._emissive);
         this.syncQuad();
         this.entity.node.add(this.mesh);
         if (this.initialClip)

package/dist/components/collider.d.ts

@@ -0,0 +1,89 @@
+import { Component, type ComponentSpace } from '../component.js';
+import type { Vec3Json } from '../scene-camera-3d.js';
+export type ColliderShape = 'box' | 'sphere' | 'capsule';
+export declare const COLLIDER_SHAPES: readonly ColliderShape[];
+/**
+ * The 3D scene's collision shape (ADR 0028), Rapier's model: alone on an
+ * entity it is a fixed wall or floor, created at the entity's position and
+ * rotation scaled by `entity.scale`, and moving the entity later does not
+ * move it. With a `RigidBody` beside it, it is the body that falls, bounces
+ * or walks. `sensor: true` makes it a trigger instead — it detects and never
+ * pushes — with the 2D Hitbox's `layer` and `collidesWith` semantics (ADR
+ * 0016); with the default mask (`['*']`) a sensor is not told about fixed
+ * solid colliders (the level's walls and floors), as a Hitbox never sees a
+ * Solid — a mask that names their layer still is. `size` is a box's full
+ * extents; `radius` a sphere's or capsule's; `height` a capsule's total
+ * end-to-end height, at least twice its radius; `offset` is in the entity's
+ * local frame. A Collider in a 2D scene creates nothing; one whose params
+ * Rapier cannot take creates no body and warns once (`validate_project`
+ * reports them as `invalid-collider-param`).
+ */
+export declare class Collider extends Component {
+    static componentName: string;
+    static space: ComponentSpace;
+    static params: {
+        shape: {
+            label: string;
+            options: ColliderShape[];
+        };
+        size: {
+            label: string;
+            kind: "vector3";
+        };
+        radius: {
+            label: string;
+            min: number;
+            step: number;
+        };
+        height: {
+            label: string;
+            min: number;
+            step: number;
+        };
+        offset: {
+            label: string;
+            kind: "vector3";
+        };
+        sensor: {
+            label: string;
+        };
+        layer: {
+            label: string;
+        };
+        collidesWith: {
+            label: string;
+            kind: "string-list";
+        };
+        friction: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        restitution: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    shape: ColliderShape;
+    /** A box's full extents `[x, y, z]`. */
+    size: Vec3Json;
+    /** A sphere's or capsule's radius. */
+    radius: number;
+    /** A capsule's total end-to-end height. */
+    height: number;
+    /** Where the shape sits in the entity's local frame. */
+    offset: Vec3Json;
+    /** A trigger: detects overlaps, never pushes or is pushed. */
+    sensor: boolean;
+    /** One exact, case-sensitive `^[a-z][a-z0-9-]*$` membership name. */
+    layer: string;
+    /** Outgoing layer interest for `onCollide`; `'*'` means every valid layer and `[]` means none. */
+    collidesWith: string[];
+    friction: number;
+    restitution: number;
+    onReady(): void;
+    onDestroy(): void;
+}

package/dist/components/collider.js

@@ -0,0 +1,57 @@
+import { Component } from '../component.js';
+export const COLLIDER_SHAPES = ['box', 'sphere', 'capsule'];
+/**
+ * The 3D scene's collision shape (ADR 0028), Rapier's model: alone on an
+ * entity it is a fixed wall or floor, created at the entity's position and
+ * rotation scaled by `entity.scale`, and moving the entity later does not
+ * move it. With a `RigidBody` beside it, it is the body that falls, bounces
+ * or walks. `sensor: true` makes it a trigger instead — it detects and never
+ * pushes — with the 2D Hitbox's `layer` and `collidesWith` semantics (ADR
+ * 0016); with the default mask (`['*']`) a sensor is not told about fixed
+ * solid colliders (the level's walls and floors), as a Hitbox never sees a
+ * Solid — a mask that names their layer still is. `size` is a box's full
+ * extents; `radius` a sphere's or capsule's; `height` a capsule's total
+ * end-to-end height, at least twice its radius; `offset` is in the entity's
+ * local frame. A Collider in a 2D scene creates nothing; one whose params
+ * Rapier cannot take creates no body and warns once (`validate_project`
+ * reports them as `invalid-collider-param`).
+ */
+export class Collider extends Component {
+    static componentName = 'Collider';
+    static space = '3d';
+    static params = {
+        shape: { label: 'Shape', options: [...COLLIDER_SHAPES] },
+        size: { label: 'Size', kind: 'vector3' },
+        radius: { label: 'Radius', min: 0.01, step: 0.05 },
+        height: { label: 'Height', min: 0.01, step: 0.05 },
+        offset: { label: 'Offset', kind: 'vector3' },
+        sensor: { label: 'Sensor' },
+        layer: { label: 'Collision Layer' },
+        collidesWith: { label: 'Collision Mask', kind: 'string-list' },
+        friction: { label: 'Friction', min: 0, max: 1, step: 0.05 },
+        restitution: { label: 'Restitution', min: 0, max: 1, step: 0.05 },
+    };
+    shape = 'box';
+    /** A box's full extents `[x, y, z]`. */
+    size = [1, 1, 1];
+    /** A sphere's or capsule's radius. */
+    radius = 0.5;
+    /** A capsule's total end-to-end height. */
+    height = 1.8;
+    /** Where the shape sits in the entity's local frame. */
+    offset = [0, 0, 0];
+    /** A trigger: detects overlaps, never pushes or is pushed. */
+    sensor = false;
+    /** One exact, case-sensitive `^[a-z][a-z0-9-]*$` membership name. */
+    layer = 'default';
+    /** Outgoing layer interest for `onCollide`; `'*'` means every valid layer and `[]` means none. */
+    collidesWith = ['*'];
+    friction = 0.5;
+    restitution = 0;
+    onReady() {
+        this.game.physics.attach(this.entity);
+    }
+    onDestroy() {
+        this.game.physics.detach(this.entity);
+    }
+}

package/dist/components/dynamic-body.d.ts

@@ -1,11 +1,12 @@
 import { type CollisionPoint, type CollisionShape } from '../collision-shape.js';
-import { Component } from '../component.js';
+import { Component, type ComponentSpace } from '../component.js';
 /**
  * Reusable linear body: integrates its public velocity and resolves only
  * against static Solid geometry. Hitbox trigger overlaps remain independent.
  */
 export declare class DynamicBody extends Component {
     static componentName: string;
+    static space: ComponentSpace;
     static params: {
         vx: {
             label: string;

package/dist/components/dynamic-body.js

@@ -17,6 +17,7 @@ const RECOVERY_ITERATIONS = 24;
  */
 export class DynamicBody extends Component {
     static componentName = 'DynamicBody';
+    static space = '2d';
     static params = {
         vx: { label: 'x velocity', step: 0.1 },
         vy: { label: 'y velocity', step: 0.1 },

package/dist/components/hitbox.d.ts

@@ -1,4 +1,4 @@
-import { Component } from '../component.js';
+import { Component, type ComponentSpace } from '../component.js';
 import { type CollisionPoint, type CollisionShape } from '../collision-shape.js';
 /**
  * Trigger collider. A pair is tested when either Hitbox's Collision Mask
@@ -8,6 +8,7 @@ import { type CollisionPoint, type CollisionShape } from '../collision-shape.js'
  */
 export declare class Hitbox extends Component {
     static componentName: string;
+    static space: ComponentSpace;
     static params: {
         layer: {
             label: string;

package/dist/components/hitbox.js

@@ -8,6 +8,7 @@ import { resolveCollisionPoints, } from '../collision-shape.js';
  */
 export class Hitbox extends Component {
     static componentName = 'Hitbox';
+    static space = '2d';
     static params = {
         layer: { label: 'Collision Layer' },
         collidesWith: { label: 'Collision Mask', kind: 'string-list' },

package/dist/components/light.d.ts

@@ -0,0 +1,69 @@
+import { Component, type ComponentSpace } from '../component.js';
+import type { LightField } from '../light-field.js';
+/**
+ * A source of 2D light owned by its entity (issue #78, `CONTEXT.md` Light):
+ * a radius in logical world units — an ellipse on an isometric screen — a
+ * color, an intensity, a falloff that is smooth or split into `bands`, and a
+ * shadow edge that is hard or `soft`. Solid tiles stop it unless
+ * `castShadows` is off. Lights brighten what the Ambient Light leaves dark;
+ * they never darken. A live Light makes its scene draw lit.
+ */
+export declare class Light extends Component {
+    static componentName: string;
+    static space: ComponentSpace;
+    static params: {
+        radius: {
+            label: string;
+            min: number;
+            step: number;
+        };
+        color: {
+            label: string;
+            kind: "color";
+        };
+        intensity: {
+            label: string;
+            min: number;
+            step: number;
+        };
+        bands: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        softness: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        castShadows: {
+            label: string;
+        };
+        offsetX: {
+            label: string;
+        };
+        offsetY: {
+            label: string;
+        };
+    };
+    /** Logical world units from its centre to where it fades out. */
+    radius: number;
+    /** `0xrrggbb`, multiplied over the art it reaches. */
+    color: number;
+    intensity: number;
+    /** 0 = smooth falloff; N = N equal steps (at most 16). */
+    bands: number;
+    /** 0 = hard shadow edge; up to 1 = the widest penumbra. */
+    softness: number;
+    /** Off: solid tiles do not stop this light. */
+    castShadows: boolean;
+    /** Logical offset from the entity's position, like a Solid's. */
+    offsetX: number;
+    offsetY: number;
+    onReady(): void;
+    onDestroy(): void;
+    /** This light as the light-map reads it: logical position, clamped params, color channels in 0..1. */
+    field(): LightField;
+}

package/dist/components/light.js

@@ -0,0 +1,60 @@
+import { Component } from '../component.js';
+import { addLight, removeLight } from '../scene-lighting.js';
+const MAX_BANDS = 16;
+const finiteOr = (value, fallback) => (Number.isFinite(value) ? value : fallback);
+/**
+ * A source of 2D light owned by its entity (issue #78, `CONTEXT.md` Light):
+ * a radius in logical world units — an ellipse on an isometric screen — a
+ * color, an intensity, a falloff that is smooth or split into `bands`, and a
+ * shadow edge that is hard or `soft`. Solid tiles stop it unless
+ * `castShadows` is off. Lights brighten what the Ambient Light leaves dark;
+ * they never darken. A live Light makes its scene draw lit.
+ */
+export class Light extends Component {
+    static componentName = 'Light';
+    static space = '2d';
+    static params = {
+        radius: { label: 'Radius', min: 0, step: 0.25 },
+        color: { label: 'Color', kind: 'color' },
+        intensity: { label: 'Intensity', min: 0, step: 0.1 },
+        bands: { label: 'Bands (0 = smooth)', min: 0, max: MAX_BANDS, step: 1 },
+        softness: { label: 'Shadow softness', min: 0, max: 1, step: 0.05 },
+        castShadows: { label: 'Cast shadows' },
+        offsetX: { label: 'x offset' },
+        offsetY: { label: 'y offset' },
+    };
+    /** Logical world units from its centre to where it fades out. */
+    radius = 4;
+    /** `0xrrggbb`, multiplied over the art it reaches. */
+    color = 0xffffff;
+    intensity = 1;
+    /** 0 = smooth falloff; N = N equal steps (at most 16). */
+    bands = 0;
+    /** 0 = hard shadow edge; up to 1 = the widest penumbra. */
+    softness = 0;
+    /** Off: solid tiles do not stop this light. */
+    castShadows = true;
+    /** Logical offset from the entity's position, like a Solid's. */
+    offsetX = 0;
+    offsetY = 0;
+    onReady() {
+        addLight(this.game.lighting, this);
+    }
+    onDestroy() {
+        removeLight(this.game.lighting, this);
+    }
+    /** This light as the light-map reads it: logical position, clamped params, color channels in 0..1. */
+    field() {
+        const color = Number.isFinite(this.color) ? Math.trunc(this.color) & 0xffffff : 0xffffff;
+        return {
+            x: this.entity.position.x + finiteOr(this.offsetX, 0),
+            y: this.entity.position.y + finiteOr(this.offsetY, 0),
+            radius: Math.max(0, finiteOr(this.radius, 0)),
+            color: [((color >> 16) & 0xff) / 255, ((color >> 8) & 0xff) / 255, (color & 0xff) / 255],
+            intensity: Math.max(0, finiteOr(this.intensity, 0)),
+            bands: Math.min(MAX_BANDS, Math.max(0, Math.round(finiteOr(this.bands, 0)))),
+            softness: Math.min(1, Math.max(0, finiteOr(this.softness, 0))),
+            castShadows: this.castShadows !== false,
+        };
+    }
+}

package/dist/components/model.d.ts

@@ -0,0 +1,63 @@
+import * as THREE from 'three/webgpu';
+import { Component, type ComponentSpace } from '../component.js';
+export type ModelShape = 'box' | 'sphere' | 'plane';
+/**
+ * A 3D thing an entity draws (3D scenes, ADR 0027): a glTF/glb from `src`
+ * (a `waica:` uri or a project path, loaded once through `game.assets`) or a
+ * primitive `shape` of a `color` and a uniform `size`. With both, `src` wins.
+ * Its root hangs under the entity's node, so the entity's position, rotation
+ * and scale place it; the glTF keeps the materials it ships with, a
+ * primitive has a standard (lit) node material. `color` and `size` follow the
+ * inspector live; a new `src` or `shape` rebuilds the content. Destroying it
+ * removes the root and disposes only what it created — never the cached glTF.
+ * In a 2D scene it creates nothing (`validate_project` reports it).
+ */
+export declare class Model extends Component {
+    static componentName: string;
+    static space: ComponentSpace;
+    static params: {
+        src: {
+            label: string;
+            kind: "model";
+        };
+        shape: {
+            label: string;
+            options: ModelShape[];
+        };
+        color: {
+            label: string;
+            kind: "color";
+        };
+        size: {
+            label: string;
+            min: number;
+            step: number;
+        };
+    };
+    static transient: string[];
+    /** What this Model draws, under the entity's node; null until it is ready. The Pointer ray-casts against it. */
+    root: THREE.Group | null;
+    private _src;
+    private _shape;
+    private _color;
+    private _size;
+    private _primitive;
+    /** A `waica:` uri or project path to a `.glb` / `.gltf`; empty draws the primitive `shape`. */
+    get src(): string;
+    set src(value: string);
+    get shape(): ModelShape;
+    set shape(value: ModelShape);
+    /** `0xrrggbb` of a primitive. */
+    get color(): number;
+    set color(value: number);
+    /** Uniform scale of a primitive: the box side, sphere diameter or plane side in world units. */
+    get size(): number;
+    set size(value: number);
+    onReady(): void;
+    onDestroy(): void;
+    private build;
+    private buildPrimitive;
+    private rebuild;
+    /** Empties the root and disposes the primitive this Model created; a glTF's clone only leaves the graph. */
+    private clear;
+}

package/dist/components/model.js

@@ -0,0 +1,117 @@
+import * as THREE from 'three/webgpu';
+import { Component } from '../component.js';
+const SHAPES = ['box', 'sphere', 'plane'];
+/** One unit of the shape: a box of side 1, a sphere of diameter 1, a plane of side 1 lying flat on the ground (normal up). */
+function primitiveGeometry(shape) {
+    switch (shape) {
+        case 'sphere':
+            return new THREE.SphereGeometry(0.5, 32, 16);
+        case 'plane':
+            return new THREE.PlaneGeometry(1, 1).rotateX(-Math.PI / 2);
+        case 'box':
+            return new THREE.BoxGeometry(1, 1, 1);
+    }
+}
+/**
+ * A 3D thing an entity draws (3D scenes, ADR 0027): a glTF/glb from `src`
+ * (a `waica:` uri or a project path, loaded once through `game.assets`) or a
+ * primitive `shape` of a `color` and a uniform `size`. With both, `src` wins.
+ * Its root hangs under the entity's node, so the entity's position, rotation
+ * and scale place it; the glTF keeps the materials it ships with, a
+ * primitive has a standard (lit) node material. `color` and `size` follow the
+ * inspector live; a new `src` or `shape` rebuilds the content. Destroying it
+ * removes the root and disposes only what it created — never the cached glTF.
+ * In a 2D scene it creates nothing (`validate_project` reports it).
+ */
+export class Model extends Component {
+    static componentName = 'Model';
+    static space = '3d';
+    static params = {
+        src: { label: 'Model file', kind: 'model' },
+        shape: { label: 'Shape', options: [...SHAPES] },
+        color: { label: 'Color', kind: 'color' },
+        size: { label: 'Size', min: 0.01, step: 0.1 },
+    };
+    static transient = ['root'];
+    /** What this Model draws, under the entity's node; null until it is ready. The Pointer ray-casts against it. */
+    root = null;
+    _src = '';
+    _shape = 'box';
+    _color = 0xffffff;
+    _size = 1;
+    _primitive = null;
+    /** A `waica:` uri or project path to a `.glb` / `.gltf`; empty draws the primitive `shape`. */
+    get src() {
+        return this._src;
+    }
+    set src(value) {
+        this._src = value;
+        this.rebuild();
+    }
+    get shape() {
+        return this._shape;
+    }
+    set shape(value) {
+        this._shape = SHAPES.includes(value) ? value : 'box';
+        this.rebuild();
+    }
+    /** `0xrrggbb` of a primitive. */
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+        this._primitive?.mesh.material.color.setHex(value);
+    }
+    /** Uniform scale of a primitive: the box side, sphere diameter or plane side in world units. */
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        this._size = value;
+        this._primitive?.mesh.scale.setScalar(value);
+    }
+    onReady() {
+        // Draws only in a 3D scene, like Sun and PointLight: 2.5D is a later block, and a lit-less mesh would come out black.
+        if (this.game.space !== '3d')
+            return;
+        this.root = new THREE.Group();
+        this.root.name = 'waica:model';
+        this.entity.node.add(this.root);
+        this.build();
+    }
+    onDestroy() {
+        this.clear();
+        this.root?.removeFromParent();
+    }
+    build() {
+        if (!this.root)
+            return;
+        if (this._src)
+            this.root.add(this.game.assets.model(this._src).root);
+        else
+            this.buildPrimitive(this.root);
+    }
+    buildPrimitive(root) {
+        const material = new THREE.MeshStandardNodeMaterial({ color: this._color });
+        const mesh = new THREE.Mesh(primitiveGeometry(this._shape), material);
+        mesh.scale.setScalar(this._size);
+        root.add(mesh);
+        this._primitive = { mesh };
+    }
+    rebuild() {
+        if (!this.root)
+            return;
+        this.clear();
+        this.build();
+    }
+    /** Empties the root and disposes the primitive this Model created; a glTF's clone only leaves the graph. */
+    clear() {
+        this.root?.clear();
+        if (!this._primitive)
+            return;
+        this._primitive.mesh.geometry.dispose();
+        this._primitive.mesh.material.dispose();
+        this._primitive = null;
+    }
+}

package/dist/components/particle-emitter.d.ts

@@ -1,4 +1,4 @@
-import { Component } from '../component.js';
+import { Component, type ComponentSpace } from '../component.js';
 import type { YSortBatchParticipant, YSortEntry } from '../render-sort.js';
 export type ParticleVector = [number, number];
 export type ParticleSpace = 'world' | 'local';
@@ -8,6 +8,7 @@ export type ParticleBlend = 'normal' | 'additive';
 /** A fixed-capacity source of short-lived, batched 2D particles. */
 export declare class ParticleEmitter extends Component implements YSortBatchParticipant {
     static componentName: string;
+    static space: ComponentSpace;
     static displayName: string;
     static params: {
         rate: {
@@ -107,6 +108,9 @@ export declare class ParticleEmitter extends Component implements YSortBatchPart
             label: string;
             step: number;
         };
+        emissive: {
+            label: string;
+        };
     };
     rate: number;
     emitting: boolean;
@@ -144,6 +148,9 @@ export declare class ParticleEmitter extends Component implements YSortBatchPart
     private _layer;
     get layer(): number;
     set layer(value: number);
+    private _emissive;
+    get emissive(): boolean;
+    set emissive(value: boolean);
     private _batch?;
     private _unsubscribeRenderSync?;
     private _emissionRemainder;

package/dist/components/particle-emitter.js

@@ -1,9 +1,11 @@
 import { Component } from '../component.js';
 import { ParticleBatch, } from '../particle-batch.js';
 import { sceneDrainsOf } from '../scene-drains.js';
+import { setEmissive } from '../render-layers.js';
 /** A fixed-capacity source of short-lived, batched 2D particles. */
 export class ParticleEmitter extends Component {
     static componentName = 'ParticleEmitter';
+    static space = '2d';
     static displayName = 'Particle Emitter';
     static params = {
         rate: { label: 'Rate', min: 0 },
@@ -30,6 +32,7 @@ export class ParticleEmitter extends Component {
         pixelArt: { label: 'Pixel art' },
         blend: { label: 'Blend', options: ['normal', 'additive'] },
         layer: { label: 'Layer', step: 1 },
+        emissive: { label: 'Emissive' },
     };
     rate = 0;
     emitting = true;
@@ -116,6 +119,16 @@ export class ParticleEmitter extends Component {
         this._batch?.setLayer(next);
         this._batch?.sync(this.renderContext());
     }
+    // Emissive (issue #78 CA-10): never darkened by the light-map.
+    _emissive = false;
+    get emissive() {
+        return this._emissive;
+    }
+    set emissive(value) {
+        this._emissive = value === true;
+        if (this._batch)
+            setEmissive(this._batch.mesh, this._emissive);
+    }
     _batch;
     _unsubscribeRenderSync;
     _emissionRemainder = 0;
@@ -133,6 +146,7 @@ export class ParticleEmitter extends Component {
             assets: this.game.assets,
         });
         this._batch.setTexture(this.texture, this.pixelArt);
+        setEmissive(this._batch.mesh, this._emissive);
         this.game.scene.add(this._batch.mesh);
         this._batch.sync(this.renderContext());
         this._unsubscribeRenderSync = this.game.onUpdate(() => this._batch?.sync(this.renderContext()));