@babylonjs/lite 0.1.1

package/gltf-feature-xmp-BUfq_IVG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-feature-xmp-BUfq_IVG.js","sources":["../src/loader-gltf/gltf-feature-xmp.ts"],"sourcesContent":["/**\n * KHR_xmp_json_ld feature.\n *\n * XMP JSON-LD is pure metadata — it has no effect on rendering. This feature\n * simply surfaces the document-level metadata packets (and the asset-referenced\n * packet) on the returned AssetContainer so applications can read provenance,\n * licensing, authorship, etc. It is dynamic-imported only when `extensionsUsed`\n * lists KHR_xmp_json_ld, so non-XMP scenes pay nothing.\n */\n\nimport type { GltfFeature } from \"./gltf-feature.js\";\n\nconst feature: GltfFeature = {\n    id: \"KHR_xmp_json_ld\",\n    async applyAsset(_meshes, _root, ctx) {\n        const json = ctx._json;\n        const packets: unknown[] = json.extensions?.KHR_xmp_json_ld?.packets ?? [];\n        const assetPacketIndex: number | undefined = json.asset?.extensions?.KHR_xmp_json_ld?.packet;\n        const assetPacket = assetPacketIndex !== undefined ? packets[assetPacketIndex] : undefined;\n        return { xmpMetadata: { packets, assetPacket } };\n    },\n};\n\nexport default feature;\n"],"names":[],"mappings":"AAYA,MAAM,UAAuB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM,WAAW,SAAS,OAAO,KAAK;AAF1C;AAGQ,UAAM,OAAO,IAAI;AACjB,UAAM,YAAqB,gBAAK,eAAL,mBAAiB,oBAAjB,mBAAkC,YAAW,CAAA;AACxE,UAAM,oBAAuC,sBAAK,UAAL,mBAAY,eAAZ,mBAAwB,oBAAxB,mBAAyC;AACtF,UAAM,cAAc,qBAAqB,SAAY,QAAQ,gBAAgB,IAAI;AACjF,WAAO,EAAE,aAAa,EAAE,SAAS,cAAY;AAAA,EACjD;AACJ;"}

package/gltf-glb-parser-D6UZWFuC.js

@@ -0,0 +1,27 @@
+function parseGlbContainer(buffer) {
+  const view = new DataView(buffer);
+  const magic = view.getUint32(0, true);
+  if (magic !== 1179937895) {
+    throw new Error("Not a valid GLB file");
+  }
+  let offset = 12;
+  const jsonLength = view.getUint32(offset, true);
+  const jsonType = view.getUint32(offset + 4, true);
+  if (jsonType !== 1313821514) {
+    throw new Error("First GLB chunk is not JSON");
+  }
+  const jsonStr = new TextDecoder().decode(new Uint8Array(buffer, offset + 8, jsonLength));
+  const json = JSON.parse(jsonStr);
+  offset += 8 + jsonLength;
+  const binLength = view.getUint32(offset, true);
+  const binType = view.getUint32(offset + 4, true);
+  if (binType !== 5130562) {
+    throw new Error("Second GLB chunk is not BIN");
+  }
+  const binChunk = new DataView(buffer, offset + 8, binLength);
+  return { json, binChunk };
+}
+export {
+  parseGlbContainer
+};
+//# sourceMappingURL=gltf-glb-parser-D6UZWFuC.js.map

