@meimu/mutracer 0.3.0 → 0.3.1

package/lib/renderer/WGPURayTracePass.js

@@ -1,3 +1,5 @@
+import { resolveSurfaceHit } from './surfaceHit.js';
+import { compactVertexLayout, packCompactVertices, packTriangleMaterials } from './compactVertices.js';
 import { causticDiagnostics } from './causticDiagnostics.js';
 import { WGPUPhotonMap, photonRadius } from './WGPUPhotonMap.js';
 import { defaultPhotonMapPhotons } from './wgsl/photonMap.compute.js';
@@ -8,10 +10,10 @@ import { causticLightCompute } from './wgsl/causticLight.compute.js';
 import { causticCasterSpheres, hasStochasticCausticCaster, causticCasterSphere, isCausticSpecular } from './caustics.js';
 import { AovPrimitiveCache } from './AovPrimitiveCache.js';
 import { packAovScene } from './aovScene.js';
-import { aovMask } from './aov.js';
+import { aovMask, AOV_ACCUMULATED_MASK, AOV_REFLECTANCE_MASK, COMPACT_AOV_KINDS } from './aov.js';
 import { proceduralEnvironmentPower } from './proceduralEnvironmentPower.js';
 import { WGPUSkyBaker } from './WGPUSkyBaker.js';
-import { initialSceneConstants, sceneAttributeLayout, sceneTraversalConstants, prepareSceneLightSampling, writeTraceLighting, packSceneAnalyticLights, writeTraceQuality, traceSampling, writeTraceSampling } from './sceneAssembly.js';
+import { initialSceneConstants, sceneTraversalConstants, prepareSceneLightSampling, writeTraceLighting, packSceneAnalyticLights, writeTraceQuality, traceSampling, writeTraceSampling } from './sceneAssembly.js';
 import { rayTraceBindGroupLayouts } from './sceneLayoutSchema.js';
 import { WGPUBindlessMaterialData } from './WGPUBindlessMaterialData.js';
 import { WGPUBindlessTextures } from './WGPUBindlessTextures.js';
@@ -22,7 +24,7 @@ import { wgpuShaderSource, wgpuPipelineConstantKeys, WGPU_SHADER_DEFINE_KEYS } f
 import { makeRayTraceUniform, WGPU_SCENE_BUFFER_MIN_BYTES } from './wgpuSceneUniform.js';
 import { constants } from './webgl.js';
 import { MATERIAL_FLOAT_COUNT } from './materialLayoutSchema.js';
-import { normalizeBounces } from './pathLimits.js';
+import { normalizeBounces, MAX_PATH_EVENTS_WGPU } from './pathLimits.js';
 import { updateMeshInstanceColors } from './prepareMeshBVH.js';
 import { updateTLASInstanceColors } from './bvhAccel.js';
 import { getMaterialHashKey } from '../scene/openPbrSchema.js';
@@ -35,8 +37,7 @@ import { packCameraUniform } from './cameraUniform.js';
 import { SHADOW_CATCHER_ACCUMULATION_BYTES } from './wgsl/chunks/shadowCatcherAccumulation.wgsl.js';
 import { DEPTH_SAMPLE_COUNT, packDepthSampleArea, unpackDepthSamples } from './depthQuery.js';
 import { MeshMembershipCache } from './meshMembership.js';
-import { mergeRefitRanges } from './bvhAccel.js';
-import { updatePreparedGeometries, canUpdateGeometries, geometryTopologyChanged, packVertexAttributes } from './geometryUpdates.js';
+import { updatePreparedGeometries, canUpdateGeometries, geometryTopologyChanged, } from './geometryUpdates.js';
 import { SceneEnvironmentCache, RectLightTextureTracker } from './sceneLightChanges.js';
 import { MaterialChangeTracker, materialIsEmissive } from './materialChanges.js';
 import { WGPUEnvMapDistribution } from './WGPUEnvMapDistribution.js';
