@babylonjs/lite 0.1.1

package/gltf-animation-D7uyTyO3.js

@@ -0,0 +1,245 @@
+import { j as mat4Invert, k as mat4Identity, l as mat4MultiplyInto, g as computeNodeWorldMatrix, r as resolveAccessor, I as INTERP_CUBICSPLINE, n as INTERP_STEP, o as INTERP_LINEAR, P as PATH_WEIGHTS, p as PATH_SCALE, q as PATH_ROTATION, t as PATH_TRANSLATION, u as findParent } from "./index-C8HOR2sB.js";
+let _parsePointerChannel = null;
+let _convertSampler = null;
+function _installPointerHandlers(parser, converter) {
+  _parsePointerChannel = parser;
+  _convertSampler = converter;
+}
+function toSamplerFloat32(src, length, normalized) {
+  if (_convertSampler) {
+    return _convertSampler(src, length, normalized);
+  }
+  return new Float32Array(src.buffer, src.byteOffset, length);
+}
+function resolveIBMs(json, binChunk, skin) {
+  const jointCount = skin.joints.length;
+  if (skin.inverseBindMatrices !== void 0) {
+    const ibmData = resolveAccessor(json, binChunk, skin.inverseBindMatrices);
+    return new Float32Array(ibmData._data.buffer, ibmData._data.byteOffset, jointCount * 16);
+  }
+  const out = new Float32Array(jointCount * 16);
+  for (let i = 0; i < jointCount; i++) {
+    const o = i * 16;
+    out[o] = out[o + 5] = out[o + 10] = out[o + 15] = 1;
+  }
+  return out;
+}
+function extractSkin(json, binChunk, skinIdx, meshWorldMatrix, parentMap, worldMatrixCache) {
+  const skin = json.skins[skinIdx];
+  const jointNodes = skin.joints;
+  const inverseBindMatrices = resolveIBMs(json, binChunk, skin);
+  const jointWorldMatrices = jointNodes.map((nodeIdx) => computeNodeWorldMatrix(json, nodeIdx, parentMap, worldMatrixCache));
+  return { jointNodes, inverseBindMatrices, jointWorldMatrices, meshWorldMatrix };
+}
+function computeBoneTextureData(skin) {
+  const numBones = skin.jointNodes.length;
+  const data = new Float32Array(numBones * 16);
+  const invMeshWorld = mat4Invert(skin.meshWorldMatrix) ?? mat4Identity();
+  const tmp = new Float32Array(16);
+  for (let i = 0; i < numBones; i++) {
+    mat4MultiplyInto(tmp, 0, invMeshWorld, 0, skin.jointWorldMatrices[i], 0);
+    mat4MultiplyInto(data, i * 16, tmp, 0, skin.inverseBindMatrices, i * 16);
+  }
+  return data;
+}
+const INTERP_MAP = {
+  LINEAR: INTERP_LINEAR,
+  STEP: INTERP_STEP,
+  CUBICSPLINE: INTERP_CUBICSPLINE
+};
+const PATH_MAP = {
+  translation: PATH_TRANSLATION,
+  rotation: PATH_ROTATION,
+  scale: PATH_SCALE,
+  weights: PATH_WEIGHTS
+};
+function parseAnimationData(json, binChunk, meshes, parentMap, worldMatrixCache, nodeMap) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (!json.animations || json.animations.length === 0) {
+    return null;
+  }
+  let pointerChannelCount = 0;
+  const clips = [];
+  for (const anim of json.animations) {
+    const samplers = [];
+    for (const s of anim.samplers) {
+      const inputAcc = resolveAccessor(json, binChunk, s.input);
+      const outputAcc = resolveAccessor(json, binChunk, s.output);
+      const inNorm = ((_a = json.accessors[s.input]) == null ? void 0 : _a.normalized) === true;
+      const outNorm = ((_b = json.accessors[s.output]) == null ? void 0 : _b.normalized) === true;
+      samplers.push({
+        input: toSamplerFloat32(inputAcc._data, inputAcc._count, inNorm),
+        output: toSamplerFloat32(outputAcc._data, outputAcc._count * outputAcc._componentCount, outNorm),
+        interpolation: INTERP_MAP[s.interpolation ?? "LINEAR"] ?? INTERP_LINEAR
+      });
+    }
+    const channels = [];
+    for (const c of anim.channels) {
+      const ptr = (_e = (_d = (_c = c.target) == null ? void 0 : _c.extensions) == null ? void 0 : _d.KHR_animation_pointer) == null ? void 0 : _e.pointer;
+      if (ptr) {
+        if (!_parsePointerChannel) {
+          continue;
+        }
+        const ch = _parsePointerChannel(ptr, c, nodeMap);
+        if (ch) {
+          channels.push(ch);
+          pointerChannelCount++;
+        }
+        continue;
+      }
+      if (c.target.node === void 0) {
+        continue;
+      }
+      const path = PATH_MAP[c.target.path];
+      if (path === void 0) {
+        continue;
+      }
+      channels.push({ samplerIdx: c.sampler, nodeIdx: c.target.node, path });
+    }
+    let duration = 0;
+    for (const s of samplers) {
+      if (s.input.length > 0) {
+        const last = s.input[s.input.length - 1];
+        if (last > duration) {
+          duration = last;
+        }
+      }
+    }
+    clips.push({ name: anim.name ?? "", channels, samplers, duration });
+  }
+  const nodeCount = ((_f = json.nodes) == null ? void 0 : _f.length) ?? 0;
+  const nodes = [];
+  for (let i = 0; i < nodeCount; i++) {
+    const n = json.nodes[i];
+    const t = n.translation ?? [0, 0, 0];
+    const r = n.rotation ?? [0, 0, 0, 1];
+    const s = n.scale ?? [1, 1, 1];
+    nodes.push({
+      parentIdx: findParent(parentMap, i),
+      _matrix: n.matrix,
+      tx: t[0],
+      ty: t[1],
+      tz: t[2],
+      rx: r[0],
+      ry: r[1],
+      rz: r[2],
+      rw: r[3],
+      sx: s[0],
+      sy: s[1],
+      sz: s[2]
+    });
+  }
+  const nodeToMeshIndices = /* @__PURE__ */ new Map();
+  let gpuIdx = 0;
+  for (let ni = 0; ni < nodeCount; ni++) {
+    const node = json.nodes[ni];
+    if (node.mesh === void 0) {
+      continue;
+    }
+    const mesh = json.meshes[node.mesh];
+    const indices = [];
+    for (let p = 0; p < mesh.primitives.length; p++) {
+      indices.push(gpuIdx++);
+    }
+    nodeToMeshIndices.set(ni, indices);
+  }
+  const skeletons = [];
+  for (let nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) {
+    const node = json.nodes[nodeIdx];
+    if (node.skin === void 0 || !json.skins) {
+      continue;
+    }
+    const meshIndices = nodeToMeshIndices.get(nodeIdx);
+    if (!meshIndices) {
+      continue;
+    }
+    const skin = json.skins[node.skin];
+    const jointNodes = skin.joints;
+    const inverseBindMatrices = resolveIBMs(json, binChunk, skin);
+    const meshWorldMatrix = computeNodeWorldMatrix(json, nodeIdx, parentMap, worldMatrixCache);
+    const invMeshWorld = mat4Invert(meshWorldMatrix) ?? mat4Identity();
+    for (const mi of meshIndices) {
+      const mesh = meshes[mi];
+      const skeleton = mesh == null ? void 0 : mesh.skeleton;
+      if (!skeleton) {
+        continue;
+      }
+      skeletons.push({
+        jointNodes,
+        inverseBindMatrices,
+        invMeshWorld,
+        boneTexture: skeleton.boneTexture,
+        boneCount: jointNodes.length,
+        boneMatrices: skeleton.boneMatrices,
+        runtimeSkeleton: skeleton
+      });
+    }
+  }
+  const morphBindings = [];
+  for (let nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) {
+    const node = json.nodes[nodeIdx];
+    if (node.mesh === void 0) {
+      continue;
+    }
+    const gltfMesh = json.meshes[node.mesh];
+    if (!((_i = (_h = (_g = gltfMesh.primitives) == null ? void 0 : _g[0]) == null ? void 0 : _h.targets) == null ? void 0 : _i.length)) {
+      continue;
+    }
+    const meshIndices = nodeToMeshIndices.get(nodeIdx);
+    if (!meshIndices) {
+      continue;
+    }
+    for (const mi of meshIndices) {
+      const mesh = meshes[mi];
+      const morphTargets = mesh == null ? void 0 : mesh.morphTargets;
+      if (!morphTargets) {
+        continue;
+      }
+      morphBindings.push({
+        nodeIdx,
+        weightsBuffer: morphTargets.weightsBuffer,
+        weights: morphTargets.weights,
+        targetCount: morphTargets.count,
+        runtimeMorphTargets: morphTargets
+      });
+    }
+  }
+  const nodeTargets = nodeMap ?? [];
+  const excludedNodeIndices = /* @__PURE__ */ new Set();
+  for (const skin of json.skins ?? []) {
+    for (const ji of skin.joints ?? []) {
+      excludedNodeIndices.add(ji);
+    }
+  }
+  for (let ni = 0; ni < nodeCount; ni++) {
+    if (((_j = json.nodes[ni]) == null ? void 0 : _j.skin) === void 0) {
+      continue;
+    }
+    let p = ni;
+    while (p >= 0 && !excludedNodeIndices.has(p)) {
+      excludedNodeIndices.add(p);
+      p = findParent(parentMap, p);
+    }
+  }
+  if (clips.length === 0 || skeletons.length === 0 && morphBindings.length === 0 && pointerChannelCount === 0 && !hasWritableNodeChannel(clips, nodeTargets, excludedNodeIndices)) {
+    return null;
+  }
+  return { clips, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices };
+}
+function hasWritableNodeChannel(clips, nodeTargets, excludedNodeIndices) {
+  for (const clip of clips) {
+    for (const ch of clip.channels) {
+      if ((ch.path === PATH_TRANSLATION || ch.path === PATH_ROTATION || ch.path === PATH_SCALE) && ch.nodeIdx >= 0 && !excludedNodeIndices.has(ch.nodeIdx) && nodeTargets[ch.nodeIdx]) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+export {
+  _installPointerHandlers,
+  computeBoneTextureData,
+  extractSkin,
+  parseAnimationData
+};
+//# sourceMappingURL=gltf-animation-D7uyTyO3.js.map

package/gltf-animation-D7uyTyO3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-animation-D7uyTyO3.js","sources":["../src/loader-gltf/gltf-animation.ts"],"sourcesContent":["/**\n *  Lazy-loaded animation/skin parsing for glTF.\n *  Dynamically imported by load-gltf.ts only when a glTF contains animations or skins.\n *\n *  This module is pointer-feature agnostic: KHR_animation_pointer (and the\n *  non-Float32 sampler conversion that CubeVisibility-style assets need) are\n *  installed via the registration seam below, so scenes that don't declare\n *  the extension pay zero bytes for it.\n */\nimport type { Mat4 } from \"../math/types.js\";\nimport type { Mesh } from \"../mesh/mesh.js\";\nimport type { GltfAnimationData, AnimationClip, AnimationSampler, AnimationChannel, NodeRest, SkeletonBinding, MorphBinding, AnimatedNodeTarget } from \"../animation/types.js\";\nimport { INTERP_LINEAR, INTERP_STEP, INTERP_CUBICSPLINE, PATH_TRANSLATION, PATH_ROTATION, PATH_SCALE, PATH_WEIGHTS } from \"../animation/types.js\";\nimport { mat4Identity } from \"../math/mat4-identity.js\";\nimport { mat4Invert } from \"../math/mat4-invert.js\";\nimport { mat4MultiplyInto } from \"../math/mat4-multiply-into.js\";\nimport { resolveAccessor, computeNodeWorldMatrix, findParent } from \"./gltf-parser.js\";\nimport type { SceneNode } from \"../scene/scene-node.js\";\n\n/** Registration seam for KHR_animation_pointer. The pointer feature module\n *  calls `_installPointerHandlers` on side-effect import; if never called,\n *  pointer channels are skipped and non-Float32 samplers fall back to the\n *  aliasing fast path (which throws on misaligned/short accessors). */\nexport type PointerChannelParser = (ptr: string, channel: any, nodeMap: readonly (SceneNode | undefined)[] | undefined) => AnimationChannel | null;\nexport type SamplerConverter = (src: ArrayBufferView, length: number, normalized: boolean) => Float32Array;\nlet _parsePointerChannel: PointerChannelParser | null = null;\nlet _convertSampler: SamplerConverter | null = null;\nexport function _installPointerHandlers(parser: PointerChannelParser, converter: SamplerConverter): void {\n    _parsePointerChannel = parser;\n    _convertSampler = converter;\n}\n\n/** Convert sampler input/output to Float32Array. Default: reinterpret existing\n *  Float32 accessor as Float32Array (legacy behaviour; fast but requires\n *  aligned Float32 data). KHR_animation_pointer installs a converter that\n *  additionally handles non-Float32 / normalized accessors. */\nfunction toSamplerFloat32(src: ArrayBufferView, length: number, normalized: boolean): Float32Array {\n    if (_convertSampler) {\n        return _convertSampler(src, length, normalized);\n    }\n    return new Float32Array(src.buffer, src.byteOffset, length);\n}\n\n/** Parsed skin/skeleton data. */\nexport interface GltfSkinData {\n    /** Node indices of joints in this skin. */\n    jointNodes: number[];\n    /** Inverse bind matrices — one 4×4 per joint (column-major Float32Array). */\n    inverseBindMatrices: Float32Array;\n    /** World matrices of each joint at rest pose. */\n    jointWorldMatrices: Mat4[];\n    /** World matrix of the mesh node that owns this skin. */\n    meshWorldMatrix: Mat4;\n}\n\n// ─── Skin / Skeleton Extraction ─────────────────────────────────────\n\n/** Resolve a skin's inverse-bind matrices, filling with identities when absent. */\nfunction resolveIBMs(json: any, binChunk: DataView, skin: any): Float32Array {\n    const jointCount = skin.joints.length;\n    if (skin.inverseBindMatrices !== undefined) {\n        const ibmData = resolveAccessor(json, binChunk, skin.inverseBindMatrices);\n        return new Float32Array(ibmData._data.buffer, ibmData._data.byteOffset, jointCount * 16);\n    }\n    const out = new Float32Array(jointCount * 16);\n    for (let i = 0; i < jointCount; i++) {\n        const o = i * 16;\n        out[o] = out[o + 5] = out[o + 10] = out[o + 15] = 1;\n    }\n    return out;\n}\n\nexport function extractSkin(\n    json: any,\n    binChunk: DataView,\n    skinIdx: number,\n    meshWorldMatrix: Mat4,\n    parentMap: Map<number, number>,\n    worldMatrixCache: Map<number, Mat4>\n): GltfSkinData {\n    const skin = json.skins[skinIdx];\n    const jointNodes: number[] = skin.joints;\n    const inverseBindMatrices = resolveIBMs(json, binChunk, skin);\n    const jointWorldMatrices: Mat4[] = jointNodes.map((nodeIdx) => computeNodeWorldMatrix(json, nodeIdx, parentMap, worldMatrixCache));\n    return { jointNodes, inverseBindMatrices, jointWorldMatrices, meshWorldMatrix };\n}\n\n/** Compute rest-pose bone texture data. Each bone gets 4 vec4 (one 4×4 matrix).\n *  Formula: boneMatrix[i] = inverse(meshWorld) * jointWorld[i] * IBM[i]\n *  At rest pose this simplifies to identity for each bone. */\nexport function computeBoneTextureData(skin: GltfSkinData): Float32Array {\n    const numBones = skin.jointNodes.length;\n    const data = new Float32Array(numBones * 16);\n    const invMeshWorld = mat4Invert(skin.meshWorldMatrix) ?? mat4Identity();\n    const tmp = new Float32Array(16);\n    for (let i = 0; i < numBones; i++) {\n        mat4MultiplyInto(tmp, 0, invMeshWorld, 0, skin.jointWorldMatrices[i]!, 0);\n        mat4MultiplyInto(data, i * 16, tmp, 0, skin.inverseBindMatrices, i * 16);\n    }\n    return data;\n}\n\n// ─── Animation Parsing ──────────────────────────────────────────────\n\nconst INTERP_MAP: Record<string, 0 | 1 | 2> = {\n    LINEAR: INTERP_LINEAR,\n    STEP: INTERP_STEP,\n    CUBICSPLINE: INTERP_CUBICSPLINE,\n};\n\nconst PATH_MAP: Record<string, 0 | 1 | 2 | 3> = {\n    translation: PATH_TRANSLATION,\n    rotation: PATH_ROTATION,\n    scale: PATH_SCALE,\n    weights: PATH_WEIGHTS,\n};\n\n/**\n * Parse glTF animation data: clips, node hierarchy, and skeleton bindings.\n * Returns null if no animations, or no drivable state at all (no skeletons,\n * no morphs, no pointer channels).\n *\n * `nodeMap` (optional) maps glTF node index → SceneNode. It's required to\n * resolve KHR_animation_pointer targets that write to node properties.\n */\nexport function parseAnimationData(\n    json: any,\n    binChunk: DataView,\n    meshes: Mesh[],\n    parentMap: Map<number, number>,\n    worldMatrixCache: Map<number, Mat4>,\n    nodeMap?: readonly (SceneNode | undefined)[]\n): GltfAnimationData | null {\n    if (!json.animations || json.animations.length === 0) {\n        return null;\n    }\n\n    let pointerChannelCount = 0;\n\n    // Parse animation clips\n    const clips: AnimationClip[] = [];\n    for (const anim of json.animations) {\n        const samplers: AnimationSampler[] = [];\n        for (const s of anim.samplers) {\n            const inputAcc = resolveAccessor(json, binChunk, s.input);\n            const outputAcc = resolveAccessor(json, binChunk, s.output);\n            const inNorm = json.accessors[s.input]?.normalized === true;\n            const outNorm = json.accessors[s.output]?.normalized === true;\n            samplers.push({\n                input: toSamplerFloat32(inputAcc._data, inputAcc._count, inNorm),\n                output: toSamplerFloat32(outputAcc._data, outputAcc._count * outputAcc._componentCount, outNorm),\n                interpolation: INTERP_MAP[s.interpolation ?? \"LINEAR\"] ?? INTERP_LINEAR,\n            });\n        }\n\n        const channels: AnimationChannel[] = [];\n        for (const c of anim.channels) {\n            // KHR_animation_pointer: delegated to the registered pointer parser\n            // (installed by gltf-feature-animation-pointer on side-effect import).\n            const ptr = c.target?.extensions?.KHR_animation_pointer?.pointer;\n            if (ptr) {\n                if (!_parsePointerChannel) {\n                    continue;\n                }\n                const ch = _parsePointerChannel(ptr, c, nodeMap);\n                if (ch) {\n                    channels.push(ch);\n                    pointerChannelCount++;\n                }\n                continue;\n            }\n            if (c.target.node === undefined) {\n                continue;\n            }\n            const path = PATH_MAP[c.target.path];\n            if (path === undefined) {\n                continue;\n            }\n            channels.push({ samplerIdx: c.sampler, nodeIdx: c.target.node, path });\n        }\n\n        let duration = 0;\n        for (const s of samplers) {\n            if (s.input.length > 0) {\n                const last = s.input[s.input.length - 1]!;\n                if (last > duration) {\n                    duration = last;\n                }\n            }\n        }\n\n        clips.push({ name: anim.name ?? \"\", channels, samplers, duration });\n    }\n\n    // Build node hierarchy (rest-pose TRS + parent indices)\n    const nodeCount = json.nodes?.length ?? 0;\n    const nodes: NodeRest[] = [];\n    for (let i = 0; i < nodeCount; i++) {\n        const n = json.nodes[i];\n        const t = n.translation ?? [0, 0, 0];\n        const r = n.rotation ?? [0, 0, 0, 1];\n        const s = n.scale ?? [1, 1, 1];\n        nodes.push({\n            parentIdx: findParent(parentMap, i),\n            _matrix: n.matrix as Mat4 | undefined,\n            tx: t[0],\n            ty: t[1],\n            tz: t[2],\n            rx: r[0],\n            ry: r[1],\n            rz: r[2],\n            rw: r[3],\n            sx: s[0],\n            sy: s[1],\n            sz: s[2],\n        });\n    }\n\n    // Build skeleton bindings (connect skin data to GPU bone textures)\n    // First, build node→gpuMesh mapping by replaying extraction order\n    const nodeToMeshIndices = new Map<number, number[]>();\n    let gpuIdx = 0;\n    for (let ni = 0; ni < nodeCount; ni++) {\n        const node = json.nodes[ni];\n        if (node.mesh === undefined) {\n            continue;\n        }\n        const mesh = json.meshes[node.mesh];\n        const indices: number[] = [];\n        for (let p = 0; p < mesh.primitives.length; p++) {\n            indices.push(gpuIdx++);\n        }\n        nodeToMeshIndices.set(ni, indices);\n    }\n\n    const skeletons: SkeletonBinding[] = [];\n    for (let nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) {\n        const node = json.nodes[nodeIdx];\n        if (node.skin === undefined || !json.skins) {\n            continue;\n        }\n\n        const meshIndices = nodeToMeshIndices.get(nodeIdx);\n        if (!meshIndices) {\n            continue;\n        }\n\n        const skin = json.skins[node.skin];\n        const jointNodes: number[] = skin.joints;\n        const inverseBindMatrices = resolveIBMs(json, binChunk, skin);\n\n        const meshWorldMatrix = computeNodeWorldMatrix(json, nodeIdx, parentMap, worldMatrixCache);\n        const invMeshWorld = mat4Invert(meshWorldMatrix) ?? mat4Identity();\n\n        // Create a binding for EACH mesh primitive of this skinned node\n        for (const mi of meshIndices) {\n            const mesh = meshes[mi];\n            const skeleton = mesh?.skeleton;\n            if (!skeleton) {\n                continue;\n            }\n            skeletons.push({\n                jointNodes,\n                inverseBindMatrices,\n                invMeshWorld,\n                boneTexture: skeleton.boneTexture,\n                boneCount: jointNodes.length,\n                boneMatrices: skeleton.boneMatrices,\n                runtimeSkeleton: skeleton,\n            });\n        }\n    }\n\n    // Build morph bindings (connect morph-target meshes to GPU weight buffers)\n    const morphBindings: MorphBinding[] = [];\n    for (let nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) {\n        const node = json.nodes[nodeIdx];\n        if (node.mesh === undefined) {\n            continue;\n        }\n        const gltfMesh = json.meshes[node.mesh];\n        if (!gltfMesh.primitives?.[0]?.targets?.length) {\n            continue;\n        }\n\n        const meshIndices = nodeToMeshIndices.get(nodeIdx);\n        if (!meshIndices) {\n            continue;\n        }\n\n        for (const mi of meshIndices) {\n            const mesh = meshes[mi];\n            const morphTargets = mesh?.morphTargets;\n            if (!morphTargets) {\n                continue;\n            }\n            morphBindings.push({\n                nodeIdx,\n                weightsBuffer: morphTargets.weightsBuffer,\n                weights: morphTargets.weights,\n                targetCount: morphTargets.count,\n                runtimeMorphTargets: morphTargets,\n            });\n        }\n    }\n\n    // Build the node-TRS writeback inputs. `nodeTargets` exposes each glTF node's\n    // live scene node (via the structural AnimatedNodeTarget view) so the controller\n    // can push evaluated local TRS back onto the scene graph, moving non-skinned\n    // node-animated meshes and their descendants. `excludedNodeIndices` lists nodes\n    // that MUST NOT be written: skin joints (driven by the skeleton path) plus\n    // skinned-mesh nodes and all their ancestors — their bone matrices bake an\n    // `invMeshWorld` captured at load, so moving them at runtime would\n    // double-transform the skinned vertices.\n    const nodeTargets: readonly (AnimatedNodeTarget | undefined)[] = (nodeMap as readonly (AnimatedNodeTarget | undefined)[] | undefined) ?? [];\n    const excludedNodeIndices = new Set<number>();\n    for (const skin of json.skins ?? []) {\n        for (const ji of skin.joints ?? []) {\n            excludedNodeIndices.add(ji);\n        }\n    }\n    for (let ni = 0; ni < nodeCount; ni++) {\n        if (json.nodes[ni]?.skin === undefined) {\n            continue;\n        }\n        let p = ni;\n        while (p >= 0 && !excludedNodeIndices.has(p)) {\n            excludedNodeIndices.add(p);\n            p = findParent(parentMap, p);\n        }\n    }\n\n    if (\n        clips.length === 0 ||\n        (skeletons.length === 0 && morphBindings.length === 0 && pointerChannelCount === 0 && !hasWritableNodeChannel(clips, nodeTargets, excludedNodeIndices))\n    ) {\n        return null;\n    }\n    return { clips, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices };\n}\n\n/** True if any clip animates a non-excluded node that has a live scene target —\n *  i.e. there is at least one plain node-TRS channel the controller can write\n *  back. Lets purely-skinned/morph/pointer assets short-circuit unchanged. */\nfunction hasWritableNodeChannel(clips: readonly AnimationClip[], nodeTargets: readonly (AnimatedNodeTarget | undefined)[], excludedNodeIndices: ReadonlySet<number>): boolean {\n    for (const clip of clips) {\n        for (const ch of clip.channels) {\n            if (\n                (ch.path === PATH_TRANSLATION || ch.path === PATH_ROTATION || ch.path === PATH_SCALE) &&\n                ch.nodeIdx >= 0 &&\n                !excludedNodeIndices.has(ch.nodeIdx) &&\n                nodeTargets[ch.nodeIdx]\n            ) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\n"],"names":[],"mappings":"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"}

package/gltf-ext-anisotropy-CknJiJK8.js

@@ -0,0 +1,22 @@
+const ext = {
+  id: "KHR_materials_anisotropy",
+  async applyMaterial(mat) {
+    var _a, _b;
+    const a = (_b = (_a = mat._rawMatDef) == null ? void 0 : _a.extensions) == null ? void 0 : _b.KHR_materials_anisotropy;
+    if (!a) {
+      return null;
+    }
+    const rot = a.anisotropyRotation ?? 0;
+    return {
+      anisotropy: {
+        isEnabled: true,
+        intensity: a.anisotropyStrength ?? 0,
+        direction: [Math.cos(rot), Math.sin(rot)]
+      }
+    };
+  }
+};
+export {
+  ext as default
+};
+//# sourceMappingURL=gltf-ext-anisotropy-CknJiJK8.js.map

package/gltf-ext-anisotropy-CknJiJK8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-anisotropy-CknJiJK8.js","sources":["../src/loader-gltf/gltf-ext-anisotropy.ts"],"sourcesContent":["/** glTF KHR_materials_anisotropy extension. */\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst ext: GltfFeature = {\n    id: \"KHR_materials_anisotropy\",\n    async applyMaterial(mat) {\n        const a = mat._rawMatDef?.extensions?.KHR_materials_anisotropy;\n        if (!a) {\n            return null;\n        }\n        const rot = a.anisotropyRotation ?? 0;\n        return {\n            anisotropy: {\n                isEnabled: true,\n                intensity: a.anisotropyStrength ?? 0,\n                direction: [Math.cos(rot), Math.sin(rot)],\n            },\n        };\n    },\n};\nexport default ext;\n"],"names":[],"mappings":"AAGA,MAAM,MAAmB;AAAA,EACrB,IAAI;AAAA,EACJ,MAAM,cAAc,KAAK;AAF7B;AAGQ,UAAM,KAAI,eAAI,eAAJ,mBAAgB,eAAhB,mBAA4B;AACtC,QAAI,CAAC,GAAG;AACJ,aAAO;AAAA,IACX;AACA,UAAM,MAAM,EAAE,sBAAsB;AACpC,WAAO;AAAA,MACH,YAAY;AAAA,QACR,WAAW;AAAA,QACX,WAAW,EAAE,sBAAsB;AAAA,QACnC,WAAW,CAAC,KAAK,IAAI,GAAG,GAAG,KAAK,IAAI,GAAG,CAAC;AAAA,MAAA;AAAA,IAC5C;AAAA,EAER;AACJ;"}