package/gltf-glb-parser-D6UZWFuC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-glb-parser-D6UZWFuC.js","sources":["../src/loader-gltf/gltf-glb-parser.ts"],"sourcesContent":["/** GLB binary container parsing. Kept separate so .gltf-only scenes do not ship it. */\n\nexport function parseGlbContainer(buffer: ArrayBuffer): { json: any; binChunk: DataView } {\n    const view = new DataView(buffer);\n\n    // Header (12 bytes)\n    const magic = view.getUint32(0, true);\n    if (magic !== 0x46546c67) {\n        throw new Error(\"Not a valid GLB file\");\n    }\n    // const version = view.getUint32(4, true);\n    // const totalLength = view.getUint32(8, true);\n\n    // JSON chunk\n    let offset = 12;\n    const jsonLength = view.getUint32(offset, true);\n    const jsonType = view.getUint32(offset + 4, true);\n    if (jsonType !== 0x4e4f534a) {\n        throw new Error(\"First GLB chunk is not JSON\");\n    }\n    const jsonStr = new TextDecoder().decode(new Uint8Array(buffer, offset + 8, jsonLength));\n    const json = JSON.parse(jsonStr);\n    offset += 8 + jsonLength;\n\n    // BIN chunk\n    const binLength = view.getUint32(offset, true);\n    const binType = view.getUint32(offset + 4, true);\n    if (binType !== 0x004e4942) {\n        throw new Error(\"Second GLB chunk is not BIN\");\n    }\n    const binChunk = new DataView(buffer, offset + 8, binLength);\n\n    return { json, binChunk };\n}\n"],"names":[],"mappings":"AAEO,SAAS,kBAAkB,QAAwD;AACtF,QAAM,OAAO,IAAI,SAAS,MAAM;AAGhC,QAAM,QAAQ,KAAK,UAAU,GAAG,IAAI;AACpC,MAAI,UAAU,YAAY;AACtB,UAAM,IAAI,MAAM,sBAAsB;AAAA,EAC1C;AAKA,MAAI,SAAS;AACb,QAAM,aAAa,KAAK,UAAU,QAAQ,IAAI;AAC9C,QAAM,WAAW,KAAK,UAAU,SAAS,GAAG,IAAI;AAChD,MAAI,aAAa,YAAY;AACzB,UAAM,IAAI,MAAM,6BAA6B;AAAA,EACjD;AACA,QAAM,UAAU,IAAI,YAAA,EAAc,OAAO,IAAI,WAAW,QAAQ,SAAS,GAAG,UAAU,CAAC;AACvF,QAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,YAAU,IAAI;AAGd,QAAM,YAAY,KAAK,UAAU,QAAQ,IAAI;AAC7C,QAAM,UAAU,KAAK,UAAU,SAAS,GAAG,IAAI;AAC/C,MAAI,YAAY,SAAY;AACxB,UAAM,IAAI,MAAM,6BAA6B;AAAA,EACjD;AACA,QAAM,WAAW,IAAI,SAAS,QAAQ,SAAS,GAAG,SAAS;AAE3D,SAAO,EAAE,MAAM,SAAA;AACnB;"}

package/gltf-interleave-DGnUlz28.js

@@ -0,0 +1,241 @@
+import { T as TYPE_SIZES, d as computeAabb, i as initMeshTransform, r as resolveAccessor, e as createMappedBuffer } from "./index-C8HOR2sB.js";
+const FLOAT = 5126;
+const UNSIGNED_SHORT = 5123;
+const UNSIGNED_INT = 5125;
+const UNSIGNED_BYTE = 5121;
+const COMP_BYTES = { [UNSIGNED_BYTE]: 1, [UNSIGNED_SHORT]: 2, [UNSIGNED_INT]: 4, [FLOAT]: 4 };
+function accessorIsStrided(json, idx) {
+  const a = json.accessors[idx];
+  const bv = json.bufferViews[a.bufferView];
+  const stride = bv.byteStride;
+  if (stride === void 0) {
+    return false;
+  }
+  const elemBytes = (TYPE_SIZES[a.type] ?? 1) * (COMP_BYTES[a.componentType] ?? 4);
+  return stride !== elemBytes;
+}
+function resolveStrided(json, binChunk, accessorIdx) {
+  const accessor = json.accessors[accessorIdx];
+  const bufferView = json.bufferViews[accessor.bufferView];
+  const ab = binChunk.buffer;
+  return {
+    _bufferView: accessor.bufferView,
+    _stride: bufferView.byteStride,
+    _offset: accessor.byteOffset ?? 0,
+    _componentType: accessor.componentType,
+    _componentCount: TYPE_SIZES[accessor.type] ?? 1,
+    _count: accessor.count,
+    _slice: new Uint8Array(ab, binChunk.byteOffset + (bufferView.byteOffset ?? 0), bufferView.byteLength)
+  };
+}
+function destrideToTight(il) {
+  const dv = new DataView(il._slice.buffer, il._slice.byteOffset, il._slice.byteLength);
+  const cb = COMP_BYTES[il._componentType] ?? 4;
+  const ct = il._componentType;
+  const cc = il._componentCount;
+  const out = new Float32Array(il._count * cc);
+  for (let v = 0; v < il._count; v++) {
+    const rowBase = il._offset + v * il._stride;
+    for (let c = 0; c < cc; c++) {
+      const off = rowBase + c * cb;
+      out[v * cc + c] = ct === FLOAT ? dv.getFloat32(off, true) : ct === UNSIGNED_SHORT ? dv.getUint16(off, true) : ct === UNSIGNED_INT ? dv.getUint32(off, true) : dv.getUint8(off);
+    }
+  }
+  return out;
+}
+function buildInterleavedPartial(json, binChunk, primitive, worldMatrix, nodeIdx) {
+  const attrs = primitive.attributes;
+  let anyStrided = false;
+  for (const name in attrs) {
+    if (accessorIsStrided(json, attrs[name])) {
+      anyStrided = true;
+      break;
+    }
+  }
+  if (!anyStrided) {
+    return void 0;
+  }
+  const vb = {};
+  let vertexCount = 0;
+  const resolveOne = (name, eager) => {
+    const idx = attrs[name];
+    if (idx === void 0) {
+      return { _tight: null, _count: 0 };
+    }
+    if (accessorIsStrided(json, idx)) {
+      const il = resolveStrided(json, binChunk, idx);
+      return { _tight: eager ? destrideToTight(il) : null, _il: il, _count: il._count };
+    }
+    const av = resolveAccessor(json, binChunk, idx);
+    return { _tight: av._data, _count: av._count };
+  };
+  const pos = resolveOne("POSITION", false);
+  vb._p = pos._il;
+  vertexCount = pos._count;
+  const nrm = resolveOne("NORMAL", false);
+  vb._n = nrm._il;
+  const uv = resolveOne("TEXCOORD_0", false);
+  vb._u = uv._il;
+  const tan = resolveOne("TANGENT", true);
+  vb._t = tan._il;
+  const uv2 = resolveOne("TEXCOORD_1", true);
+  vb._u2 = uv2._il;
+  const col = resolveOne("COLOR_0", true);
+  vb._c = col._il;
+  const positions = pos._tight;
+  let normals = nrm._tight;
+  let uvs = uv._tight;
+  const tangents = tan._tight;
+  const uv2s = uv2._tight;
+  const colors = col._tight;
+  if (!normals && !vb._n) {
+    normals = new Float32Array(vertexCount * 3);
+  }
+  if (!uvs && !vb._u) {
+    uvs = new Float32Array(vertexCount * 2);
+  }
+  const idxData = primitive.indices !== void 0 ? resolveAccessor(json, binChunk, primitive.indices) : null;
+  const indices = idxData ? idxData._data instanceof Uint32Array ? new Uint32Array(idxData._data) : idxData._data instanceof Uint8Array ? Uint16Array.from(idxData._data) : new Uint16Array(idxData._data.buffer, idxData._data.byteOffset, idxData._count) : new Uint16Array(0);
+  return {
+    _positions: positions,
+    _normals: normals,
+    _tangents: tangents,
+    _uvs: uvs,
+    _uv2s: uv2s,
+    _colors: colors,
+    _indices: indices,
+    _vertexCount: vertexCount,
+    _indexCount: (idxData == null ? void 0 : idxData._count) ?? 0,
+    _worldMatrix: worldMatrix,
+    _vb: vb,
+    _nodeIndex: nodeIdx,
+    _primitive: primitive
+  };
+}
+function buildInterleavedGpu(engine, m) {
+  var _a, _b, _c, _d;
+  const vbsrc = m._vb;
+  const shared = /* @__PURE__ */ new Map();
+  const vbuf = (a, tight) => {
+    if (!a) {
+      return tight ? createMappedBuffer(engine, tight, GPUBufferUsage.VERTEX) : null;
+    }
+    let b = shared.get(a._bufferView);
+    if (!b) {
+      shared.set(a._bufferView, b = createMappedBuffer(engine, a._slice, GPUBufferUsage.VERTEX));
+    }
+    return b;
+  };
+  return {
+    positionBuffer: vbuf(vbsrc._p, m._positions),
+    normalBuffer: vbuf(vbsrc._n, m._normals),
+    tangentBuffer: m._tangents ? vbuf(vbsrc._t, m._tangents) : null,
+    uvBuffer: vbuf(vbsrc._u, m._uvs),
+    uv2Buffer: m._uv2s ? vbuf(vbsrc._u2, m._uv2s) : null,
+    colorBuffer: m._colors ? vbuf(vbsrc._c, m._colors) : null,
+    indexBuffer: createMappedBuffer(engine, m._indices, GPUBufferUsage.INDEX),
+    indexCount: m._indexCount,
+    indexFormat: m._indices instanceof Uint32Array ? "uint32" : "uint16",
+    _vbLayout: vbsrc,
+    _vbKey: `vb${((_a = vbsrc._p) == null ? void 0 : _a._stride) ?? 0}.${((_b = vbsrc._n) == null ? void 0 : _b._stride) ?? 0}.${((_c = vbsrc._t) == null ? void 0 : _c._stride) ?? 0}.${((_d = vbsrc._u) == null ? void 0 : _d._stride) ?? 0}`
+  };
+}
+function buildInterleavedMesh(engine, m, index, material) {
+  var _a;
+  const gpu = buildInterleavedGpu(engine, m);
+  const [boundMin, boundMax] = m._vb._p ? computeAabbStrided(m._vb._p, m._worldMatrix) : computeAabb(m._positions, m._worldMatrix);
+  const mesh = {
+    name: `gltf_mesh_${index}`,
+    material,
+    receiveShadows: false,
+    boundMin,
+    boundMax,
+    skeleton: null,
+    morphTargets: null,
+    _materialDirty: false,
+    _gpu: gpu
+  };
+  initMeshTransform(mesh);
+  installLazyCpu(mesh, m);
+  mesh._cpuIndices = m._indices instanceof Uint32Array ? m._indices : new Uint32Array(m._indices);
+  (_a = engine._dlr) == null ? void 0 : _a.m(mesh, m._uv2s, m._tangents, m._colors, m._indices, gpu.indexFormat);
+  return mesh;
+}
+function computeAabbStrided(il, world) {
+  const dv = new DataView(il._slice.buffer, il._slice.byteOffset, il._slice.byteLength);
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (let v = 0; v < il._count; v++) {
+    const base = il._offset + v * il._stride;
+    const lx = dv.getFloat32(base, true);
+    const ly = dv.getFloat32(base + 4, true);
+    const lz = dv.getFloat32(base + 8, true);
+    let x = lx, y = ly, z = lz;
+    if (world) {
+      x = world[0] * lx + world[4] * ly + world[8] * lz + world[12];
+      y = world[1] * lx + world[5] * ly + world[9] * lz + world[13];
+      z = world[2] * lx + world[6] * ly + world[10] * lz + world[14];
+    }
+    if (x < minX) {
+      minX = x;
+    }
+    if (x > maxX) {
+      maxX = x;
+    }
+    if (y < minY) {
+      minY = y;
+    }
+    if (y > maxY) {
+      maxY = y;
+    }
+    if (z < minZ) {
+      minZ = z;
+    }
+    if (z > maxZ) {
+      maxZ = z;
+    }
+  }
+  return [
+    [minX, minY, minZ],
+    [maxX, maxY, maxZ]
+  ];
+}
+function installLazyCpu(mesh, m) {
+  const vb = m._vb;
+  if (vb._p) {
+    Object.defineProperty(mesh, "_cpuPositions", lazyCpuDesc(vb._p));
+  } else if (m._positions) {
+    mesh._cpuPositions = m._positions;
+  }
+  if (vb._n) {
+    Object.defineProperty(mesh, "_cpuNormals", lazyCpuDesc(vb._n));
+  } else if (m._normals) {
+    mesh._cpuNormals = m._normals;
+  }
+  if (vb._u) {
+    Object.defineProperty(mesh, "_cpuUvs", lazyCpuDesc(vb._u));
+  } else if (m._uvs) {
+    mesh._cpuUvs = m._uvs;
+  }
+}
+function lazyCpuDesc(il) {
+  let cached;
+  return {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return cached ?? (cached = destrideToTight(il));
+    },
+    set(v) {
+      cached = v;
+    }
+  };
+}
+export {
+  accessorIsStrided,
+  buildInterleavedMesh,
+  buildInterleavedPartial,
+  computeAabbStrided,
+  installLazyCpu
+};
+//# sourceMappingURL=gltf-interleave-DGnUlz28.js.map

