@meimu/mutracer 0.1.5 → 0.3.0

package/lib/renderer/prepareMeshBVH.js

@@ -1,158 +1,17 @@
+import { isProceduralSkyImage } from '../scene/skyParameters.js';
+import { prepareSceneMeshes, computeGeometryNormals } from './scenePreparation.js';
 import InstancedMesh from '../scene/InstancedMesh.js';
-import { meshInstanceCount, meshInstanceTransform, PackedMeshInstances } from './meshInstances.js';
+import { meshInstanceCount } from './meshInstances.js';
 import { createCanvas } from '../util/canvas.js';
-import { packMaterialIndexAndWeightToInt } from './materialIndices.js';
 import { getGeometryBvh, setGeometryBvh, geometryBvhConfigMatches } from './geometryBvh.js';
-import { writeMaterialIndices } from './materialIndices.js';
-import { vec2, vec3 } from '../math.js';
-import Geometry, { Attribute } from '../scene/Geometry.js';
+import { displacementBaseGeometry, computeDisplacementMinmax, computeTrianglesDisplacementRange, conservativeTrianglesDisplacementRange } from './displacementPreparation.js';
+export { sphericalProjectionTriangle, triplanarProjectionTriangle } from './displacementPreparation.js';
+import Geometry from '../scene/Geometry.js';
 import { buildBLAS } from './bvhAccel.js';
-import { colorLuminance } from './lightSampling.js';
 import { isTextureDataSource } from '../scene/Texture.js';
