@zephyr3d/scene 0.8.1 → 0.9.0

package/dist/animation/fixed_geometry_cache_track.js

@@ -0,0 +1,138 @@
+import { AnimationTrack } from './animationtrack.js';
+import { createGeometryCacheState, mixGeometryCacheBoundingBox, ensureGeometryCacheMeshBinding } from './geometry_cache_utils.js';
+
+class FixedGeometryCacheTrack extends AnimationTrack {
+    _times;
+    _frames;
+    _state;
+    _meshBindings;
+    constructor(times, frames, embedded){
+        super(embedded);
+        this._times = times ?? new Float32Array();
+        this._frames = frames ?? [];
+        this._state = this._frames.length > 0 ? createGeometryCacheState(this._frames[0]) : null;
+        this._meshBindings = new WeakMap();
+    }
+    get times() {
+        return this._times;
+    }
+    set times(value) {
+        this._times = value ?? new Float32Array();
+    }
+    get frames() {
+        return this._frames;
+    }
+    set frames(value) {
+        this._frames = value ?? [];
+        this._state = this._frames.length > 0 ? createGeometryCacheState(this._frames[0]) : null;
+    }
+    calculateState(_target, currentTime) {
+        if (this._frames.length === 0) {
+            throw new Error('FixedGeometryCacheTrack.calculateState(): no frames available');
+        }
+        if (this._frames.length === 1 || this._times.length <= 1) {
+            return this.copyFrameToState(this._frames[0]);
+        }
+        if (currentTime <= this._times[0]) {
+            return this.copyFrameToState(this._frames[0]);
+        }
+        const lastIndex = this._times.length - 1;
+        if (currentTime >= this._times[lastIndex]) {
+            return this.copyFrameToState(this._frames[lastIndex]);
+        }
+        let right = 1;
+        while(right < this._times.length && this._times[right] < currentTime){
+            right++;
+        }
+        const left = Math.max(0, right - 1);
+        const start = this._times[left];
+        const end = this._times[right];
+        const t = end > start ? (currentTime - start) / (end - start) : 0;
+        return this.interpolateFrames(this._frames[left], this._frames[right], t);
+    }
+    applyState(target, state) {
+        const mesh = target;
+        const binding = this.ensureMeshBinding(mesh, state);
+        binding.positionBuffer.bufferSubData(0, state.positions);
+        if (binding.normalBuffer && state.normals) {
+            binding.normalBuffer.bufferSubData(0, state.normals);
+        }
+        mesh.setAnimatedBoundingBox(state.boundingBox);
+    }
+    mixState(a, b, t) {
+        if (!this._state) {
+            throw new Error('FixedGeometryCacheTrack.mixState(): invalid state');
+        }
+        const positions = new Float32Array(a.positions.length);
+        for(let i = 0; i < positions.length; i++){
+            positions[i] = a.positions[i] + (b.positions[i] - a.positions[i]) * t;
+        }
+        let normals = null;
+        if (a.normals && b.normals && a.normals.length === b.normals.length) {
+            normals = new Float32Array(a.normals.length);
+            for(let i = 0; i < normals.length; i++){
+                normals[i] = a.normals[i] + (b.normals[i] - a.normals[i]) * t;
+            }
+        }
+        return {
+            positions,
+            normals,
+            boundingBox: mixGeometryCacheBoundingBox(a.boundingBox, b.boundingBox, t)
+        };
+    }
+    getBlendId() {
+        return 'fixed-geometry-cache';
+    }
+    getDuration() {
+        return this._times.length > 0 ? this._times[this._times.length - 1] : 0;
+    }
+    reset(target) {
+        if (this._frames.length > 0) {
+            this.applyState(target, this.copyFrameToState(this._frames[0]));
+        }
+    }
+    copyFrameToState(frame) {
+        if (!this._state) {
+            this._state = createGeometryCacheState(frame);
+        }
+        this._state.positions.set(frame.positions);
+        if (frame.normals) {
+            if (!this._state.normals || this._state.normals.length !== frame.normals.length) {
+                this._state.normals = new Float32Array(frame.normals.length);
+            }
+            this._state.normals.set(frame.normals);
+        } else {
+            this._state.normals = null;
+        }
+        this._state.boundingBox.minPoint.set(frame.boundingBox.minPoint);
+        this._state.boundingBox.maxPoint.set(frame.boundingBox.maxPoint);
+        return this._state;
+    }
+    interpolateFrames(a, b, t) {
+        if (!this._state) {
+            this._state = createGeometryCacheState(a);
+        }
+        for(let i = 0; i < this._state.positions.length; i++){
+            this._state.positions[i] = a.positions[i] + (b.positions[i] - a.positions[i]) * t;
+        }
+        if (a.normals && b.normals && a.normals.length === b.normals.length) {
+            if (!this._state.normals || this._state.normals.length !== a.normals.length) {
+                this._state.normals = new Float32Array(a.normals.length);
+            }
+            for(let i = 0; i < this._state.normals.length; i++){
+                this._state.normals[i] = a.normals[i] + (b.normals[i] - a.normals[i]) * t;
+            }
+        } else {
+            this._state.normals = null;
+        }
+        this._state.boundingBox.minPoint.setXYZ(a.boundingBox.minPoint.x + (b.boundingBox.minPoint.x - a.boundingBox.minPoint.x) * t, a.boundingBox.minPoint.y + (b.boundingBox.minPoint.y - a.boundingBox.minPoint.y) * t, a.boundingBox.minPoint.z + (b.boundingBox.minPoint.z - a.boundingBox.minPoint.z) * t);
+        this._state.boundingBox.maxPoint.setXYZ(a.boundingBox.maxPoint.x + (b.boundingBox.maxPoint.x - a.boundingBox.maxPoint.x) * t, a.boundingBox.maxPoint.y + (b.boundingBox.maxPoint.y - a.boundingBox.maxPoint.y) * t, a.boundingBox.maxPoint.z + (b.boundingBox.maxPoint.z - a.boundingBox.maxPoint.z) * t);
+        return this._state;
+    }
+    ensureMeshBinding(mesh, state) {
+        return ensureGeometryCacheMeshBinding(this._meshBindings, mesh, state, 'FixedGeometryCacheTrack.applyState()');
+    }
+}
+
+export { FixedGeometryCacheTrack };
+//# sourceMappingURL=fixed_geometry_cache_track.js.map