package/gltf-interleave-DGnUlz28.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-interleave-DGnUlz28.js","sources":["../src/loader-gltf/gltf-interleave.ts"],"sourcesContent":["/**\n * Interleaved (strided) glTF vertex-buffer support — dynamically imported.\n *\n * The engine renders interleaved attributes genuinely: the raw strided\n * bufferView slice is uploaded ONCE as a shared GPU buffer and bound to each\n * attribute at its byte offset with the pipeline's vertex `arrayStride` set to\n * the bufferView byteStride. The loader never rewrites the asset.\n *\n * This whole module is loaded via `await import()` only when an asset actually\n * contains an interleaved bufferView, so non-interleaved scenes pay ZERO bundle\n * cost. The tight CPU copy of position/normal/uv (for AABB, picking, CSG, …) is\n * de-strided LAZILY — only on first CPU read via `installLazyCpu` — so scenes\n * that only render never materialize it.\n */\n\nimport type { Mat4 } from \"../math/types.js\";\nimport type { Aabb } from \"../math/aabb.js\";\nimport { computeAabb } from \"../math/compute-aabb.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { Mesh, MeshGPU } from \"../mesh/mesh.js\";\nimport { initMeshTransform } from \"../mesh/mesh.js\";\nimport type { PbrMaterialProps } from \"../material/pbr/pbr-material.js\";\nimport { createMappedBuffer } from \"../resource/gpu-buffers.js\";\nimport { resolveAccessor, TYPE_SIZES } from \"./gltf-parser.js\";\nimport type { GltfMeshData } from \"./load-gltf.js\";\n\nconst FLOAT = 5126;\nconst UNSIGNED_SHORT = 5123;\nconst UNSIGNED_INT = 5125;\nconst UNSIGNED_BYTE = 5121;\n\nconst COMP_BYTES: Record<number, number> = { [UNSIGNED_BYTE]: 1, [UNSIGNED_SHORT]: 2, [UNSIGNED_INT]: 4, [FLOAT]: 4 };\n\n/** Interleave descriptor for one attribute sourced from a strided bufferView.\n *  The raw slice is shared across attributes of the same bufferView; the\n *  pipeline uses `_stride` as arrayStride and binds at `_offset`. */\nexport interface AccessorInterleave {\n    /** @internal glTF bufferView index — shared-buffer key (same view → one GPU buffer). */\n    _bufferView: number;\n    /** @internal Interleave byte stride (bufferView.byteStride) → pipeline arrayStride. */\n    _stride: number;\n    /** @internal Attribute byte offset within the bufferView → setVertexBuffer bind offset. */\n    _offset: number;\n    /** @internal glTF component type (FLOAT, UNSIGNED_SHORT, …). */\n    _componentType: number;\n    /** @internal Components per vertex. */\n    _componentCount: number;\n    /** @internal Vertex count. */\n    _count: number;\n    /** @internal Raw bufferView bytes (shared across attributes). Retained after GPU upload\n     *  so the CPU copy can be de-strided lazily on demand. */\n    _slice?: Uint8Array;\n}\n\n/** Per-attribute interleave sources for a primitive (keys mirror MeshVbLayout). */\nexport interface GltfVb {\n    /** @internal */\n    _p?: AccessorInterleave;\n    /** @internal */\n    _n?: AccessorInterleave;\n    /** @internal */\n    _t?: AccessorInterleave;\n    /** @internal */\n    _u?: AccessorInterleave;\n    /** @internal */\n    _u2?: AccessorInterleave;\n    /** @internal */\n    _c?: AccessorInterleave;\n}\n\n/** True if accessor `idx`'s bufferView is interleaved (byteStride present and\n *  larger than the attribute's tightly-packed element size). */\nexport function accessorIsStrided(json: any, idx: number): boolean {\n    const a = json.accessors[idx];\n    const bv = json.bufferViews[a.bufferView];\n    const stride: number | undefined = bv.byteStride;\n    if (stride === undefined) {\n        return false;\n    }\n    const elemBytes = (TYPE_SIZES[a.type] ?? 1) * (COMP_BYTES[a.componentType] ?? 4);\n    return stride !== elemBytes;\n}\n\n/** Resolve a strided accessor into an {@link AccessorInterleave} descriptor. */\nfunction resolveStrided(json: any, binChunk: DataView, accessorIdx: number): AccessorInterleave {\n    const accessor = json.accessors[accessorIdx];\n    const bufferView = json.bufferViews[accessor.bufferView];\n    const ab = binChunk.buffer as ArrayBuffer;\n    return {\n        _bufferView: accessor.bufferView,\n        _stride: bufferView.byteStride,\n        _offset: accessor.byteOffset ?? 0,\n        _componentType: accessor.componentType,\n        _componentCount: TYPE_SIZES[accessor.type] ?? 1,\n        _count: accessor.count,\n        _slice: new Uint8Array(ab, binChunk.byteOffset + (bufferView.byteOffset ?? 0), bufferView.byteLength),\n    };\n}\n\n/** De-stride an interleaved attribute into a tight Float32Array, reading raw\n *  component values (no normalization) so the result matches what a tight\n *  accessor view would have produced. */\nfunction destrideToTight(il: AccessorInterleave): Float32Array {\n    const dv = new DataView(il._slice!.buffer, il._slice!.byteOffset, il._slice!.byteLength);\n    const cb = COMP_BYTES[il._componentType] ?? 4;\n    const ct = il._componentType;\n    const cc = il._componentCount;\n    const out = new Float32Array(il._count * cc);\n    for (let v = 0; v < il._count; v++) {\n        const rowBase = il._offset + v * il._stride;\n        for (let c = 0; c < cc; c++) {\n            const off = rowBase + c * cb;\n            out[v * cc + c] =\n                ct === FLOAT ? dv.getFloat32(off, true) : ct === UNSIGNED_SHORT ? dv.getUint16(off, true) : ct === UNSIGNED_INT ? dv.getUint32(off, true) : dv.getUint8(off);\n        }\n    }\n    return out;\n}\n\n/** Build a mesh-data partial for a primitive, but ONLY if it actually sources\n *  ≥1 attribute from an interleaved (strided) bufferView. Returns `undefined`\n *  for fully-tight primitives so the caller falls back to its tight path.\n *\n *  Strided POSITION/NORMAL/TEXCOORD_0 attributes keep their raw slice in `_vb`\n *  (for genuine GPU interleaving) and leave the tight CPU field `null` — the\n *  de-strided copy is materialized lazily on first CPU read (see\n *  {@link installLazyCpu}). Strided TANGENT/TEXCOORD_1/COLOR are eagerly\n *  de-strided (they feed device-lost recovery), but no current asset interleaves\n *  them. Tight attributes resolve exactly like the core loader. */\nexport function buildInterleavedPartial(json: any, binChunk: DataView, primitive: any, worldMatrix: Mat4, nodeIdx: number): Omit<GltfMeshData, \"_material\"> | undefined {\n    const attrs = primitive.attributes;\n\n    // Per-primitive gate: bail (→ tight path) unless a vertex attribute is strided.\n    let anyStrided = false;\n    for (const name in attrs) {\n        if (accessorIsStrided(json, attrs[name])) {\n            anyStrided = true;\n            break;\n        }\n    }\n    if (!anyStrided) {\n        return undefined;\n    }\n\n    const vb: GltfVb = {};\n    let vertexCount = 0;\n\n    // Resolve one attribute. Returns the interleave descriptor (when the source is\n    // strided) and/or a tight CPU array. `eager` de-strides strided sources up-front\n    // (TANGENT/UV2/COLOR feed device-lost recovery); lazy ones leave `_tight` null and\n    // are de-strided on demand. The caller assigns `vb.<attr>` with a STATIC property\n    // name (never a computed `vb[key]`) — a computed write would stay an unmangled\n    // literal while every reader uses the mangled static name, corrupting the object\n    // across the dynamic-import chunk boundary.\n    const resolveOne = (name: string, eager: boolean): { _tight: Float32Array | null; _il?: AccessorInterleave; _count: number } => {\n        const idx = attrs[name];\n        if (idx === undefined) {\n            return { _tight: null, _count: 0 };\n        }\n        if (accessorIsStrided(json, idx)) {\n            const il = resolveStrided(json, binChunk, idx);\n            return { _tight: eager ? destrideToTight(il) : null, _il: il, _count: il._count };\n        }\n        const av = resolveAccessor(json, binChunk, idx);\n        return { _tight: av._data as Float32Array, _count: av._count };\n    };\n\n    const pos = resolveOne(\"POSITION\", false);\n    vb._p = pos._il;\n    vertexCount = pos._count;\n    const nrm = resolveOne(\"NORMAL\", false);\n    vb._n = nrm._il;\n    const uv = resolveOne(\"TEXCOORD_0\", false);\n    vb._u = uv._il;\n    const tan = resolveOne(\"TANGENT\", true);\n    vb._t = tan._il;\n    const uv2 = resolveOne(\"TEXCOORD_1\", true);\n    vb._u2 = uv2._il;\n    const col = resolveOne(\"COLOR_0\", true);\n    vb._c = col._il;\n\n    const positions = pos._tight;\n    let normals = nrm._tight;\n    let uvs = uv._tight;\n    const tangents = tan._tight;\n    const uv2s = uv2._tight;\n    const colors = col._tight;\n\n    // Absent (not merely strided) NORMAL/UV need a tight zero-filled buffer so the\n    // GPU has a bindable vertex buffer — matches the core loader's tight path.\n    if (!normals && !vb._n) {\n        normals = new Float32Array(vertexCount * 3);\n    }\n    if (!uvs && !vb._u) {\n        uvs = new Float32Array(vertexCount * 2);\n    }\n\n    const idxData = primitive.indices !== undefined ? resolveAccessor(json, binChunk, primitive.indices) : null;\n    const indices = idxData\n        ? idxData._data instanceof Uint32Array\n            ? new Uint32Array(idxData._data)\n            : idxData._data instanceof Uint8Array\n              ? Uint16Array.from(idxData._data)\n              : new Uint16Array(idxData._data.buffer, idxData._data.byteOffset, idxData._count)\n        : new Uint16Array(0);\n\n    return {\n        _positions: positions,\n        _normals: normals,\n        _tangents: tangents,\n        _uvs: uvs,\n        _uv2s: uv2s,\n        _colors: colors,\n        _indices: indices,\n        _vertexCount: vertexCount,\n        _indexCount: idxData?._count ?? 0,\n        _worldMatrix: worldMatrix,\n        _vb: vb,\n        _nodeIndex: nodeIdx,\n        _primitive: primitive,\n    };\n}\n\n/** Build the GPU geometry for an interleaved mesh: one shared buffer per\n *  bufferView for strided attributes (bound at offset with arrayStride), tight\n *  attributes get their own buffer — byte-identical to non-interleaved meshes.\n *  The raw `_slice` is intentionally retained on `_vb` so the CPU copy can be\n *  de-strided lazily later (see {@link installLazyCpu}). */\nfunction buildInterleavedGpu(engine: EngineContext, m: GltfMeshData): MeshGPU {\n    const vbsrc = m._vb!;\n    const shared = new Map<number, GPUBuffer>();\n    const vbuf = (a: AccessorInterleave | undefined, tight: Float32Array | null): GPUBuffer | null => {\n        if (!a) {\n            return tight ? createMappedBuffer(engine, tight, GPUBufferUsage.VERTEX) : null;\n        }\n        let b = shared.get(a._bufferView);\n        if (!b) {\n            shared.set(a._bufferView, (b = createMappedBuffer(engine, a._slice!, GPUBufferUsage.VERTEX)));\n        }\n        return b;\n    };\n    return {\n        positionBuffer: vbuf(vbsrc._p, m._positions)!,\n        normalBuffer: vbuf(vbsrc._n, m._normals)!,\n        tangentBuffer: m._tangents ? vbuf(vbsrc._t, m._tangents) : null,\n        uvBuffer: vbuf(vbsrc._u, m._uvs)!,\n        uv2Buffer: m._uv2s ? vbuf(vbsrc._u2, m._uv2s) : null,\n        colorBuffer: m._colors ? vbuf(vbsrc._c, m._colors) : null,\n        indexBuffer: createMappedBuffer(engine, m._indices, GPUBufferUsage.INDEX),\n        indexCount: m._indexCount,\n        indexFormat: (m._indices instanceof Uint32Array ? \"uint32\" : \"uint16\") as GPUIndexFormat,\n        _vbLayout: vbsrc,\n        _vbKey: `vb${vbsrc._p?._stride ?? 0}.${vbsrc._n?._stride ?? 0}.${vbsrc._t?._stride ?? 0}.${vbsrc._u?._stride ?? 0}`,\n    };\n}\n\n/** Build a complete engine mesh from interleaved glTF mesh-data. Owns ALL\n *  interleave-specific work (GPU upload, AABB fold, lazy CPU install, device-lost\n *  retention) so the core loader's tight path stays byte-identical to the\n *  non-interleaved engine — keeping interleave bytes out of every glTF scene that\n *  doesn't use it. */\nexport function buildInterleavedMesh(engine: EngineContext, m: GltfMeshData, index: number, material: PbrMaterialProps): Mesh {\n    const gpu = buildInterleavedGpu(engine, m);\n\n    // AABB: fold strided positions straight from the slice; tight positions normally.\n    const [boundMin, boundMax] = m._vb!._p ? computeAabbStrided(m._vb!._p, m._worldMatrix) : computeAabb(m._positions!, m._worldMatrix);\n\n    const mesh = {\n        name: `gltf_mesh_${index}`,\n        material,\n        receiveShadows: false,\n        boundMin,\n        boundMax,\n        skeleton: null,\n        morphTargets: null,\n        _materialDirty: false,\n        _gpu: gpu,\n    } as unknown as Mesh;\n    initMeshTransform(mesh);\n\n    // Lazy CPU geometry: the de-strided tight copy is built only on first read.\n    installLazyCpu(mesh, m);\n    mesh._cpuIndices = m._indices instanceof Uint32Array ? m._indices : new Uint32Array(m._indices);\n    engine._dlr?.m(mesh, m._uv2s, m._tangents, m._colors, m._indices, gpu.indexFormat);\n\n    return mesh as Mesh;\n}\n\n/** Fold an AABB directly over an interleaved (strided) FLOAT vec3 position\n *  source — no tight copy is materialized. Mirrors {@link computeAabb}'s\n *  world-transform handling. All current interleaved assets use FLOAT positions. */\nexport function computeAabbStrided(il: AccessorInterleave, world?: Mat4): Aabb {\n    const dv = new DataView(il._slice!.buffer, il._slice!.byteOffset, il._slice!.byteLength);\n    let minX = Infinity,\n        minY = Infinity,\n        minZ = Infinity;\n    let maxX = -Infinity,\n        maxY = -Infinity,\n        maxZ = -Infinity;\n    for (let v = 0; v < il._count; v++) {\n        const base = il._offset + v * il._stride;\n        const lx = dv.getFloat32(base, true);\n        const ly = dv.getFloat32(base + 4, true);\n        const lz = dv.getFloat32(base + 8, true);\n        let x = lx,\n            y = ly,\n            z = lz;\n        if (world) {\n            x = world[0]! * lx + world[4]! * ly + world[8]! * lz + world[12]!;\n            y = world[1]! * lx + world[5]! * ly + world[9]! * lz + world[13]!;\n            z = world[2]! * lx + world[6]! * ly + world[10]! * lz + world[14]!;\n        }\n        if (x < minX) {\n            minX = x;\n        }\n        if (x > maxX) {\n            maxX = x;\n        }\n        if (y < minY) {\n            minY = y;\n        }\n        if (y > maxY) {\n            maxY = y;\n        }\n        if (z < minZ) {\n            minZ = z;\n        }\n        if (z > maxZ) {\n            maxZ = z;\n        }\n    }\n    return [\n        [minX, minY, minZ],\n        [maxX, maxY, maxZ],\n    ];\n}\n\n/** Install lazy CPU-geometry accessors on an interleaved mesh. Each of\n *  `_cpuPositions/_cpuNormals/_cpuUvs` that comes from a strided source is\n *  defined as a getter that de-strides a tight copy on first access and caches\n *  it; tight attributes are assigned directly. A mesh that is never picked /\n *  CSG'd / navigated never materializes the de-strided arrays.\n *\n *  The property names are written as STATIC literals (not a computed key) so the\n *  minifier mangles them identically to the static reads in the picking /\n *  device-lost code — a computed `defineProperty(mesh, key)` would leave the name\n *  an unmangled literal and mismatch those reads across the chunk boundary. */\nexport function installLazyCpu(mesh: any, m: GltfMeshData): void {\n    const vb = m._vb!;\n    if (vb._p) {\n        Object.defineProperty(mesh, \"_cpuPositions\", lazyCpuDesc(vb._p));\n    } else if (m._positions) {\n        mesh._cpuPositions = m._positions;\n    }\n    if (vb._n) {\n        Object.defineProperty(mesh, \"_cpuNormals\", lazyCpuDesc(vb._n));\n    } else if (m._normals) {\n        mesh._cpuNormals = m._normals;\n    }\n    if (vb._u) {\n        Object.defineProperty(mesh, \"_cpuUvs\", lazyCpuDesc(vb._u));\n    } else if (m._uvs) {\n        mesh._cpuUvs = m._uvs;\n    }\n}\n\n/** Build a caching lazy-getter descriptor that de-strides `il` on first read. */\nfunction lazyCpuDesc(il: AccessorInterleave): PropertyDescriptor {\n    let cached: Float32Array | undefined;\n    return {\n        configurable: true,\n        enumerable: true,\n        get(): Float32Array {\n            return (cached ??= destrideToTight(il));\n        },\n        set(v: Float32Array): void {\n            cached = v;\n        },\n    };\n}\n"],"names":[],"mappings":"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"}