-import { generateVertexTangents, hasGeneratedVertexTangents } from '../util/geometry.js';
-function computeGeometryBounds(geometry) {
-    const min = vec3.fromValues(Infinity, Infinity, Infinity);
-    const max = vec3.fromValues(-Infinity, -Infinity, -Infinity);
-    const positions = geometry.position.array;
-    const stride = geometry.position.itemSize;
-    for (let offset = 0; offset + 2 < positions.length; offset += stride) {
-        const x = positions[offset];
-        const y = positions[offset + 1];
-        const z = positions[offset + 2];
-        if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
-            continue;
-        }
-        min[0] = Math.min(min[0], x);
-        min[1] = Math.min(min[1], y);
-        min[2] = Math.min(min[2], z);
-        max[0] = Math.max(max[0], x);
-        max[1] = Math.max(max[1], y);
-        max[2] = Math.max(max[2], z);
-    }
-    return [min, max];
-}
-export function getBvhBounds(geometry) {
-    const bvh = getGeometryBvh(geometry);
-    const floats = new Float32Array(bvh.buffer);
-    if (bvh.layout === 'bvh4') {
-        return [
-            [floats[0], floats[1], floats[2]],
-            [
-                floats[0] + floats[3],
-                floats[1] + floats[4],
-                floats[2] + floats[5]
-            ]
-        ];
-    }
-    if (bvh.layout === 'bvh-gpu') {
-        const words = new Uint32Array(bvh.buffer);
-        if (words[11] === 0) {
-            return [
-                [
-                    Math.min(floats[0], floats[8]),
-                    Math.min(floats[1], floats[9]),
-                    Math.min(floats[2], floats[10])
-                ],
-                [
-                    Math.max(floats[4], floats[12]),
-                    Math.max(floats[5], floats[13]),
-                    Math.max(floats[6], floats[14])
-                ]
-            ];
-        }
-        // A single-leaf BVH_GPU node does not store its own bounds.
-        return computeGeometryBounds(geometry);
-    }
-    if (bvh.layout === 'cwbvh') {
-        const words = new Uint32Array(bvh.buffer);
-        const header = words[3];
-        const signedByte = (value) => (value << 24) >> 24;
-        const scale = [
-            2 ** signedByte(header),
-            2 ** signedByte(header >> 8),
-            2 ** signedByte(header >> 16)
-        ];
-        const min = [floats[0], floats[1], floats[2]];
-        const max = [...min];
-        for (let slot = 0; slot < 8; slot++) {
-            const meta = (words[6 + (slot >> 2)] >> ((slot & 3) * 8)) & 0xff;
-            if (!meta)
-                continue;
-            const shift = (slot & 3) * 8;
-            const half = slot >> 2;
-            max[0] = Math.max(max[0], min[0] + ((words[14 + half] >> shift) & 0xff) * scale[0]);
-            max[1] = Math.max(max[1], min[1] + ((words[16 + half] >> shift) & 0xff) * scale[1]);
-            max[2] = Math.max(max[2], min[2] + ((words[18 + half] >> shift) & 0xff) * scale[2]);
-        }
-        return [min, max];
-    }
-    return [
-        [floats[0], floats[1], floats[2]],
-        [floats[4], floats[5], floats[6]]
-    ];
-}
-export function computeBounds(_geometry, m, bvhBounds, result = { min: vec3.create(), max: vec3.create() }, p = vec3.create()) {
-    const { min, max } = result;
-    vec3.set(min, Infinity, Infinity, Infinity);
-    vec3.set(max, -Infinity, -Infinity, -Infinity);
-    // Transforming the eight BLAS AABB corners is exact for an affine transform
-    // and independent of mesh vertex count. The previous rotated path scanned
-    // every vertex on every instance update.
-    for (let corner = 0; corner < 8; corner++) {
-        vec3.set(p, bvhBounds[(corner >> 0) & 1][0], bvhBounds[(corner >> 1) & 1][1], bvhBounds[(corner >> 2) & 1][2]);
-        vec3.transformMat4(p, p, m);
-        if (!p.every(isFinite))
-            continue;
-        vec3.min(min, min, p);
-        vec3.max(max, max, p);
-    }
-    return result;
-}
-export function updateMeshInstanceTransforms(bindings, current, dirtyIndices) {
-    if (bindings.some(binding => binding.mesh instanceof InstancedMesh)) {
-        const packed = new PackedMeshInstances(bindings.reduce((count, binding) => count + meshInstanceCount(binding.mesh), 0));
-        const matrix = Array(16).fill(0);
-        const boundsScratch = { min: vec3.create(), max: vec3.create() }, pointScratch = vec3.create();
-        let sourceIndex = 0;
-        for (const binding of bindings) {
-            const { mesh, geometry, bvhBounds, blasIndex, materialIndices, displacementScale } = binding;
-            for (let i = 0; i < meshInstanceCount(mesh); i++, sourceIndex++) {
-                meshInstanceTransform(mesh, i, matrix);
-                const bounds = computeBounds(geometry, matrix, bvhBounds, boundsScratch, pointScratch);
-                if (!bounds.min.every(Number.isFinite) || !bounds.max.every(Number.isFinite) || !matrix.every(Number.isFinite))
-                    continue;
-                const index = packed.length++;
-                packed.sourceIndices[index] = sourceIndex;
-                packed.transforms.set(matrix, index * 16);
-                packed.bounds.set(bounds.min, index * 6);
-                packed.bounds.set(bounds.max, index * 6 + 3);
-                packed.blasIndices[index] = blasIndex;
-                packed.materials[index] = packMaterialIndexAndWeightToInt(materialIndices[0], 1);
-                packed.displacement[index] = displacementScale;
-                const colors = mesh instanceof InstancedMesh ? mesh.colors : undefined;
-                for (let k = 0; k < 3; k++)
-                    packed.colors[index * 3 + k] = colors?.[i * 3 + k] ?? 1;
-            }
-        }
-        return packed;
-    }
-    const update = ({ mesh, geometry, blasIndex, materialIndices, displacementScale, bvhBounds }) => ({
-        bounds: computeBounds(geometry, mesh.transform, bvhBounds),
-        blasIndex,
-        transform: mesh.transform,
-        materialsIndices: materialIndices.map((idx) => packMaterialIndexAndWeightToInt(idx, 1)),
-        displacementScale
-    });
-    if (!current || !dirtyIndices)
-        return bindings.map(update);
-    const next = current.slice();
-    dirtyIndices.forEach((index) => {
-        const binding = bindings[index];
-        if (binding)
-            next[index] = update(binding);
-    });
-    return next;
-}
+import { generateVertexTangents } from '../util/geometry.js';
+export { getBvhBounds } from './geometryBvhBounds.js';
+export { computeBounds, updateMeshInstanceTransforms } from './scenePreparation.js';
 /** Returns the first material used for CPU displacement. */
 export function getMeshDisplacementMaterial(mesh) {
     return mesh.materials[0];
@@ -186,7 +45,6 @@ export function getDisplacementTextureDataCacheKey(texture) {
         image.height
     ].join('|');
 }
