@waica/engine 0.30.1 → 0.31.1

package/dist/components/animator-sources.js

@@ -0,0 +1,125 @@
+import * as THREE from 'three/webgpu';
+/** A clip of the file as one sound of the mix: its own action, advanced by the mixer at its `speed`. */
+export class ClipSource {
+    name;
+    action;
+    constructor(name, action) {
+        this.name = name;
+        this.action = action;
+    }
+    /** A `loop: false` clip clamps when it ends, which three marks by pausing it: nothing else pauses an action here. */
+    get finished() {
+        return this.action.loop === THREE.LoopOnce && this.action.paused;
+    }
+    get time() {
+        return this.action.time;
+    }
+    get progress() {
+        const { duration } = this.action.getClip();
+        return duration > 0 ? Math.min(this.action.time / duration, 1) : 1;
+    }
+    get playing() {
+        return this.action.isRunning();
+    }
+    start() {
+        this.action.reset().play();
+    }
+    stop() {
+        this.action.stop();
+    }
+    apply(weight) {
+        this.action.setEffectiveWeight(weight);
+    }
+    addWeights(weight, into) {
+        into[this.name] = (into[this.name] ?? 0) + weight;
+    }
+}
+/**
+ * A blend as one sound of the mix (issue #205, ADR 0033): its points share
+ * one normalized phase, advanced by the step over the cycle interpolated by
+ * the points' shares, so walk and run put their feet down together; each
+ * point's action sits at that phase of its own clip, weighted by its share.
+ */
+export class BlendSource {
+    name;
+    points;
+    value;
+    phase = 0;
+    constructor(name, points, value) {
+        this.name = name;
+        this.points = points;
+        this.value = value;
+    }
+    /** A blend loops: it never finishes. */
+    get finished() {
+        return false;
+    }
+    /** The phase as seconds of the interpolated cycle. */
+    get time() {
+        return this.phase * this.cycle(blendShares(this.points, this.value()));
+    }
+    get progress() {
+        return this.phase;
+    }
+    get playing() {
+        return true;
+    }
+    start() {
+        this.phase = 0;
+        for (const point of this.points)
+            point.action.reset().play();
+    }
+    stop() {
+        for (const point of this.points)
+            point.action.stop();
+    }
+    apply(weight, dt) {
+        const shares = blendShares(this.points, this.value());
+        const cycle = this.cycle(shares);
+        if (cycle > 0) {
+            this.phase += dt / cycle;
+            this.phase -= Math.floor(this.phase);
+        }
+        for (const [index, point] of this.points.entries()) {
+            point.action.time = this.phase * point.duration;
+            point.action.setEffectiveWeight(weight * (shares[index] ?? 0));
+        }
+    }
+    addWeights(weight, into) {
+        const shares = blendShares(this.points, this.value());
+        for (const [index, point] of this.points.entries()) {
+            const share = shares[index] ?? 0;
+            if (share > 0)
+                into[point.clip] = (into[point.clip] ?? 0) + weight * share;
+        }
+    }
+    cycle(shares) {
+        return this.points.reduce((sum, point, index) => sum + (shares[index] ?? 0) * point.cycle, 0);
+    }
+}
+/**
+ * Each point's share of a 1D blend at `value`: the two points around it,
+ * weighted linearly by where it falls between their thresholds; past either
+ * end, that end alone. `points` are in threshold order.
+ */
+export function blendShares(points, value) {
+    const shares = points.map(() => 0);
+    const last = points.length - 1;
+    const first = points[0];
+    const final = points[last];
+    if (!first || !final)
+        return shares;
+    if (value <= first.at)
+        shares[0] = 1;
+    else if (value >= final.at)
+        shares[last] = 1;
+    else {
+        const index = points.findIndex((point, i) => i < last && value < (points[i + 1]?.at ?? point.at));
+        const low = points[index]?.at ?? first.at;
+        const high = points[index + 1]?.at ?? low;
+        const t = high > low ? (value - low) / (high - low) : 1;
+        shares[index] = 1 - t;
+        shares[index + 1] = t;
+    }
+    return shares;
+}

package/dist/components/animator.d.ts

@@ -1,11 +1,16 @@
 import type { ClipTarget } from '../animation/clip-target.js';
 import { Component, type ComponentSpace } from '../component.js';