package/gltf-pbr-builder-ext-BFOxOCnQ.js

@@ -0,0 +1,85 @@
+import { z as pbrGroupBuilder, A as uploadTex, B as linearToSrgbByte, f as cloneTexture2D } from "./index-C8HOR2sB.js";
+function wrapTexCoord(tex, texInfo) {
+  var _a, _b;
+  if (!texInfo) {
+    return tex;
+  }
+  if (tex._texCoord === 1) {
+    return tex;
+  }
+  const ti = texInfo;
+  const tc = ((_b = (_a = ti.extensions) == null ? void 0 : _a.KHR_texture_transform) == null ? void 0 : _b.texCoord) ?? ti.texCoord;
+  return tc === 1 ? cloneTexture2D(tex, { _texCoord: 1 }) : tex;
+}
+function buildDefaultPbrTexturesExt(engine, mat, sampler, generateMipmaps, getCachedTex, wrapTex) {
+  const wrap = (tex, ti) => wrapTexCoord(wrapTex(tex, ti), ti);
+  const raw = mat._rawMatDef ?? {};
+  const pbr = raw.pbrMetallicRoughness ?? {};
+  const baseColorTexture = mat._baseColorImage ? wrap(getCachedTex(mat._baseColorImage, true), pbr.baseColorTexture) : (() => {
+    const f = mat._baseColorFactor;
+    return uploadTex(
+      engine,
+      null,
+      true,
+      sampler,
+      generateMipmaps,
+      new Uint8Array([linearToSrgbByte(f[0]), linearToSrgbByte(f[1]), linearToSrgbByte(f[2]), Math.round(Math.max(0, Math.min(1, f[3])) * 255)])
+    );
+  })();
+  const normalTexture = mat._normalImage ? wrap(getCachedTex(mat._normalImage, false), raw.normalTexture) : void 0;
+  const emissiveTexture = mat._emissiveImage ? wrap(getCachedTex(mat._emissiveImage, true), raw.emissiveTexture) : void 0;
+  const occlusionOnUv2 = mat._occlusionTexCoord !== 0 && mat._occlusionImage && !mat._metallicRoughnessImage;
+  let occlusionTexture;
+  const single = mat._metallicRoughnessImage ?? (occlusionOnUv2 ? null : mat._occlusionImage);
+  let ormTexture;
+  if (occlusionOnUv2) {
+    const clamp = (v) => Math.round(Math.max(0, Math.min(1, v)) * 255);
+    ormTexture = uploadTex(engine, null, false, sampler, generateMipmaps, new Uint8Array([255, clamp(mat._roughnessFactor), clamp(mat._metallicFactor), 255]));
+    occlusionTexture = wrap(getCachedTex(mat._occlusionImage, false), raw.occlusionTexture);
+  } else if (single && (!mat._metallicRoughnessImage || !mat._occlusionImage || mat._metallicRoughnessImage === mat._occlusionImage)) {
+    const ormTi = mat._metallicRoughnessImage ? pbr.metallicRoughnessTexture : raw.occlusionTexture;
+    ormTexture = wrap(getCachedTex(single, false), ormTi);
+  } else if (!single) {
+    const clamp = (v) => Math.round(Math.max(0, Math.min(1, v)) * 255);
+    ormTexture = uploadTex(engine, null, false, sampler, generateMipmaps, new Uint8Array([255, clamp(mat._roughnessFactor), clamp(mat._metallicFactor), 255]));
+  } else {
+    ormTexture = wrap(getCachedTex(mat._metallicRoughnessImage, false), pbr.metallicRoughnessTexture);
+  }
+  return { baseColorTexture, ormTexture, normalTexture, emissiveTexture, occlusionTexture };
+}
+function assemblePbrPropsExt(mat, tex, extLayers) {
+  var _a, _b, _c, _d;
+  const ef = mat._emissiveFactor;
+  const defaultFactor = ef[0] === 1 && ef[1] === 1 && ef[2] === 1 || ef[0] === 0 && ef[1] === 0 && ef[2] === 0;
+  const hasAnyUvTx = !!tex.baseColorTexture._hasTx || !!((_a = tex.normalTexture) == null ? void 0 : _a._hasTx) || !!tex.ormTexture._hasTx || !!((_b = tex.emissiveTexture) == null ? void 0 : _b._hasTx) || !!((_c = tex.occlusionTexture) == null ? void 0 : _c._hasTx);
+  return {
+    baseColorTexture: tex.baseColorTexture,
+    normalTexture: tex.normalTexture,
+    ormTexture: tex.ormTexture,
+    emissiveTexture: tex.emissiveTexture,
+    ...mat._baseColorImage && !isDefaultBaseColorFactor(mat._baseColorFactor) ? { baseColorFactor: mat._baseColorFactor } : void 0,
+    doubleSided: mat._doubleSided,
+    occlusionStrength: mat._occlusionImage ? 1 : 0,
+    ...mat._occlusionTexCoord ? { occlusionTexCoord: mat._occlusionTexCoord } : void 0,
+    ...tex.occlusionTexture ? { occlusionTexture: tex.occlusionTexture } : void 0,
+    ...mat._normalScale !== 1 ? { normalTextureScale: mat._normalScale } : void 0,
+    ...mat._metallicRoughnessImage ? { metallicFactor: mat._metallicFactor, roughnessFactor: mat._roughnessFactor } : void 0,
+    ...!defaultFactor ? { emissiveColor: [ef[0], ef[1], ef[2]] } : void 0,
+    enableSpecularAA: true,
+    ...mat._alphaMode === "BLEND" ? { alphaBlend: true, alpha: mat._baseColorFactor[3] } : void 0,
+    ...mat._alphaMode === "MASK" ? { alpha: mat._baseColorFactor[3], alphaCutOff: mat._alphaCutoff } : void 0,
+    ...hasAnyUvTx ? { _hasUvTx: true } : void 0,
+    ...((_d = mat._rawMatDef) == null ? void 0 : _d.name) ? { name: mat._rawMatDef.name } : void 0,
+    ...extLayers,
+    _buildGroup: pbrGroupBuilder,
+    _uboVersion: 0
+  };
+}
+function isDefaultBaseColorFactor(f) {
+  return f[0] === 1 && f[1] === 1 && f[2] === 1 && f[3] === 1;
+}
+export {
+  assemblePbrPropsExt,
+  buildDefaultPbrTexturesExt
+};
+//# sourceMappingURL=gltf-pbr-builder-ext-BFOxOCnQ.js.map