-const detailedProjectiveRangeTriangleLimit = 100_000;
 const displacementMinmaxCache = new Map();
 export function getPreparedMeshGeometryCacheKey(mesh) {
     const source = mesh.geometry;
@@ -238,8 +96,6 @@ export function getPreparedMeshGeometry(mesh) {
 }
 export function computeMinmaxCPU(_geometry, heightImage) {
     const w = heightImage.width;
-    const minmaxData = [];
-    const maxMipLevel = Math.log2(w);
     let heightPixels;
     let sourceChannels;
     let normalizeHeight;
@@ -259,157 +115,17 @@ export function computeMinmaxCPU(_geometry, heightImage) {
             throw new Error('The displacement texture is not CPU-readable.');
         canvas.width = w;
         canvas.height = w;
+        if (isProceduralSkyImage(heightImage))
+            throw new Error('ProceduralSky is only supported as an environment or background.');
         ctx.drawImage(heightImage, 0, 0, w, w);
         heightPixels = ctx.getImageData(0, 0, w, w).data;
         sourceChannels = 4;
         normalizeHeight = (value) => value;
     }
-    let mipmapSize = w;
-    for (let lod = 0; lod <= maxMipLevel; lod++) {
-        const prevMinmaxData = minmaxData[Math.max(0, lod - 1)];
-        const minmax = new Uint8Array(mipmapSize * mipmapSize * 2);
-        minmaxData.push(minmax);
-        const channels = lod === 0 ? sourceChannels : 2;
-        for (let y = 0; y < mipmapSize; y++) {
-            for (let x = 0; x < mipmapSize; x++) {
-                const yx = y * mipmapSize + x;
-                const idx = yx * channels;
-                let min = 0;
-                let max = 0;
-                if (lod == 0) {
-                    min = normalizeHeight(heightPixels[idx]);
-                    max = min;
-                    if (y < mipmapSize - 1 && x < mipmapSize - 1) {
-                        const h = normalizeHeight(heightPixels[idx + (mipmapSize + 1) * channels]);
-                        min = Math.min(min, h);
-                        max = Math.max(max, h);
-                    }
-                    if (y < mipmapSize - 1) {
-                        const h = normalizeHeight(heightPixels[idx + mipmapSize * channels]);
-                        min = Math.min(min, h);
-                        max = Math.max(max, h);
-                    }
-                    if (x < mipmapSize - 1) {
-                        const h = normalizeHeight(heightPixels[idx + channels]);
-                        min = Math.min(min, h);
-                        max = Math.max(max, h);
-                    }
-                }
-                else {
-                    const x2 = x * 2;
-                    const y2 = y * 2;
-                    const prevMipmapSize = mipmapSize * 2;
-                    const idx2 = (y2 * prevMipmapSize + x2) * channels;
-                    const idx2_0 = idx2;
-                    const idx2_1 = idx2 + channels;
-                    const idx2_2 = idx2 + prevMipmapSize * channels;
-                    const idx2_3 = idx2 + prevMipmapSize * channels + channels;
-                    min = Math.min(prevMinmaxData[idx2_0], prevMinmaxData[idx2_1], prevMinmaxData[idx2_2], prevMinmaxData[idx2_3]);
-                    max = Math.max(prevMinmaxData[idx2_0 + 1], prevMinmaxData[idx2_1 + 1], prevMinmaxData[idx2_2 + 1], prevMinmaxData[idx2_3 + 1]);
-                }
-                minmax[yx * 2] = min;
-                minmax[yx * 2 + 1] = max;
-            }
-        }
-        mipmapSize = mipmapSize / 2;
-    }
-    return minmaxData;
-}
-function sphericalProjection(n, uv) {
-    const theta = Math.atan2(n[0], n[2]) / (2.0 * Math.PI) + 0.5;
-    const phi = Math.acos(n[1]) / Math.PI;
-    vec2.set(uv, theta, 1.0 - phi);
-}
-export function sphericalProjectionTriangle(na, nb, nc, uvA, uvB, uvC) {
-    sphericalProjection(na, uvA);
-    sphericalProjection(nb, uvB);
-    sphericalProjection(nc, uvC);
-    let onSeam = false;
-    for (let i = 0; i < 2; i++) {
-        if (Math.abs(uvA[i] - uvB[i]) > 0.5 ||
-            Math.abs(uvA[i] - uvC[i]) > 0.5 ||
-            Math.abs(uvB[i] - uvC[i]) > 0.5) {
-            const maxU = Math.max(uvA[i], uvB[i], uvC[i]);
-            if (maxU - uvA[i] > 0.5) {
-                uvA[i] += 1.0;
-                onSeam = true;
-            }
-            if (maxU - uvB[i] > 0.5) {
-                uvB[i] += 1.0;
-                onSeam = true;
-            }
-            if (maxU - uvC[i] > 0.5) {
-                uvC[i] += 1.0;
-                onSeam = true;
-            }
-        }
-    }
-    return onSeam;
-}
-function getMaxAxisIndex(n) {
-    const x = Math.abs(n[0]);
-    const y = Math.abs(n[1]);
-    const z = Math.abs(n[2]);
-    return x > y && x > z ? 0 : y > z ? 1 : 2;
-}
-export function triplanarProjectionTriangle(a, b, c, na, nb, nc, uvA, uvB, uvC) {
-    const tmpMaxX = Math.max(Math.abs(na[0]), Math.abs(nb[0]), Math.abs(nc[0]));
-    const tmpMaxY = Math.max(Math.abs(na[1]), Math.abs(nb[1]), Math.abs(nc[1]));
-    const tmpMaxZ = Math.max(Math.abs(na[2]), Math.abs(nb[2]), Math.abs(nc[2]));
-    if (tmpMaxX > tmpMaxY && tmpMaxX > tmpMaxZ) {
-        // yz
-        vec2.set(uvA, a[1], a[2]);
-        vec2.set(uvB, b[1], b[2]);
-        vec2.set(uvC, c[1], c[2]);
-    }
-    else if (tmpMaxY > tmpMaxX && tmpMaxY > tmpMaxZ) {
-        // xz
-        vec2.set(uvA, a[0], a[2]);
-        vec2.set(uvB, b[0], b[2]);
-        vec2.set(uvC, c[0], c[2]);
-    }
-    else {
-        // xy
-        vec2.set(uvA, a[0], a[1]);
-        vec2.set(uvB, b[0], b[1]);
-        vec2.set(uvC, c[0], c[1]);
-    }
-}
-function findRoots(triAabbMinP, triAabbMaxP, maxDepth, roots) {
-    let d = vec2.sub(vec2.create(), triAabbMaxP, triAabbMinP);
-    let size = Math.max(d[0], d[1]);
-    let startMipLevel = maxDepth - Math.floor(Math.log2(Math.floor(1.0 / size))) - 1;
-    if (!isFinite(startMipLevel)) {
-        startMipLevel = maxDepth;
-    }
-    startMipLevel = Math.max(startMipLevel, 0);
-    let rootCount = 0;
-    while (true) {
-        const mipSize = Math.pow(2.0, maxDepth - startMipLevel);
-        const minTexelX = Math.floor(mipSize * triAabbMinP[0]);
-        const minTexelY = Math.floor(mipSize * triAabbMinP[1]);
-        const maxTexelX = Math.floor(mipSize * triAabbMaxP[0]);
-        const maxTexelY = Math.floor(mipSize * triAabbMaxP[1]);
-        if ((maxTexelX - minTexelX < 2 &&
-            maxTexelY - minTexelY < 2 &&
-            startMipLevel >= 0) ||
-            startMipLevel >= maxDepth) {
-            for (let y = minTexelY; y <= maxTexelY; y++) {
-                for (let x = minTexelX; x <= maxTexelX; x++) {
-                    if (rootCount < roots.length) {
-                        vec3.set(roots[rootCount], Math.floor(x), Math.floor(y), startMipLevel);
-                        rootCount++;
-                    }
-                }
-            }
-            break;
-        }
-        startMipLevel++;
-    }
-    return rootCount;
+    return computeDisplacementMinmax(w, sourceChannels, index => normalizeHeight(heightPixels[index]));
 }
 export function getTrianglesDisplacementRange(geometry, heightTexture, material) {
-    const indices = geometry.indices.array;
+    const indices = geometry.indexArray;
     const uvs = geometry.uv?.array;
     const uvProjection = material.displacementUvProjection;
     if (!heightTexture)
@@ -423,16 +139,10 @@ export function getTrianglesDisplacementRange(geometry, heightTexture, material)
         return;
     }
     const triangleCount = indices.length / 3;
-    if (triangleCount >= detailedProjectiveRangeTriangleLimit) {
-        // A conservative full-height prism is much cheaper to prepare for dense
-        // source meshes and remains intersection-safe. Per-triangle UV min/max is
-        // retained for smaller meshes where tighter BVH nodes matter more.
-        const conservative = new Float32Array(triangleCount * 2);
-        for (let triangle = 0; triangle < triangleCount; triangle++) {
-            conservative[triangle * 2 + 1] = 1;
-        }
+    // Dense meshes retain the shared conservative full-height prism path.
+    const conservative = conservativeTrianglesDisplacementRange(triangleCount);
+    if (conservative)
         return conservative;
-    }
     const minmaxCacheKey = getDisplacementTextureDataCacheKey(heightTexture);
     let minmaxData = displacementMinmaxCache.get(minmaxCacheKey);
     if (!minmaxData) {
@@ -442,127 +152,7 @@ export function getTrianglesDisplacementRange(geometry, heightTexture, material)
         }
         displacementMinmaxCache.set(minmaxCacheKey, minmaxData);
     }
