@haiyue/extensions 0.1.0

package/dist/chunks/GltfAnimationRuntime-CRHsLycN.js

@@ -0,0 +1,631 @@
+import { Transform3D } from '@haiyue/engine/components';
+import { mat4 } from 'wgpu-matrix';
+import { EngineError, EngineErrorCode } from '@haiyue/engine';
+import { ErrorRecovery, ErrorDomain } from '@haiyue/engine/core';
+import { createAbortError } from '@haiyue/engine/experimental/async';
+
+function throwIfGltfLoadAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw createAbortError('glTF load aborted.', signal.reason);
+}
+function attachGltfSource(error, src) {
+    if (error instanceof Error && error.name === 'AbortError')
+        return error;
+    if (error instanceof EngineError) {
+        return new EngineError(error.code, error.message, {
+            domain: error.domain,
+            recoverable: error.recoverable,
+            recovery: error.recovery,
+            context: { url: src, resourceType: 'model/gltf', ...error.context },
+            ...(error.path === undefined ? {} : { path: error.path }),
+            ...(error.hint === undefined ? {} : { hint: error.hint }),
+            ...(error.docsPath === undefined ? {} : { docsPath: error.docsPath }),
+            cause: error,
+        });
+    }
+    return gltfDataError(error instanceof Error ? error.message : String(error), { url: src }, undefined, error);
+}
+function gltfDataError(message, context = {}, path, cause) {
+    const accessor = /[Aa]ccessor\s+(\d+)/.exec(message)?.[1];
+    const bufferView = /bufferView\s+(\d+)/i.exec(message)?.[1];
+    const buffer = /buffer\s+(\d+)/i.exec(message)?.[1];
+    const failedLoad = /^Failed to load/.test(message);
+    const resolvedPath = path
+        ?? (accessor === undefined ? undefined : `gltf.accessors[${accessor}]`)
+        ?? (bufferView === undefined ? undefined : `gltf.bufferViews[${bufferView}]`)
+        ?? (buffer === undefined ? undefined : `gltf.buffers[${buffer}]`)
+        ?? 'gltf';
+    return new EngineError(failedLoad ? EngineErrorCode.AssetLoadFailed : EngineErrorCode.AssetInvalidData, message, {
+        domain: ErrorDomain.Component,
+        recovery: failedLoad ? ErrorRecovery.Retry : ErrorRecovery.ReleaseResource,
+        context: {
+            resourceType: 'model/gltf',
+            ...context,
+            ...(accessor === undefined ? {} : { accessor: Number(accessor) }),
+            ...(bufferView === undefined ? {} : { bufferView: Number(bufferView) }),
+            ...(buffer === undefined ? {} : { buffer: Number(buffer) }),
+        },
+        path: resolvedPath,
+        cause,
+    });
+}
+
+const COMPONENT_BYTE_SIZE = {
+    5120: 1,
+    5121: 1,
+    5122: 2,
+    5123: 2,
+    5125: 4,
+    5126: 4,
+};
+const TYPE_SIZE = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16,
+};
+function readAccessorFloat(gltf, buffers, accessorIndex, expectedSize) {
+    const accessor = getAccessor(gltf, accessorIndex);
+    const itemSize = TYPE_SIZE[accessor.type];
+    if (itemSize < expectedSize)
+        throw gltfDataError(`Accessor ${accessorIndex} has ${itemSize} components, expected ${expectedSize}.`);
+    const out = new Float32Array(accessor.count * expectedSize);
+    readAccessorValues(gltf, buffers, accessor, (values, index) => {
+        for (let i = 0; i < expectedSize; i++)
+            out[index * expectedSize + i] = values[i] ?? 0;
+    });
+    return out;
+}
+function readAccessorMat4(gltf, buffers, accessorIndex) {
+    const accessor = getAccessor(gltf, accessorIndex);
+    if (TYPE_SIZE[accessor.type] !== 16)
+        throw gltfDataError(`Accessor ${accessorIndex} is not MAT4.`);
+    const out = [];
+    readAccessorValues(gltf, buffers, accessor, values => {
+        const matrix = new Float32Array(16);
+        for (let i = 0; i < 16; i++)
+            matrix[i] = values[i] ?? 0;
+        out.push(matrix);
+    });
+    return out;
+}
+function readAccessorUnsigned(gltf, buffers, accessorIndex, expectedSize) {
+    const accessor = getAccessor(gltf, accessorIndex);
+    const itemSize = TYPE_SIZE[accessor.type];
+    if (itemSize < expectedSize)
+        throw gltfDataError(`Accessor ${accessorIndex} has ${itemSize} components, expected ${expectedSize}.`);
+    const out = accessor.componentType === 5125
+        ? new Uint32Array(accessor.count * expectedSize)
+        : new Uint16Array(accessor.count * expectedSize);
+    readAccessorValues(gltf, buffers, accessor, (values, index) => {
+        for (let i = 0; i < expectedSize; i++)
+            out[index * expectedSize + i] = values[i] ?? 0;
+    });
+    return out;
+}
+function readAccessorIndices(gltf, buffers, accessorIndex) {
+    const accessor = getAccessor(gltf, accessorIndex);
+    const out = accessor.componentType === 5125 ? new Uint32Array(accessor.count) : new Uint16Array(accessor.count);
+    readAccessorValues(gltf, buffers, accessor, (values, index) => {
+        out[index] = values[0] ?? 0;
+    });
+    return out;
+}
+function generateFlatNormals(positions, indices) {
+    const normals = new Float32Array(positions.length);
+    const triangleCount = indices ? indices.length / 3 : positions.length / 9;
+    for (let tri = 0; tri < triangleCount; tri++) {
+        const ia = indices ? indices[tri * 3] : tri * 3;
+        const ib = indices ? indices[tri * 3 + 1] : tri * 3 + 1;
+        const ic = indices ? indices[tri * 3 + 2] : tri * 3 + 2;
+        if (ia === undefined || ib === undefined || ic === undefined)
+            continue;
+        const ax = requiredFiniteArrayValue(positions, ia * 3, 'POSITION');
+        const ay = requiredFiniteArrayValue(positions, ia * 3 + 1, 'POSITION');
+        const az = requiredFiniteArrayValue(positions, ia * 3 + 2, 'POSITION');
+        const bx = requiredFiniteArrayValue(positions, ib * 3, 'POSITION');
+        const by = requiredFiniteArrayValue(positions, ib * 3 + 1, 'POSITION');
+        const bz = requiredFiniteArrayValue(positions, ib * 3 + 2, 'POSITION');
+        const cx = requiredFiniteArrayValue(positions, ic * 3, 'POSITION');
+        const cy = requiredFiniteArrayValue(positions, ic * 3 + 1, 'POSITION');
+        const cz = requiredFiniteArrayValue(positions, ic * 3 + 2, 'POSITION');
+        const abx = bx - ax, aby = by - ay, abz = bz - az;
+        const acx = cx - ax, acy = cy - ay, acz = cz - az;
+        const nx = aby * acz - abz * acy;
+        const ny = abz * acx - abx * acz;
+        const nz = abx * acy - aby * acx;
+        const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+        const nnx = nx / len;
+        const nny = ny / len;
+        const nnz = nz / len;
+        addNormal(normals, ia, nnx, nny, nnz);
+        addNormal(normals, ib, nnx, nny, nnz);
+        addNormal(normals, ic, nnx, nny, nnz);
+    }
+    for (let i = 0; i < normals.length; i += 3) {
+        const nx = requiredFiniteArrayValue(normals, i, 'generated normals');
+        const ny = requiredFiniteArrayValue(normals, i + 1, 'generated normals');
+        const nz = requiredFiniteArrayValue(normals, i + 2, 'generated normals');
+        const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+        normals[i] = nx / len;
+        normals[i + 1] = ny / len;
+        normals[i + 2] = nz / len;
+    }
+    return normals;
+}
+function readAccessorValues(gltf, buffers, accessor, write) {
+    const itemSize = TYPE_SIZE[accessor.type];
+    const componentSize = COMPONENT_BYTE_SIZE[accessor.componentType];
+    const values = new Float64Array(itemSize);
+    if (accessor.bufferView !== undefined) {
+        const view = getBufferView(gltf, accessor.bufferView);
+        const dataView = new DataView(getBuffer(buffers, view.buffer));
+        const stride = view.byteStride ?? itemSize * componentSize;
+        const start = (view.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+        for (let index = 0; index < accessor.count; index++) {
+            readAccessorTuple(dataView, start + index * stride, itemSize, componentSize, accessor.componentType, Boolean(accessor.normalized), values);
+            write(values, index);
+        }
+    }
+    else {
+        values.fill(0);
+        for (let index = 0; index < accessor.count; index++)
+            write(values, index);
+    }
+    if (accessor.sparse?.count)
+        readSparseAccessorValues(gltf, buffers, accessor, values, write);
+}
+function readSparseAccessorValues(gltf, buffers, accessor, values, write) {
+    const sparse = accessor.sparse;
+    if (!sparse)
+        return;
+    const itemSize = TYPE_SIZE[accessor.type];
+    const componentSize = COMPONENT_BYTE_SIZE[accessor.componentType];
+    const indexComponentSize = COMPONENT_BYTE_SIZE[sparse.indices.componentType];
+    const indicesView = getBufferView(gltf, sparse.indices.bufferView);
+    const valuesView = getBufferView(gltf, sparse.values.bufferView);
+    const indicesData = new DataView(getBuffer(buffers, indicesView.buffer));
+    const valuesData = new DataView(getBuffer(buffers, valuesView.buffer));
+    const indicesStart = (indicesView.byteOffset ?? 0) + (sparse.indices.byteOffset ?? 0);
+    const valuesStart = (valuesView.byteOffset ?? 0) + (sparse.values.byteOffset ?? 0);
+    for (let sparseIndex = 0; sparseIndex < sparse.count; sparseIndex++) {
+        const index = readSparseIndex(indicesData, indicesStart + sparseIndex * indexComponentSize, sparse.indices.componentType);
+        if (index < 0 || index >= accessor.count)
+            throw gltfDataError(`Sparse accessor index ${index} is out of bounds.`);
+        readAccessorTuple(valuesData, valuesStart + sparseIndex * itemSize * componentSize, itemSize, componentSize, accessor.componentType, Boolean(accessor.normalized), values);
+        write(values, index);
+    }
+}
+function readAccessorTuple(dataView, offset, itemSize, componentSize, componentType, normalized, out) {
+    for (let component = 0; component < itemSize; component++) {
+        out[component] = readComponent(dataView, offset + component * componentSize, componentType, normalized);
+    }
+}
+function readSparseIndex(view, offset, componentType) {
+    switch (componentType) {
+        case 5121: return view.getUint8(offset);
+        case 5123: return view.getUint16(offset, true);
+        case 5125: return view.getUint32(offset, true);
+    }
+}
+function getBufferView(gltf, bufferViewIndex) {
+    const view = gltf.bufferViews?.[bufferViewIndex];
+    if (!view)
+        throw gltfDataError(`Missing bufferView ${bufferViewIndex}.`);
+    return view;
+}
+function getBuffer(buffers, bufferIndex) {
+    const buffer = buffers[bufferIndex];
+    if (!buffer)
+        throw gltfDataError(`Missing buffer ${bufferIndex}.`);
+    return buffer;
+}
+function getAccessor(gltf, accessorIndex) {
+    const accessor = gltf.accessors?.[accessorIndex];
+    if (!accessor)
+        throw gltfDataError(`Missing accessor ${accessorIndex}.`);
+    return accessor;
+}
+function readComponent(view, offset, componentType, normalized) {
+    switch (componentType) {
+        case 5120: {
+            const value = view.getInt8(offset);
+            return normalized ? Math.max(value / 127, -1) : value;
+        }
+        case 5121: {
+            const value = view.getUint8(offset);
+            return normalized ? value / 255 : value;
+        }
+        case 5122: {
+            const value = view.getInt16(offset, true);
+            return normalized ? Math.max(value / 32767, -1) : value;
+        }
+        case 5123: {
+            const value = view.getUint16(offset, true);
+            return normalized ? value / 65535 : value;
+        }
+        case 5125: return view.getUint32(offset, true);
+        case 5126: return view.getFloat32(offset, true);
+    }
+}
+function addNormal(normals, index, x, y, z) {
+    const offset = index * 3;
+    if (offset < 0 || offset + 2 >= normals.length) {
+        throw gltfDataError(`Triangle index ${index} is outside the POSITION accessor.`);
+    }
+    normals[offset] = (normals[offset] ?? 0) + x;
+    normals[offset + 1] = (normals[offset + 1] ?? 0) + y;
+    normals[offset + 2] = (normals[offset + 2] ?? 0) + z;
+}
+function requiredFiniteArrayValue(values, index, label) {
+    const value = values[index];
+    if (value === undefined || !Number.isFinite(value)) {
+        throw gltfDataError(`${label} is missing a finite value at index ${index}.`);
+    }
+    return value;
+}
+
+const conservativeBoundsByGeometry = new WeakMap();
+function registerGltfConservativeBounds(geometry, bounds) {
+    conservativeBoundsByGeometry.set(geometry, bounds);
+}
+function createAnimationClips(gltf, buffers, targets, skinnedPrimitives) {
+    return (gltf.animations ?? []).map((animation, index) => {
+        const channels = [];
+        let duration = 0;
+        for (const channel of animation.channels ?? []) {
+            const sampler = animation.samplers?.[channel.sampler];
+            const nodeIndex = channel.target.node;
+            const path = channel.target.path;
+            if (!sampler || nodeIndex === undefined || !isAnimationPath(path))
+                continue;
+            const target = targets.get(nodeIndex);
+            if (!target)
+                continue;
+            const input = readAccessorFloat(gltf, buffers, sampler.input, 1);
+            const outputSize = path === 'weights' ? Math.max(target.weights.length, target.morphPrimitives[0]?.positionTargets.length ?? 0, 1) : path === 'rotation' ? 4 : 3;
+            const output = path === 'weights'
+                ? readAccessorFloat(gltf, buffers, sampler.output, 1)
+                : readAccessorFloat(gltf, buffers, sampler.output, outputSize);
+            duration = Math.max(duration, input[input.length - 1] ?? 0);
+            channels.push({
+                target,
+                path,
+                interpolation: sampler.interpolation ?? 'LINEAR',
+                valueSize: outputSize,
+                input,
+                output,
+                sampleA: new Float32Array(outputSize),
+                sampleB: new Float32Array(outputSize),
+                sampleOut: new Float32Array(outputSize),
+                quatScratch: new Float32Array(4),
+            });
+        }
+        return {
+            name: animation.name || `Animation ${index + 1}`,
+            duration,
+            channels,
+            skinnedPrimitives,
+            stateCache: new Map(),
+            activeStates: [],
+        };
+    });
+}
+function isAnimationPath(path) {
+    return path === 'translation' || path === 'rotation' || path === 'scale' || path === 'weights';
+}
+function applyGltfAnimationClip(clip, time) {
+    if (clip.duration <= 0)
+        return;
+    const localTime = ((time % clip.duration) + clip.duration) % clip.duration;
+    const states = clip.stateCache;
+    const activeStates = clip.activeStates;
+    activeStates.length = 0;
+    for (const channel of clip.channels) {
+        const value = sampleAnimationChannel(channel, localTime, channel.sampleOut);
+        if (channel.path === 'weights') {
+            applyMorphWeights(channel.target, value);
+            continue;
+        }
+        let state = states.get(channel.target);
+        if (!state) {
+            state = {
+                target: channel.target,
+                translation: new Float32Array(3),
+                rotation: new Float32Array(4),
+                scale: new Float32Array(3),
+                matrix: new Float32Array(16),
+                active: false,
+            };
+            states.set(channel.target, state);
+        }
+        if (!state.active) {
+            state.translation.set(channel.target.translation);
+            state.rotation.set(channel.target.rotation);
+            state.scale.set(channel.target.scale);
+            state.active = true;
+            activeStates.push(state);
+        }
+        if (channel.path === 'translation')
+            copyComponents(value, state.translation, 3);
+        else if (channel.path === 'scale')
+            copyComponents(value, state.scale, 3);
+        else
+            normalizeQuat(value, state.rotation);
+    }
+    for (const state of activeStates) {
+        state.target.transform.localMatrix = composeTrsMatrix(state.translation, state.rotation, state.scale, state.matrix);
+        state.active = false;
+    }
+    for (const skinnedPrimitive of clip.skinnedPrimitives) {
+        updateSkinnedPrimitive(skinnedPrimitive);
+    }
+}
+function sampleAnimationChannel(channel, time, out) {
+    const times = channel.input;
+    const count = times.length;
+    const componentCount = channel.valueSize;
+    if (count === 0) {
+        fillDefaultAnimationValue(out, componentCount);
+        return out;
+    }
+    const firstTime = requiredFiniteArrayValue(times, 0, 'animation input');
+    const lastTime = requiredFiniteArrayValue(times, count - 1, 'animation input');
+    if (time <= firstTime)
+        return readAnimationValue(channel, 0, componentCount, out);
+    if (time >= lastTime)
+        return readAnimationValue(channel, count - 1, componentCount, out);
+    let frame = 0;
+    while (frame + 1 < count && requiredFiniteArrayValue(times, frame + 1, 'animation input') < time)
+        frame++;
+    const t0 = requiredFiniteArrayValue(times, frame, 'animation input');
+    const t1 = requiredFiniteArrayValue(times, frame + 1, 'animation input');
+    const alpha = channel.interpolation === 'STEP' ? 0 : (time - t0) / Math.max(0.000001, t1 - t0);
+    const a = readAnimationValue(channel, frame, componentCount, channel.sampleA);
+    if (channel.interpolation === 'STEP') {
+        copyComponents(a, out, componentCount);
+        return out;
+    }
+    const b = readAnimationValue(channel, frame + 1, componentCount, channel.sampleB);
+    if (channel.path === 'rotation')
+        return slerpQuat(a, b, alpha, out, channel.quatScratch);
+    return lerpArray(a, b, alpha, out, componentCount);
+}
+function readAnimationValue(channel, frame, componentCount, out) {
+    const cubic = channel.interpolation === 'CUBICSPLINE';
+    const stride = cubic ? componentCount * 3 : componentCount;
+    const offset = frame * stride + (cubic ? componentCount : 0);
+    for (let i = 0; i < componentCount; i++)
+        out[i] = channel.output[offset + i] ?? (i === 3 ? 1 : 0);
+    return out;
+}
+function fillDefaultAnimationValue(out, componentCount) {
+    for (let i = 0; i < componentCount; i++)
+        out[i] = i === 3 ? 1 : 0;
+}
+function copyComponents(source, target, count) {
+    for (let i = 0; i < count; i++)
+        target[i] = source[i] ?? 0;
+}
+function lerpArray(a, b, alpha, out, componentCount) {
+    for (let i = 0; i < componentCount; i++) {
+        const value = a[i] ?? 0;
+        out[i] = value + ((b[i] ?? value) - value) * alpha;
+    }
+    return out;
+}
+function normalizeQuat(q, out) {
+    const qx = q[0] ?? 0;
+    const qy = q[1] ?? 0;
+    const qz = q[2] ?? 0;
+    const qw = q[3] ?? 1;
+    const len = Math.hypot(qx, qy, qz, qw) || 1;
+    out[0] = qx / len;
+    out[1] = qy / len;
+    out[2] = qz / len;
+    out[3] = qw / len;
+    return out;
+}
+function slerpQuat(aRaw, bRaw, alpha, out, scratch) {
+    const a = normalizeQuat(aRaw, out);
+    const b = normalizeQuat(bRaw, scratch);
+    let bx = b[0] ?? 0;
+    let by = b[1] ?? 0;
+    let bz = b[2] ?? 0;
+    let bw = b[3] ?? 1;
+    const ax = a[0] ?? 0;
+    const ay = a[1] ?? 0;
+    const az = a[2] ?? 0;
+    const aw = a[3] ?? 1;
+    let dot = ax * bx + ay * by + az * bz + aw * bw;
+    if (dot < 0) {
+        dot = -dot;
+        bx = -bx;
+        by = -by;
+        bz = -bz;
+        bw = -bw;
+    }
+    if (dot > 0.9995) {
+        out[0] = ax + (bx - ax) * alpha;
+        out[1] = ay + (by - ay) * alpha;
+        out[2] = az + (bz - az) * alpha;
+        out[3] = aw + (bw - aw) * alpha;
+        return normalizeQuat(out, out);
+    }
+    const theta0 = Math.acos(Math.min(1, Math.max(-1, dot)));
+    const sinTheta0 = Math.sin(theta0);
+    const theta = theta0 * alpha;
+    const sinTheta = Math.sin(theta);
+    const s0 = Math.cos(theta) - dot * sinTheta / sinTheta0;
+    const s1 = sinTheta / sinTheta0;
+    out[0] = ax * s0 + bx * s1;
+    out[1] = ay * s0 + by * s1;
+    out[2] = az * s0 + bz * s1;
+    out[3] = aw * s0 + bw * s1;
+    return normalizeQuat(out, out);
+}
+function composeTrsMatrix(translation, rotation, scale, out = new Float32Array(16)) {
+    const rx = rotation[0] ?? 0;
+    const ry = rotation[1] ?? 0;
+    const rz = rotation[2] ?? 0;
+    const rw = rotation[3] ?? 1;
+    const len = Math.hypot(rx, ry, rz, rw) || 1;
+    const x = rx / len;
+    const y = ry / len;
+    const z = rz / len;
+    const w = rw / len;
+    const sx = scale[0] ?? 1;
+    const sy = scale[1] ?? 1;
+    const sz = scale[2] ?? 1;
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+    const xx = x * x2;
+    const xy = x * y2;
+    const xz = x * z2;
+    const yy = y * y2;
+    const yz = y * z2;
+    const zz = z * z2;
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+    out[0] = (1 - (yy + zz)) * sx;
+    out[1] = (xy + wz) * sx;
+    out[2] = (xz - wy) * sx;
+    out[3] = 0;
+    out[4] = (xy - wz) * sy;
+    out[5] = (1 - (xx + zz)) * sy;
+    out[6] = (yz + wx) * sy;
+    out[7] = 0;
+    out[8] = (xz + wy) * sz;
+    out[9] = (yz - wx) * sz;
+    out[10] = (1 - (xx + yy)) * sz;
+    out[11] = 0;
+    out[12] = translation[0] ?? 0;
+    out[13] = translation[1] ?? 0;
+    out[14] = translation[2] ?? 0;
+    out[15] = 1;
+    return out;
+}
+function applyMorphWeights(target, weights) {
+    if (target.morphPrimitives.length === 0)
+        return;
+    target.weights.length = weights.length;
+    for (let i = 0; i < weights.length; i++)
+        target.weights[i] = weights[i] ?? 0;
+    for (const morph of target.morphPrimitives) {
+        morph.geometry.setMorphWeights(target.weights);
+        updateConservativeMorphBounds(morph.geometry, target.weights);
+        if (morph.geometry.morphUseGpu)
+            continue;
+        const positions = morph.geometry.positions;
+        positions.set(morph.geometry.morphBasePositions ?? morph.basePositions);
+        for (let targetIndex = 0; targetIndex < morph.positionTargets.length; targetIndex++) {
+            const weight = weights[targetIndex] ?? 0;
+            if (weight === 0)
+                continue;
+            const delta = morph.positionTargets[targetIndex];
+            if (!delta || delta.length !== positions.length) {
+                throw gltfDataError('Morph POSITION target does not match the base position count.');
+            }
+            for (let i = 0; i < positions.length; i++) {
+                positions[i] = requiredFiniteArrayValue(positions, i, 'morph positions')
+                    + requiredFiniteArrayValue(delta, i, 'morph POSITION target') * weight;
+            }
+        }
+        const normals = morph.geometry.normals;
+        const baseNormals = morph.geometry.morphBaseNormals ?? morph.baseNormals;
+        if (normals && baseNormals) {
+            normals.set(baseNormals);
+            for (let targetIndex = 0; targetIndex < morph.normalTargets.length; targetIndex++) {
+                const weight = weights[targetIndex] ?? 0;
+                if (weight === 0)
+                    continue;
+                const delta = morph.normalTargets[targetIndex];
+                if (!delta || delta.length !== normals.length) {
+                    throw gltfDataError('Morph NORMAL target does not match the base normal count.');
+                }
+                for (let i = 0; i < normals.length; i++) {
+                    normals[i] = requiredFiniteArrayValue(normals, i, 'morph normals')
+                        + requiredFiniteArrayValue(delta, i, 'morph NORMAL target') * weight;
+                }
+            }
+        }
+        morph.geometry.markDirty();
+    }
+}
+function updateSkinnedPrimitive(runtime) {
+    const meshWorldMatrix = updateEntityWorldMatrix(runtime.meshEntity);
+    const meshTransform = runtime.meshEntity.getComponent(Transform3D);
+    let dirty = runtime.lastMeshWorldVersion !== (meshTransform?.worldVersion ?? 0)
+        || runtime.lastGeometryVersion !== runtime.geometry.version;
+    for (let jointIndex = 0; jointIndex < runtime.jointTargets.length; jointIndex++) {
+        const target = runtime.jointTargets[jointIndex];
+        if (!target)
+            continue;
+        updateEntityWorldMatrix(target.entity);
+        const worldVersion = target.transform.worldVersion;
+        if (runtime.lastJointWorldVersions[jointIndex] !== worldVersion)
+            dirty = true;
+    }
+    if (!dirty)
+        return;
+    const inverseMeshWorld = mat4.inverse(meshWorldMatrix, runtime.inverseMeshWorldScratch);
+    for (let jointIndex = 0; jointIndex < runtime.jointTargets.length; jointIndex++) {
+        const jointTarget = runtime.jointTargets[jointIndex];
+        const inverseBind = runtime.inverseBindMatrices[jointIndex];
+        if (!jointTarget || !inverseBind) {
+            runtime.jointMatrices.set(IDENTITY_MATRIX, jointIndex * 16);
+            continue;
+        }
+        mat4.multiply(jointTarget.transform.worldMatrix, inverseBind, runtime.jointMatrixScratch);
+        mat4.multiply(inverseMeshWorld, runtime.jointMatrixScratch, runtime.skinMatrixScratch);
+        runtime.jointMatrices.set(runtime.skinMatrixScratch, jointIndex * 16);
+    }
+    runtime.geometry.updateSkinningMatrices(runtime.jointMatrices);
+    updateConservativeSkinBounds(runtime.geometry);
+    runtime.lastMeshWorldVersion = meshTransform?.worldVersion ?? 0;
+    runtime.lastGeometryVersion = runtime.geometry.version;
+    for (let jointIndex = 0; jointIndex < runtime.jointTargets.length; jointIndex++) {
+        runtime.lastJointWorldVersions[jointIndex] = runtime.jointTargets[jointIndex]?.transform.worldVersion ?? -1;
+    }
+}
+function updateConservativeMorphBounds(geometry, weights) {
+    const bounds = conservativeBoundsByGeometry.get(geometry);
+    if (!bounds)
+        return;
+    bounds.updateMorphWeights(weights);
+    geometry.setLocalBounds(geometry.skinning
+        ? bounds.getSkinnedBounds(geometry.skinning.jointMatrices, geometry.skinning.joints, geometry.skinning.weights)
+        : bounds.getSourceBounds());
+}
+function updateConservativeSkinBounds(geometry) {
+    const bounds = conservativeBoundsByGeometry.get(geometry);
+    if (!bounds || !geometry.skinning)
+        return;
+    geometry.setLocalBounds(bounds.getSkinnedBounds(geometry.skinning.jointMatrices, geometry.skinning.joints, geometry.skinning.weights));
+}
+const IDENTITY_MATRIX = mat4.identity();
+function updateEntityWorldMatrix(entity) {
+    const transform = entity.getComponent(Transform3D);
+    const parent = entity.parent;
+    const parentWorld = parent ? updateEntityWorldMatrix(parent) : null;
+    if (transform) {
+        if (parent) {
+            const parentTransform = parent.getComponent(Transform3D);
+            transform.updateWorldMatrix(parentTransform?.worldMatrix ?? parentWorld ?? undefined, parentTransform?.worldVersion ?? 0);
+        }
+        else {
+            transform.updateWorldMatrix(undefined, 0);
+        }
+        return transform.worldMatrix;
+    }
+    return parentWorld ?? IDENTITY_MATRIX;
+}
+
+export { applyGltfAnimationClip as a, applyMorphWeights as b, composeTrsMatrix as c, attachGltfSource as d, createAnimationClips as e, readAccessorIndices as f, gltfDataError as g, generateFlatNormals as h, readAccessorUnsigned as i, registerGltfConservativeBounds as j, readAccessorMat4 as k, readAccessorFloat as r, throwIfGltfLoadAborted as t, updateSkinnedPrimitive as u };
+//# sourceMappingURL=GltfAnimationRuntime-CRHsLycN.js.map