@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/bvhAccel.js

@@ -1,12 +1,11 @@
-import { readMeshInstance } from './meshInstances.js';
-// Bounding volume hierarchies of scene geometry (BLAS) and mesh instances
-// (TLAS), built with the binned SAH builder in ./binnedSahBvh and written
-// directly in the BVH2 layout read by the traversal shaders.
-import { Attribute } from '../scene/Geometry.js';
+import { readMeshInstance, meshInstancesLength } from './packedMeshInstances.js';
 import { mat4, vec3 } from '../math.js';
 import { buildBinnedSahBvh, layoutBvh2 } from './binnedSahBvh.js';
-const vec3Min = vec3.min;
-const vec3Max = vec3.max;
+import { read, write } from '../math/access.js';
+import { attributeLength, attributeValue, indexStorage } from '../scene/attributeData.js';
+import { Box3 } from './Box3.js';
+import { quantizeDisplacementRange } from './displacementRange.js';
+export { Box3 } from './Box3.js';
 export const INSTANCE_VEC4_STRIDE = 10;
 export const INSTANCE_WORD_STRIDE = INSTANCE_VEC4_STRIDE * 4;
 const BLAS_LAYOUT_SHIFT = 30;
@@ -23,17 +22,9 @@ function encodeBlasOffset(offset, layout) {
     }
     return (offset | (blasLayoutCodes[layout] << BLAS_LAYOUT_SHIFT)) | 0;
 }
-export class Box3 {
-    min;
-    max;
-    constructor() {
-        this.min = [Infinity, Infinity, Infinity];
-        this.max = [-Infinity, -Infinity, -Infinity];
-    }
-}
 function unionBounds(bounds, a, b) {
-    vec3Min(bounds.min, a.min, b.min);
-    vec3Max(bounds.max, a.max, b.max);
+    vec3.min(bounds.min, a.min, b.min);
+    vec3.max(bounds.max, a.max, b.max);
     return bounds;
 }
 // Keep a bounded specialization range for unusually deep hierarchies while