package/dist/animation/fixed_geometry_cache_track.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed_geometry_cache_track.js","sources":["../../src/animation/fixed_geometry_cache_track.ts"],"sourcesContent":["import { AnimationTrack } from './animationtrack';\r\nimport type { Mesh } from '../scene';\r\nimport type { Nullable } from '@zephyr3d/base';\r\nimport {\r\n  createGeometryCacheState,\r\n  ensureGeometryCacheMeshBinding,\r\n  mixGeometryCacheBoundingBox,\r\n  type GeometryCacheFrame,\r\n  type GeometryCacheMeshBinding,\r\n  type GeometryCacheState\r\n} from './geometry_cache_utils';\r\n\r\nexport type FixedGeometryCacheFrame = GeometryCacheFrame;\r\nexport type FixedGeometryCacheState = GeometryCacheState;\r\n\r\nexport class FixedGeometryCacheTrack extends AnimationTrack<FixedGeometryCacheState> {\r\n  private _times: Float32Array;\r\n  private _frames: FixedGeometryCacheFrame[];\r\n  private _state: Nullable<FixedGeometryCacheState>;\r\n  private readonly _meshBindings: WeakMap<Mesh, GeometryCacheMeshBinding>;\r\n\r\n  constructor(times?: Float32Array, frames?: FixedGeometryCacheFrame[], embedded?: boolean) {\r\n    super(embedded);\r\n    this._times = times ?? new Float32Array();\r\n    this._frames = frames ?? [];\r\n    this._state = this._frames.length > 0 ? createGeometryCacheState(this._frames[0]) : null;\r\n    this._meshBindings = new WeakMap();\r\n  }\r\n\r\n  get times() {\r\n    return this._times;\r\n  }\r\n\r\n  set times(value: Float32Array) {\r\n    this._times = value ?? new Float32Array();\r\n  }\r\n\r\n  get frames() {\r\n    return this._frames;\r\n  }\r\n\r\n  set frames(value: FixedGeometryCacheFrame[]) {\r\n    this._frames = value ?? [];\r\n    this._state = this._frames.length > 0 ? createGeometryCacheState(this._frames[0]) : null;\r\n  }\r\n\r\n  calculateState(_target: object, currentTime: number) {\r\n    if (this._frames.length === 0) {\r\n      throw new Error('FixedGeometryCacheTrack.calculateState(): no frames available');\r\n    }\r\n    if (this._frames.length === 1 || this._times.length <= 1) {\r\n      return this.copyFrameToState(this._frames[0]);\r\n    }\r\n    if (currentTime <= this._times[0]) {\r\n      return this.copyFrameToState(this._frames[0]);\r\n    }\r\n    const lastIndex = this._times.length - 1;\r\n    if (currentTime >= this._times[lastIndex]) {\r\n      return this.copyFrameToState(this._frames[lastIndex]);\r\n    }\r\n    let right = 1;\r\n    while (right < this._times.length && this._times[right] < currentTime) {\r\n      right++;\r\n    }\r\n    const left = Math.max(0, right - 1);\r\n    const start = this._times[left];\r\n    const end = this._times[right];\r\n    const t = end > start ? (currentTime - start) / (end - start) : 0;\r\n    return this.interpolateFrames(this._frames[left], this._frames[right], t);\r\n  }\r\n\r\n  applyState(target: object, state: FixedGeometryCacheState) {\r\n    const mesh = target as Mesh;\r\n    const binding = this.ensureMeshBinding(mesh, state);\r\n    binding.positionBuffer.bufferSubData(0, state.positions as unknown as Float32Array<ArrayBuffer>);\r\n    if (binding.normalBuffer && state.normals) {\r\n      binding.normalBuffer.bufferSubData(0, state.normals as unknown as Float32Array<ArrayBuffer>);\r\n    }\r\n    mesh.setAnimatedBoundingBox(state.boundingBox);\r\n  }\r\n\r\n  mixState(a: FixedGeometryCacheState, b: FixedGeometryCacheState, t: number) {\r\n    if (!this._state) {\r\n      throw new Error('FixedGeometryCacheTrack.mixState(): invalid state');\r\n    }\r\n    const positions = new Float32Array(a.positions.length);\r\n    for (let i = 0; i < positions.length; i++) {\r\n      positions[i] = a.positions[i] + (b.positions[i] - a.positions[i]) * t;\r\n    }\r\n    let normals: Nullable<Float32Array> = null;\r\n    if (a.normals && b.normals && a.normals.length === b.normals.length) {\r\n      normals = new Float32Array(a.normals.length);\r\n      for (let i = 0; i < normals.length; i++) {\r\n        normals[i] = a.normals[i] + (b.normals[i] - a.normals[i]) * t;\r\n      }\r\n    }\r\n    return {\r\n      positions,\r\n      normals,\r\n      boundingBox: mixGeometryCacheBoundingBox(a.boundingBox, b.boundingBox, t)\r\n    };\r\n  }\r\n\r\n  getBlendId() {\r\n    return 'fixed-geometry-cache';\r\n  }\r\n\r\n  getDuration() {\r\n    return this._times.length > 0 ? this._times[this._times.length - 1] : 0;\r\n  }\r\n\r\n  reset(target: object) {\r\n    if (this._frames.length > 0) {\r\n      this.applyState(target, this.copyFrameToState(this._frames[0]));\r\n    }\r\n  }\r\n\r\n  private copyFrameToState(frame: FixedGeometryCacheFrame) {\r\n    if (!this._state) {\r\n      this._state = createGeometryCacheState(frame);\r\n    }\r\n    this._state.positions.set(frame.positions);\r\n    if (frame.normals) {\r\n      if (!this._state.normals || this._state.normals.length !== frame.normals.length) {\r\n        this._state.normals = new Float32Array(frame.normals.length);\r\n      }\r\n      this._state.normals.set(frame.normals);\r\n    } else {\r\n      this._state.normals = null;\r\n    }\r\n    this._state.boundingBox.minPoint.set(frame.boundingBox.minPoint);\r\n    this._state.boundingBox.maxPoint.set(frame.boundingBox.maxPoint);\r\n    return this._state;\r\n  }\r\n\r\n  private interpolateFrames(a: FixedGeometryCacheFrame, b: FixedGeometryCacheFrame, t: number) {\r\n    if (!this._state) {\r\n      this._state = createGeometryCacheState(a);\r\n    }\r\n    for (let i = 0; i < this._state.positions.length; i++) {\r\n      this._state.positions[i] = a.positions[i] + (b.positions[i] - a.positions[i]) * t;\r\n    }\r\n    if (a.normals && b.normals && a.normals.length === b.normals.length) {\r\n      if (!this._state.normals || this._state.normals.length !== a.normals.length) {\r\n        this._state.normals = new Float32Array(a.normals.length);\r\n      }\r\n      for (let i = 0; i < this._state.normals.length; i++) {\r\n        this._state.normals[i] = a.normals[i] + (b.normals[i] - a.normals[i]) * t;\r\n      }\r\n    } else {\r\n      this._state.normals = null;\r\n    }\r\n    this._state.boundingBox.minPoint.setXYZ(\r\n      a.boundingBox.minPoint.x + (b.boundingBox.minPoint.x - a.boundingBox.minPoint.x) * t,\r\n      a.boundingBox.minPoint.y + (b.boundingBox.minPoint.y - a.boundingBox.minPoint.y) * t,\r\n      a.boundingBox.minPoint.z + (b.boundingBox.minPoint.z - a.boundingBox.minPoint.z) * t\r\n    );\r\n    this._state.boundingBox.maxPoint.setXYZ(\r\n      a.boundingBox.maxPoint.x + (b.boundingBox.maxPoint.x - a.boundingBox.maxPoint.x) * t,\r\n      a.boundingBox.maxPoint.y + (b.boundingBox.maxPoint.y - a.boundingBox.maxPoint.y) * t,\r\n      a.boundingBox.maxPoint.z + (b.boundingBox.maxPoint.z - a.boundingBox.maxPoint.z) * t\r\n    );\r\n    return this._state;\r\n  }\r\n\r\n  private ensureMeshBinding(mesh: Mesh, state: FixedGeometryCacheState) {\r\n    return ensureGeometryCacheMeshBinding(\r\n      this._meshBindings,\r\n      mesh,\r\n      state,\r\n      'FixedGeometryCacheTrack.applyState()'\r\n    );\r\n  }\r\n}\r\n"],"names":["FixedGeometryCacheTrack","AnimationTrack","_times","_frames","_state","_meshBindings","times","frames","embedded","Float32Array","length","createGeometryCacheState","WeakMap","value","calculateState","_target","currentTime","Error","copyFrameToState","lastIndex","right","left","Math","max","start","end","t","interpolateFrames","applyState","target","state","mesh","binding","ensureMeshBinding","positionBuffer","bufferSubData","positions","normalBuffer","normals","setAnimatedBoundingBox","boundingBox","mixState","a","b","i","mixGeometryCacheBoundingBox","getBlendId","getDuration","reset","frame","set","minPoint","maxPoint","setXYZ","x","y","z","ensureGeometryCacheMeshBinding"],"mappings":"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"}