package/gltf-pbr-builder-ext-BFOxOCnQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-pbr-builder-ext-BFOxOCnQ.js","sources":["../src/loader-gltf/gltf-pbr-builder-ext.ts"],"sourcesContent":["/** Lazy-loaded slow path for PBR material assembly.\n *  Only pulled into bundles whose glTF uses features that require per-texture\n *  wrapping (e.g. KHR_texture_transform) or occlusion on UV2 (texCoord=1 with\n *  no shared MR image). Scene1 (BoomBox) and any vanilla-PBR glTF skip this\n *  module entirely. */\n\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { Texture2D } from \"../texture/texture-2d.js\";\nimport { cloneTexture2D } from \"../texture/texture-2d.js\";\nimport type { PbrMaterialProps } from \"../material/pbr/pbr-material.js\";\nimport { pbrGroupBuilder } from \"../material/pbr/pbr-material.js\";\nimport type { GltfMaterialData } from \"./gltf-material.js\";\nimport { linearToSrgbByte } from \"../math/color.js\";\nimport type { TextureWrapFn, GenerateMipmapsFn } from \"./gltf-pbr-builder.js\";\nimport { uploadTex } from \"./gltf-pbr-builder.js\";\n\nexport interface PbrTexturesExt {\n    baseColorTexture: Texture2D;\n    ormTexture: Texture2D;\n    normalTexture: Texture2D | undefined;\n    emissiveTexture: Texture2D | undefined;\n    occlusionTexture: Texture2D | undefined;\n}\n\n/** Stamp `_texCoord=1` on a clone when textureInfo selects UV1 and the\n *  wrapTex layer didn't already set it (i.e. scene has no KHR_texture_transform). */\nfunction wrapTexCoord(tex: Texture2D, texInfo: unknown): Texture2D {\n    if (!texInfo) {\n        return tex;\n    }\n    if ((tex as { _texCoord?: 0 | 1 })._texCoord === 1) {\n        return tex;\n    }\n    const ti = texInfo as { texCoord?: number; extensions?: { KHR_texture_transform?: { texCoord?: number } } };\n    const tc = ti.extensions?.KHR_texture_transform?.texCoord ?? ti.texCoord;\n    return tc === 1 ? cloneTexture2D(tex, { _texCoord: 1 }) : tex;\n}\n\n/** Build textures with wrapTex + occlusionOnUv2 support. Mirrors master's\n *  default texture building but honors per-textureInfo wrapping so\n *  KHR_texture_transform can attach per-texture UV state. */\nexport function buildDefaultPbrTexturesExt(\n    engine: EngineContext,\n    mat: GltfMaterialData,\n    sampler: GPUSampler,\n    generateMipmaps: GenerateMipmapsFn,\n    getCachedTex: (bitmap: ImageBitmap, srgb: boolean) => Texture2D,\n    wrapTex: TextureWrapFn\n): PbrTexturesExt {\n    const wrap: TextureWrapFn = (tex, ti) => wrapTexCoord(wrapTex(tex, ti), ti);\n    const raw = mat._rawMatDef ?? {};\n    const pbr = raw.pbrMetallicRoughness ?? {};\n    const baseColorTexture = mat._baseColorImage\n        ? wrap(getCachedTex(mat._baseColorImage, true), pbr.baseColorTexture)\n        : (() => {\n              const f = mat._baseColorFactor;\n              return uploadTex(\n                  engine,\n                  null,\n                  true,\n                  sampler,\n                  generateMipmaps,\n                  new Uint8Array([linearToSrgbByte(f[0]), linearToSrgbByte(f[1]), linearToSrgbByte(f[2]), Math.round(Math.max(0, Math.min(1, f[3])) * 255)])\n              );\n          })();\n    const normalTexture = mat._normalImage ? wrap(getCachedTex(mat._normalImage, false), raw.normalTexture) : undefined;\n    const emissiveTexture = mat._emissiveImage ? wrap(getCachedTex(mat._emissiveImage, true), raw.emissiveTexture) : undefined;\n\n    const occlusionOnUv2 = mat._occlusionTexCoord !== 0 && mat._occlusionImage && !mat._metallicRoughnessImage;\n    let occlusionTexture: Texture2D | undefined;\n    const single = mat._metallicRoughnessImage ?? (occlusionOnUv2 ? null : mat._occlusionImage);\n    let ormTexture: Texture2D;\n    if (occlusionOnUv2) {\n        const clamp = (v: number) => Math.round(Math.max(0, Math.min(1, v)) * 255);\n        ormTexture = uploadTex(engine, null, false, sampler, generateMipmaps, new Uint8Array([255, clamp(mat._roughnessFactor), clamp(mat._metallicFactor), 255]));\n        occlusionTexture = wrap(getCachedTex(mat._occlusionImage!, false), raw.occlusionTexture);\n    } else if (single && (!mat._metallicRoughnessImage || !mat._occlusionImage || mat._metallicRoughnessImage === mat._occlusionImage)) {\n        const ormTi = mat._metallicRoughnessImage ? pbr.metallicRoughnessTexture : raw.occlusionTexture;\n        ormTexture = wrap(getCachedTex(single, false), ormTi);\n    } else if (!single) {\n        const clamp = (v: number) => Math.round(Math.max(0, Math.min(1, v)) * 255);\n        ormTexture = uploadTex(engine, null, false, sampler, generateMipmaps, new Uint8Array([255, clamp(mat._roughnessFactor), clamp(mat._metallicFactor), 255]));\n    } else {\n        ormTexture = wrap(getCachedTex(mat._metallicRoughnessImage!, false), pbr.metallicRoughnessTexture);\n    }\n    return { baseColorTexture, ormTexture, normalTexture, emissiveTexture, occlusionTexture };\n}\n\n/** Slow-path assembly: adds occlusionTexCoord and occlusionTexture props. */\nexport function assemblePbrPropsExt(mat: GltfMaterialData, tex: PbrTexturesExt, extLayers: Partial<PbrMaterialProps> | undefined): PbrMaterialProps {\n    const ef = mat._emissiveFactor;\n    const defaultFactor = (ef[0] === 1 && ef[1] === 1 && ef[2] === 1) || (ef[0] === 0 && ef[1] === 0 && ef[2] === 0);\n    // Precompute UV-transform presence so the renderer doesn't scan 5 textures\n    // per mesh. Any wrapped texture with `_hasTx=true` (set by gltf-ext-uv-transform)\n    // flips this once at build time; omitted entirely on fast path.\n    const hasAnyUvTx =\n        !!(tex.baseColorTexture as { _hasTx?: true })._hasTx ||\n        !!(tex.normalTexture as { _hasTx?: true } | undefined)?._hasTx ||\n        !!(tex.ormTexture as { _hasTx?: true })._hasTx ||\n        !!(tex.emissiveTexture as { _hasTx?: true } | undefined)?._hasTx ||\n        !!(tex.occlusionTexture as { _hasTx?: true } | undefined)?._hasTx;\n    return {\n        baseColorTexture: tex.baseColorTexture,\n        normalTexture: tex.normalTexture,\n        ormTexture: tex.ormTexture,\n        emissiveTexture: tex.emissiveTexture,\n        ...(mat._baseColorImage && !isDefaultBaseColorFactor(mat._baseColorFactor) ? { baseColorFactor: mat._baseColorFactor } : undefined),\n        doubleSided: mat._doubleSided,\n        occlusionStrength: mat._occlusionImage ? 1.0 : 0,\n        ...(mat._occlusionTexCoord ? { occlusionTexCoord: mat._occlusionTexCoord } : undefined),\n        ...(tex.occlusionTexture ? { occlusionTexture: tex.occlusionTexture } : undefined),\n        ...(mat._normalScale !== 1 ? { normalTextureScale: mat._normalScale } : undefined),\n        ...(mat._metallicRoughnessImage ? { metallicFactor: mat._metallicFactor, roughnessFactor: mat._roughnessFactor } : undefined),\n        ...(!defaultFactor ? { emissiveColor: [ef[0], ef[1], ef[2]] as [number, number, number] } : undefined),\n        enableSpecularAA: true,\n        ...(mat._alphaMode === \"BLEND\" ? { alphaBlend: true, alpha: mat._baseColorFactor[3] } : undefined),\n        ...(mat._alphaMode === \"MASK\" ? { alpha: mat._baseColorFactor[3], alphaCutOff: mat._alphaCutoff } : undefined),\n        ...(hasAnyUvTx ? { _hasUvTx: true } : undefined),\n        ...(mat._rawMatDef?.name ? { name: mat._rawMatDef.name as string } : undefined),\n        ...extLayers,\n        _buildGroup: pbrGroupBuilder,\n        _uboVersion: 0,\n    } as PbrMaterialProps;\n}\n\nfunction isDefaultBaseColorFactor(f: readonly number[]): boolean {\n    return f[0] === 1 && f[1] === 1 && f[2] === 1 && f[3] === 1;\n}\n"],"names":[],"mappings":"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"}