-/** Per-clip overrides, keyed by the glTF's clip name: a one-shot (`loop: false`) and a playback rate. */
+import { type AnimatorBlend } from './animator-blends.js';
+export type { AnimatorBlend, AnimatorBlendPoint } from './animator-blends.js';
+export { DEFAULT_BLEND_SMOOTHING } from './animator-blends.js';
+/** Per-clip overrides, keyed by the glTF's clip name: a one-shot (`loop: false`), a playback rate and a fade-in. */
 export interface AnimatorClipOverride {
     /** Defaults to true; false plays the clip once and holds its last pose. */
     loop?: boolean;
     /** Playback rate; 1 by default, 2 finishes in half the time. */
     speed?: number;
+    /** Seconds of fade into this clip (issue #205); without it, the Animator's `fade`. 0 cuts. */
+    fade?: number;
 }
 /** What `inspect_runtime` shows of an Animator. */
 export interface AnimatorState {
@@ -18,16 +23,23 @@ export interface AnimatorState {
     playing: boolean;
     /** The pose fingerprint of the rig (see poseHash); empty with no skeleton. */
     poseHash: string;
+    /** Each glb clip's effective weight, only those above 0, the ones fading out included (issue #205). */
+    weights: Record<string, number>;
+    /** The smoothed value of every parameter the blends read or `setParam` wrote. */
+    params: Record<string, number>;
 }
 /**
- * Plays the glTF clips of the Model beside it (issue #166, ADR 0029): the
- * 3D Clip Target. One AnimationMixer over the Model's own clone, one action
+ * Plays the glTF clips of the Model beside it (issue #166, ADR 0029; mixing,
+ * issue #205, ADR 0033): the 3D Clip Target. One AnimationMixer over the Model's own clone, one action
  * per clip, advanced by the Simulation Step in onUpdate — nothing runs per
  * render frame, so the pose is deterministic and visible step by step. A
  * StateMachine finds it like it finds an AnimatedSprite and plays the clip of
  * each state; `clip:end` fires when a `loop: false` clip finishes. A `play`
  * before the model loaded is remembered and applied when it settles;
- * otherwise `initialClip` plays then. In a 2D scene it creates nothing.
+ * otherwise `initialClip` plays then. A fade into a clip lasts its own
+ * `clips[name].fade` or `fade`, every sounding clip leaving from the weight
+ * it has; `blends` are virtual clips mixing several by a `setParam` value.
+ * In a 2D scene it creates nothing.
  */
 export declare class Animator extends Component implements ClipTarget {
     static componentName: string;
@@ -51,18 +63,30 @@ export declare class Animator extends Component implements ClipTarget {
     fade: number;
     /**
      * Per-clip overrides by glTF clip name (authored in JSON, like
-     * AnimatedSprite.clips). Read when the actions are built, as the model
-     * settles: a change after that applies on the next build (a Model rebuild).
+     * AnimatedSprite.clips). `loop` and `speed` are read when the actions are
+     * built, as the model settles, so a change after that applies on the next
+     * build (a Model rebuild); `fade` is read at every `play`.
      */
     clips: Record<string, AnimatorClipOverride>;
+    /**
+     * 1D blends by name (`AnimatorBlend`, authored in JSON like `clips`): each
+     * is a clip `play` accepts. Its `param` and `points` are read when the
+     * actions are built, as the model settles; its `smoothing` every step.
+     */
+    blends: Record<string, AnimatorBlend>;
     /** The clip playing now; undefined before the first play. */
     current: string | undefined;
     private mixer;
-    private readonly actions;
-    private active;
+    /** What `play` accepts, by name, for the current build: the file's clips, then the blends. */
+    private readonly sources;
+    /** The fades between them. */
+    private readonly mix;
+    /** The named parameters the blends read; they outlive a rebuild. */
+    private readonly params;
+    /** Each blend the current build made playable, by name, and the parameter it reads; null before a build. */
+    private built;
     /** A play asked for before the model loaded. */
     private requested;
-    private finished;
     private root;
     private readonly warned;
     private attached;
@@ -82,11 +106,61 @@ export declare class Animator extends Component implements ClipTarget {
      */
     get clipProgress(): number;
     onReady(): void;
-    /** Plays a clip: a no-op for the running one, a restart for a finished one, a crossfade from any other over `fade` seconds. */
+    /**
+     * Plays a clip: a no-op for the running one, a restart for a finished one,
+     * and from any other a fade over the clip's own `clips[name].fade`, else
+     * `fade` seconds, every sounding clip leaving from the weight it has (ADR 0033).
+     */
     play(name: string): void;
+    /**
+     * Aims a named parameter at `value`; the blends reading it follow, smoothed
+     * by the first blend that names it (once built, the first one the build made
+     * playable). Kept when made before the model loads;
+     * a value that is not a finite number is ignored with one warning.
+     */
+    setParam(name: string, value: number): void;
     onUpdate(dt: number): void;
+    /**
+     * One step of the parameters, the fades and the mixer while the Game does
+     * not simulate (issue #205): the editor's edit-mode preview of a blend
+     * drives the selected entity's Animator alone through it, once per frame,
+     * following its Model as onUpdate does. In Play it does nothing: onUpdate
+     * steps the Animator then.
+     */
+    previewStep(dt: number): void;
+    /**
+     * Ends an edit-mode preview (issue #205) as a freshly built stage starts:
+     * no parameter written, every clip stopped (three puts the rig back in the
+     * pose its file was built in) and `initialClip`, if any, asked for again
+     * from its start. In Play, or before the model loads, it does nothing.
+     */
+    previewReset(): void;
     onDestroy(): void;
     inspectState(): AnimatorState;
+    /** One step of the parameters, then of the fades, then of the mixer. */
+    private advance;
+    /** The smoothing of the first blend that reads `param`; none without one. */
+    private smoothingOf;
+    /** The parameters the blends read, in declaration order. */
+    private blendParams;
+    /**
+     * Each blend's name and the parameter it reads: once built, only the blends
+     * the build made playable (one it dropped decides nothing); before, every
+     * authored blend that names a parameter.
+     */
+    private blendReaders;
+    /** The authored blends by name; a `blends` that is not an object (JSON props arrive unchecked) warns once and counts as none. */
+    private authoredBlends;
+    /** The fade into `name`: its own `clips[name].fade` when that is a finite number ≥ 0, else `fade`. */
+    private fadeInto;
+    /**
+     * Keeps the mixer on the Model's current clone. A rebuilt Model (a new src
+     * or shape) draws a new clone: the mixer over the old one would animate a
+     * graph nobody draws, so it is torn down and the clip it was playing is
+     * asked for again on the new one. A Model listed after the Animator, which
+     * onReady could not see, is attached here.
+     */
+    private syncModel;
     /**
      * Takes the sibling Model's handle and builds the mixer when it settles. A
      * Model later in the component order is not there at onReady, so the first

package/dist/components/animator.js

@@ -2,16 +2,24 @@ import * as THREE from 'three/webgpu';
 import { poseHash } from '../animation/pose-hash.js';
 import { Component } from '../component.js';
 import { reportRejection } from '../report-rejection.js';
+import { blendReaders, blendSmoothing, blendsRecord, buildBlendSources } from './animator-blends.js';
+export { DEFAULT_BLEND_SMOOTHING } from './animator-blends.js';
+import { AnimatorMix } from './animator-mix.js';
+import { AnimatorParams } from './animator-params.js';
+import { ClipSource } from './animator-sources.js';
 import { Model } from './model.js';
 /**
- * Plays the glTF clips of the Model beside it (issue #166, ADR 0029): the
- * 3D Clip Target. One AnimationMixer over the Model's own clone, one action
+ * Plays the glTF clips of the Model beside it (issue #166, ADR 0029; mixing,
+ * issue #205, ADR 0033): the 3D Clip Target. One AnimationMixer over the Model's own clone, one action
  * per clip, advanced by the Simulation Step in onUpdate — nothing runs per
  * render frame, so the pose is deterministic and visible step by step. A
  * StateMachine finds it like it finds an AnimatedSprite and plays the clip of
  * each state; `clip:end` fires when a `loop: false` clip finishes. A `play`
  * before the model loaded is remembered and applied when it settles;
- * otherwise `initialClip` plays then. In a 2D scene it creates nothing.
+ * otherwise `initialClip` plays then. A fade into a clip lasts its own
+ * `clips[name].fade` or `fade`, every sounding clip leaving from the weight
+ * it has; `blends` are virtual clips mixing several by a `setParam` value.
+ * In a 2D scene it creates nothing.
  */
 export class Animator extends Component {
     static componentName = 'Animator';
@@ -21,25 +29,37 @@ export class Animator extends Component {
         initialClip: { label: 'Initial clip' },
         fade: { label: 'Fade (s)', min: 0, max: 1, step: 0.05 },
     };
-    static transient = ['current', 'mixer', 'actions', 'active', 'requested', 'finished', 'root', 'warned', 'attached', 'handle', 'names', 'pending'];
+    static transient = ['current', 'mixer', 'sources', 'mix', 'params', 'built', 'requested', 'root', 'warned', 'attached', 'handle', 'names', 'pending'];
     /** The clip that plays once the model settles, when nothing asked for one before. */
     initialClip = '';
     /** Crossfade between clips, in seconds; 0 cuts. */
     fade = 0.15;
     /**
      * Per-clip overrides by glTF clip name (authored in JSON, like
-     * AnimatedSprite.clips). Read when the actions are built, as the model
-     * settles: a change after that applies on the next build (a Model rebuild).
+     * AnimatedSprite.clips). `loop` and `speed` are read when the actions are
+     * built, as the model settles, so a change after that applies on the next
+     * build (a Model rebuild); `fade` is read at every `play`.
      */
     clips = {};
+    /**
+     * 1D blends by name (`AnimatorBlend`, authored in JSON like `clips`): each
+     * is a clip `play` accepts. Its `param` and `points` are read when the
+     * actions are built, as the model settles; its `smoothing` every step.
+     */
+    blends = {};
     /** The clip playing now; undefined before the first play. */
     current;
     mixer = null;
-    actions = new Map();
-    active = null;
+    /** What `play` accepts, by name, for the current build: the file's clips, then the blends. */
+    sources = new Map();
+    /** The fades between them. */
+    mix = new AnimatorMix();
+    /** The named parameters the blends read; they outlive a rebuild. */
+    params = new AnimatorParams();
+    /** Each blend the current build made playable, by name, and the parameter it reads; null before a build. */
+    built = null;
     /** A play asked for before the model loaded. */
     requested;
-    finished = false;
     root = null;
     warned = new Set();
     attached = false;
@@ -53,7 +73,7 @@ export class Animator extends Component {
         return this.names;
     }
     get clipFinished() {
-        return this.finished;
+        return this.mix.target?.finished ?? false;
     }
     get clipsPending() {
         return this.pending;
@@ -64,11 +84,7 @@ export class Animator extends Component {
      * loop starts over at 0. 0 while nothing plays.
      */
     get clipProgress() {
-        const action = this.active;
-        if (!action)
-            return 0;
-        const { duration } = action.getClip();
-        return duration > 0 ? Math.min(action.time / duration, 1) : 1;
+        return this.mix.target?.progress ?? 0;
     }
     onReady() {
         if (this.game.space !== '3d')
@@ -76,7 +92,11 @@ export class Animator extends Component {
         this.pending = true;
         this.attach();
     }
-    /** Plays a clip: a no-op for the running one, a restart for a finished one, a crossfade from any other over `fade` seconds. */
+    /**
+     * Plays a clip: a no-op for the running one, a restart for a finished one,
+     * and from any other a fade over the clip's own `clips[name].fade`, else
+     * `fade` seconds, every sounding clip leaving from the weight it has (ADR 0033).
+     */
     play(name) {
         if (this.game.space !== '3d')
             return;
@@ -84,50 +104,137 @@ export class Animator extends Component {
             this.requested = name;
             return;
         }
-        const action = this.actions.get(name);
-        if (!action) {
+        const source = this.sources.get(name);
+        if (!source) {
             this.warnOnce(name, `[waica] "${this.entity.name}": no clip "${name}"`);
             return;
         }
-        if (action === this.active && !this.finished)
+        if (source === this.mix.target && !source.finished)
             return;
-        const previous = this.active;
-        this.active = action;
         this.current = name;
-        this.finished = false;
-        action.reset().setEffectiveWeight(1).play();
-        if (!previous || previous === action)
+        this.mix.enter(source, this.fadeInto(name));
+    }
+    /**
+     * Aims a named parameter at `value`; the blends reading it follow, smoothed
+     * by the first blend that names it (once built, the first one the build made
+     * playable). Kept when made before the model loads;
+     * a value that is not a finite number is ignored with one warning.
+     */
+    setParam(name, value) {
+        if (this.game.space !== '3d')
+            return;
+        if (!Number.isFinite(value)) {
+            this.warnOnce(`param:${name}`, `[waica] "${this.entity.name}": setParam("${name}") needs a finite number; ignored`);
             return;
-        if (this.fade <= 0)
-            previous.stop();
-        else
-            previous.crossFadeTo(action, this.fade, false);
+        }
+        this.params.set(name, value, this.smoothingOf(name));
     }
     onUpdate(dt) {
         if (this.game.space !== '3d')
             return;
-        // A rebuilt Model (a new src or shape) draws a new clone: the mixer over
-        // the old one would animate a graph nobody draws, so it is torn down and
-        // the clip it was playing is asked for again on the new one.
-        if (this.attached && (this.entity.get(Model)?.handle ?? null) !== this.handle)
-            this.detach();
-        if (!this.attached)
-            this.attach(true);
-        this.mixer?.update(dt);
+        this.syncModel();
+        this.advance(dt);
+    }
+    /**
+     * One step of the parameters, the fades and the mixer while the Game does
+     * not simulate (issue #205): the editor's edit-mode preview of a blend
+     * drives the selected entity's Animator alone through it, once per frame,
+     * following its Model as onUpdate does. In Play it does nothing: onUpdate
+     * steps the Animator then.
+     */
+    previewStep(dt) {
+        if (this.game.simulate || this.game.space !== '3d')
+            return;
+        this.syncModel();
+        this.advance(dt);
+    }
+    /**
+     * Ends an edit-mode preview (issue #205) as a freshly built stage starts:
+     * no parameter written, every clip stopped (three puts the rig back in the
+     * pose its file was built in) and `initialClip`, if any, asked for again
+     * from its start. In Play, or before the model loads, it does nothing.
+     */
+    previewReset() {
+        if (this.game.simulate || this.game.space !== '3d' || !this.mixer)
+            return;
+        this.params.clear();
+        this.mix.clear();
+        this.current = undefined;
+        if (this.initialClip)
+            this.play(this.initialClip);
     }
     onDestroy() {
         this.release();
         this.pending = false;
     }
     inspectState() {
+        const target = this.mix.target;
         return {
             loaded: this.mixer !== null,
             current: this.current ?? null,
-            time: this.active?.time ?? 0,
-            playing: this.active !== null && this.active.isRunning(),
+            time: target?.time ?? 0,
+            playing: target?.playing ?? false,
             poseHash: this.root ? poseHash(this.root) : '',
+            weights: this.mix.weights(),
+            params: this.params.snapshot(this.blendParams()),
         };
     }
+    /** One step of the parameters, then of the fades, then of the mixer. */
+    advance(dt) {
+        this.params.step(dt, (name) => this.smoothingOf(name));
+        if (!this.mixer)
+            return;
+        this.mix.step(dt);
+        this.mixer.update(dt);
+    }
+    /** The smoothing of the first blend that reads `param`; none without one. */
+    smoothingOf(param) {
+        const reader = this.blendReaders().find(([, reads]) => reads === param);
+        return reader === undefined ? 0 : blendSmoothing(this.authoredBlends()[reader[0]]);
+    }
+    /** The parameters the blends read, in declaration order. */
+    blendParams() {
+        return [...new Set(this.blendReaders().map(([, param]) => param))];
+    }
+    /**
+     * Each blend's name and the parameter it reads: once built, only the blends
+     * the build made playable (one it dropped decides nothing); before, every
+     * authored blend that names a parameter.
+     */
+    blendReaders() {
+        return this.built ? [...this.built] : blendReaders(this.authoredBlends());
+    }
+    /** The authored blends by name; a `blends` that is not an object (JSON props arrive unchecked) warns once and counts as none. */
+    authoredBlends() {
+        const blends = blendsRecord(this.blends);
+        if (blends)
+            return blends;
+        this.warnOnce('blends', `[waica] "${this.entity.name}": blends must be an object of blends by name; none plays`);
+        return {};
+    }
+    /** The fade into `name`: its own `clips[name].fade` when that is a finite number ≥ 0, else `fade`. */
+    fadeInto(name) {
+        const own = this.clips[name]?.fade;
+        if (own === undefined)
+            return this.fade;
+        if (typeof own === 'number' && Number.isFinite(own) && own >= 0)
+            return own;
+        this.warnOnce(`fade:${name}`, `[waica] "${this.entity.name}": clips.${name}.fade must be a number of seconds ≥ 0; fading over ${this.fade}`);
+        return this.fade;
+    }
+    /**
+     * Keeps the mixer on the Model's current clone. A rebuilt Model (a new src
+     * or shape) draws a new clone: the mixer over the old one would animate a
+     * graph nobody draws, so it is torn down and the clip it was playing is
+     * asked for again on the new one. A Model listed after the Animator, which
+     * onReady could not see, is attached here.
+     */
+    syncModel() {
+        if (this.attached && (this.entity.get(Model)?.handle ?? null) !== this.handle)
+            this.detach();
+        if (!this.attached)
+            this.attach(true);
+    }
     /**
      * Takes the sibling Model's handle and builds the mixer when it settles. A
      * Model later in the component order is not there at onReady, so the first
@@ -162,14 +269,14 @@ export class Animator extends Component {
     }
     /** Stops and drops the mixer, its actions and the clone they ran over. */
     release() {
+        this.mix.clear();
         this.mixer?.stopAllAction();
         if (this.mixer && this.root)
             this.mixer.uncacheRoot(this.root);
         this.mixer = null;
-        this.active = null;
         this.current = undefined;
-        this.finished = false;
-        this.actions.clear();
+        this.sources.clear();
+        this.built = null;
         this.names = [];
         this.root = null;
         this.handle = null;
@@ -179,13 +286,22 @@ export class Animator extends Component {
         this.mixer = mixer;
         this.root = handle.root;
         for (const clip of handle.animations)
-            this.actions.set(clip.name, this.configure(mixer.clipAction(clip), clip.name));
-        this.names = [...this.actions.keys()];
-        this.pending = false;
-        mixer.addEventListener('finished', (event) => {
-            if (event.action === this.active)
-                this.finished = true;
+            this.sources.set(clip.name, new ClipSource(clip.name, this.configure(mixer.clipAction(clip), clip.name)));
+        const authored = this.authoredBlends();
+        const blends = buildBlendSources({
+            blends: authored,
+            clips: this.clips,
+            mixer,
+            animations: handle.animations,
+            value: (param) => this.params.value(param),
+            warn: (key, message) => this.warnOnce(key, `[waica] "${this.entity.name}": ${message}`),
         });
+        for (const blend of blends)
+            this.sources.set(blend.name, blend);
+        const playable = new Set(blends.map((blend) => blend.name));
+        this.built = new Map(blendReaders(authored).filter(([name]) => playable.has(name)));
+        this.names = [...this.sources.keys()];
+        this.pending = false;
         const first = this.requested ?? this.initialClip;
         this.requested = undefined;
         if (first)

package/dist/components/model.d.ts

@@ -34,6 +34,12 @@ export declare class Model extends Component {
             min: number;
             step: number;
         };
+        castShadows: {
+            label: string;
+        };
+        receiveShadows: {
+            label: string;
+        };
     };
     static transient: string[];
     /** What this Model draws, under the entity's node; null until it is ready. The Pointer ray-casts against it. */
@@ -49,6 +55,8 @@ export declare class Model extends Component {
     private _shape;
     private _color;
     private _size;
+    private _castShadows;
+    private _receiveShadows;
     private _primitive;
     /** A `waica:` uri or project path to a `.glb` / `.gltf`; empty draws the primitive `shape`. */
     get src(): string;
@@ -61,11 +69,19 @@ export declare class Model extends Component {
     /** Uniform scale of a primitive: the box side, sphere diameter or plane side in world units. */
     get size(): number;
     set size(value: number);
+    /** Whether this Model's meshes cast shadows; only false opts out. */
+    get castShadows(): boolean;
+    set castShadows(value: unknown);
+    /** Whether this Model's meshes receive shadows; only false opts out. */
+    get receiveShadows(): boolean;
+    set receiveShadows(value: unknown);
     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. */
+    /** Participation belongs to this Model's meshes, never their shared glTF resources. */
+    private applyShadowFlags;
+    /** Retire clone-local render state; shared glTF geometry/materials stay cache-owned. */
     private clear;
 }