-    const maxDepth = Math.log2(heightImage.width);
-    const trianglesDisplacementRange = new Float32Array((indices.length / 3) * 2);
-    const normal = geometry.normal.array;
-    const position = geometry.position.array;
-    const uv1 = vec2.create();
-    const uv2 = vec2.create();
-    const uv3 = vec2.create();
-    const p1 = vec3.create();
-    const p2 = vec3.create();
-    const p3 = vec3.create();
-    const n1 = vec3.create();
-    const n2 = vec3.create();
-    const n3 = vec3.create();
-    const isTriplanar = uvProjection === 'triplanar';
-    const isSpherical = uvProjection === 'spherical';
-    const isCylindrical = uvProjection === 'cylindrical';
-    const uvScale = material.displacementUvProjectionScale;
-    const minUv = vec2.create();
-    const maxUv = vec2.create();
-    const roots = [];
-    for (let i = 0; i < 100; i++) {
-        roots.push([0, 0, 0]);
-    }
-    for (let i = 0; i < indices.length; i += 3) {
-        const i1 = indices[i];
-        const i2 = indices[i + 1];
-        const i3 = indices[i + 2];
-        const i1_2 = i1 * 2;
-        const i2_2 = i2 * 2;
-        const i3_2 = i3 * 2;
-        const i1_3 = i1 * 3;
-        const i2_3 = i2 * 3;
-        const i3_3 = i3 * 3;
-        if (uvs) {
-            vec2.set(uv1, uvs[i1_2], uvs[i1_2 + 1]);
-            vec2.set(uv2, uvs[i2_2], uvs[i2_2 + 1]);
-            vec2.set(uv3, uvs[i3_2], uvs[i3_2 + 1]);
-        }
-        else {
-            vec2.set(uv1, 0, 0);
-            vec2.set(uv2, 0, 0);
-            vec2.set(uv3, 0, 0);
-        }
-        let onSeam = false;
-        if (isTriplanar || isSpherical || isCylindrical) {
-            vec3.set(n1, normal[i1_3], normal[i1_3 + 1], normal[i1_3 + 2]);
-            vec3.set(n2, normal[i2_3], normal[i2_3 + 1], normal[i2_3 + 2]);
-            vec3.set(n3, normal[i3_3], normal[i3_3 + 1], normal[i3_3 + 2]);
-            vec3.normalize(n1, n1);
-            vec3.normalize(n2, n2);
-            vec3.normalize(n3, n3);
-            if (isTriplanar || isSpherical || isCylindrical) {
-                vec3.set(p1, position[i1_3], position[i1_3 + 1], position[i1_3 + 2]);
-                vec3.set(p2, position[i2_3], position[i2_3 + 1], position[i2_3 + 2]);
-                vec3.set(p3, position[i3_3], position[i3_3 + 1], position[i3_3 + 2]);
-            }
-            if (isTriplanar) {
-                // Is on the seam. Needs full prism to avoid empty seams.
-                const xMaxIndex = getMaxAxisIndex(n1);
-                const yMaxIndex = getMaxAxisIndex(n2);
-                const zMaxIndex = getMaxAxisIndex(n3);
-                if (!(xMaxIndex === yMaxIndex && yMaxIndex === zMaxIndex)) {
-                    onSeam = true;
-                }
-                /* prettier-ignore */
-                triplanarProjectionTriangle(p1, p2, p3, n1, n2, n3, uv1, uv2, uv3);
-            }
-            else if (isSpherical) {
-                vec3.normalize(p1, p1);
-                vec3.normalize(p2, p2);
-                vec3.normalize(p3, p3);
-                onSeam = sphericalProjectionTriangle(p1, p2, p3, uv1, uv2, uv3);
-            }
-            else {
-                const u1 = Math.atan2(p1[2], p1[0]) / (Math.PI * 2) + 0.5;
-                const u2 = Math.atan2(p2[2], p2[0]) / (Math.PI * 2) + 0.5;
-                const u3 = Math.atan2(p3[2], p3[0]) / (Math.PI * 2) + 0.5;
-                vec2.set(uv1, u1, p1[1]);
-                vec2.set(uv2, u2, p2[1]);
-                vec2.set(uv3, u3, p3[1]);
-                onSeam = Math.max(u1, u2, u3) - Math.min(u1, u2, u3) > 0.5;
-            }
-        }
-        vec2.scale(uv1, uv1, uvScale);
-        vec2.scale(uv2, uv2, uvScale);
-        vec2.scale(uv3, uv3, uvScale);
-        // TODO PDM don't have zero area triangle issue.
-        let minHeight = Infinity;
-        let maxHeight = -Infinity;
-        if (onSeam) {
-            minHeight = 0.0;
-            maxHeight = 255.0;
-        }
-        else {
-            vec2.copy(maxUv, uv1);
-            vec2.copy(minUv, uv1);
-            vec2.min(minUv, minUv, uv2);
-            vec2.min(minUv, minUv, uv3);
-            vec2.max(maxUv, maxUv, uv2);
-            vec2.max(maxUv, maxUv, uv3);
-            const rootCount = findRoots(minUv, maxUv, maxDepth, roots);
-            for (let k = 0; k < rootCount; k++) {
-                const mipLevel = roots[k][2];
-                const mipSize = Math.pow(2, maxDepth - mipLevel);
-                const minmax = minmaxData[mipLevel];
-                const x = ((roots[k][0] % mipSize) + mipSize) % mipSize;
-                let y = ((roots[k][1] % mipSize) + mipSize) % mipSize;
-                if (isFlipY) {
-                    y = mipSize - y - 1;
-                }
-                const idx = (y * mipSize + x) * 2;
-                minHeight = Math.min(minHeight, minmax[idx]);
-                maxHeight = Math.max(maxHeight, minmax[idx + 1]);
-            }
-        }
-        // TODO this will cause flat surface optimization fail.
-        // But not adding bias will leads to small gap between flat surface and displaced surface.
-        trianglesDisplacementRange[(i / 3) * 2] = Math.max((Math.floor(minHeight) - 4) / 255, 0);
-        trianglesDisplacementRange[(i / 3) * 2 + 1] = Math.min((Math.ceil(maxHeight) + 4) / 255, 1);
-    }
-    return trianglesDisplacementRange;
+    return computeTrianglesDisplacementRange(geometry, minmaxData, heightImage.width, isFlipY, material);
 }
 const warnedDirectionGeometry = new WeakSet();
 /** Prepare auto-generated source attributes before the renderer captures array identities. */