package/gltf-variants-DFbr8EES.js

@@ -0,0 +1,88 @@
+import { aN as identityTexWrap, aO as getOrCreateSampler, aP as assembleMaterial, aQ as runMatExts, A as uploadTex, aR as makeImageFetcher } from "./index-C8HOR2sB.js";
+import { buildDefaultPbrTexturesExt, assemblePbrPropsExt } from "./gltf-pbr-builder-ext-BFOxOCnQ.js";
+async function loadVariantMaterials(json, binChunk, baseUrl, variantNames, meshes, engine, exts, wrapTex = identityTexWrap) {
+  var _a;
+  const generateMipmaps = (await import("./index-C8HOR2sB.js").then((n) => n.gg)).generateMipmaps;
+  const sampler = getOrCreateSampler(engine, {
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+    addressModeU: "repeat",
+    addressModeV: "repeat",
+    maxAnisotropy: 4
+  });
+  const matCache = /* @__PURE__ */ new Map();
+  const imageCache = /* @__PURE__ */ new Map();
+  const fetchImg = makeImageFetcher(json, binChunk, baseUrl, imageCache);
+  const getCachedTex = (bitmap, srgb) => uploadTex(engine, bitmap, srgb, sampler, generateMipmaps);
+  const extCtx = {
+    _engine: engine,
+    async _texture(texInfo, sRGB) {
+      if (!texInfo) {
+        return void 0;
+      }
+      const img = await fetchImg(texInfo);
+      return img ? wrapTex(uploadTex(engine, img, sRGB, sampler, generateMipmaps), texInfo) : void 0;
+    },
+    _uploadImage(bitmap, sRGB) {
+      return uploadTex(engine, bitmap, sRGB, sampler, generateMipmaps);
+    }
+  };
+  const getMat = (matIdx) => {
+    let p = matCache.get(matIdx);
+    if (!p) {
+      p = assembleMaterial(json, binChunk, matIdx, baseUrl, imageCache);
+      matCache.set(matIdx, p);
+    }
+    return p;
+  };
+  const pbrCache = /* @__PURE__ */ new Map();
+  const getPbr = (gltfMat) => {
+    let p = pbrCache.get(gltfMat);
+    if (!p) {
+      p = (async () => {
+        const tex = buildDefaultPbrTexturesExt(engine, gltfMat, sampler, generateMipmaps, getCachedTex, wrapTex);
+        const layers = await runMatExts(gltfMat, exts, extCtx);
+        return assemblePbrPropsExt(gltfMat, tex, layers);
+      })();
+      pbrCache.set(gltfMat, p);
+    }
+    return p;
+  };
+  const originals = [];
+  const variants = {};
+  for (const name of variantNames) {
+    variants[name] = [];
+  }
+  let meshIdx = 0;
+  for (let nodeIdx = 0; nodeIdx < json.nodes.length; nodeIdx++) {
+    const node = json.nodes[nodeIdx];
+    if (node.mesh === void 0) {
+      continue;
+    }
+    const gltfMesh = json.meshes[node.mesh];
+    for (const primitive of gltfMesh.primitives) {
+      const mesh = meshes[meshIdx];
+      const variantExt = (_a = primitive.extensions) == null ? void 0 : _a.KHR_materials_variants;
+      if (variantExt == null ? void 0 : variantExt.mappings) {
+        originals.push({ mesh, material: mesh.material });
+        for (const mapping of variantExt.mappings) {
+          const gltfMat = await getMat(mapping.material);
+          const pbrMat = await getPbr(gltfMat);
+          for (const vi of mapping.variants) {
+            const name = variantNames[vi];
+            if (name) {
+              variants[name].push({ mesh, material: pbrMat });
+            }
+          }
+        }
+      }
+      meshIdx++;
+    }
+  }
+  return { names: variantNames, variants, originals };
+}
+export {
+  loadVariantMaterials
+};
+//# sourceMappingURL=gltf-variants-DFbr8EES.js.map