package/dist/animation/geometry_cache_utils.js

@@ -0,0 +1,120 @@
+import { getEngine, getDevice } from '../app/api.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
+import { Vector3 } from '@zephyr3d/base';
+
+const geometryCacheMeshStates = new WeakMap();
+function createGeometryCacheState(frame) {
+    return {
+        positions: new Float32Array(frame.positions.length),
+        normals: frame.normals ? new Float32Array(frame.normals.length) : null,
+        boundingBox: new BoundingBox()
+    };
+}
+function mixGeometryCacheBoundingBox(a, b, t) {
+    return new BoundingBox(new Vector3(a.minPoint.x + (b.minPoint.x - a.minPoint.x) * t, a.minPoint.y + (b.minPoint.y - a.minPoint.y) * t, a.minPoint.z + (b.minPoint.z - a.minPoint.z) * t), new Vector3(a.maxPoint.x + (b.maxPoint.x - a.maxPoint.x) * t, a.maxPoint.y + (b.maxPoint.y - a.maxPoint.y) * t, a.maxPoint.z + (b.maxPoint.z - a.maxPoint.z) * t));
+}
+function ensureGeometryCacheMeshBinding(meshBindings, mesh, state, errorPrefix) {
+    let binding = meshBindings.get(mesh);
+    if (!binding) {
+        const primitive = mesh.primitive;
+        const meshState = geometryCacheMeshStates.get(mesh);
+        const originalPrimitive = meshState?.originalPrimitive ?? primitive;
+        if (!originalPrimitive) {
+            throw new Error(`${errorPrefix}: target mesh has no primitive`);
+        }
+        validateGeometryCacheState(originalPrimitive, state, errorPrefix);
+        const ensuredState = meshState ? ensureGeometryCacheNormalBuffer(meshState, originalPrimitive, state, errorPrefix) : createGeometryCacheMeshState(originalPrimitive, state);
+        geometryCacheMeshStates.set(mesh, ensuredState);
+        if (mesh.primitive !== ensuredState.cachePrimitive) {
+            mesh.primitive = ensuredState.cachePrimitive;
+        }
+        binding = {
+            originalPrimitive,
+            primitive: ensuredState.cachePrimitive,
+            positionBuffer: ensuredState.positionBuffer,
+            normalBuffer: ensuredState.normalBuffer
+        };
+        meshBindings.set(mesh, binding);
+    }
+    return binding;
+}
+async function restoreGeometryCacheMeshBinding(mesh) {
+    const meshState = geometryCacheMeshStates.get(mesh);
+    if (!meshState) {
+        return false;
+    }
+    const primitiveToRestore = await resolveOriginalPrimitive(meshState);
+    if (mesh.primitive === meshState.cachePrimitive) {
+        mesh.primitive = primitiveToRestore;
+    }
+    mesh.setAnimatedBoundingBox(null);
+    mesh.scene?.queueUpdateNode(mesh);
+    geometryCacheMeshStates.delete(mesh);
+    return true;
+}
+function validateGeometryCacheState(primitive, state, errorPrefix) {
+    const expectedPositionLength = primitive.getNumVertices() * 3;
+    if (state.positions.length !== expectedPositionLength) {
+        throw new Error(`${errorPrefix}: position count mismatch, expected ${expectedPositionLength}, got ${state.positions.length}`);
+    }
+    if (state.normals) {
+        const expectedNormalLength = primitive.getNumVertices() * 3;
+        if (state.normals.length !== expectedNormalLength) {
+            throw new Error(`${errorPrefix}: normal count mismatch, expected ${expectedNormalLength}, got ${state.normals.length}`);
+        }
+    }
+}
+function createGeometryCacheMeshState(originalPrimitive, state) {
+    const cachePrimitive = originalPrimitive.clone();
+    cachePrimitive.setBoundingVolume(originalPrimitive.getBoundingVolume());
+    const primitiveAssetId = getEngine().resourceManager.getAssetId(originalPrimitive);
+    if (primitiveAssetId) {
+        getEngine().resourceManager.setAssetId(cachePrimitive, primitiveAssetId);
+    }
+    cachePrimitive.removeVertexBuffer('position');
+    const positionBuffer = getDevice().createVertexBuffer('position_f32x3', state.positions, {
+        dynamic: true
+    });
+    cachePrimitive.setVertexBuffer(positionBuffer);
+    let normalBuffer = null;
+    if (state.normals) {
+        cachePrimitive.removeVertexBuffer('normal');
+        normalBuffer = getDevice().createVertexBuffer('normal_f32x3', state.normals, {
+            dynamic: true
+        });
+        cachePrimitive.setVertexBuffer(normalBuffer);
+    }
+    return {
+        originalPrimitive,
+        originalPrimitiveAssetId: primitiveAssetId ?? '',
+        cachePrimitive,
+        positionBuffer,
+        normalBuffer
+    };
+}
+function ensureGeometryCacheNormalBuffer(meshState, originalPrimitive, state, errorPrefix) {
+    if (state.normals && !meshState.normalBuffer) {
+        const expectedNormalLength = originalPrimitive.getNumVertices() * 3;
+        if (state.normals.length !== expectedNormalLength) {
+            throw new Error(`${errorPrefix}: normal count mismatch, expected ${expectedNormalLength}, got ${state.normals.length}`);
+        }
+        meshState.cachePrimitive.removeVertexBuffer('normal');
+        meshState.normalBuffer = getDevice().createVertexBuffer('normal_f32x3', state.normals, {
+            dynamic: true
+        });
+        meshState.cachePrimitive.setVertexBuffer(meshState.normalBuffer);
+    }
+    return meshState;
+}
+async function resolveOriginalPrimitive(meshState) {
+    if (meshState.originalPrimitiveAssetId) {
+        const restoredPrimitive = await getEngine().resourceManager.fetchPrimitive(meshState.originalPrimitiveAssetId);
+        if (restoredPrimitive) {
+            return restoredPrimitive;
+        }
+    }
+    return meshState.originalPrimitive;
+}
+
+export { createGeometryCacheState, ensureGeometryCacheMeshBinding, mixGeometryCacheBoundingBox, restoreGeometryCacheMeshBinding };
+//# sourceMappingURL=geometry_cache_utils.js.map