@@ -600,21 +190,7 @@ export function getMeshBlasInput(mesh) {
     // attributes for texture coordinates and shading. This same input works for
     // built-in, TinyBVH and Worker builds; the shader offsets its base identically.
     const bias = heightMap ? getMeshDisplacementMaterial(mesh).displacementBias : 0;
-    if (bias !== 0) {
-        const positions = geometry.position.array.slice();
-        const normals = geometry.normal.array;
-        for (let vertex = 0; vertex < geometry.vertexCount; vertex++) {
-            const p = vertex * geometry.position.itemSize, n = vertex * geometry.normal.itemSize;
-            const length = Math.hypot(normals[n], normals[n + 1], normals[n + 2]);
-            if (length > 0) {
-                for (let axis = 0; axis < 3; axis++)
-                    positions[p + axis] += normals[n + axis] / length * bias;
-            }
-        }
-        return { geometry: new Geometry({ ...geometry, position: new Attribute(positions, geometry.position.itemSize) }),
-            displacementScale, trianglesDisplacement };
-    }
-    return { geometry, displacementScale, trianglesDisplacement };
+    return { geometry: displacementBaseGeometry(geometry, bias), displacementScale, trianglesDisplacement };
 }
 /** Whether a static mesh still needs a BLAS before it can be rendered. */
 export function meshNeedsStaticBvh(mesh, config) {
@@ -656,210 +232,13 @@ function prepareMeshGeometryBvh(mesh, displacement = true) {
     return { geometry, displacementScale };
 }
 export function updateMeshInstances(meshes, options = {}) {
-    const materialIndexMap = new Map();
-    const geometryIndexMap = new Map();
-    const geometries = [];
-    const materials = [];
-    const globalMaterialIndicesMap = [];
-    const emissiveBindings = [];
-    const instanceBindings = [];
-    const instances = meshes
-        .filter((mesh) => mesh.geometry.position?.array.length > 0)
-        .map((mesh) => {
-        let { geometry, displacementScale } = prepareMeshGeometryBvh(mesh, options.displacement !== false);
-        const bvhBounds = getBvhBounds(geometry);
-        const bounds = computeBounds(geometry, mesh.transform, bvhBounds);
-        let geoIdx = geometryIndexMap.get(geometry);
-        const materialsIndices = mesh.materials.map((material) => {
-            const key = material;
-            if (!materialIndexMap.has(key)) {
-                materialIndexMap.set(key, materials.length);
-                materials.push(material);
-            }
-            return materialIndexMap.get(key);
-        });
-        // Explicit vertex indices are global after merging. Batches with a
-        // different material table need their own vertex region, even when the
-        // table contains just one material. Equal tables can share the region.
-        if (geoIdx != null && geometry.materialIndex &&
-            (materialsIndices.length !== globalMaterialIndicesMap[geoIdx].length ||
-                materialsIndices.some((index, i) => index !== globalMaterialIndicesMap[geoIdx][i]))) {
-            const bvh = getGeometryBvh(geometry);
-            geometry = new Geometry(geometry);
-            setGeometryBvh(geometry, bvh);
-            geoIdx = undefined;
-        }
-        if (geoIdx == null) {
-            geoIdx = geometries.length;
-            geometryIndexMap.set(geometry, geometries.length);
-            geometries.push(geometry);
-            // Same number with geometries.
-            globalMaterialIndicesMap.push(materialsIndices);
-        }
-        const instance = {
-            bounds,
-            blasIndex: geoIdx,
-            transform: mesh.transform,
-            materialsIndices: materialsIndices.map((idx) => packMaterialIndexAndWeightToInt(idx, 1)),
-            displacementScale
-        };
-        if (!(mesh instanceof InstancedMesh) && (!bounds.min.every(isFinite) ||
-            !bounds.max.every(isFinite) ||
-            !mesh.transform.every(isFinite))) {
-            return undefined;
-        }
-        if (mesh.materials.some((material) => !material.unlit && !material.shadowCatcher &&
-            colorLuminance(material.emissionColor) * material.emissionLuminance > 1e-8)) {
-            emissiveBindings.push({ mesh, geometry, materialIndices: materialsIndices });
-        }
-        instanceBindings.push({
-            mesh,
-            geometry,
-            blasIndex: geoIdx,
-            materialIndices: materialsIndices,
-            displacementScale,
-            bvhBounds
-        });
-        return instance;
-    })
-        .filter((instance) => instance != null);
-    const geometryRegions = new Map();
-    const geometry = mergeGeometry(geometries, globalMaterialIndicesMap, geometryRegions);
-    return {
-        geometry,
-        geometries,
-        geometryRegions,
-        geometryStates: new Map(instanceBindings.map(binding => {
-            const source = binding.mesh.geometry;
-            return [source, { topologyVersion: source.topologyVersion, indices: source.indices.array,
-                    indexCount: source.indices.array.length }];
-        })),
-        instances: meshes.some(mesh => mesh instanceof InstancedMesh) ? updateMeshInstanceTransforms(instanceBindings) : instances,
-        materials,
-        instanceBindings,
-        emissiveBindings,
-        blases: geometries.map((geo) => ({
-            bvh: getGeometryBvh(geo),
-            verticesCount: geo.vertexCount,
-            trainglesCount: geo.indices.array.length / 3
-        }))
-    };
-}
-function mergeGeometry(geometries, globalMaterialIndicesMap, regions) {
-    const totalVertexCount = geometries.reduce((sum, geo) => sum + geo.vertexCount, 0);
-    const totalIndexCount = geometries.reduce((sum, geo) => sum + geo.indices.array.length, 0);
-    const positionAttrib = new Attribute(new Float32Array(3 * totalVertexCount), 3);
-    const normalAttrib = new Attribute(new Float32Array(3 * totalVertexCount), 3);
-    const uvAttrib = new Attribute(new Float32Array(2 * totalVertexCount), 2);
-    const uv1Attrib = new Attribute(new Float32Array(2 * totalVertexCount), 2);
-    const indexAttrib = new Attribute(new Uint32Array(totalIndexCount), 1);
-    const materialIndexAttrib = new Attribute(new Int32Array(4 * totalVertexCount), 4);
-    const hasColor = geometries.some((geo) => geo.color);
-    const hasTangent = geometries.some((geo) => geo.tangent);
-    const mergedGeometry = new Geometry({
-        position: positionAttrib,
-        normal: normalAttrib,
-        uv: uvAttrib,
-        uv1: uv1Attrib,
-        materialIndex: materialIndexAttrib,
-        color: hasColor
-            ? new Attribute(new Float32Array(3 * totalVertexCount).fill(1), 3)
-            : undefined,
-        tangent: hasTangent
-            ? new Attribute(new Float32Array(4 * totalVertexCount), 4)
-            : undefined,
-        indices: indexAttrib
-    });
-    let currentVertex = 0;
-    let currentIndex = 0;
-    geometries.forEach((geometry, idx) => {
-        const vertexCount = geometry.vertexCount;
-        const globalMaterialIndex = globalMaterialIndicesMap[idx];
-        regions.set(geometry, { vertexOffset: currentVertex, indexOffset: currentIndex, materialIndices: globalMaterialIndex });
-        positionAttrib.array.set(geometry.position.array, currentVertex * 3);
-        normalAttrib.array.set(geometry.normal.array, currentVertex * 3);
-        if (geometry.uv) {
-            uvAttrib.array.set(geometry.uv.array, currentVertex * 2);
-        }
-        uv1Attrib.array.set((geometry.uv1 ?? geometry.uv)?.array ?? new Float32Array(vertexCount * 2), currentVertex * 2);
-        if (geometry.color) {
-            mergedGeometry.color.array.set(geometry.color.array, currentVertex * 3);
-        }
-        if (geometry.tangent) {
-            const source = geometry.tangent;
-            for (let v = 0; v < vertexCount; v++) {
-                for (let c = 0; c < 4; c++)
-                    mergedGeometry.tangent.array[(currentVertex + v) * 4 + c] =
-                        c < source.itemSize ? source.array[v * source.itemSize + c] : hasGeneratedVertexTangents(geometry) ? 0 : 2;
-            }
-        }
-        writeMaterialIndices(geometry, globalMaterialIndex, materialIndexAttrib.array, currentVertex);
-        const meshIndices = geometry.indices.array;
-        for (let i = 0; i < meshIndices.length; i++) {
-            indexAttrib.array[currentIndex + i] = currentVertex + meshIndices[i];
-        }
-        currentVertex += vertexCount;
-        currentIndex += meshIndices.length;
-    });
-    return mergedGeometry;
-}
-function computeGeometryNormals(geometry) {
-    const indices = geometry.indices;
-    const positions = geometry.position.array;
-    geometry.normal = new Attribute(new Float32Array(positions.length), 3);
-    const normals = geometry.normal.array;
-    const p1 = vec3.create();
-    const p2 = vec3.create();
-    const p3 = vec3.create();
-    const v21 = vec3.create();
-    const v32 = vec3.create();
-    const n = vec3.create();
-    const len = indices
-        ? indices.array.length
-        : geometry.vertexCount;
-    let i1, i2, i3;
-    for (let f = 0; f < len;) {
-        if (indices) {
-            i1 = indices.array[f++];
-            i2 = indices.array[f++];
-            i3 = indices.array[f++];
-        }
-        else {
-            i1 = f++;
-            i2 = f++;
-            i3 = f++;
-        }
-        vec3.set(p1, positions[i1 * 3], positions[i1 * 3 + 1], positions[i1 * 3 + 2]);
-        vec3.set(p2, positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]);
-        vec3.set(p3, positions[i3 * 3], positions[i3 * 3 + 1], positions[i3 * 3 + 2]);
-        vec3.sub(v21, p1, p2);
-        vec3.sub(v32, p2, p3);
-        vec3.cross(n, v21, v32);
-        // Already be weighted by the triangle area
-        for (let i = 0; i < 3; i++) {
-            normals[i1 * 3 + i] = normals[i1 * 3 + i] + n[i];
-            normals[i2 * 3 + i] = normals[i2 * 3 + i] + n[i];
-            normals[i3 * 3 + i] = normals[i3 * 3 + i] + n[i];
-        }
-    }
-    for (let i = 0; i < normals.length;) {
-        vec3.set(n, normals[i], normals[i + 1], normals[i + 2]);
-        vec3.normalize(n, n);
-        normals[i++] = n[0];
-        normals[i++] = n[1];
-        normals[i++] = n[2];
-    }
-}
-/** Batch records are regenerated together; refit all numeric source slots. */
-export function dirtyMeshInstanceIndices(bindings, meshes, instances) {
-    if (instances instanceof PackedMeshInstances)
-        return new Set(Array.from({ length: instances.length }, (_, i) => i));
-    return new Set(bindings.flatMap((binding, i) => meshes.has(binding.mesh) ? [i] : []));
+    return prepareSceneMeshes(meshes, mesh => prepareMeshGeometryBvh(mesh, options.displacement !== false));
 }
+export { dirtyPreparedInstanceIndices as dirtyMeshInstanceIndices } from './scenePreparation.js';
 /** Refreshes color storage without computing transforms or bounds. Returns packed source slots. */
 export function updateMeshInstanceColors(bindings, instances, meshes) {
     const dirty = new Set();
-    if (!(instances instanceof PackedMeshInstances))
+    if (Array.isArray(instances))
         return dirty;
     let sourceStart = 0, packedIndex = 0;
     for (const { mesh } of bindings) {