package/gltf-variants-DFbr8EES.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-variants-DFbr8EES.js","sources":["../src/loader-gltf/gltf-variants.ts"],"sourcesContent":["/**\n * KHR_materials_variants — glTF parsing + GPU upload for variant materials.\n *\n * Dynamically imported by load-gltf.ts ONLY when the extension is present.\n * This keeps variant code fully tree-shaken from bundles that don't use it.\n */\n\nimport type { Mesh } from \"../mesh/mesh.js\";\nimport type { PbrMaterialProps } from \"../material/pbr/pbr-material.js\";\nimport type { GltfMaterialData, GltfMatExtCtx } from \"./gltf-material.js\";\nimport { assembleMaterial, makeImageFetcher } from \"./gltf-material.js\";\nimport type { GltfFeature } from \"./gltf-feature.js\";\nimport type { MaterialVariantData, VariantMeshEntry } from \"./material-variants.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\nimport { getOrCreateSampler } from \"../resource/gpu-pool.js\";\nimport { runMatExts, uploadTex, type GenerateMipmapsFn, type TextureWrapFn, identityTexWrap } from \"./gltf-pbr-builder.js\";\nimport { buildDefaultPbrTexturesExt, assemblePbrPropsExt } from \"./gltf-pbr-builder-ext.js\";\n\n/**\n * Self-contained variant material loader.\n * Parses variant mappings from glTF JSON primitives, assembles + uploads variant materials,\n * and builds MaterialVariantData. Called only when KHR_materials_variants is present.\n */\nexport async function loadVariantMaterials(\n    json: any,\n    binChunk: DataView,\n    baseUrl: string,\n    variantNames: string[],\n    meshes: Mesh[],\n    engine: EngineContext,\n    exts: GltfFeature[],\n    wrapTex: TextureWrapFn = identityTexWrap\n): Promise<MaterialVariantData> {\n    const generateMipmaps: GenerateMipmapsFn = (await import(\"../texture/generate-mipmaps.js\")).generateMipmaps;\n\n    const sampler = getOrCreateSampler(engine, {\n        magFilter: \"linear\",\n        minFilter: \"linear\",\n        mipmapFilter: \"linear\",\n        addressModeU: \"repeat\",\n        addressModeV: \"repeat\",\n        maxAnisotropy: 4,\n    });\n\n    const matCache = new Map<number, Promise<GltfMaterialData>>();\n    const imageCache = new Map<number, Promise<ImageBitmap>>();\n    const fetchImg = makeImageFetcher(json, binChunk, baseUrl, imageCache);\n    const getCachedTex = (bitmap: ImageBitmap, srgb: boolean) => uploadTex(engine, bitmap, srgb, sampler, generateMipmaps);\n    const extCtx: GltfMatExtCtx = {\n        _engine: engine,\n        async _texture(texInfo, sRGB) {\n            if (!texInfo) {\n                return undefined;\n            }\n            const img = await fetchImg(texInfo);\n            return img ? wrapTex(uploadTex(engine, img, sRGB, sampler, generateMipmaps), texInfo) : undefined;\n        },\n        _uploadImage(bitmap, sRGB) {\n            return uploadTex(engine, bitmap, sRGB, sampler, generateMipmaps);\n        },\n    };\n    const getMat = (matIdx: number): Promise<GltfMaterialData> => {\n        let p = matCache.get(matIdx);\n        if (!p) {\n            p = assembleMaterial(json, binChunk, matIdx, baseUrl, imageCache);\n            matCache.set(matIdx, p);\n        }\n        return p;\n    };\n\n    const pbrCache = new Map<GltfMaterialData, Promise<PbrMaterialProps>>();\n    const getPbr = (gltfMat: GltfMaterialData): Promise<PbrMaterialProps> => {\n        let p = pbrCache.get(gltfMat);\n        if (!p) {\n            p = (async () => {\n                const tex = buildDefaultPbrTexturesExt(engine, gltfMat, sampler, generateMipmaps, getCachedTex, wrapTex);\n                const layers = await runMatExts(gltfMat, exts, extCtx);\n                return assemblePbrPropsExt(gltfMat, tex, layers);\n            })();\n            pbrCache.set(gltfMat, p);\n        }\n        return p;\n    };\n\n    const originals: VariantMeshEntry[] = [];\n    const variants: Record<string, VariantMeshEntry[]> = {};\n    for (const name of variantNames) {\n        variants[name] = [];\n    }\n\n    let meshIdx = 0;\n    for (let nodeIdx = 0; nodeIdx < json.nodes.length; nodeIdx++) {\n        const node = json.nodes[nodeIdx];\n        if (node.mesh === undefined) {\n            continue;\n        }\n        const gltfMesh = json.meshes[node.mesh];\n        for (const primitive of gltfMesh.primitives) {\n            const mesh = meshes[meshIdx]!;\n            const variantExt = primitive.extensions?.KHR_materials_variants;\n            if (variantExt?.mappings) {\n                originals.push({ mesh, material: mesh.material });\n                for (const mapping of variantExt.mappings as { material: number; variants: number[] }[]) {\n                    const gltfMat = await getMat(mapping.material);\n                    const pbrMat = await getPbr(gltfMat);\n                    for (const vi of mapping.variants) {\n                        const name = variantNames[vi];\n                        if (name) {\n                            variants[name]!.push({ mesh, material: pbrMat });\n                        }\n                    }\n                }\n            }\n            meshIdx++;\n        }\n    }\n\n    return { names: variantNames, variants, originals };\n}\n"],"names":[],"mappings":";;AAuBA,eAAsB,qBAClB,MACA,UACA,SACA,cACA,QACA,QACA,MACA,UAAyB,iBACG;;AAC5B,QAAM,mBAAsC,MAAM,OAAO,qBAAgC,EAAA,KAAA,OAAA,EAAA,EAAA,GAAG;AAE5F,QAAM,UAAU,mBAAmB,QAAQ;AAAA,IACvC,WAAW;AAAA,IACX,WAAW;AAAA,IACX,cAAc;AAAA,IACd,cAAc;AAAA,IACd,cAAc;AAAA,IACd,eAAe;AAAA,EAAA,CAClB;AAED,QAAM,+BAAe,IAAA;AACrB,QAAM,iCAAiB,IAAA;AACvB,QAAM,WAAW,iBAAiB,MAAM,UAAU,SAAS,UAAU;AACrE,QAAM,eAAe,CAAC,QAAqB,SAAkB,UAAU,QAAQ,QAAQ,MAAM,SAAS,eAAe;AACrH,QAAM,SAAwB;AAAA,IAC1B,SAAS;AAAA,IACT,MAAM,SAAS,SAAS,MAAM;AAC1B,UAAI,CAAC,SAAS;AACV,eAAO;AAAA,MACX;AACA,YAAM,MAAM,MAAM,SAAS,OAAO;AAClC,aAAO,MAAM,QAAQ,UAAU,QAAQ,KAAK,MAAM,SAAS,eAAe,GAAG,OAAO,IAAI;AAAA,IAC5F;AAAA,IACA,aAAa,QAAQ,MAAM;AACvB,aAAO,UAAU,QAAQ,QAAQ,MAAM,SAAS,eAAe;AAAA,IACnE;AAAA,EAAA;AAEJ,QAAM,SAAS,CAAC,WAA8C;AAC1D,QAAI,IAAI,SAAS,IAAI,MAAM;AAC3B,QAAI,CAAC,GAAG;AACJ,UAAI,iBAAiB,MAAM,UAAU,QAAQ,SAAS,UAAU;AAChE,eAAS,IAAI,QAAQ,CAAC;AAAA,IAC1B;AACA,WAAO;AAAA,EACX;AAEA,QAAM,+BAAe,IAAA;AACrB,QAAM,SAAS,CAAC,YAAyD;AACrE,QAAI,IAAI,SAAS,IAAI,OAAO;AAC5B,QAAI,CAAC,GAAG;AACJ,WAAK,YAAY;AACb,cAAM,MAAM,2BAA2B,QAAQ,SAAS,SAAS,iBAAiB,cAAc,OAAO;AACvG,cAAM,SAAS,MAAM,WAAW,SAAS,MAAM,MAAM;AACrD,eAAO,oBAAoB,SAAS,KAAK,MAAM;AAAA,MACnD,GAAA;AACA,eAAS,IAAI,SAAS,CAAC;AAAA,IAC3B;AACA,WAAO;AAAA,EACX;AAEA,QAAM,YAAgC,CAAA;AACtC,QAAM,WAA+C,CAAA;AACrD,aAAW,QAAQ,cAAc;AAC7B,aAAS,IAAI,IAAI,CAAA;AAAA,EACrB;AAEA,MAAI,UAAU;AACd,WAAS,UAAU,GAAG,UAAU,KAAK,MAAM,QAAQ,WAAW;AAC1D,UAAM,OAAO,KAAK,MAAM,OAAO;AAC/B,QAAI,KAAK,SAAS,QAAW;AACzB;AAAA,IACJ;AACA,UAAM,WAAW,KAAK,OAAO,KAAK,IAAI;AACtC,eAAW,aAAa,SAAS,YAAY;AACzC,YAAM,OAAO,OAAO,OAAO;AAC3B,YAAM,cAAa,eAAU,eAAV,mBAAsB;AACzC,UAAI,yCAAY,UAAU;AACtB,kBAAU,KAAK,EAAE,MAAM,UAAU,KAAK,UAAU;AAChD,mBAAW,WAAW,WAAW,UAAwD;AACrF,gBAAM,UAAU,MAAM,OAAO,QAAQ,QAAQ;AAC7C,gBAAM,SAAS,MAAM,OAAO,OAAO;AACnC,qBAAW,MAAM,QAAQ,UAAU;AAC/B,kBAAM,OAAO,aAAa,EAAE;AAC5B,gBAAI,MAAM;AACN,uBAAS,IAAI,EAAG,KAAK,EAAE,MAAM,UAAU,QAAQ;AAAA,YACnD;AAAA,UACJ;AAAA,QACJ;AAAA,MACJ;AACA;AAAA,IACJ;AAAA,EACJ;AAEA,SAAO,EAAE,OAAO,cAAc,UAAU,UAAA;AAC5C;"}