@@ -139,16 +130,17 @@ export function emptyBLAS() {
  */
 export function buildBLAS(geometry, displacementScale = 0, trianglesDisplacement) {
     const position = geometry.position;
-    const indices = geometry.indices?.array;
-    if (!position || !indices || !Attribute.getCount(position)) {
+    const indexAttribute = geometry.indices;
+    if (!position || !indexAttribute || !position.array.length) {
         return emptyBvh(false);
     }
+    const indices = indexStorage(indexAttribute.array);
     const positions = position.array;
     const stride = position.itemSize;
     const normal = trianglesDisplacement ? geometry.normal : undefined;
     const normals = normal?.array;
     const normalStride = normal?.itemSize ?? 0;
-    const triangleCount = Math.floor(indices.length / 3);
+    const triangleCount = Math.floor(attributeLength(indices) / 3);
     const aabbs = new Float32Array(triangleCount * 6);
     const triangles = new Uint32Array(triangleCount);
     let count = 0;
@@ -162,7 +154,7 @@ export function buildBLAS(geometry, displacementScale = 0, trianglesDisplacement
                 maxHeight = displacementScale;
             }
         }
-        if (triangleBounds(positions, stride, normals, normalStride, indices[t * 3], indices[t * 3 + 1], indices[t * 3 + 2], minHeight, maxHeight, aabbs, count * 6)) {
+        if (triangleBounds(positions, stride, normals, normalStride, attributeValue(indices, t * 3), attributeValue(indices, t * 3 + 1), attributeValue(indices, t * 3 + 2), minHeight, maxHeight, aabbs, count * 6)) {
             triangles[count++] = t;
         }
     }
@@ -175,6 +167,7 @@ export function buildBLAS(geometry, displacementScale = 0, trianglesDisplacement
     const floats = new Float32Array(buffer);
     const ints = new Int32Array(buffer);
     let buildSurfaceArea = 0;
+    const triangleIds = [];
     for (let k = 0; k < order.length; k++) {
         const node = order[k];
         const o = offsets[node] * 4, b = node * 6;
@@ -197,9 +190,11 @@ export function buildBLAS(geometry, displacementScale = 0, trianglesDisplacement
         for (let i = 0; i < prims; i++) {
             const t = triangles[primIndices[leftFirst[node] + i]];
             const e = o + 8 + i * 4;
-            ints[e] = indices[t * 3];
-            ints[e + 1] = indices[t * 3 + 1];
-            ints[e + 2] = indices[t * 3 + 2];
+            if (trianglesDisplacement)
+                triangleIds.push(e / 4, t);
+            ints[e] = attributeValue(indices, t * 3);
+            ints[e + 1] = attributeValue(indices, t * 3 + 1);
+            ints[e + 2] = attributeValue(indices, t * 3 + 2);
             // Pack minH, maxH to one channel.
             ints[e + 3] = trianglesDisplacement
                 ? packH(trianglesDisplacement[t * 2], trianglesDisplacement[t * 2 + 1])
@@ -208,6 +203,7 @@ export function buildBLAS(geometry, displacementScale = 0, trianglesDisplacement
     }
     return {
         builder: 'builtin',
+        triangleIds: trianglesDisplacement ? new Uint32Array(triangleIds) : undefined,
         buildSurfaceArea,
         maxDepth,
         maxLeafPrimitives,
@@ -235,16 +231,22 @@ function instanceBounds(instance, out, o) {
     const displacementScale = instance.displacementScale;
     if (displacementScale) {
         const m = instance.transform;
-        padX = Math.max(0, displacementScale * Math.hypot(m[0], m[1], m[2]));
-        padY = Math.max(0, displacementScale * Math.hypot(m[4], m[5], m[6]));
-        padZ = Math.max(0, displacementScale * Math.hypot(m[8], m[9], m[10]));
+        padX = Math.max(0, displacementScale * Math.hypot(read(m, 0), read(m, 1), read(m, 2)));
+        padY = Math.max(0, displacementScale * Math.hypot(read(m, 4), read(m, 5), read(m, 6)));
+        padZ = Math.max(0, displacementScale * Math.hypot(read(m, 8), read(m, 9), read(m, 10)));
     }
-    out[o] = min[0] - padX;
-    out[o + 1] = min[1] - padY;
-    out[o + 2] = min[2] - padZ;
-    out[o + 3] = max[0] + padX;
-    out[o + 4] = max[1] + padY;
-    out[o + 5] = max[2] + padZ;
+    out[o] = read(min, 0) - padX;
+    out[o + 1] = read(min, 1) - padY;
+    out[o + 2] = read(min, 2) - padZ;
+    out[o + 3] = read(max, 0) + padX;
+    out[o + 4] = read(max, 1) + padY;
+    out[o + 5] = read(max, 2) + padZ;
+}
+function writeInstanceColor(output, offset, instance) {
+    const color = instance.color;
+    output[offset] = color ? color[0] : 1;
+    output[offset + 1] = color ? color[1] : 1;
+    output[offset + 2] = color ? color[2] : 1;
 }
 function writeInstanceRecord(instanceInts, instanceFloats, targetIndex, instance, placement) {
     const offset = targetIndex * INSTANCE_WORD_STRIDE;
@@ -252,13 +254,36 @@ function writeInstanceRecord(instanceInts, instanceFloats, targetIndex, instance
     instanceInts[offset + 1] = placement.vertexOffsets[instance.blasIndex];
     instanceInts[offset + 2] = instance.materialsIndices[0] || 0;
     instanceFloats[offset + 3] = instance.displacementScale || 0;
-    instanceFloats.set(instance.color ?? [1, 1, 1], offset + 36);
+    writeInstanceColor(instanceFloats, offset + 36, instance);
     instanceFloats[offset + 39] = 0;
-    const inverse = mat4.invert(mat4.create(), instance.transform);
+    const inverse = mat4.invert(new Float64Array(16), instance.transform);
     for (let i = 0; i < 16; i++) {
         instanceFloats[offset + 4 + i] = inverse[i];
-        instanceFloats[offset + 20 + i] = instance.transform[i];
+        instanceFloats[offset + 20 + i] = read(instance.transform, i);
+    }
+}
+// Hardware adapters use the same instance/material/matrix packing without a
+// software hierarchy. Offsets are primitive offsets in their indexed geometry.
+export function packLinearInstances(instances, primitiveOffsets, vertexOffsets) {
+    const buffer = new ArrayBuffer(meshInstancesLength(instances) * INSTANCE_WORD_STRIDE * 4);
+    const words = new Int32Array(buffer), floats = new Float32Array(buffer);
+    const placement = { blasOffsets: primitiveOffsets, vertexOffsets,
+        layouts: primitiveOffsets.map(() => 'bvh2') };
+    for (let i = 0; i < meshInstancesLength(instances); i++) {
+        writeInstanceRecord(words, floats, i, readMeshInstance(instances, i), placement);
     }
+    return buffer;
+}
+/** Repack only selected source-order instance slots for hardware adapters. */
+export function refitLinearInstances(buffer, instances, primitiveOffsets, vertexOffsets, dirty) {
+    const words = new Int32Array(buffer), floats = new Float32Array(buffer);
+    const placement = { blasOffsets: primitiveOffsets, vertexOffsets, layouts: primitiveOffsets.map(() => 'bvh2') };
+    const ranges = [];
+    for (const index of dirty) {
+        writeInstanceRecord(words, floats, index, readMeshInstance(instances, index), placement);
+        ranges.push({ offset: index * INSTANCE_WORD_STRIDE * 4, size: INSTANCE_WORD_STRIDE * 4 });
+    }
+    return mergeRefitRanges(ranges);
 }
 /**
  * Builds a BVH2 TLAS over the instances. Leaves store
@@ -266,20 +291,20 @@ function writeInstanceRecord(instanceInts, instanceFloats, targetIndex, instance
  * are written in leaf order to instancesBuffer.
  */
 export function buildTLAS(instances, blases) {
-    if (!instances.length)
+    if (!meshInstancesLength(instances))
         return emptyBvh(true);
     const placement = getBlasPlacement(blases);
-    const aabbs = new Float32Array(instances.length * 6);
-    for (let i = 0; i < instances.length; i++) {
+    const aabbs = new Float32Array(meshInstancesLength(instances) * 6);
+    for (let i = 0; i < meshInstancesLength(instances); i++) {
         instanceBounds(readMeshInstance(instances, i), aabbs, i * 6);
     }
-    const bvh = buildBinnedSahBvh(aabbs, instances.length);
+    const bvh = buildBinnedSahBvh(aabbs, meshInstancesLength(instances));
     const { order, offsets, vec4Count, maxDepth, maxLeafPrimitives } = layoutBvh2(bvh);
     const { bounds, leftFirst, primCount, primIndices } = bvh;
     const buffer = new ArrayBuffer(vec4Count * 16);
     const floats = new Float32Array(buffer);
     const ints = new Int32Array(buffer);
-    const instancesBuffer = new ArrayBuffer(instances.length * INSTANCE_WORD_STRIDE * 4);
+    const instancesBuffer = new ArrayBuffer(meshInstancesLength(instances) * INSTANCE_WORD_STRIDE * 4);
     const instanceInts = new Int32Array(instancesBuffer);
     const instanceFloats = new Float32Array(instancesBuffer);
     let target = 0;
@@ -320,6 +345,47 @@ export function buildTLAS(instances, blases) {
         instancesBuffer
     };
 }
+/** Bounds transport for a platform BVH builder; same padding as buildTLAS. */
+export function meshInstanceBounds(instances) {
+    const bounds = new Float32Array(meshInstancesLength(instances) * 6);
+    for (let i = 0; i < meshInstancesLength(instances); i++)
+        instanceBounds(readMeshInstance(instances, i), bounds, i * 6);
+    return bounds;
+}
+/** Pack a platform-built BVH2 hierarchy whose leaf x lane holds source indices. */
+export function packBuiltTLAS(instances, blases, hierarchy) {
+    const count = meshInstancesLength(instances);
+    if (!count)
+        return emptyBvh(true);
+    const placement = getBlasPlacement(blases), words = new Int32Array(hierarchy.buffer);
+    const instancesBuffer = new ArrayBuffer(count * INSTANCE_WORD_STRIDE * 4);
+    const instanceInts = new Int32Array(instancesBuffer), instanceFloats = new Float32Array(instancesBuffer);
+    const stack = [0];
+    let target = 0;
+    while (stack.length) {
+        const node = stack.pop(), o = node * 4, child = words[o + 3];
+        if (child >= 0) {
+            stack.push(child);
+            stack.push(node + 2);
+            continue;
+        }
+        for (let i = 0; i < -child; i++) {
+            const e = o + 8 + i * 4, source = words[e];
+            if (source < 0 || source >= count || target >= count)
+                throw new Error('Invalid platform TLAS instance');
+            const instance = readMeshInstance(instances, source);
+            words[e] = target;
+            words[e + 1] = placement.blasOffsets[instance.blasIndex];
+            words[e + 2] = source;
+            words[e + 3] = 0;
+            writeInstanceRecord(instanceInts, instanceFloats, target++, instance, placement);
+        }
+    }
+    if (target !== count)
+        throw new Error('Platform TLAS instance count mismatch');
+    hierarchy.instancesBuffer = instancesBuffer;
+    return hierarchy;
+}
 const tlasRefitMetadata = new WeakMap();
 function getTLASRefitMetadata(flattened, ints) {
     const cached = tlasRefitMetadata.get(flattened);
@@ -369,11 +435,19 @@ export function mergeRefitRanges(ranges) {
             previous.size = Math.max(previous.size, range.offset + range.size - previous.offset);
         }
         else {
-            merged.push({ ...range });
+            merged.push({ offset: range.offset, size: range.size });
         }
     }
     return merged;
 }
+/** A transactional candidate shares immutable refit topology metadata. */
+export function copyTLASForRefit(flattened) {
+    const next = { ...flattened, buffer: flattened.buffer.slice(0), instancesBuffer: flattened.instancesBuffer?.slice(0) };
+    if (flattened.buffer.byteLength && flattened.instancesBuffer) {
+        tlasRefitMetadata.set(next, getTLASRefitMetadata(flattened, new Int32Array(flattened.buffer)));
+    }
+    return next;
+}
 export function refitTLAS(flattened, instances, blases, dirtySourceIndices) {
     if (!flattened.instancesBuffer || !flattened.buffer.byteLength) {
         return { tlasRanges: [], instanceRanges: [] };
@@ -389,21 +463,21 @@ export function refitTLAS(flattened, instances, blases, dirtySourceIndices) {
     }
     function addInstanceBounds(bounds, instance) {
         instanceBounds(instance, scratch, 0);
-        bounds.min[0] = Math.min(bounds.min[0], scratch[0]);
-        bounds.min[1] = Math.min(bounds.min[1], scratch[1]);
-        bounds.min[2] = Math.min(bounds.min[2], scratch[2]);
-        bounds.max[0] = Math.max(bounds.max[0], scratch[3]);
-        bounds.max[1] = Math.max(bounds.max[1], scratch[4]);
-        bounds.max[2] = Math.max(bounds.max[2], scratch[5]);
+        write(bounds.min, 0, Math.min(read(bounds.min, 0), scratch[0]));
+        write(bounds.min, 1, Math.min(read(bounds.min, 1), scratch[1]));
+        write(bounds.min, 2, Math.min(read(bounds.min, 2), scratch[2]));
+        write(bounds.max, 0, Math.max(read(bounds.max, 0), scratch[3]));
+        write(bounds.max, 1, Math.max(read(bounds.max, 1), scratch[4]));
+        write(bounds.max, 2, Math.max(read(bounds.max, 2), scratch[5]));
     }
     function writeNodeBounds(index, bounds) {
         const base = index * 4;
-        floats[base] = bounds.min[0];
-        floats[base + 1] = bounds.min[1];
-        floats[base + 2] = bounds.min[2];
-        floats[base + 4] = bounds.max[0];
-        floats[base + 5] = bounds.max[1];
-        floats[base + 6] = bounds.max[2];
+        floats[base] = read(bounds.min, 0);
+        floats[base + 1] = read(bounds.min, 1);
+        floats[base + 2] = read(bounds.min, 2);
+        floats[base + 4] = read(bounds.max, 0);
+        floats[base + 5] = read(bounds.max, 1);
+        floats[base + 6] = read(bounds.max, 2);
     }
     function readNodeBounds(index) {
         const base = index * 4;
@@ -543,13 +617,26 @@ function getBlasRefitData(buffer) {
     return data;
 }
 /** Refit a BVH2 BLAS after vertex deformation, preserving topology. */
-export function refitBLAS(flattened, geometry) {
+export function refitBLAS(flattened, geometry, displacement) {
     if ((flattened.layout ?? 'bvh2') !== 'bvh2' || !flattened.buffer.byteLength) {
         return false;
     }
     const { offsets, vertices, postorder } = getBlasRefitData(flattened.buffer);
     const floats = new Float32Array(flattened.buffer), ints = new Int32Array(flattened.buffer);
     const positions = geometry.position.array, stride = geometry.position.itemSize;
+    const sourceTriangles = new Int32Array(displacement ? floats.length / 4 : 0).fill(-1);
+    const prism = new Float32Array(6);
+    if (displacement) {
+        // Leaf source IDs remain distinct even for duplicate index triples.
+        // Refuse old caches without this metadata before mutating their bounds.
+        const triangleIds = flattened.triangleIds;
+        if (!(triangleIds instanceof Uint32Array))
+            return false;
+        for (let i = 0; i < triangleIds.length; i += 2) {
+            const record = Number(triangleIds[i]);
+            sourceTriangles[record] = triangleIds[i + 1];
+        }
+    }
     if (flattened.buildSurfaceArea == null) {
         let area = 0;
         for (const index of postorder) {
@@ -573,6 +660,25 @@ export function refitBLAS(flattened, geometry) {
             maxY = Math.max(floats[left + 5], floats[right + 5]);
             maxZ = Math.max(floats[left + 6], floats[right + 6]);
         }
+        else if (displacement) {
+            for (let i = 0; i < -child; i++) {
+                const record = base + 8 + i * 4;
+                const ia = ints[record], ib = ints[record + 1], ic = ints[record + 2];
+                const triangle = sourceTriangles[record / 4];
+                if (triangle < 0)
+                    return false;
+                const minimum = displacement.ranges[triangle * 2], maximum = displacement.ranges[triangle * 2 + 1];
+                if (!triangleBounds(positions, stride, displacement.normal, 3, ia, ib, ic, minimum * displacement.scale, maximum * displacement.scale, prism, 0))
+                    return false;
+                ints[record + 3] = flattened.builder === 'tinybvh' ? quantizeDisplacementRange(minimum, maximum) : packH(minimum, maximum);
+                minX = Math.min(minX, prism[0]);
+                minY = Math.min(minY, prism[1]);
+                minZ = Math.min(minZ, prism[2]);
+                maxX = Math.max(maxX, prism[3]);
+                maxY = Math.max(maxY, prism[4]);
+                maxZ = Math.max(maxZ, prism[5]);
+            }
+        }
         else {
             const start = offsets[index], end = start + 1 + vertices[start];
             for (let i = start + 1; i < end; i++) {
@@ -606,16 +712,20 @@ export function updateTLASInstanceColors(flattened, instances, dirty) {
     const metadata = getTLASRefitMetadata(flattened, new Int32Array(flattened.buffer));
     const floats = new Float32Array(flattened.instancesBuffer);
     const ranges = [];
-    for (const source of dirty)
-        for (const leaf of metadata.leavesBySource.get(source) ?? []) {
+    for (const source of dirty) {
+        const leaves = metadata.leavesBySource.get(source);
+        if (!leaves)
+            continue;
+        for (const leaf of leaves) {
             for (const entry of metadata.instancesByLeaf.get(leaf) ?? []) {
                 if (entry.source !== source)
                     continue;
                 const offset = entry.target * INSTANCE_WORD_STRIDE + 36;
-                floats.set(readMeshInstance(instances, source).color ?? [1, 1, 1], offset);
+                writeInstanceColor(floats, offset, readMeshInstance(instances, source));
                 ranges.push({ offset: offset * 4, size: 16 });
             }
         }
+    }
     return mergeRefitRanges(ranges);
 }
 //# sourceMappingURL=bvhAccel.js.map