package/dist/animation/geometry_cache_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_cache_utils.js","sources":["../../src/animation/geometry_cache_utils.ts"],"sourcesContent":["import { getDevice, getEngine } from '../app/api';\r\nimport type { Mesh } from '../scene';\r\nimport type { Primitive } from '../render/primitive';\r\nimport { BoundingBox } from '../utility/bounding_volume';\r\nimport type { Nullable } from '@zephyr3d/base';\r\nimport { Vector3 } from '@zephyr3d/base';\r\nimport type { StructuredBuffer } from '@zephyr3d/device';\r\n\r\nexport type GeometryCacheFrame = {\r\n  positions: Float32Array;\r\n  normals?: Nullable<Float32Array>;\r\n  boundingBox: BoundingBox;\r\n};\r\n\r\nexport type GeometryCacheState = {\r\n  positions: Float32Array;\r\n  normals?: Nullable<Float32Array>;\r\n  boundingBox: BoundingBox;\r\n};\r\n\r\nexport type GeometryCacheMeshBinding = {\r\n  originalPrimitive: Primitive;\r\n  primitive: Primitive;\r\n  positionBuffer: StructuredBuffer;\r\n  normalBuffer: Nullable<StructuredBuffer>;\r\n};\r\n\r\ntype GeometryCacheMeshState = {\r\n  originalPrimitive: Primitive;\r\n  originalPrimitiveAssetId: string;\r\n  cachePrimitive: Primitive;\r\n  positionBuffer: StructuredBuffer;\r\n  normalBuffer: Nullable<StructuredBuffer>;\r\n};\r\n\r\nconst geometryCacheMeshStates = new WeakMap<Mesh, GeometryCacheMeshState>();\r\n\r\nexport function createGeometryCacheState(\r\n  frame: Pick<GeometryCacheFrame, 'positions' | 'normals'>\r\n): GeometryCacheState {\r\n  return {\r\n    positions: new Float32Array(frame.positions.length),\r\n    normals: frame.normals ? new Float32Array(frame.normals.length) : null,\r\n    boundingBox: new BoundingBox()\r\n  };\r\n}\r\n\r\nexport function mixGeometryCacheBoundingBox(a: BoundingBox, b: BoundingBox, t: number) {\r\n  return new BoundingBox(\r\n    new Vector3(\r\n      a.minPoint.x + (b.minPoint.x - a.minPoint.x) * t,\r\n      a.minPoint.y + (b.minPoint.y - a.minPoint.y) * t,\r\n      a.minPoint.z + (b.minPoint.z - a.minPoint.z) * t\r\n    ),\r\n    new Vector3(\r\n      a.maxPoint.x + (b.maxPoint.x - a.maxPoint.x) * t,\r\n      a.maxPoint.y + (b.maxPoint.y - a.maxPoint.y) * t,\r\n      a.maxPoint.z + (b.maxPoint.z - a.maxPoint.z) * t\r\n    )\r\n  );\r\n}\r\n\r\nexport function ensureGeometryCacheMeshBinding(\r\n  meshBindings: WeakMap<Mesh, GeometryCacheMeshBinding>,\r\n  mesh: Mesh,\r\n  state: GeometryCacheState,\r\n  errorPrefix: string\r\n) {\r\n  let binding = meshBindings.get(mesh);\r\n  if (!binding) {\r\n    const primitive = mesh.primitive;\r\n    const meshState = geometryCacheMeshStates.get(mesh);\r\n    const originalPrimitive = meshState?.originalPrimitive ?? primitive;\r\n    if (!originalPrimitive) {\r\n      throw new Error(`${errorPrefix}: target mesh has no primitive`);\r\n    }\r\n    validateGeometryCacheState(originalPrimitive, state, errorPrefix);\r\n    const ensuredState = meshState\r\n      ? ensureGeometryCacheNormalBuffer(meshState, originalPrimitive, state, errorPrefix)\r\n      : createGeometryCacheMeshState(originalPrimitive, state);\r\n    geometryCacheMeshStates.set(mesh, ensuredState);\r\n    if (mesh.primitive !== ensuredState.cachePrimitive) {\r\n      mesh.primitive = ensuredState.cachePrimitive;\r\n    }\r\n    binding = {\r\n      originalPrimitive,\r\n      primitive: ensuredState.cachePrimitive,\r\n      positionBuffer: ensuredState.positionBuffer,\r\n      normalBuffer: ensuredState.normalBuffer\r\n    };\r\n    meshBindings.set(mesh, binding);\r\n  }\r\n  return binding;\r\n}\r\n\r\nexport async function restoreGeometryCacheMeshBinding(mesh: Mesh) {\r\n  const meshState = geometryCacheMeshStates.get(mesh);\r\n  if (!meshState) {\r\n    return false;\r\n  }\r\n  const primitiveToRestore = await resolveOriginalPrimitive(meshState);\r\n  if (mesh.primitive === meshState.cachePrimitive) {\r\n    mesh.primitive = primitiveToRestore;\r\n  }\r\n  mesh.setAnimatedBoundingBox(null);\r\n  mesh.scene?.queueUpdateNode(mesh);\r\n  geometryCacheMeshStates.delete(mesh);\r\n  return true;\r\n}\r\n\r\nfunction validateGeometryCacheState(primitive: Primitive, state: GeometryCacheState, errorPrefix: string) {\r\n  const expectedPositionLength = primitive.getNumVertices() * 3;\r\n  if (state.positions.length !== expectedPositionLength) {\r\n    throw new Error(\r\n      `${errorPrefix}: position count mismatch, expected ${expectedPositionLength}, got ${state.positions.length}`\r\n    );\r\n  }\r\n  if (state.normals) {\r\n    const expectedNormalLength = primitive.getNumVertices() * 3;\r\n    if (state.normals.length !== expectedNormalLength) {\r\n      throw new Error(\r\n        `${errorPrefix}: normal count mismatch, expected ${expectedNormalLength}, got ${state.normals.length}`\r\n      );\r\n    }\r\n  }\r\n}\r\n\r\nfunction createGeometryCacheMeshState(\r\n  originalPrimitive: Primitive,\r\n  state: GeometryCacheState\r\n): GeometryCacheMeshState {\r\n  const cachePrimitive = originalPrimitive.clone();\r\n  cachePrimitive.setBoundingVolume(originalPrimitive.getBoundingVolume()!);\r\n  const primitiveAssetId = getEngine().resourceManager.getAssetId(originalPrimitive);\r\n  if (primitiveAssetId) {\r\n    getEngine().resourceManager.setAssetId(cachePrimitive, primitiveAssetId);\r\n  }\r\n  cachePrimitive.removeVertexBuffer('position');\r\n  const positionBuffer = getDevice().createVertexBuffer(\r\n    'position_f32x3',\r\n    state.positions as unknown as Float32Array<ArrayBuffer>,\r\n    {\r\n      dynamic: true\r\n    }\r\n  )!;\r\n  cachePrimitive.setVertexBuffer(positionBuffer);\r\n  let normalBuffer: Nullable<StructuredBuffer> = null;\r\n  if (state.normals) {\r\n    cachePrimitive.removeVertexBuffer('normal');\r\n    normalBuffer = getDevice().createVertexBuffer(\r\n      'normal_f32x3',\r\n      state.normals as unknown as Float32Array<ArrayBuffer>,\r\n      {\r\n        dynamic: true\r\n      }\r\n    )!;\r\n    cachePrimitive.setVertexBuffer(normalBuffer);\r\n  }\r\n  return {\r\n    originalPrimitive,\r\n    originalPrimitiveAssetId: primitiveAssetId ?? '',\r\n    cachePrimitive,\r\n    positionBuffer,\r\n    normalBuffer\r\n  };\r\n}\r\n\r\nfunction ensureGeometryCacheNormalBuffer(\r\n  meshState: GeometryCacheMeshState,\r\n  originalPrimitive: Primitive,\r\n  state: GeometryCacheState,\r\n  errorPrefix: string\r\n) {\r\n  if (state.normals && !meshState.normalBuffer) {\r\n    const expectedNormalLength = originalPrimitive.getNumVertices() * 3;\r\n    if (state.normals.length !== expectedNormalLength) {\r\n      throw new Error(\r\n        `${errorPrefix}: normal count mismatch, expected ${expectedNormalLength}, got ${state.normals.length}`\r\n      );\r\n    }\r\n    meshState.cachePrimitive.removeVertexBuffer('normal');\r\n    meshState.normalBuffer = getDevice().createVertexBuffer(\r\n      'normal_f32x3',\r\n      state.normals as unknown as Float32Array<ArrayBuffer>,\r\n      {\r\n        dynamic: true\r\n      }\r\n    )!;\r\n    meshState.cachePrimitive.setVertexBuffer(meshState.normalBuffer);\r\n  }\r\n  return meshState;\r\n}\r\n\r\nasync function resolveOriginalPrimitive(meshState: GeometryCacheMeshState) {\r\n  if (meshState.originalPrimitiveAssetId) {\r\n    const restoredPrimitive = await getEngine().resourceManager.fetchPrimitive(\r\n      meshState.originalPrimitiveAssetId\r\n    );\r\n    if (restoredPrimitive) {\r\n      return restoredPrimitive;\r\n    }\r\n  }\r\n  return meshState.originalPrimitive;\r\n}\r\n"],"names":["geometryCacheMeshStates","WeakMap","createGeometryCacheState","frame","positions","Float32Array","length","normals","boundingBox","BoundingBox","mixGeometryCacheBoundingBox","a","b","t","Vector3","minPoint","x","y","z","maxPoint","ensureGeometryCacheMeshBinding","meshBindings","mesh","state","errorPrefix","binding","get","primitive","meshState","originalPrimitive","Error","validateGeometryCacheState","ensuredState","ensureGeometryCacheNormalBuffer","createGeometryCacheMeshState","set","cachePrimitive","positionBuffer","normalBuffer","restoreGeometryCacheMeshBinding","primitiveToRestore","resolveOriginalPrimitive","setAnimatedBoundingBox","scene","queueUpdateNode","delete","expectedPositionLength","getNumVertices","expectedNormalLength","clone","setBoundingVolume","getBoundingVolume","primitiveAssetId","getEngine","resourceManager","getAssetId","setAssetId","removeVertexBuffer","getDevice","createVertexBuffer","dynamic","setVertexBuffer","originalPrimitiveAssetId","restoredPrimitive","fetchPrimitive"],"mappings":"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"}