package/gradient-block-DL_60sDc.js

@@ -0,0 +1,50 @@
+import { f as formatFloat } from "./_math-factory-C-QqW-Wi.js";
+function readSteps(raw) {
+  if (!Array.isArray(raw)) {
+    return [
+      { step: 0, color: { r: 0, g: 0, b: 0 } },
+      { step: 1, color: { r: 1, g: 1, b: 1 } }
+    ];
+  }
+  return raw.map((entry) => {
+    if (!entry || typeof entry !== "object") {
+      return null;
+    }
+    const e = entry;
+    const c = e.color;
+    if (typeof e.step !== "number" || !c || typeof c.r !== "number" || typeof c.g !== "number" || typeof c.b !== "number") {
+      return null;
+    }
+    return { step: e.step, color: { r: c.r, g: c.g, b: c.b } };
+  }).filter((entry) => entry !== null);
+}
+function colorLiteral(step) {
+  return `vec3<f32>(${formatFloat(step.color.r)}, ${formatFloat(step.color.g)}, ${formatFloat(step.color.b)})`;
+}
+const emitter = {
+  className: "GradientBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = block.inputs.get("gradient");
+    const steps = readSteps(block.serialized.colorSteps);
+    if (!(input == null ? void 0 : input.source) || steps.length === 0) {
+      return { expr: "vec3<f32>(0.0, 0.0, 0.0)", type: "vec3f" };
+    }
+    const gradient = ctx.resolve(block, "gradient", stage, state);
+    const g = gradient.type === "f32" ? gradient.expr : `((${gradient.expr}).x)`;
+    const tempColor = ctx.temp(state, "gradientColor");
+    const tempPosition = ctx.temp(state, "gradientPosition");
+    state[stage].body.push(`var ${tempColor}: vec3<f32> = ${colorLiteral(steps[0])};`);
+    state[stage].body.push(`var ${tempPosition}: f32;`);
+    for (let i = 1; i < steps.length; i++) {
+      const previous = steps[i - 1];
+      const current = steps[i];
+      state[stage].body.push(`${tempPosition} = clamp((${g} - ${formatFloat(previous.step)}) / (${formatFloat(current.step)} - ${formatFloat(previous.step)}), 0.0, 1.0);`);
+      state[stage].body.push(`${tempColor} = mix(${tempColor}, ${colorLiteral(current)}, ${tempPosition});`);
+    }
+    return { expr: tempColor, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=gradient-block-DL_60sDc.js.map

package/gradient-block-DL_60sDc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient-block-DL_60sDc.js","sources":["../src/material/node/blocks/gradient-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\nimport { formatFloat } from \"./_math-factory.js\";\n\ninterface ColorStep {\n    readonly step: number;\n    readonly color: { readonly r: number; readonly g: number; readonly b: number };\n}\n\nfunction readSteps(raw: unknown): ColorStep[] {\n    if (!Array.isArray(raw)) {\n        return [\n            { step: 0, color: { r: 0, g: 0, b: 0 } },\n            { step: 1, color: { r: 1, g: 1, b: 1 } },\n        ];\n    }\n    return raw\n        .map((entry): ColorStep | null => {\n            if (!entry || typeof entry !== \"object\") {\n                return null;\n            }\n            const e = entry as Record<string, unknown>;\n            const c = e.color as Record<string, unknown> | undefined;\n            if (typeof e.step !== \"number\" || !c || typeof c.r !== \"number\" || typeof c.g !== \"number\" || typeof c.b !== \"number\") {\n                return null;\n            }\n            return { step: e.step, color: { r: c.r, g: c.g, b: c.b } };\n        })\n        .filter((entry): entry is ColorStep => entry !== null);\n}\n\nfunction colorLiteral(step: ColorStep): string {\n    return `vec3<f32>(${formatFloat(step.color.r)}, ${formatFloat(step.color.g)}, ${formatFloat(step.color.b)})`;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"GradientBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = block.inputs.get(\"gradient\");\n        const steps = readSteps(block.serialized.colorSteps);\n        if (!input?.source || steps.length === 0) {\n            return { expr: \"vec3<f32>(0.0, 0.0, 0.0)\", type: \"vec3f\" };\n        }\n        const gradient = ctx.resolve(block, \"gradient\", stage, state);\n        const g = gradient.type === \"f32\" ? gradient.expr : `((${gradient.expr}).x)`;\n        const tempColor = ctx.temp(state, \"gradientColor\");\n        const tempPosition = ctx.temp(state, \"gradientPosition\");\n        state[stage].body.push(`var ${tempColor}: vec3<f32> = ${colorLiteral(steps[0]!)};`);\n        state[stage].body.push(`var ${tempPosition}: f32;`);\n        for (let i = 1; i < steps.length; i++) {\n            const previous = steps[i - 1]!;\n            const current = steps[i]!;\n            state[stage].body.push(`${tempPosition} = clamp((${g} - ${formatFloat(previous.step)}) / (${formatFloat(current.step)} - ${formatFloat(previous.step)}), 0.0, 1.0);`);\n            state[stage].body.push(`${tempColor} = mix(${tempColor}, ${colorLiteral(current)}, ${tempPosition});`);\n        }\n        return { expr: tempColor, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":";AAQA,SAAS,UAAU,KAA2B;AAC1C,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACrB,WAAO;AAAA,MACH,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAE;AAAA,MACrC,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,EAAA,EAAE;AAAA,IAAE;AAAA,EAE/C;AACA,SAAO,IACF,IAAI,CAAC,UAA4B;AAC9B,QAAI,CAAC,SAAS,OAAO,UAAU,UAAU;AACrC,aAAO;AAAA,IACX;AACA,UAAM,IAAI;AACV,UAAM,IAAI,EAAE;AACZ,QAAI,OAAO,EAAE,SAAS,YAAY,CAAC,KAAK,OAAO,EAAE,MAAM,YAAY,OAAO,EAAE,MAAM,YAAY,OAAO,EAAE,MAAM,UAAU;AACnH,aAAO;AAAA,IACX;AACA,WAAO,EAAE,MAAM,EAAE,MAAM,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,IAAE;AAAA,EAC3D,CAAC,EACA,OAAO,CAAC,UAA8B,UAAU,IAAI;AAC7D;AAEA,SAAS,aAAa,MAAyB;AAC3C,SAAO,aAAa,YAAY,KAAK,MAAM,CAAC,CAAC,KAAK,YAAY,KAAK,MAAM,CAAC,CAAC,KAAK,YAAY,KAAK,MAAM,CAAC,CAAC;AAC7G;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,MAAM,OAAO,IAAI,UAAU;AACzC,UAAM,QAAQ,UAAU,MAAM,WAAW,UAAU;AACnD,QAAI,EAAC,+BAAO,WAAU,MAAM,WAAW,GAAG;AACtC,aAAO,EAAE,MAAM,4BAA4B,MAAM,QAAA;AAAA,IACrD;AACA,UAAM,WAAW,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK;AAC5D,UAAM,IAAI,SAAS,SAAS,QAAQ,SAAS,OAAO,KAAK,SAAS,IAAI;AACtE,UAAM,YAAY,IAAI,KAAK,OAAO,eAAe;AACjD,UAAM,eAAe,IAAI,KAAK,OAAO,kBAAkB;AACvD,UAAM,KAAK,EAAE,KAAK,KAAK,OAAO,SAAS,iBAAiB,aAAa,MAAM,CAAC,CAAE,CAAC,GAAG;AAClF,UAAM,KAAK,EAAE,KAAK,KAAK,OAAO,YAAY,QAAQ;AAClD,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,YAAM,WAAW,MAAM,IAAI,CAAC;AAC5B,YAAM,UAAU,MAAM,CAAC;AACvB,YAAM,KAAK,EAAE,KAAK,KAAK,GAAG,YAAY,aAAa,CAAC,MAAM,YAAY,SAAS,IAAI,CAAC,QAAQ,YAAY,QAAQ,IAAI,CAAC,MAAM,YAAY,SAAS,IAAI,CAAC,eAAe;AACpK,YAAM,KAAK,EAAE,KAAK,KAAK,GAAG,SAAS,UAAU,SAAS,KAAK,aAAa,OAAO,CAAC,KAAK,YAAY,IAAI;AAAA,IACzG;AACA,WAAO,EAAE,MAAM,WAAW,MAAM,QAAA;AAAA,EACpC;AACJ;"}