@babylonjs/lite 0.2.0 → 1.0.1

package/{gltf-glb-parser-D6UZWFuC.js → gltf-glb-parser-CqOeXFOz.js}

@@ -1,5 +1,6 @@
+import { D as DV, e as U8 } from "./index-C-tEgwbZ.js";
 function parseGlbContainer(buffer) {
-  const view = new DataView(buffer);
+  const view = new DV(buffer);
   const magic = view.getUint32(0, true);
   if (magic !== 1179937895) {
     throw new Error("Not a valid GLB file");
@@ -10,7 +11,7 @@ function parseGlbContainer(buffer) {
   if (jsonType !== 1313821514) {
     throw new Error("First GLB chunk is not JSON");
   }
-  const jsonStr = new TextDecoder().decode(new Uint8Array(buffer, offset + 8, jsonLength));
+  const jsonStr = new TextDecoder().decode(new U8(buffer, offset + 8, jsonLength));
   const json = JSON.parse(jsonStr);
   offset += 8 + jsonLength;
   const binLength = view.getUint32(offset, true);
@@ -18,10 +19,10 @@ function parseGlbContainer(buffer) {
   if (binType !== 5130562) {
     throw new Error("Second GLB chunk is not BIN");
   }
-  const binChunk = new DataView(buffer, offset + 8, binLength);
+  const binChunk = new DV(buffer, offset + 8, binLength);
   return { json, binChunk };
 }
 export {
   parseGlbContainer
 };
-//# sourceMappingURL=gltf-glb-parser-D6UZWFuC.js.map
+//# sourceMappingURL=gltf-glb-parser-CqOeXFOz.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-glb-parser-CqOeXFOz.js","sources":["../src/loader-gltf/gltf-glb-parser.ts"],"sourcesContent":["import { U8, DV } from \"../engine/typed-arrays.js\";\n/** 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 DV(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 U8(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 DV(buffer, offset + 8, binLength);\n\n    return { json, binChunk };\n}\n"],"names":[],"mappings":";AAGO,SAAS,kBAAkB,QAAwD;AACtF,QAAM,OAAO,IAAI,GAAG,MAAM;AAG1B,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,GAAG,QAAQ,SAAS,GAAG,UAAU,CAAC;AAC/E,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,GAAG,QAAQ,SAAS,GAAG,SAAS;AAErD,SAAO,EAAE,MAAM,SAAA;AACnB;"}

package/{gltf-interleave-C9eBqH_F.js → gltf-interleave-DWf27t-h.js}

@@ -1,4 +1,4 @@
-import { T as TYPE_SIZES, d as computeAabb, i as initMeshTransform, r as resolveAccessor, e as createMappedBuffer } from "./index-B7Qhw0xL.js";
+import { g as TYPE_SIZES, h as computeAabb, i as initMeshTransform, U as U32, a as F32, r as resolveAccessor, e as U8, j as U16, D as DV, k as createMappedBuffer, B as BU } from "./index-C-tEgwbZ.js";
 const FLOAT = 5126;
 const UNSIGNED_SHORT = 5123;
 const UNSIGNED_INT = 5125;
@@ -25,15 +25,15 @@ function resolveStrided(json, binChunk, accessorIdx) {
     _componentType: accessor.componentType,
     _componentCount: TYPE_SIZES[accessor.type] ?? 1,
     _count: accessor.count,
-    _slice: new Uint8Array(ab, binChunk.byteOffset + (bufferView.byteOffset ?? 0), bufferView.byteLength)
+    _slice: new U8(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 dv = new DV(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);
+  const out = new F32(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++) {
@@ -89,13 +89,13 @@ function buildInterleavedPartial(json, binChunk, primitive, worldMatrix, nodeIdx
   const uv2s = uv2._tight;
   const colors = col._tight;
   if (!normals && !vb._n) {
-    normals = new Float32Array(vertexCount * 3);
+    normals = new F32(vertexCount * 3);
   }
   if (!uvs && !vb._u) {
-    uvs = new Float32Array(vertexCount * 2);
+    uvs = new F32(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);
+  const indices = idxData ? idxData._data instanceof U32 ? new U32(idxData._data) : idxData._data instanceof U8 ? Uint16Array.from(idxData._data) : new U16(idxData._data.buffer, idxData._data.byteOffset, idxData._count) : new U16(0);
   return {
     _positions: positions,
     _normals: normals,
@@ -118,11 +118,11 @@ function buildInterleavedGpu(engine, m) {
   const shared = /* @__PURE__ */ new Map();
   const vbuf = (a, tight) => {
     if (!a) {
-      return tight ? createMappedBuffer(engine, tight, GPUBufferUsage.VERTEX) : null;
+      return tight ? createMappedBuffer(engine, tight, BU.VERTEX) : null;
     }
     let b = shared.get(a._bufferView);
     if (!b) {
-      shared.set(a._bufferView, b = createMappedBuffer(engine, a._slice, GPUBufferUsage.VERTEX));
+      shared.set(a._bufferView, b = createMappedBuffer(engine, a._slice, BU.VERTEX));
     }
     return b;
   };
@@ -133,9 +133,9 @@ function buildInterleavedGpu(engine, m) {
     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),
+    indexBuffer: createMappedBuffer(engine, m._indices, BU.INDEX),
     indexCount: m._indexCount,
-    indexFormat: m._indices instanceof Uint32Array ? "uint32" : "uint16",
+    indexFormat: m._indices instanceof U32 ? "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}`
   };
@@ -152,17 +152,16 @@ function buildInterleavedMesh(engine, m, index, material) {
     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);
+  mesh._cpuIndices = m._indices instanceof U32 ? m._indices : new U32(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);
+  const dv = new DV(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++) {
@@ -238,4 +237,4 @@ export {
   computeAabbStrided,
   installLazyCpu
 };
-//# sourceMappingURL=gltf-interleave-C9eBqH_F.js.map
+//# sourceMappingURL=gltf-interleave-DWf27t-h.js.map

package/gltf-interleave-DWf27t-h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-interleave-DWf27t-h.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 { F32, U32, U16, U8, DV } from \"../engine/typed-arrays.js\";\nimport { BU } from \"../engine/gpu-flags.js\";\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 U8(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 DV(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 F32(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 F32(vertexCount * 3);\n    }\n    if (!uvs && !vb._u) {\n        uvs = new F32(vertexCount * 2);\n    }\n\n    const idxData = primitive.indices !== undefined ? resolveAccessor(json, binChunk, primitive.indices) : null;\n    const indices = idxData\n        ? idxData._data instanceof U32\n            ? new U32(idxData._data)\n            : idxData._data instanceof U8\n              ? Uint16Array.from(idxData._data)\n              : new U16(idxData._data.buffer, idxData._data.byteOffset, idxData._count)\n        : new U16(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, BU.VERTEX) : null;\n        }\n        let b = shared.get(a._bufferView);\n        if (!b) {\n            shared.set(a._bufferView, (b = createMappedBuffer(engine, a._slice!, BU.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, BU.INDEX),\n        indexCount: m._indexCount,\n        indexFormat: (m._indices instanceof U32 ? \"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        _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 U32 ? m._indices : new U32(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 DV(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":";AA4BA,MAAM,QAAQ;AACd,MAAM,iBAAiB;AACvB,MAAM,eAAe;AACrB,MAAM,gBAAgB;AAEtB,MAAM,aAAqC,EAAE,CAAC,aAAa,GAAG,GAAG,CAAC,cAAc,GAAG,GAAG,CAAC,YAAY,GAAG,GAAG,CAAC,KAAK,GAAG,EAAA;AAyC3G,SAAS,kBAAkB,MAAW,KAAsB;AAC/D,QAAM,IAAI,KAAK,UAAU,GAAG;AAC5B,QAAM,KAAK,KAAK,YAAY,EAAE,UAAU;AACxC,QAAM,SAA6B,GAAG;AACtC,MAAI,WAAW,QAAW;AACtB,WAAO;AAAA,EACX;AACA,QAAM,aAAa,WAAW,EAAE,IAAI,KAAK,MAAM,WAAW,EAAE,aAAa,KAAK;AAC9E,SAAO,WAAW;AACtB;AAGA,SAAS,eAAe,MAAW,UAAoB,aAAyC;AAC5F,QAAM,WAAW,KAAK,UAAU,WAAW;AAC3C,QAAM,aAAa,KAAK,YAAY,SAAS,UAAU;AACvD,QAAM,KAAK,SAAS;AACpB,SAAO;AAAA,IACH,aAAa,SAAS;AAAA,IACtB,SAAS,WAAW;AAAA,IACpB,SAAS,SAAS,cAAc;AAAA,IAChC,gBAAgB,SAAS;AAAA,IACzB,iBAAiB,WAAW,SAAS,IAAI,KAAK;AAAA,IAC9C,QAAQ,SAAS;AAAA,IACjB,QAAQ,IAAI,GAAG,IAAI,SAAS,cAAc,WAAW,cAAc,IAAI,WAAW,UAAU;AAAA,EAAA;AAEpG;AAKA,SAAS,gBAAgB,IAAsC;AAC3D,QAAM,KAAK,IAAI,GAAG,GAAG,OAAQ,QAAQ,GAAG,OAAQ,YAAY,GAAG,OAAQ,UAAU;AACjF,QAAM,KAAK,WAAW,GAAG,cAAc,KAAK;AAC5C,QAAM,KAAK,GAAG;AACd,QAAM,KAAK,GAAG;AACd,QAAM,MAAM,IAAI,IAAI,GAAG,SAAS,EAAE;AAClC,WAAS,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK;AAChC,UAAM,UAAU,GAAG,UAAU,IAAI,GAAG;AACpC,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,YAAM,MAAM,UAAU,IAAI;AAC1B,UAAI,IAAI,KAAK,CAAC,IACV,OAAO,QAAQ,GAAG,WAAW,KAAK,IAAI,IAAI,OAAO,iBAAiB,GAAG,UAAU,KAAK,IAAI,IAAI,OAAO,eAAe,GAAG,UAAU,KAAK,IAAI,IAAI,GAAG,SAAS,GAAG;AAAA,IACnK;AAAA,EACJ;AACA,SAAO;AACX;AAYO,SAAS,wBAAwB,MAAW,UAAoB,WAAgB,aAAmB,SAA8D;AACpK,QAAM,QAAQ,UAAU;AAGxB,MAAI,aAAa;AACjB,aAAW,QAAQ,OAAO;AACtB,QAAI,kBAAkB,MAAM,MAAM,IAAI,CAAC,GAAG;AACtC,mBAAa;AACb;AAAA,IACJ;AAAA,EACJ;AACA,MAAI,CAAC,YAAY;AACb,WAAO;AAAA,EACX;AAEA,QAAM,KAAa,CAAA;AACnB,MAAI,cAAc;AASlB,QAAM,aAAa,CAAC,MAAc,UAA8F;AAC5H,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI,QAAQ,QAAW;AACnB,aAAO,EAAE,QAAQ,MAAM,QAAQ,EAAA;AAAA,IACnC;AACA,QAAI,kBAAkB,MAAM,GAAG,GAAG;AAC9B,YAAM,KAAK,eAAe,MAAM,UAAU,GAAG;AAC7C,aAAO,EAAE,QAAQ,QAAQ,gBAAgB,EAAE,IAAI,MAAM,KAAK,IAAI,QAAQ,GAAG,OAAA;AAAA,IAC7E;AACA,UAAM,KAAK,gBAAgB,MAAM,UAAU,GAAG;AAC9C,WAAO,EAAE,QAAQ,GAAG,OAAuB,QAAQ,GAAG,OAAA;AAAA,EAC1D;AAEA,QAAM,MAAM,WAAW,YAAY,KAAK;AACxC,KAAG,KAAK,IAAI;AACZ,gBAAc,IAAI;AAClB,QAAM,MAAM,WAAW,UAAU,KAAK;AACtC,KAAG,KAAK,IAAI;AACZ,QAAM,KAAK,WAAW,cAAc,KAAK;AACzC,KAAG,KAAK,GAAG;AACX,QAAM,MAAM,WAAW,WAAW,IAAI;AACtC,KAAG,KAAK,IAAI;AACZ,QAAM,MAAM,WAAW,cAAc,IAAI;AACzC,KAAG,MAAM,IAAI;AACb,QAAM,MAAM,WAAW,WAAW,IAAI;AACtC,KAAG,KAAK,IAAI;AAEZ,QAAM,YAAY,IAAI;AACtB,MAAI,UAAU,IAAI;AAClB,MAAI,MAAM,GAAG;AACb,QAAM,WAAW,IAAI;AACrB,QAAM,OAAO,IAAI;AACjB,QAAM,SAAS,IAAI;AAInB,MAAI,CAAC,WAAW,CAAC,GAAG,IAAI;AACpB,cAAU,IAAI,IAAI,cAAc,CAAC;AAAA,EACrC;AACA,MAAI,CAAC,OAAO,CAAC,GAAG,IAAI;AAChB,UAAM,IAAI,IAAI,cAAc,CAAC;AAAA,EACjC;AAEA,QAAM,UAAU,UAAU,YAAY,SAAY,gBAAgB,MAAM,UAAU,UAAU,OAAO,IAAI;AACvG,QAAM,UAAU,UACV,QAAQ,iBAAiB,MACrB,IAAI,IAAI,QAAQ,KAAK,IACrB,QAAQ,iBAAiB,KACvB,YAAY,KAAK,QAAQ,KAAK,IAC9B,IAAI,IAAI,QAAQ,MAAM,QAAQ,QAAQ,MAAM,YAAY,QAAQ,MAAM,IAC5E,IAAI,IAAI,CAAC;AAEf,SAAO;AAAA,IACH,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,WAAW;AAAA,IACX,MAAM;AAAA,IACN,OAAO;AAAA,IACP,SAAS;AAAA,IACT,UAAU;AAAA,IACV,cAAc;AAAA,IACd,cAAa,mCAAS,WAAU;AAAA,IAChC,cAAc;AAAA,IACd,KAAK;AAAA,IACL,YAAY;AAAA,IACZ,YAAY;AAAA,EAAA;AAEpB;AAOA,SAAS,oBAAoB,QAAuB,GAA0B;;AAC1E,QAAM,QAAQ,EAAE;AAChB,QAAM,6BAAa,IAAA;AACnB,QAAM,OAAO,CAAC,GAAmC,UAAiD;AAC9F,QAAI,CAAC,GAAG;AACJ,aAAO,QAAQ,mBAAmB,QAAQ,OAAO,GAAG,MAAM,IAAI;AAAA,IAClE;AACA,QAAI,IAAI,OAAO,IAAI,EAAE,WAAW;AAChC,QAAI,CAAC,GAAG;AACJ,aAAO,IAAI,EAAE,aAAc,IAAI,mBAAmB,QAAQ,EAAE,QAAS,GAAG,MAAM,CAAE;AAAA,IACpF;AACA,WAAO;AAAA,EACX;AACA,SAAO;AAAA,IACH,gBAAgB,KAAK,MAAM,IAAI,EAAE,UAAU;AAAA,IAC3C,cAAc,KAAK,MAAM,IAAI,EAAE,QAAQ;AAAA,IACvC,eAAe,EAAE,YAAY,KAAK,MAAM,IAAI,EAAE,SAAS,IAAI;AAAA,IAC3D,UAAU,KAAK,MAAM,IAAI,EAAE,IAAI;AAAA,IAC/B,WAAW,EAAE,QAAQ,KAAK,MAAM,KAAK,EAAE,KAAK,IAAI;AAAA,IAChD,aAAa,EAAE,UAAU,KAAK,MAAM,IAAI,EAAE,OAAO,IAAI;AAAA,IACrD,aAAa,mBAAmB,QAAQ,EAAE,UAAU,GAAG,KAAK;AAAA,IAC5D,YAAY,EAAE;AAAA,IACd,aAAc,EAAE,oBAAoB,MAAM,WAAW;AAAA,IACrD,WAAW;AAAA,IACX,QAAQ,OAAK,WAAM,OAAN,mBAAU,YAAW,CAAC,MAAI,WAAM,OAAN,mBAAU,YAAW,CAAC,MAAI,WAAM,OAAN,mBAAU,YAAW,CAAC,MAAI,WAAM,OAAN,mBAAU,YAAW,CAAC;AAAA,EAAA;AAEzH;AAOO,SAAS,qBAAqB,QAAuB,GAAiB,OAAe,UAAkC;;AAC1H,QAAM,MAAM,oBAAoB,QAAQ,CAAC;AAGzC,QAAM,CAAC,UAAU,QAAQ,IAAI,EAAE,IAAK,KAAK,mBAAmB,EAAE,IAAK,IAAI,EAAE,YAAY,IAAI,YAAY,EAAE,YAAa,EAAE,YAAY;AAElI,QAAM,OAAO;AAAA,IACT,MAAM,aAAa,KAAK;AAAA,IACxB;AAAA,IACA,gBAAgB;AAAA,IAChB;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV,cAAc;AAAA,IACd,MAAM;AAAA,EAAA;AAEV,oBAAkB,IAAI;AAGtB,iBAAe,MAAM,CAAC;AACtB,OAAK,cAAc,EAAE,oBAAoB,MAAM,EAAE,WAAW,IAAI,IAAI,EAAE,QAAQ;AAC9E,eAAO,SAAP,mBAAa,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,IAAI;AAEtE,SAAO;AACX;AAKO,SAAS,mBAAmB,IAAwB,OAAoB;AAC3E,QAAM,KAAK,IAAI,GAAG,GAAG,OAAQ,QAAQ,GAAG,OAAQ,YAAY,GAAG,OAAQ,UAAU;AACjF,MAAI,OAAO,UACP,OAAO,UACP,OAAO;AACX,MAAI,OAAO,WACP,OAAO,WACP,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK;AAChC,UAAM,OAAO,GAAG,UAAU,IAAI,GAAG;AACjC,UAAM,KAAK,GAAG,WAAW,MAAM,IAAI;AACnC,UAAM,KAAK,GAAG,WAAW,OAAO,GAAG,IAAI;AACvC,UAAM,KAAK,GAAG,WAAW,OAAO,GAAG,IAAI;AACvC,QAAI,IAAI,IACJ,IAAI,IACJ,IAAI;AACR,QAAI,OAAO;AACP,UAAI,MAAM,CAAC,IAAK,KAAK,MAAM,CAAC,IAAK,KAAK,MAAM,CAAC,IAAK,KAAK,MAAM,EAAE;AAC/D,UAAI,MAAM,CAAC,IAAK,KAAK,MAAM,CAAC,IAAK,KAAK,MAAM,CAAC,IAAK,KAAK,MAAM,EAAE;AAC/D,UAAI,MAAM,CAAC,IAAK,KAAK,MAAM,CAAC,IAAK,KAAK,MAAM,EAAE,IAAK,KAAK,MAAM,EAAE;AAAA,IACpE;AACA,QAAI,IAAI,MAAM;AACV,aAAO;AAAA,IACX;AACA,QAAI,IAAI,MAAM;AACV,aAAO;AAAA,IACX;AACA,QAAI,IAAI,MAAM;AACV,aAAO;AAAA,IACX;AACA,QAAI,IAAI,MAAM;AACV,aAAO;AAAA,IACX;AACA,QAAI,IAAI,MAAM;AACV,aAAO;AAAA,IACX;AACA,QAAI,IAAI,MAAM;AACV,aAAO;AAAA,IACX;AAAA,EACJ;AACA,SAAO;AAAA,IACH,CAAC,MAAM,MAAM,IAAI;AAAA,IACjB,CAAC,MAAM,MAAM,IAAI;AAAA,EAAA;AAEzB;AAYO,SAAS,eAAe,MAAW,GAAuB;AAC7D,QAAM,KAAK,EAAE;AACb,MAAI,GAAG,IAAI;AACP,WAAO,eAAe,MAAM,iBAAiB,YAAY,GAAG,EAAE,CAAC;AAAA,EACnE,WAAW,EAAE,YAAY;AACrB,SAAK,gBAAgB,EAAE;AAAA,EAC3B;AACA,MAAI,GAAG,IAAI;AACP,WAAO,eAAe,MAAM,eAAe,YAAY,GAAG,EAAE,CAAC;AAAA,EACjE,WAAW,EAAE,UAAU;AACnB,SAAK,cAAc,EAAE;AAAA,EACzB;AACA,MAAI,GAAG,IAAI;AACP,WAAO,eAAe,MAAM,WAAW,YAAY,GAAG,EAAE,CAAC;AAAA,EAC7D,WAAW,EAAE,MAAM;AACf,SAAK,UAAU,EAAE;AAAA,EACrB;AACJ;AAGA,SAAS,YAAY,IAA4C;AAC7D,MAAI;AACJ,SAAO;AAAA,IACH,cAAc;AAAA,IACd,YAAY;AAAA,IACZ,MAAoB;AAChB,aAAQ,oBAAW,gBAAgB,EAAE;AAAA,IACzC;AAAA,IACA,IAAI,GAAuB;AACvB,eAAS;AAAA,IACb;AAAA,EAAA;AAER;"}

package/{gltf-pbr-builder-ext-DPC0zg_u.js → gltf-pbr-builder-ext-DvFxuOqN.js}

@@ -1,4 +1,4 @@
-import { k as pbrGroupBuilder, u as uploadTex, l as linearToSrgbByte, o as cloneTexture2D } from "./index-B7Qhw0xL.js";
+import { s as pbrGroupBuilder, u as uploadTex, e as U8, t as linearToSrgbByte, v as cloneTexture2D } from "./index-C-tEgwbZ.js";
 function wrapTexCoord(tex, texInfo) {
   var _a, _b;
   if (!texInfo) {
@@ -23,7 +23,7 @@ function buildDefaultPbrTexturesExt(engine, mat, sampler, generateMipmaps, getCa
       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)])
+      new U8([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;
@@ -34,14 +34,14 @@ function buildDefaultPbrTexturesExt(engine, mat, sampler, generateMipmaps, getCa
   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]));
+    ormTexture = uploadTex(engine, null, false, sampler, generateMipmaps, new U8([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]));
+    ormTexture = uploadTex(engine, null, false, sampler, generateMipmaps, new U8([255, clamp(mat._roughnessFactor), clamp(mat._metallicFactor), 255]));
   } else {
     ormTexture = wrap(getCachedTex(mat._metallicRoughnessImage, false), pbr.metallicRoughnessTexture);
   }
@@ -82,4 +82,4 @@ export {
   assemblePbrPropsExt,
   buildDefaultPbrTexturesExt
 };
-//# sourceMappingURL=gltf-pbr-builder-ext-DPC0zg_u.js.map
+//# sourceMappingURL=gltf-pbr-builder-ext-DvFxuOqN.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-pbr-builder-ext-DvFxuOqN.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 { U8 } from \"../engine/typed-arrays.js\";\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 U8([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 U8([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 U8([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-CnBEZr0o.js → gltf-variants-CUvzYGYX.js}

@@ -1,8 +1,8 @@
-import { aV as identityTexWrap, aW as getOrCreateSampler, aX as assembleMaterial, aY as runMatExts, u as uploadTex, aZ as makeImageFetcher } from "./index-B7Qhw0xL.js";
-import { buildDefaultPbrTexturesExt, assemblePbrPropsExt } from "./gltf-pbr-builder-ext-DPC0zg_u.js";
+import { bt as identityTexWrap, bu as getOrCreateSampler, bv as assembleMaterial, bw as runMatExts, u as uploadTex, bx as makeImageFetcher } from "./index-C-tEgwbZ.js";
+import { buildDefaultPbrTexturesExt, assemblePbrPropsExt } from "./gltf-pbr-builder-ext-DvFxuOqN.js";
 async function loadVariantMaterials(json, binChunk, baseUrl, variantNames, meshes, engine, exts, wrapTex = identityTexWrap) {
   var _a;
-  const generateMipmaps = (await import("./index-B7Qhw0xL.js").then((n) => n.gC)).generateMipmaps;
+  const generateMipmaps = (await import("./index-C-tEgwbZ.js").then((n) => n.jw)).generateMipmaps;
   const sampler = getOrCreateSampler(engine, {
     magFilter: "linear",
     minFilter: "linear",
@@ -85,4 +85,4 @@ async function loadVariantMaterials(json, binChunk, baseUrl, variantNames, meshe
 export {
   loadVariantMaterials
 };
-//# sourceMappingURL=gltf-variants-CnBEZr0o.js.map
+//# sourceMappingURL=gltf-variants-CUvzYGYX.js.map

package/{gltf-variants-CnBEZr0o.js.map → gltf-variants-CUvzYGYX.js.map}

@@ -1 +1 @@
-{"version":3,"file":"gltf-variants-CnBEZr0o.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;"}
+{"version":3,"file":"gltf-variants-CUvzYGYX.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/gpu-task-timer-Dgkff80h.js

@@ -0,0 +1,236 @@
+import { m as makeTimingSnapshot } from "./index-C-tEgwbZ.js";
+const INITIAL_TASK_CAPACITY = 64;
+const MAX_IN_FLIGHT_READBACKS = 3;
+function createGpuTaskTimer(device) {
+  if (!device.features.has("timestamp-query")) {
+    return null;
+  }
+  const queryCount = INITIAL_TASK_CAPACITY * 2;
+  return {
+    device,
+    querySet: device.createQuerySet({ type: "timestamp", count: queryCount }),
+    resolveBuffer: device.createBuffer({
+      size: queryCount * 8,
+      usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC
+    }),
+    readbackPool: [],
+    records: [],
+    wrappedGraphs: [],
+    patchedContextLists: [],
+    patchedSurfaceLists: [],
+    taskCapacity: INITIAL_TASK_CAPACITY,
+    currentEncoder: null,
+    frameIndex: 0,
+    droppedTaskCount: 0,
+    inFlight: 0,
+    skipFrame: false
+  };
+}
+function installGpuTaskTimer(timer, engine, publish) {
+  patchSurfaceList(timer, engine._surfaces);
+  for (const surface of engine.surfaces) {
+    patchSurface(timer, surface);
+  }
+  const previousResolve = engine._gpuTimerResolve;
+  const resolveTaskTiming = () => finishTaskTimingFrame(timer, publish);
+  const resolveBoth = () => {
+    previousResolve == null ? void 0 : previousResolve();
+    resolveTaskTiming();
+  };
+  engine._gpuTaskTimerResolve = resolveTaskTiming;
+  engine._gpuTimerResolve = resolveBoth;
+  return () => restoreWrappedFrameGraphs(timer, engine, previousResolve, resolveTaskTiming, resolveBoth);
+}
+function patchSurfaceList(timer, list) {
+  for (const patched of timer.patchedSurfaceLists) {
+    if (patched.list === list) {
+      return;
+    }
+  }
+  const push = list.push;
+  list.push = (...items) => {
+    const length = push.apply(list, items);
+    for (const surface of items) {
+      patchSurface(timer, surface);
+    }
+    return length;
+  };
+  timer.patchedSurfaceLists.push({ list, push });
+}
+function patchSurface(timer, surface) {
+  const contexts = surface._renderingContexts;
+  patchContextList(timer, contexts);
+  for (const context of contexts) {
+    const graph = getFrameGraphFromContext(context);
+    if (graph) {
+      wrapFrameGraph(timer, graph);
+    }
+  }
+}
+function patchContextList(timer, list) {
+  for (const patched of timer.patchedContextLists) {
+    if (patched.list === list) {
+      return;
+    }
+  }
+  const push = list.push;
+  list.push = (...items) => {
+    const length = push.apply(list, items);
+    for (const context of items) {
+      const graph = getFrameGraphFromContext(context);
+      if (graph) {
+        wrapFrameGraph(timer, graph);
+      }
+    }
+    return length;
+  };
+  timer.patchedContextLists.push({ list, push });
+}
+function wrapFrameGraph(timer, graph) {
+  for (const wrapped of timer.wrappedGraphs) {
+    if (wrapped.graph === graph) {
+      return;
+    }
+  }
+  const original = graph.execute;
+  const timed = () => executeTimedFrameGraph(timer, graph);
+  graph.execute = timed;
+  timer.wrappedGraphs.push({ graph, execute: original });
+}
+function restoreWrappedFrameGraphs(timer, engine, previousResolve, resolveTaskTiming, resolveBoth) {
+  for (const patched of timer.patchedSurfaceLists) {
+    patched.list.push = patched.push;
+  }
+  timer.patchedSurfaceLists.length = 0;
+  for (const patched of timer.patchedContextLists) {
+    patched.list.push = patched.push;
+  }
+  timer.patchedContextLists.length = 0;
+  for (const wrapped of timer.wrappedGraphs) {
+    wrapped.graph.execute = wrapped.execute;
+  }
+  timer.wrappedGraphs.length = 0;
+  timer.currentEncoder = null;
+  if (engine._gpuTaskTimerResolve === resolveTaskTiming) {
+    engine._gpuTaskTimerResolve = void 0;
+  }
+  if (engine._gpuTimerResolve === resolveBoth) {
+    engine._gpuTimerResolve = previousResolve;
+  } else if (engine._gpuTimerResolve === resolveTaskTiming) {
+    engine._gpuTimerResolve = void 0;
+  }
+}
+function getFrameGraphFromContext(context) {
+  const owner = context;
+  const graph = owner._frameGraph ?? owner.frameGraph;
+  return isFrameGraph(graph) ? graph : null;
+}
+function isFrameGraph(value) {
+  return typeof value === "object" && value !== null && "_tasks" in value && "execute" in value;
+}
+function executeTimedFrameGraph(timer, graph) {
+  let drawCalls = 0;
+  for (const task of graph._tasks) {
+    drawCalls += gpuTaskTimerExecute(timer, task);
+  }
+  return drawCalls;
+}
+function gpuTaskTimerExecute(timer, task) {
+  const encoder = task.engine._currentEncoder;
+  if (timer.currentEncoder !== encoder) {
+    beginTaskTimingFrame(timer, encoder);
+  }
+  if (timer.skipFrame) {
+    return executeTask(task);
+  }
+  const measuredCount = timer.records.length;
+  const taskIndex = measuredCount + timer.droppedTaskCount;
+  if (measuredCount >= timer.taskCapacity) {
+    timer.droppedTaskCount++;
+    return executeTask(task);
+  }
+  const beginQueryIndex = measuredCount * 2;
+  const endQueryIndex = beginQueryIndex + 1;
+  encoder.beginComputePass({ timestampWrites: { querySet: timer.querySet, beginningOfPassWriteIndex: beginQueryIndex } }).end();
+  const drawCalls = executeTask(task);
+  encoder.beginComputePass({ timestampWrites: { querySet: timer.querySet, endOfPassWriteIndex: endQueryIndex } }).end();
+  timer.records.push({ index: taskIndex, name: task.name, beginQueryIndex, endQueryIndex });
+  return drawCalls;
+}
+function executeTask(task) {
+  if (task.execute) {
+    return task.execute();
+  }
+  let drawCalls = 0;
+  for (const pass of task._passes) {
+    drawCalls += pass._execute();
+  }
+  return drawCalls;
+}
+function beginTaskTimingFrame(timer, encoder) {
+  timer.currentEncoder = encoder;
+  timer.records.length = 0;
+  timer.droppedTaskCount = 0;
+  timer.skipFrame = timer.inFlight > MAX_IN_FLIGHT_READBACKS;
+}
+function finishTaskTimingFrame(timer, publish) {
+  timer.frameIndex++;
+  const taskCount = timer.records.length;
+  if (timer.skipFrame || taskCount === 0 || timer.inFlight > MAX_IN_FLIGHT_READBACKS) {
+    return;
+  }
+  const queryCount = taskCount * 2;
+  const byteLength = queryCount * 8;
+  const readback = timer.readbackPool.pop() ?? createReadbackBuffer(timer);
+  const encoder = timer.device.createCommandEncoder({ label: "gpu-task-timing-resolve" });
+  encoder.resolveQuerySet(timer.querySet, 0, queryCount, timer.resolveBuffer, 0);
+  encoder.copyBufferToBuffer(timer.resolveBuffer, 0, readback, 0, byteLength);
+  timer.device.queue.submit([encoder.finish()]);
+  timer.inFlight++;
+  void finishTaskTimingReadback(timer, {
+    buffer: readback,
+    byteLength,
+    frameIndex: timer.frameIndex,
+    records: timer.records.slice(),
+    droppedTaskCount: timer.droppedTaskCount,
+    publish
+  });
+}
+function createReadbackBuffer(timer) {
+  return timer.device.createBuffer({
+    size: timer.taskCapacity * 16,
+    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+  });
+}
+async function finishTaskTimingReadback(timer, pending) {
+  const buffer = pending.buffer;
+  try {
+    await Promise.resolve();
+    await buffer.mapAsync(GPUMapMode.READ, 0, pending.byteLength);
+    const raw = new BigUint64Array(buffer.getMappedRange(0, pending.byteLength));
+    const tasks = [];
+    for (const record of pending.records) {
+      const begin = raw[record.beginQueryIndex];
+      const end = raw[record.endQueryIndex];
+      if (end >= begin) {
+        tasks.push({ index: record.index, name: record.name, durationMs: Number(end - begin) / 1e6 });
+      }
+    }
+    buffer.unmap();
+    timer.readbackPool.push(buffer);
+    timer.inFlight--;
+    pending.publish(makeTimingSnapshot("available", true, true, pending.frameIndex, tasks, pending.droppedTaskCount));
+  } catch (error) {
+    timer.inFlight--;
+    buffer.destroy();
+    pending.publish(makeTimingSnapshot("error", true, true, pending.frameIndex, [], pending.droppedTaskCount, readbackErrorMessage(error)));
+  }
+}
+function readbackErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  createGpuTaskTimer,
+  installGpuTaskTimer
+};
+//# sourceMappingURL=gpu-task-timer-Dgkff80h.js.map

package/gpu-task-timer-Dgkff80h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-task-timer-Dgkff80h.js","sources":["../src/engine/gpu-task-timer.ts"],"sourcesContent":["import type { EngineContext, RenderingContext } from \"./engine.js\";\nimport type { FrameGraph } from \"../frame-graph/frame-graph.js\";\nimport type { Task } from \"../frame-graph/task.js\";\nimport type { SurfaceContext } from \"./surface.js\";\nimport { makeTimingSnapshot, type RenderTaskGpuTiming, type RenderTaskGpuTimings } from \"./gpu-task-timing.js\";\n\nconst INITIAL_TASK_CAPACITY = 64;\nconst MAX_IN_FLIGHT_READBACKS = 3;\n\ninterface TaskTimingRecord {\n    readonly index: number;\n    readonly name: string;\n    readonly beginQueryIndex: number;\n    readonly endQueryIndex: number;\n}\n\ninterface PendingTaskTimingReadback {\n    readonly buffer: GPUBuffer;\n    readonly byteLength: number;\n    readonly frameIndex: number;\n    readonly records: readonly TaskTimingRecord[];\n    readonly droppedTaskCount: number;\n    readonly publish: (snapshot: RenderTaskGpuTimings) => void;\n}\n\ninterface WrappedFrameGraph {\n    readonly graph: FrameGraph;\n    readonly execute: () => number;\n}\n\ninterface PatchedContextList {\n    readonly list: RenderingContext[];\n    readonly push: (...items: RenderingContext[]) => number;\n}\n\ninterface PatchedSurfaceList {\n    readonly list: SurfaceContext[];\n    readonly push: (...items: SurfaceContext[]) => number;\n}\n\n/** @internal GPU resources/state for opt-in per-frame-graph-task timestamp queries. */\nexport interface GpuTaskTimer {\n    readonly device: GPUDevice;\n    readonly querySet: GPUQuerySet;\n    readonly resolveBuffer: GPUBuffer;\n    readonly readbackPool: GPUBuffer[];\n    readonly records: TaskTimingRecord[];\n    readonly wrappedGraphs: WrappedFrameGraph[];\n    readonly patchedContextLists: PatchedContextList[];\n    readonly patchedSurfaceLists: PatchedSurfaceList[];\n    readonly taskCapacity: number;\n    currentEncoder: GPUCommandEncoder | null;\n    frameIndex: number;\n    droppedTaskCount: number;\n    inFlight: number;\n    skipFrame: boolean;\n}\n\n/** Create the per-task GPU timer, or null when timestamp queries are unsupported. */\nexport function createGpuTaskTimer(device: GPUDevice): GpuTaskTimer | null {\n    if (!device.features.has(\"timestamp-query\")) {\n        return null;\n    }\n    const queryCount = INITIAL_TASK_CAPACITY * 2;\n    return {\n        device,\n        querySet: device.createQuerySet({ type: \"timestamp\", count: queryCount }),\n        resolveBuffer: device.createBuffer({\n            size: queryCount * 8,\n            usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,\n        }),\n        readbackPool: [],\n        records: [],\n        wrappedGraphs: [],\n        patchedContextLists: [],\n        patchedSurfaceLists: [],\n        taskCapacity: INITIAL_TASK_CAPACITY,\n        currentEncoder: null,\n        frameIndex: 0,\n        droppedTaskCount: 0,\n        inFlight: 0,\n        skipFrame: false,\n    };\n}\n\n/** Install timed frame-graph execute wrappers on all contexts currently registered with the engine. */\nexport function installGpuTaskTimer(timer: GpuTaskTimer, engine: EngineContext, publish: (snapshot: RenderTaskGpuTimings) => void): () => void {\n    patchSurfaceList(timer, engine._surfaces);\n    for (const surface of engine.surfaces) {\n        patchSurface(timer, surface);\n    }\n    const previousResolve = engine._gpuTimerResolve;\n    const resolveTaskTiming = () => finishTaskTimingFrame(timer, publish);\n    const resolveBoth = () => {\n        previousResolve?.();\n        resolveTaskTiming();\n    };\n    engine._gpuTaskTimerResolve = resolveTaskTiming;\n    engine._gpuTimerResolve = resolveBoth;\n    return () => restoreWrappedFrameGraphs(timer, engine, previousResolve, resolveTaskTiming, resolveBoth);\n}\n\nfunction patchSurfaceList(timer: GpuTaskTimer, list: SurfaceContext[]): void {\n    for (const patched of timer.patchedSurfaceLists) {\n        if (patched.list === list) {\n            return;\n        }\n    }\n    const push = list.push;\n    list.push = (...items: SurfaceContext[]) => {\n        const length = push.apply(list, items);\n        for (const surface of items) {\n            patchSurface(timer, surface);\n        }\n        return length;\n    };\n    timer.patchedSurfaceLists.push({ list, push });\n}\n\nfunction patchSurface(timer: GpuTaskTimer, surface: SurfaceContext): void {\n    const contexts = surface._renderingContexts;\n    patchContextList(timer, contexts);\n    for (const context of contexts) {\n        const graph = getFrameGraphFromContext(context);\n        if (graph) {\n            wrapFrameGraph(timer, graph);\n        }\n    }\n}\n\nfunction patchContextList(timer: GpuTaskTimer, list: RenderingContext[]): void {\n    for (const patched of timer.patchedContextLists) {\n        if (patched.list === list) {\n            return;\n        }\n    }\n    const push = list.push;\n    list.push = (...items: RenderingContext[]) => {\n        const length = push.apply(list, items);\n        for (const context of items) {\n            const graph = getFrameGraphFromContext(context);\n            if (graph) {\n                wrapFrameGraph(timer, graph);\n            }\n        }\n        return length;\n    };\n    timer.patchedContextLists.push({ list, push });\n}\n\nfunction wrapFrameGraph(timer: GpuTaskTimer, graph: FrameGraph): void {\n    for (const wrapped of timer.wrappedGraphs) {\n        if (wrapped.graph === graph) {\n            return;\n        }\n    }\n    const original = graph.execute;\n    const timed = () => executeTimedFrameGraph(timer, graph);\n    graph.execute = timed;\n    timer.wrappedGraphs.push({ graph, execute: original });\n}\n\nfunction restoreWrappedFrameGraphs(\n    timer: GpuTaskTimer,\n    engine: EngineContext,\n    previousResolve: (() => void) | undefined,\n    resolveTaskTiming: () => void,\n    resolveBoth: () => void\n): void {\n    for (const patched of timer.patchedSurfaceLists) {\n        patched.list.push = patched.push;\n    }\n    timer.patchedSurfaceLists.length = 0;\n    for (const patched of timer.patchedContextLists) {\n        patched.list.push = patched.push;\n    }\n    timer.patchedContextLists.length = 0;\n    for (const wrapped of timer.wrappedGraphs) {\n        wrapped.graph.execute = wrapped.execute;\n    }\n    timer.wrappedGraphs.length = 0;\n    timer.currentEncoder = null;\n    if (engine._gpuTaskTimerResolve === resolveTaskTiming) {\n        engine._gpuTaskTimerResolve = undefined;\n    }\n    if (engine._gpuTimerResolve === resolveBoth) {\n        engine._gpuTimerResolve = previousResolve;\n    } else if (engine._gpuTimerResolve === resolveTaskTiming) {\n        engine._gpuTimerResolve = undefined;\n    }\n}\n\nfunction getFrameGraphFromContext(context: RenderingContext): FrameGraph | null {\n    const owner = context as RenderingContext & { _frameGraph?: unknown; frameGraph?: unknown };\n    const graph = owner._frameGraph ?? owner.frameGraph;\n    return isFrameGraph(graph) ? graph : null;\n}\n\nfunction isFrameGraph(value: unknown): value is FrameGraph {\n    return typeof value === \"object\" && value !== null && \"_tasks\" in value && \"execute\" in value;\n}\n\nfunction executeTimedFrameGraph(timer: GpuTaskTimer, graph: FrameGraph): number {\n    let drawCalls = 0;\n    for (const task of graph._tasks) {\n        drawCalls += gpuTaskTimerExecute(timer, task);\n    }\n    return drawCalls;\n}\n\n/** Execute one frame-graph task bracketed by timestamp writes. */\nfunction gpuTaskTimerExecute(timer: GpuTaskTimer, task: Task): number {\n    const encoder = task.engine._currentEncoder;\n    if (timer.currentEncoder !== encoder) {\n        beginTaskTimingFrame(timer, encoder);\n    }\n    if (timer.skipFrame) {\n        return executeTask(task);\n    }\n\n    const measuredCount = timer.records.length;\n    const taskIndex = measuredCount + timer.droppedTaskCount;\n    if (measuredCount >= timer.taskCapacity) {\n        timer.droppedTaskCount++;\n        return executeTask(task);\n    }\n    const beginQueryIndex = measuredCount * 2;\n    const endQueryIndex = beginQueryIndex + 1;\n    encoder.beginComputePass({ timestampWrites: { querySet: timer.querySet, beginningOfPassWriteIndex: beginQueryIndex } }).end();\n    const drawCalls = executeTask(task);\n    encoder.beginComputePass({ timestampWrites: { querySet: timer.querySet, endOfPassWriteIndex: endQueryIndex } }).end();\n    timer.records.push({ index: taskIndex, name: task.name, beginQueryIndex, endQueryIndex });\n    return drawCalls;\n}\n\nfunction executeTask(task: Task): number {\n    if (task.execute) {\n        return task.execute();\n    }\n    let drawCalls = 0;\n    for (const pass of task._passes) {\n        drawCalls += pass._execute();\n    }\n    return drawCalls;\n}\n\nfunction beginTaskTimingFrame(timer: GpuTaskTimer, encoder: GPUCommandEncoder): void {\n    timer.currentEncoder = encoder;\n    timer.records.length = 0;\n    timer.droppedTaskCount = 0;\n    timer.skipFrame = timer.inFlight > MAX_IN_FLIGHT_READBACKS;\n}\n\n/** Resolve this frame's task timestamps after renderFrame has submitted the command buffer. */\nfunction finishTaskTimingFrame(timer: GpuTaskTimer, publish: (snapshot: RenderTaskGpuTimings) => void): void {\n    timer.frameIndex++;\n    const taskCount = timer.records.length;\n    if (timer.skipFrame || taskCount === 0 || timer.inFlight > MAX_IN_FLIGHT_READBACKS) {\n        return;\n    }\n\n    const queryCount = taskCount * 2;\n    const byteLength = queryCount * 8;\n    const readback = timer.readbackPool.pop() ?? createReadbackBuffer(timer);\n    const encoder = timer.device.createCommandEncoder({ label: \"gpu-task-timing-resolve\" });\n    encoder.resolveQuerySet(timer.querySet, 0, queryCount, timer.resolveBuffer, 0);\n    encoder.copyBufferToBuffer(timer.resolveBuffer, 0, readback, 0, byteLength);\n    timer.device.queue.submit([encoder.finish()]);\n    timer.inFlight++;\n    void finishTaskTimingReadback(timer, {\n        buffer: readback,\n        byteLength,\n        frameIndex: timer.frameIndex,\n        records: timer.records.slice(),\n        droppedTaskCount: timer.droppedTaskCount,\n        publish,\n    });\n}\n\nfunction createReadbackBuffer(timer: GpuTaskTimer): GPUBuffer {\n    return timer.device.createBuffer({\n        size: timer.taskCapacity * 16,\n        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,\n    });\n}\n\nasync function finishTaskTimingReadback(timer: GpuTaskTimer, pending: PendingTaskTimingReadback): Promise<void> {\n    const buffer = pending.buffer;\n    try {\n        // Let the resolve/copy submit leave the JavaScript stack before mapping.\n        await Promise.resolve();\n        await buffer.mapAsync(GPUMapMode.READ, 0, pending.byteLength);\n        const raw = new BigUint64Array(buffer.getMappedRange(0, pending.byteLength));\n        const tasks: RenderTaskGpuTiming[] = [];\n        for (const record of pending.records) {\n            const begin = raw[record.beginQueryIndex]!;\n            const end = raw[record.endQueryIndex]!;\n            if (end >= begin) {\n                tasks.push({ index: record.index, name: record.name, durationMs: Number(end - begin) / 1e6 });\n            }\n        }\n        buffer.unmap();\n        timer.readbackPool.push(buffer);\n        timer.inFlight--;\n        pending.publish(makeTimingSnapshot(\"available\", true, true, pending.frameIndex, tasks, pending.droppedTaskCount));\n    } catch (error) {\n        timer.inFlight--;\n        buffer.destroy();\n        pending.publish(makeTimingSnapshot(\"error\", true, true, pending.frameIndex, [], pending.droppedTaskCount, readbackErrorMessage(error)));\n    }\n}\n\nfunction readbackErrorMessage(error: unknown): string {\n    return error instanceof Error ? error.message : String(error);\n}\n"],"names":[],"mappings":"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"}

package/gpu-timer-CUpqT_hK.js

@@ -0,0 +1,55 @@
+function gpuTimingSupportedFor(device) {
+  return device.features.has("timestamp-query");
+}
+function createGpuFrameTimer(device) {
+  if (!gpuTimingSupportedFor(device)) {
+    return null;
+  }
+  const querySet = device.createQuerySet({ type: "timestamp", count: 2 });
+  const resolveBuf = device.createBuffer({
+    size: 16,
+    usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC
+  });
+  return { device, querySet, resolveBuf, pool: [], lastMs: 0, inFlight: 0 };
+}
+function gpuFrameTimerBegin(timer, encoder) {
+  encoder.beginComputePass({ timestampWrites: { querySet: timer.querySet, beginningOfPassWriteIndex: 0 } }).end();
+}
+function gpuFrameTimerEnd(timer, encoder) {
+  encoder.beginComputePass({ timestampWrites: { querySet: timer.querySet, endOfPassWriteIndex: 1 } }).end();
+}
+function gpuFrameTimerResolve(timer) {
+  if (timer.inFlight > 3) {
+    return;
+  }
+  const dev = timer.device;
+  const rb = timer.pool.pop() ?? dev.createBuffer({ size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ });
+  const enc = dev.createCommandEncoder();
+  enc.resolveQuerySet(timer.querySet, 0, 2, timer.resolveBuf, 0);
+  enc.copyBufferToBuffer(timer.resolveBuf, 0, rb, 0, 16);
+  dev.queue.submit([enc.finish()]);
+  timer.inFlight++;
+  rb.mapAsync(GPUMapMode.READ).then(
+    () => {
+      const a = new BigInt64Array(rb.getMappedRange());
+      const ms = Number(a[1] - a[0]) / 1e6;
+      if (ms >= 0 && ms < 5e3) {
+        timer.lastMs = timer.lastMs > 0 ? timer.lastMs * 0.8 + ms * 0.2 : ms;
+      }
+      rb.unmap();
+      timer.pool.push(rb);
+      timer.inFlight--;
+    },
+    () => {
+      timer.inFlight--;
+    }
+  );
+}
+export {
+  createGpuFrameTimer,
+  gpuFrameTimerBegin,
+  gpuFrameTimerEnd,
+  gpuFrameTimerResolve,
+  gpuTimingSupportedFor
+};
+//# sourceMappingURL=gpu-timer-CUpqT_hK.js.map