package/dist/animation/ik_modifier.js

@@ -10,6 +10,7 @@ import { SkeletonModifier } from './skeleton_modifier.js';
  */ class IKModifier extends SkeletonModifier {
     _solver;
     _target;
+    _weight;
     /**
    * Create an IK post-processor.
    *
@@ -17,7 +18,8 @@ import { SkeletonModifier } from './skeleton_modifier.js';
    * @param target - Target position for the end effector
    * @param weight - Blend weight [0-1] (default: 1.0)
    */ constructor(solver, target, weight = 1.0){
-        super(weight);
+        super();
+        this._weight = weight;
         this._solver = solver;
         this._target = target.clone();
     }
@@ -55,6 +57,12 @@ import { SkeletonModifier } from './skeleton_modifier.js';
     // IK solvers typically don't need explicit reset
     // as they solve based on current joint positions
     }
+    _getWeight() {
+        return this._weight;
+    }
+    _setWeight(value) {
+        this._weight = Math.max(0, Math.min(1, value));
+    }
 }
 
 export { IKModifier };

package/dist/animation/ik_modifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"ik_modifier.js","sources":["../../src/animation/ik_modifier.ts"],"sourcesContent":["import { SkeletonModifier } from './skeleton_modifier';\r\nimport type { Skeleton } from './skeleton';\r\nimport type { IKSolver } from './ik/ik_solver';\r\nimport type { Vector3 } from '@zephyr3d/base';\r\n\r\n/**\r\n * Skeleton modifier for IK solvers.\r\n *\r\n * Integrates IK solving into the skeleton post-processing pipeline.\r\n * The IK solver is executed each frame and results are blended with the base animation.\r\n *\r\n * @public\r\n */\r\nexport class IKModifier<Solver extends IKSolver = IKSolver> extends SkeletonModifier {\r\n  private _solver: Solver;\r\n  private _target: Vector3;\r\n\r\n  /**\r\n   * Create an IK post-processor.\r\n   *\r\n   * @param solver - The IK solver to integrate\r\n   * @param target - Target position for the end effector\r\n   * @param weight - Blend weight [0-1] (default: 1.0)\r\n   */\r\n  constructor(solver: Solver, target: Vector3, weight: number = 1.0) {\r\n    super(weight);\r\n    this._solver = solver;\r\n    this._target = target.clone();\r\n  }\r\n\r\n  /**\r\n   * Get the IK solver.\r\n   */\r\n  get solver(): Solver {\r\n    return this._solver;\r\n  }\r\n\r\n  /**\r\n   * Get the current target position.\r\n   */\r\n  get target(): Vector3 {\r\n    return this._target.clone();\r\n  }\r\n\r\n  /**\r\n   * Set the target position for the end effector.\r\n   *\r\n   * @param target - New target position (will be cloned)\r\n   */\r\n  setTarget(target: Vector3): void {\r\n    this._target.set(target);\r\n  }\r\n\r\n  /**\r\n   * Apply IK solving to skeleton joints.\r\n   */\r\n  apply(_skeleton: Skeleton, _deltaTime: number): void {\r\n    if (!this._enabled || this._weight <= 0) {\r\n      return;\r\n    }\r\n\r\n    // Solve IK\r\n    this._solver.solve(this._target);\r\n\r\n    // Apply to nodes with blending\r\n    this._solver.applyToNodes(this._weight);\r\n  }\r\n\r\n  /**\r\n   * Reset the IK solver to initial state.\r\n   */\r\n  reset(): void {\r\n    // IK solvers typically don't need explicit reset\r\n    // as they solve based on current joint positions\r\n  }\r\n}\r\n"],"names":["IKModifier","SkeletonModifier","_solver","_target","solver","target","weight","clone","setTarget","set","apply","_skeleton","_deltaTime","_enabled","_weight","solve","applyToNodes","reset"],"mappings":";;AAKA;;;;;;;IAQO,MAAMA,UAAuDC,SAAAA,gBAAAA,CAAAA;IAC1DC,OAAgB;IAChBC,OAAiB;AAEzB;;;;;;AAMC,MACD,YAAYC,MAAc,EAAEC,MAAe,EAAEC,MAAAA,GAAiB,GAAG,CAAE;AACjE,QAAA,KAAK,CAACA,MAAAA,CAAAA;QACN,IAAI,CAACJ,OAAO,GAAGE,MAAAA;AACf,QAAA,IAAI,CAACD,OAAO,GAAGE,MAAAA,CAAOE,KAAK,EAAA;AAC7B;AAEA;;AAEC,MACD,IAAIH,MAAiB,GAAA;QACnB,OAAO,IAAI,CAACF,OAAO;AACrB;AAEA;;AAEC,MACD,IAAIG,MAAkB,GAAA;AACpB,QAAA,OAAO,IAAI,CAACF,OAAO,CAACI,KAAK,EAAA;AAC3B;AAEA;;;;MAKAC,SAAAA,CAAUH,MAAe,EAAQ;AAC/B,QAAA,IAAI,CAACF,OAAO,CAACM,GAAG,CAACJ,MAAAA,CAAAA;AACnB;AAEA;;AAEC,MACDK,KAAMC,CAAAA,SAAmB,EAAEC,UAAkB,EAAQ;QACnD,IAAI,CAAC,IAAI,CAACC,QAAQ,IAAI,IAAI,CAACC,OAAO,IAAI,CAAG,EAAA;AACvC,YAAA;AACF;;AAGA,QAAA,IAAI,CAACZ,OAAO,CAACa,KAAK,CAAC,IAAI,CAACZ,OAAO,CAAA;;AAG/B,QAAA,IAAI,CAACD,OAAO,CAACc,YAAY,CAAC,IAAI,CAACF,OAAO,CAAA;AACxC;AAEA;;AAEC,MACDG,KAAc,GAAA;;;AAGd;AACF;;;;"}
+{"version":3,"file":"ik_modifier.js","sources":["../../src/animation/ik_modifier.ts"],"sourcesContent":["import { SkeletonModifier } from './skeleton_modifier';\r\nimport type { Skeleton } from './skeleton';\r\nimport type { IKSolver } from './ik/ik_solver';\r\nimport type { Vector3 } from '@zephyr3d/base';\r\n\r\n/**\r\n * Skeleton modifier for IK solvers.\r\n *\r\n * Integrates IK solving into the skeleton post-processing pipeline.\r\n * The IK solver is executed each frame and results are blended with the base animation.\r\n *\r\n * @public\r\n */\r\nexport class IKModifier<Solver extends IKSolver = IKSolver> extends SkeletonModifier {\r\n  private _solver: Solver;\r\n  private _target: Vector3;\r\n  private _weight: number;\r\n\r\n  /**\r\n   * Create an IK post-processor.\r\n   *\r\n   * @param solver - The IK solver to integrate\r\n   * @param target - Target position for the end effector\r\n   * @param weight - Blend weight [0-1] (default: 1.0)\r\n   */\r\n  constructor(solver: Solver, target: Vector3, weight: number = 1.0) {\r\n    super();\r\n    this._weight = weight;\r\n    this._solver = solver;\r\n    this._target = target.clone();\r\n  }\r\n\r\n  /**\r\n   * Get the IK solver.\r\n   */\r\n  get solver(): Solver {\r\n    return this._solver;\r\n  }\r\n\r\n  /**\r\n   * Get the current target position.\r\n   */\r\n  get target(): Vector3 {\r\n    return this._target.clone();\r\n  }\r\n\r\n  /**\r\n   * Set the target position for the end effector.\r\n   *\r\n   * @param target - New target position (will be cloned)\r\n   */\r\n  setTarget(target: Vector3): void {\r\n    this._target.set(target);\r\n  }\r\n\r\n  /**\r\n   * Apply IK solving to skeleton joints.\r\n   */\r\n  apply(_skeleton: Skeleton, _deltaTime: number): void {\r\n    if (!this._enabled || this._weight <= 0) {\r\n      return;\r\n    }\r\n\r\n    // Solve IK\r\n    this._solver.solve(this._target);\r\n\r\n    // Apply to nodes with blending\r\n    this._solver.applyToNodes(this._weight);\r\n  }\r\n\r\n  /**\r\n   * Reset the IK solver to initial state.\r\n   */\r\n  reset(): void {\r\n    // IK solvers typically don't need explicit reset\r\n    // as they solve based on current joint positions\r\n  }\r\n\r\n  protected _getWeight(): number {\r\n    return this._weight;\r\n  }\r\n\r\n  protected _setWeight(value: number): void {\r\n    this._weight = Math.max(0, Math.min(1, value));\r\n  }\r\n}\r\n"],"names":["IKModifier","SkeletonModifier","_solver","_target","_weight","solver","target","weight","clone","setTarget","set","apply","_skeleton","_deltaTime","_enabled","solve","applyToNodes","reset","_getWeight","_setWeight","value","Math","max","min"],"mappings":";;AAKA;;;;;;;IAQO,MAAMA,UAAuDC,SAAAA,gBAAAA,CAAAA;IAC1DC,OAAgB;IAChBC,OAAiB;IACjBC,OAAgB;AAExB;;;;;;AAMC,MACD,YAAYC,MAAc,EAAEC,MAAe,EAAEC,MAAAA,GAAiB,GAAG,CAAE;QACjE,KAAK,EAAA;QACL,IAAI,CAACH,OAAO,GAAGG,MAAAA;QACf,IAAI,CAACL,OAAO,GAAGG,MAAAA;AACf,QAAA,IAAI,CAACF,OAAO,GAAGG,MAAAA,CAAOE,KAAK,EAAA;AAC7B;AAEA;;AAEC,MACD,IAAIH,MAAiB,GAAA;QACnB,OAAO,IAAI,CAACH,OAAO;AACrB;AAEA;;AAEC,MACD,IAAII,MAAkB,GAAA;AACpB,QAAA,OAAO,IAAI,CAACH,OAAO,CAACK,KAAK,EAAA;AAC3B;AAEA;;;;MAKAC,SAAAA,CAAUH,MAAe,EAAQ;AAC/B,QAAA,IAAI,CAACH,OAAO,CAACO,GAAG,CAACJ,MAAAA,CAAAA;AACnB;AAEA;;AAEC,MACDK,KAAMC,CAAAA,SAAmB,EAAEC,UAAkB,EAAQ;QACnD,IAAI,CAAC,IAAI,CAACC,QAAQ,IAAI,IAAI,CAACV,OAAO,IAAI,CAAG,EAAA;AACvC,YAAA;AACF;;AAGA,QAAA,IAAI,CAACF,OAAO,CAACa,KAAK,CAAC,IAAI,CAACZ,OAAO,CAAA;;AAG/B,QAAA,IAAI,CAACD,OAAO,CAACc,YAAY,CAAC,IAAI,CAACZ,OAAO,CAAA;AACxC;AAEA;;AAEC,MACDa,KAAc,GAAA;;;AAGd;IAEUC,UAAqB,GAAA;QAC7B,OAAO,IAAI,CAACd,OAAO;AACrB;AAEUe,IAAAA,UAAAA,CAAWC,KAAa,EAAQ;QACxC,IAAI,CAAChB,OAAO,GAAGiB,IAAKC,CAAAA,GAAG,CAAC,CAAGD,EAAAA,IAAAA,CAAKE,GAAG,CAAC,CAAGH,EAAAA,KAAAA,CAAAA,CAAAA;AACzC;AACF;;;;"}