@@ -51,7 +52,7 @@ import { generateBackgroundMapFromSceneBackground, environmentRotation, backgrou
 import { WORKGROUP_SIZE } from './wgsl/rayTrace.compute.js';
 import { envMapDistribution, environmentMapSourcesMatch } from './envMapDistribution.js';
 import { updateMeshInstances, updateMeshInstanceTransforms } from './prepareMeshBVH.js';
-import { buildTLAS, concatBLASBuffers, getTraversalStackSizes, refitBLAS, refitTLAS } from './bvhAccel.js';
+import { buildWebTLAS, getTraversalStackSizes, refitBLAS, refitTLAS } from './bvhAccel.js';
 import { isTextureDataSource } from '../scene/Texture.js';
 import { DEFAULT_BEVEL_SAMPLES, DEFAULT_DIRECT_LIGHT_CANDIDATES, normalizeBevelSamples, normalizeDirectLightCandidates } from './RenderingPipeline.js';
 import { EmissiveTriangleCache, LightChoiceBuffer, estimateEnvironmentPower } from './lightSampling.js';
@@ -271,6 +272,7 @@ class WGPURayTracePass {
     _clamping;
     _transmissiveAlphaMin = 1;
     _viewProjInv = mat4.create();
+    _projectionInv = mat4.create();
     _cameraWorld = mat4.create();
     _apertureRadius = 0;
     _focusDistance = 10;
@@ -286,7 +288,8 @@ class WGPURayTracePass {
     _depthTracePipeline;
     _depthPipeline;
     _shaderCache;
-    _debugBVHBuffer;
+    _bvhCPU;
+    _bvhDataBytes = 0;
     // Fold scene invariants before backend inlining; runtime edits use uniforms.
     _bakePipelineConstants = true;
     constructor(device, _textureSelection = { requested: 'atlas' }) {
@@ -296,7 +299,7 @@ class WGPURayTracePass {
         if (_textureSelection.support)
             this._bindless = new WGPUBindlessTextures(device);
         this._uniforms = {
-            cameraUniform: this._uniformBuffer(36 * 4),
+            cameraUniform: this._uniformBuffer(52 * 4),
             rtUniform: this._uniformBuffer(this._rtUniform.buffer.byteLength),
             analyticLights: this._uniformBuffer(FIXED_LIGHT_COUNT * PIXELS_PER_LIGHT * 4 * 4)
         };
@@ -558,6 +561,9 @@ class WGPURayTracePass {
     _updateGPUBuffer(label, gpuBuffer, data, minSize = WGPU_SCENE_BUFFER_MIN_BYTES) {
         const device = this._device;
         const size = Math.max(data.byteLength, minSize);
+        const limit = Math.min(device.limits?.maxBufferSize ?? Infinity, device.limits?.maxStorageBufferBindingSize ?? Infinity);
+        if (size > limit)
+            throw new RangeError(`${label} buffer requires ${size} bytes; device storage buffer limit is ${limit} bytes.`);
         if (gpuBuffer == null || gpuBuffer.size < size) {
             this._needsUpdateBindGroups = true;
             if (gpuBuffer) {
@@ -568,10 +574,22 @@ class WGPURayTracePass {
                 size,
                 usage: GPUBufferUsage.STORAGE |
                     GPUBufferUsage.COPY_DST |
-                    GPUBufferUsage.COPY_SRC
+                    GPUBufferUsage.COPY_SRC,
+                // Chromium's mapped-creation IPC payload is limited to a signed 32-bit
+                // size even when the adapter supports larger storage buffers.
+                mappedAtCreation: size < 0x80000000
             });
+            if (size < 0x80000000) {
+                new Uint8Array(gpuBuffer.getMappedRange()).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+                gpuBuffer.unmap();
+                return gpuBuffer;
+            }
+        }
+        // Bound each staging allocation/IPC payload for large or reused buffers.
+        const chunkBytes = 64 * 1024 * 1024;
+        for (let offset = 0; offset < data.byteLength; offset += chunkBytes) {
+            this._device.queue.writeBuffer(gpuBuffer, offset, data.buffer, data.byteOffset + offset, Math.min(chunkBytes, data.byteLength - offset));
         }
-        this._device.queue.writeBuffer(gpuBuffer, 0, data.buffer);
         return gpuBuffer;
     }
     _uniformBuffer(size) {
@@ -646,6 +664,7 @@ class WGPURayTracePass {
             this._preparePhotonTarget();
             const pipelineInputs = JSON.stringify([
                 this._constants,
+                Boolean(this._constants.SPECTRAL) && this._shareSpectralPrefix,
                 this._hasDisplacement,
                 this._alphaBlendStrategy,
                 this._blasLayoutMask,
@@ -675,6 +694,7 @@ class WGPURayTracePass {
             const pipelineConstantsKeys = wgpuPipelineConstantKeys(constants);
             const defineCode = WGPU_SHADER_DEFINE_KEYS.map((key) => `const ${key} = ${constants[key]};`).join('\n');
             const structure = {
+                shareSpectralPrefix: Boolean(constants.SPECTRAL) && this._shareSpectralPrefix,
                 hasDisplacement: this._hasDisplacement,
                 caustics: this._causticKey,
                 bindless: !!this._bindless,
@@ -756,13 +776,14 @@ class WGPURayTracePass {
     }
     /** Snapshots everything compilation needs. The task must not read mutable pass state afterwards. */
     _startTraceVariant(signature, constants, shader) {
+        const shareSpectralPrefix = Boolean(constants.SPECTRAL) && this._shareSpectralPrefix;
         const bake = this._bakePipelineConstants, bindless = this._bindless;
         const hasDisplacement = this._hasDisplacement, blasLayoutMask = this._blasLayoutMask;
         const lightTracing = this._lightTracing, photonMapping = this._photonMapping;
         const causticKey = this._causticKey, transport = this._transport;
         const { hasAlpha, hasSceneAlpha, defineCode, pipelineConstantsKeys } = shader;
         const emitterSource = (mode) => {
-            const code = causticLightCompute(constants, blasLayoutMask, hasDisplacement, mode, '', causticDiagnostics.fullEmissionRandom !== false);
+            const code = causticLightCompute(constants, blasLayoutMask, hasDisplacement, mode, '', causticDiagnostics.fullEmissionRandom !== false, true, true);
             return bindless ? bindlessShaderSource(code, this._textureSelection.support.enable) : code;
         };
         const lightEmitter = lightTracing ? this._causticLight ??= new WGPUCausticLightPass(this._device) : undefined;
@@ -786,13 +807,16 @@ class WGPURayTracePass {
             startedAt = shaderCompilationNow();
             // Override values are not part of the WGSL unless they are baked, so a
             // quality edit can share the module that the driver has already parsed.
-            const moduleKey = JSON.stringify([causticKey, !!bindless, hasAlpha, hasSceneAlpha, hasDisplacement,
+            const moduleKey = JSON.stringify([causticKey, !!bindless, shareSpectralPrefix, Boolean(constants.SPECTRAL), hasAlpha, hasSceneAlpha, hasDisplacement,
                 constants.USE_ANISOTROPY_DIRECTIONS, constants.USE_COAT_NORMAL_FRAMES, blasLayoutMask, defineCode, pipelineConstantsKeys,
                 bake && pipelineConstantsKeys.map((key) => constants[key])]);
             let source = this._traceModules.get(moduleKey);
             if (!source) {
                 let code = wgpuShaderSource(constants, {
+                    maxPathEvents: MAX_PATH_EVENTS_WGPU,
                     hasDisplacement,
+                    channelIndependentRis: Boolean(constants.SPECTRAL),
+                    shareSpectralPrefix,
                     hasAlpha,
                     hasSceneAlpha,
                     ...transport?.features,
@@ -805,7 +829,11 @@ class WGPURayTracePass {
                     hasAnisotropyDirections: Boolean(constants.USE_ANISOTROPY_DIRECTIONS),
                     hasCoatNormals: Boolean(constants.USE_COAT_NORMAL_FRAMES),
                     blasLayoutMask,
-                    dynamicEnvironment: true
+                    cameraProjectionInverse: true,
+                    perInstanceBounds: true,
+                    compactVertices: true,
+                    dynamicEnvironment: true,
+                    displayAovStorage: true
                 }, bake);
                 if (bindless)
                     code = bindlessShaderSource(code, this._textureSelection.support.enable);
@@ -948,20 +976,21 @@ class WGPURayTracePass {
         if (index >= 0)
             this._queuedCompiles.push(...this._queuedCompiles.splice(index, 1));
     }
-    _prepareAovPipelines(kinds) {
+    _prepareAovPipelines(kinds, compact = false) {
         const trace = this._rayTracePipeline;
         if (!trace || !this._depthCompute)
             return;
-        const reflectance = (aovMask(kinds) & 24) !== 0;
+        const reflectance = (aovMask(kinds) & AOV_REFLECTANCE_MASK) !== 0;
         let variants = this._aovPipelines.get(trace);
         if (!variants) {
             variants = new Map();
             this._aovPipelines.set(trace, variants);
         }
-        let pipelines = variants.get(reflectance);
+        const key = Number(reflectance) + Number(compact) * 2;
+        let pipelines = variants.get(key);
         if (!pipelines) {
             pipelines = {};
-            variants.set(reflectance, pipelines);
+            variants.set(key, pipelines);
             const pending = pipelines;
             const textures = this._bindless, groupIndex = textures ? 2 : 3;
             const output = this._device.createBindGroupLayout({ entries: [
@@ -973,7 +1002,7 @@ class WGPURayTracePass {
                 ] });
             const descriptor = { bindGroupLayouts: Array.from({ length: groupIndex }, (_, i) => trace.getBindGroupLayout(i)).concat(output) };
             const layout = this._device.createPipelineLayout(textures ? resourceTableLayout(descriptor) : descriptor);
-            const compute = { ...this._depthCompute, constants: { ...this._depthCompute.constants, DEPTH_QUERY_MODE: 1, AOV_REFLECTANCE: reflectance ? 1 : 0 } };
+            const compute = { ...this._depthCompute, constants: { ...this._depthCompute.constants, DEPTH_QUERY_MODE: 1, AOV_REFLECTANCE: reflectance ? 1 : 0, AOV_COMPACT: compact ? 1 : 0 } };
             // Keep the UI responsive during first use, and reuse both variants across
             // preview/final target changes rather than recreating synchronous pipelines.
             void Promise.all([
@@ -985,30 +1014,33 @@ class WGPURayTracePass {
             throw pipelines.error;
         return pipelines;
     }
-    prepareAovs(kinds) {
-        const pipelines = this._prepareAovPipelines(kinds);
+    prepareAovs(kinds, compact = false) {
+        const pipelines = this._prepareAovPipelines(kinds, compact);
         return !!pipelines?.accumulation && !!pipelines.center;
     }
-    renderAovs(state, camera, samples, cap, kinds) {
+    renderAovs(state, camera, samples, cap, kinds, resolution) {
         const groups = this._rayTraceBindGroups;
         if (!groups || !this._tlas || !this._preparedMeshData || !kinds.length)
             return false;
-        const pipelines = this._prepareAovPipelines(kinds);
+        const compact = !!resolution && kinds.every(kind => COMPACT_AOV_KINDS.includes(kind));
+        const pipelines = this._prepareAovPipelines(kinds, compact);
         if (!pipelines?.accumulation || !pipelines.center)
             return false;
-        state.resize(this._width, this._height);
+        state.resize(resolution?.width ?? this._width, resolution?.height ?? this._height, compact);
         const textures = this._bindless, groupIndex = textures ? 2 : 3;
         const target = Math.min(samples, cap);
         if (state.centerReady && state.samples >= target)
             return true;
         if (!state.frame) {
-            const primitiveIds = this._aovPrimitiveCache.get(this._preparedMeshData, this._tlas);
-            const packed = packAovScene(this._preparedMeshData, this._tlas, camera, this._width, this._height, state.history, primitiveIds, false);
+            // Only the center pass reads primitive IDs and compact display AOVs skip
+            // it; building the map walks every BVH leaf on the main thread.
+            const primitiveIds = compact ? undefined : this._aovPrimitiveCache.get(this._preparedMeshData, this._tlas);
+            const packed = packAovScene(this._preparedMeshData, this._tlas, camera, state.width, state.height, state.history, primitiveIds, false);
             state.frame = packed.frame;
             state.setScene(packed.words, primitiveIds);
         }
         this._device.queue.writeBuffer(this._uniforms.rtUniform, 0, this._rtUniform.buffer);
-        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance));
+        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance, this._projectionInv));
         const device = this._device;
         const run = (pipeline, sample) => {
             // A fresh uniform for each queued dispatch keeps batch samples independent.
@@ -1032,11 +1064,12 @@ class WGPURayTracePass {
             parameters.destroy();
         };
         if (!state.centerReady) {
-            run(pipelines.center, 0);
+            if (!compact)
+                run(pipelines.center, 0);
             state.centerReady = true;
             state.history.accept(state.frame);
         }
-        if ((aovMask(kinds) & 31) === 0)
+        if ((aovMask(kinds) & AOV_ACCUMULATED_MASK) === 0)
             state.samples = target;
         while (state.samples < target) {
             run(pipelines.accumulation, state.samples);
@@ -1044,13 +1077,27 @@ class WGPURayTracePass {
         }
         return true;
     }
-    async readDepthSamples(area, aspect) {
+    async pickSurface(x, y, aspect) {
+        const source = this._preparedMeshData, tlas = this._tlas;
+        if (!source || !tlas)
+            return;
+        const values = await this._readDepthSamples({ x, y, size: 0 }, aspect, true);
+        if (!values || source !== this._preparedMeshData || tlas !== this._tlas)
+            return;
+        return resolveSurfaceHit(source, tlas, values);
+    }
+    readDepthSamples(area, aspect) {
+        return this._readDepthSamples(area, aspect);
+    }
+    async _readDepthSamples(area, aspect, picking = false) {
         const tracePipeline = this._rayTracePipeline;
         const groups = this._rayTraceBindGroups;
         const textures = this._bindless, textureRevision = textures?.revision;
         if (!tracePipeline || !groups || !this._depthCompute || this.isCompilingShader())
             return;
         const packed = packDepthSampleArea(area, aspect ?? this._width / this._height);
+        if (picking)
+            packed.set([-1, -1], 2);
         if (this._depthTracePipeline !== tracePipeline || !this._depthPipeline) {
             const outputLayout = this._shaderCache.createBindGroupLayout({
                 label: 'Depth query output',
@@ -1102,7 +1149,8 @@ class WGPURayTracePass {
             encoder.copyBufferToBuffer(output, 0, readback, 0, bytes);
             device.queue.submit([encoder.finish()]);
             await readback.mapAsync(GPUMapMode.READ);
-            return unpackDepthSamples(new Float32Array(readback.getMappedRange()));
+            const rgba = new Float32Array(readback.getMappedRange());
+            return picking ? rgba.slice(0, 4) : unpackDepthSamples(rgba);
         }
         finally {
             if (readback.mapState === 'mapped')
@@ -1333,12 +1381,12 @@ class WGPURayTracePass {
         return (causticBatch ? 1 : 0) | (photonBatch ? 2 : 0);
     }
     async getDebugBVHData() {
-        if (!this._debugBVHBuffer) {
-            throw new Error(`software-bvh exposes no CPU-readable BVH debug buffer`);
-        }
-        return {
-            buffer: this._debugBVHBuffer
-        };
+        if (!this._bvhCPU)
+            throw new Error('software-bvh exposes no CPU-readable BVH debug buffer');
+        // Debug capture pays for a combined copy only when explicitly requested.
+        const buffer = new ArrayBuffer(this._bvhDataBytes);
+        this._writeBVH(buffer, this._bvhCPU.tlas, this._bvhCPU.blases);
+        return { buffer };
     }
     getDiagnostics() {
         const atlas = this._materialData instanceof MaterialTable ? this._materialData.textureAtlasStats : undefined;
@@ -1379,7 +1427,7 @@ class WGPURayTracePass {
         return this._apertureRadius > 0;
     }
     setBounce(bounce) {
-        const next = normalizeBounces(bounce);
+        const next = normalizeBounces(bounce, MAX_PATH_EVENTS_WGPU);
         const changed = this._bounces !== next;
         this._bounces = next;
         this._rtUniform.views.bounces[0] = next;
@@ -1435,9 +1483,11 @@ class WGPURayTracePass {
         this._ensureAdaptiveSamplingTexture(width, height);
         this._device.queue.writeTexture({ texture: this._adaptiveSamplingTexture }, data, { bytesPerRow: width * Float32Array.BYTES_PER_ELEMENT }, [width, height]);
     }
+    _shareSpectralPrefix = true;
     setQuality(options) {
+        this._shareSpectralPrefix = options.dispersionWavelengths !== 1;
         WGPURayTracePass.prototype._setCaustics.call(this, options.caustics);
-        writeTraceQuality(this._rtUniform.views, options);
+        writeTraceQuality(this._rtUniform.views, options, MAX_PATH_EVENTS_WGPU);
     }
     _setCaustics(settings) {
         this._causticSettings = settings;
@@ -1870,22 +1920,54 @@ class WGPURayTracePass {
         const stacks = getTraversalStackSizes(tlas, blases);
         this._constants.TLAS_STACK_SIZE = retainedShaderCapacity(stacks.tlas, Number(this._constants.TLAS_STACK_SIZE ?? 0));
         this._constants.BLAS_STACK_SIZE = retainedShaderCapacity(stacks.blas, Number(this._constants.BLAS_STACK_SIZE ?? 0), 32);
-        const tlasBuffer = new Float32Array(tlas.buffer);
-        const blasBuffer = new Float32Array(concatBLASBuffers(blases));
-        const bvhData = new Float32Array(tlasBuffer.length + blasBuffer.length);
-        const blasOffset = tlasBuffer.length / 4;
-        bvhData.set(tlasBuffer);
-        bvhData.set(blasBuffer, blasOffset * 4);
-        const bvhBuffer = this._updateGPUBuffer('BVH', this._bvhBuffer, bvhData);
+        const size = tlas.buffer.byteLength + blases.reduce((sum, b) => sum + b.bvh.buffer.byteLength, 0);
+        const limit = Math.min(this._device.limits.maxBufferSize, this._device.limits.maxStorageBufferBindingSize);
+        if (size > limit)
+            throw new RangeError(`BVH buffer requires ${size} bytes; device storage buffer limit is ${limit} bytes.`);
+        let bvhBuffer = this._bvhBuffer;
+        if (!bvhBuffer || bvhBuffer.size < Math.max(size, WGPU_SCENE_BUFFER_MIN_BYTES)) {
+            bvhBuffer?.destroy();
+            bvhBuffer = this._device.createBuffer({ label: 'BVH', size: Math.max(size, WGPU_SCENE_BUFFER_MIN_BYTES),
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC, mappedAtCreation: size < 0x80000000 });
+            if (size < 0x80000000) {
+                this._writeBVH(bvhBuffer.getMappedRange(), tlas, blases);
+                bvhBuffer.unmap();
+            }
+            else
+                this._uploadBVHBlocks(bvhBuffer, tlas, blases);
+        }
+        else
+            this._uploadBVHBlocks(bvhBuffer, tlas, blases);
+        this._bvhCPU = { tlas, blases };
+        this._bvhDataBytes = size;
+        const blasOffset = tlas.buffer.byteLength / 16;
         const instancesBuffer = this._updateGPUBuffer('Instances', this._instancesBuffer, new Float32Array(tlas.instancesBuffer));
-        if (bvhBuffer !== this._bvhBuffer || instancesBuffer !== this._instancesBuffer) {
+        if (bvhBuffer !== this._bvhBuffer || instancesBuffer !== this._instancesBuffer)
             this._needsUpdateBindGroups = true;
-        }
         this._bvhBuffer = bvhBuffer;
         this._instancesBuffer = instancesBuffer;
-        this._debugBVHBuffer = bvhData.buffer.slice(0);
         this._rtUniform.views.blasOffset.set([blasOffset]);
     }
+    _uploadBVHBlocks(buffer, tlas, blases) {
+        this._device.queue.writeBuffer(buffer, 0, tlas.buffer);
+        let target = tlas.buffer.byteLength;
+        for (const blas of blases) {
+            const chunkBytes = 64 * 1024 * 1024;
+            for (let offset = 0; offset < blas.bvh.buffer.byteLength; offset += chunkBytes) {
+                this._device.queue.writeBuffer(buffer, target + offset, blas.bvh.buffer, offset, Math.min(chunkBytes, blas.bvh.buffer.byteLength - offset));
+            }
+            target += blas.bvh.buffer.byteLength;
+        }
+    }
+    _writeBVH(buffer, tlas, blases) {
+        const bytes = new Uint8Array(buffer);
+        bytes.set(new Uint8Array(tlas.buffer));
+        let offset = tlas.buffer.byteLength;
+        for (const blas of blases) {
+            bytes.set(new Uint8Array(blas.bvh.buffer), offset);
+            offset += blas.bvh.buffer.byteLength;
+        }
+    }
     _updateMeshData() {
         this._pendingGeometryUpdates.clear();
         this._emissiveCache = new EmissiveTriangleCache();
@@ -1900,7 +1982,7 @@ class WGPURayTracePass {
         }
         this._geometriesNeedRefit.clear();
         // TODO check bvh needs to change
-        const res = updateMeshInstances(meshes);
+        const res = updateMeshInstances(meshes, { mergeAttributes: false });
         this._preparedMeshData = res;
         this._membershipCache.capture(res);
         this._pendingMembershipData = undefined;
@@ -1908,7 +1990,7 @@ class WGPURayTracePass {
         const mergedGeometry = res.geometry;
         const materials = res.materials;
         const isEmpty = meshes.length === 0 || res.instances.length === 0;
-        const tlas = buildTLAS(res.instances, res.blases);
+        const tlas = buildWebTLAS(res.instances, res.blases);
         this._tlas = tlas;
         this._uploadBVH(tlas, res.blases);
         const materialData = (this._materialData = this._createMaterialData(materials, this._analyticLights, {
@@ -1918,13 +2000,23 @@ class WGPURayTracePass {
         }));
         this._emissiveTriangles = this._emissiveCache.collect(res.emissiveBindings, materials);
         this._needsUpdateLightSamplingData = true;
-        const attributeLayout = sceneAttributeLayout(mergedGeometry);
+        // Displacement geometry and its CPU BVH bounds must use the same normal.
+        // Preserve f32 normals in these scenes, avoiding quantization outside bounds.
+        const attributeLayout = compactVertexLayout(res.geometries, materials.some(m => !!m.displacementMap));
         const { stride, offsets } = attributeLayout;
-        const attrBufferData = new F32(mergedGeometry.vertexCount * stride);
-        packVertexAttributes(mergedGeometry, attrBufferData, stride, offsets, 0, mergedGeometry.vertexCount);
+        const vertexWords = res.geometries.reduce((sum, g) => sum + g.vertexCount, 0) * stride;
+        const materialWords = attributeLayout.constants.HAS_TRIANGLE_MATERIAL ? this._bvhDataBytes / 16 : 0;
+        const attrBufferData = new Uint32Array(vertexWords + materialWords);
+        attributeLayout.constants.MATERIALINDEX_OFF = vertexWords;
+        for (const geometry of res.geometries) {
+            const region = res.geometryRegions.get(geometry);
+            packCompactVertices(geometry, attrBufferData, stride, offsets, 0, geometry.vertexCount, region.vertexOffset, false, !!attributeLayout.constants.COLOR_FLOAT, !!attributeLayout.constants.NORMAL_FLOAT);
+        }
         this._attributeData = attrBufferData;
         this._attributeStride = stride;
         this._attributeOffsets = offsets;
+        Object.assign(this._constants, attributeLayout.constants);
+        this._packTriangleMaterials(res, tlas);
         this._attrBuffers = this._updateGPUBuffer('Attributes', this._attrBuffers, attrBufferData);
         this._materialsBuffer = this._updateGPUBuffer('Materials', this._materialsBuffer, materialData.getBufferArray(), 
         // WGSL requires a runtime array binding to contain at least one
@@ -1971,11 +2063,47 @@ class WGPURayTracePass {
         if (this._bindless)
             this._constants.NUM_MAPS = 20;
     }
+    _packTriangleMaterials(res, tlas) {
+        if (!this._constants.HAS_TRIANGLE_MATERIAL)
+            return;
+        let offset = Number(this._constants.MATERIALINDEX_OFF) + tlas.buffer.byteLength / 16;
+        res.geometries.forEach((g, i) => {
+            packTriangleMaterials(g, res.geometryRegions.get(g).materialIndices, res.blases[i].bvh.buffer, this._attributeData, offset);
+            offset += res.blases[i].bvh.buffer.byteLength / 16;
+        });
+    }
+    _refreshTriangleMaterials(res, tlas) {
+        if (!this._constants.HAS_TRIANGLE_MATERIAL)
+            return;
+        const vertexWords = Number(this._constants.MATERIALINDEX_OFF);
+        const required = vertexWords + this._bvhDataBytes / 16;
+        if (this._attributeData.length !== required) {
+            const next = new Uint32Array(required);
+            next.set(this._attributeData.subarray(0, vertexWords));
+            this._attributeData = next;
+        }
+        this._packTriangleMaterials(res, tlas);
+        if (this._attrBuffers.size < this._attributeData.byteLength) {
+            this._attrBuffers = this._updateGPUBuffer('Attributes', this._attrBuffers, this._attributeData);
+        }
+        else {
+            const first = vertexWords * 4, end = this._attributeData.byteLength, chunk = 64 * 1024 * 1024;
+            for (let offset = first; offset < end; offset += chunk) {
+                this._device.queue.writeBuffer(this._attrBuffers, offset, this._attributeData.buffer, offset, Math.min(chunk, end - offset));
+            }
+        }
+    }
     _updateGeometryData() {
         const res = this._preparedMeshData, tlas = this._tlas;
+        // Promote the scene color plane if an edit introduces HDR/negative RGB.
+        if (!this._constants.COLOR_FLOAT && [...this._pendingGeometryUpdates].some(g => g.color?.array.some(value => !(value >= 0 && value <= 1)))) {
+            this._updateMeshData();
+            return;
+        }
         const update = updatePreparedGeometries(res, this._pendingGeometryUpdates);
-        for (const { first, count, topologyChanged, deformationOnly } of update.vertices) {
-            packVertexAttributes(res.geometry, this._attributeData, this._attributeStride, this._attributeOffsets, first, count, topologyChanged, deformationOnly);
+        for (const { first, count, deformationOnly } of update.vertices) {
+            const geometry = res.geometries.find(g => res.geometryRegions.get(g).vertexOffset === first);
+            packCompactVertices(geometry, this._attributeData, this._attributeStride, this._attributeOffsets, 0, count, first, deformationOnly, !!this._constants.COLOR_FLOAT, !!this._constants.NORMAL_FLOAT);
             const offset = first * this._attributeStride * 4, size = count * this._attributeStride * 4;
             this._device.queue.writeBuffer(this._attrBuffers, offset, this._attributeData.buffer, offset, size);
         }
@@ -1991,17 +2119,13 @@ class WGPURayTracePass {
             this._uploadBVH(tlas, res.blases);
         }
         else {
-            const bytes = new Uint8Array(this._debugBVHBuffer);
-            const ranges = [];
             for (const { blas, offset } of update.blases) {
-                const target = tlas.buffer.byteLength + offset;
-                bytes.set(new Uint8Array(blas.buffer), target);
-                ranges.push({ offset: target, size: blas.buffer.byteLength });
-            }
-            for (const { offset, size } of mergeRefitRanges(ranges)) {
-                this._device.queue.writeBuffer(this._bvhBuffer, offset, this._debugBVHBuffer, offset, size);
+                this._device.queue.writeBuffer(this._bvhBuffer, tlas.buffer.byteLength + offset, blas.buffer);
             }
         }
+        if (this._constants.HAS_TRIANGLE_MATERIAL && (update.relocated || update.vertices.some(v => v.topologyChanged))) {
+            this._refreshTriangleMaterials(res, tlas);
+        }
         const bits = { bvh2: 1, bvh4: 2, 'bvh-gpu': 4, cwbvh: 8 };
         this._blasLayoutMask = res.blases.reduce((mask, b) => mask | bits[b.bvh.layout ?? 'bvh2'], 0);
         const stacks = getTraversalStackSizes(tlas, res.blases);
@@ -2061,9 +2185,10 @@ class WGPURayTracePass {
         if (pending)
             this._residentPreparedMeshData = res;
         this._pendingMembershipData = undefined;
-        const tlas = buildTLAS(instances, res.blases);
+        const tlas = buildWebTLAS(instances, res.blases);
         this._tlas = tlas;
         this._uploadBVH(tlas, res.blases);
+        this._refreshTriangleMaterials(res, tlas);
         this._emissiveTriangles = this._emissiveCache.collect(emissiveBindings, res.materials);
         this._needsUpdateLightSamplingData = true;
         this._rtUniform.views.isEmpty[0] = +(instances.length === 0);
@@ -2097,8 +2222,9 @@ class WGPURayTracePass {
         const previousInstances = res.instances;
         res.instances = updateMeshInstanceTransforms(res.instanceBindings, incremental ? res.instances : undefined, incremental ? dirtyIndices : undefined);
         if (!sameInstanceMembership(previousInstances, res.instances)) {
-            this._tlas = buildTLAS(res.instances, res.blases);
+            this._tlas = buildWebTLAS(res.instances, res.blases);
             this._uploadBVH(this._tlas, res.blases);
+            this._refreshTriangleMaterials(res, this._tlas);
             this._emissiveTriangles = this._emissiveCache.collect(res.emissiveBindings, res.materials);
             this._needsUpdateLightSamplingData = true;
             this._rtUniform.views.isEmpty[0] = +(res.instances.length === 0);
@@ -2107,16 +2233,12 @@ class WGPURayTracePass {
             return;
         }
         const ranges = refitTLAS(tlas, res.instances, res.blases, incremental ? dirtyIndices : undefined);
-        const tlasData = new Float32Array(tlas.buffer);
         for (const { offset, size } of ranges.tlasRanges) {
             this._device.queue.writeBuffer(this._bvhBuffer, offset, tlas.buffer, offset, size);
         }
         for (const { offset, size } of ranges.instanceRanges) {
             this._device.queue.writeBuffer(this._instancesBuffer, offset, tlas.instancesBuffer, offset, size);
         }
-        if (this._debugBVHBuffer) {
-            new Float32Array(this._debugBVHBuffer).set(tlasData);
-        }
         if (!incremental ||
             res.emissiveBindings.some(({ mesh }) => this._dirtyTransformMeshes.has(mesh))) {
             this._emissiveTriangles = this._emissiveCache.collect(res.emissiveBindings, res.materials);
@@ -2254,7 +2376,8 @@ class WGPURayTracePass {
         const viewProjectionInvMat = this._viewProjInv;
         this._apertureRadius = cameraApertureRadius(camera);
         this._focusDistance = camera.focusDistance;
-        this._updateViewProjInv(camera, viewProjectionInvMat);
+        mat4.invert(this._projectionInv, projection);
+        mat4.mul(viewProjectionInvMat, camera.transform, this._projectionInv);
         mat4.copy(this._cameraWorld, camera.transform);
     }
     cameraChanged(camera) {
@@ -2310,7 +2433,7 @@ class WGPURayTracePass {
         const arr = this._rtUniform.views.jitter;
         arr[0] = x;
         arr[1] = y;
-        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance));
+        this._device.queue.writeBuffer(this._uniforms.cameraUniform, 0, packCameraUniform(this._viewProjInv, this._cameraWorld, this._apertureRadius, this._focusDistance, this._projectionInv));
     }
     setSampleTiles(columns, rows, tileX, tileY) {
         const arr = this._rtUniform.views.scaleOffset;