@ifc-lite/renderer 1.22.1 → 1.23.1

package/dist/index.js

@@ -5,8 +5,9 @@
  * @ifc-lite/renderer - WebGPU renderer
  */
 export { WebGPUDevice } from './device.js';
-export { RenderPipeline, InstancedRenderPipeline } from './pipeline.js';
+export { RenderPipeline } from './pipeline.js';
 export { Camera } from './camera.js';
+export { pickFitPolicy } from './camera-fit-policy.js';
 export { Scene } from './scene.js';
 export { Picker } from './picker.js';
 export { MathUtils } from './math.js';
@@ -27,8 +28,6 @@ export { SnapDetector, SnapType } from './snap-detector.js';
 export { BVH } from './bvh.js';
 export { FederationRegistry, federationRegistry } from './federation-registry.js';
 export * from './types.js';
-// Zero-copy GPU upload (new - faster, less memory)
-export { ZeroCopyGpuUploader, createZeroCopyUploader, } from './zero-copy-uploader.js';
 // Extracted manager classes
 export { PickingManager } from './picking-manager.js';
 export { RaycastEngine } from './raycast-engine.js';
@@ -37,13 +36,12 @@ export { PointPicker, decodePickSample } from './point-picker.js';
 export { PointCloudRenderer } from './pointcloud/point-cloud-renderer.js';
 export { PointRenderPipeline } from './pointcloud/point-pipeline.js';
 import { WebGPUDevice } from './device.js';
-import { RenderPipeline, InstancedRenderPipeline } from './pipeline.js';
+import { RenderPipeline } from './pipeline.js';
 import { Camera } from './camera.js';
 import { Scene } from './scene.js';
 import { Picker } from './picker.js';
 import { MathUtils } from './math.js';
 import { FrustumUtils } from '@ifc-lite/spatial';
-import { deduplicateMeshes } from '@ifc-lite/geometry';
 import { SectionPlaneRenderer } from './section-plane.js';
 import { Section2DOverlayRenderer } from './section-2d-overlay.js';
 import { SymbolicFillPipeline, SymbolicTextPipeline, } from './symbolic-overlay-pipelines.js';
@@ -83,7 +81,6 @@ function computeBvhFingerprint(meshes) {
 export class Renderer {
     device;
     pipeline = null;
-    instancedPipeline = null;
     camera;
     scene;
     picker = null;
@@ -170,7 +167,6 @@ export class Renderer {
             this.canvas.height = height;
         }
         this.pipeline = new RenderPipeline(this.device, width, height);
-        this.instancedPipeline = new InstancedRenderPipeline(this.device, width, height);
         this.picker = new Picker(this.device, width, height);
         this.sectionPlaneRenderer = new SectionPlaneRenderer(this.device.getDevice(), this.device.getFormat(), this.pipeline.getSampleCount());
         this.section2DOverlayRenderer = new Section2DOverlayRenderer(this.device.getDevice(), this.device.getFormat(), this.pipeline.getSampleCount());
@@ -601,155 +597,6 @@ export class Renderer {
         }
         this.scene.addMesh(mesh);
     }
-    /**
-     * Add instanced geometry to scene
-     * Converts InstancedGeometry from geometry package to InstancedMesh for rendering
-     */
-    addInstancedGeometry(geometry) {
-        if (!this.instancedPipeline || !this.device.isInitialized()) {
-            throw new Error('Renderer not initialized. Call init() first.');
-        }
-        const device = this.device.getDevice();
-        // Upload positions and normals interleaved
-        const vertexCount = geometry.positions.length / 3;
-        const vertexData = new Float32Array(vertexCount * 6);
-        for (let i = 0; i < vertexCount; i++) {
-            vertexData[i * 6 + 0] = geometry.positions[i * 3 + 0];
-            vertexData[i * 6 + 1] = geometry.positions[i * 3 + 1];
-            vertexData[i * 6 + 2] = geometry.positions[i * 3 + 2];
-            vertexData[i * 6 + 3] = geometry.normals[i * 3 + 0];
-            vertexData[i * 6 + 4] = geometry.normals[i * 3 + 1];
-            vertexData[i * 6 + 5] = geometry.normals[i * 3 + 2];
-        }
-        // Create vertex buffer with exact size needed (ensure it matches data size)
-        const vertexBufferSize = vertexData.byteLength;
-        const vertexBuffer = device.createBuffer({
-            size: vertexBufferSize,
-            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-        });
-        device.queue.writeBuffer(vertexBuffer, 0, vertexData);
-        // Create index buffer
-        const indexBuffer = device.createBuffer({
-            size: geometry.indices.byteLength,
-            usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
-        });
-        device.queue.writeBuffer(indexBuffer, 0, geometry.indices);
-        // Create instance buffer: each instance is 80 bytes (20 floats: 16 for transform + 4 for color)
-        const instanceCount = geometry.instance_count;
-        const instanceData = new Float32Array(instanceCount * 20);
-        const expressIdToInstanceIndex = new Map();
-        for (let i = 0; i < instanceCount; i++) {
-            const instance = geometry.get_instance(i);
-            if (!instance)
-                continue;
-            const baseIdx = i * 20;
-            // Copy transform (16 floats)
-            instanceData.set(instance.transform, baseIdx);
-            // Copy color (4 floats)
-            instanceData[baseIdx + 16] = instance.color[0];
-            instanceData[baseIdx + 17] = instance.color[1];
-            instanceData[baseIdx + 18] = instance.color[2];
-            instanceData[baseIdx + 19] = instance.color[3];
-            expressIdToInstanceIndex.set(instance.expressId, i);
-        }
-        const instanceBuffer = device.createBuffer({
-            size: instanceData.byteLength,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-        });
-        device.queue.writeBuffer(instanceBuffer, 0, instanceData);
-        // Create and cache bind group to avoid per-frame allocation
-        const bindGroup = this.instancedPipeline.createInstanceBindGroup(instanceBuffer);
-        const instancedMesh = {
-            geometryId: Number(geometry.geometryId),
-            vertexBuffer,
-            indexBuffer,
-            indexCount: geometry.indices.length,
-            instanceBuffer,
-            instanceCount: instanceCount,
-            expressIdToInstanceIndex,
-            bindGroup,
-        };
-        this.scene.addInstancedMesh(instancedMesh);
-    }
-    /**
-     * Convert MeshData array to instanced meshes for optimized rendering
-     * Groups identical geometries and creates GPU instanced draw calls
-     * Call this in background after initial streaming completes
-     */
-    convertToInstanced(meshDataArray) {
-        if (!this.instancedPipeline || !this.device.isInitialized()) {
-            console.warn('[Renderer] Cannot convert to instanced: renderer not initialized');
-            return;
-        }
-        const instancedData = deduplicateMeshes(meshDataArray);
-        const device = this.device.getDevice();
-        let totalInstances = 0;
-        for (const group of instancedData) {
-            const vertexCount = group.positions.length / 3;
-            const vertexData = new Float32Array(vertexCount * 6);
-            for (let i = 0; i < vertexCount; i++) {
-                vertexData[i * 6 + 0] = group.positions[i * 3 + 0];
-                vertexData[i * 6 + 1] = group.positions[i * 3 + 1];
-                vertexData[i * 6 + 2] = group.positions[i * 3 + 2];
-                vertexData[i * 6 + 3] = group.normals[i * 3 + 0];
-                vertexData[i * 6 + 4] = group.normals[i * 3 + 1];
-                vertexData[i * 6 + 5] = group.normals[i * 3 + 2];
-            }
-            const vertexBuffer = device.createBuffer({
-                size: vertexData.byteLength,
-                usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-            });
-            device.queue.writeBuffer(vertexBuffer, 0, vertexData);
-            const indexBuffer = device.createBuffer({
-                size: group.indices.byteLength,
-                usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
-            });
-            device.queue.writeBuffer(indexBuffer, 0, group.indices);
-            const instanceCount = group.instances.length;
-            const instanceData = new Float32Array(instanceCount * 20);
-            const expressIdToInstanceIndex = new Map();
-            const identityTransform = new Float32Array([
-                1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
-            ]);
-            for (let i = 0; i < instanceCount; i++) {
-                const instance = group.instances[i];
-                const baseIdx = i * 20;
-                instanceData.set(identityTransform, baseIdx);
-                instanceData[baseIdx + 16] = instance.color[0];
-                instanceData[baseIdx + 17] = instance.color[1];
-                instanceData[baseIdx + 18] = instance.color[2];
-                instanceData[baseIdx + 19] = instance.color[3];
-                expressIdToInstanceIndex.set(instance.expressId, i);
-            }
-            const instanceBuffer = device.createBuffer({
-                size: instanceData.byteLength,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-            });
-            device.queue.writeBuffer(instanceBuffer, 0, instanceData);
-            const bindGroup = this.instancedPipeline.createInstanceBindGroup(instanceBuffer);
-            let geometryHash = 0;
-            for (let i = 0; i < group.geometryHash.length; i++) {
-                geometryHash = ((geometryHash << 5) - geometryHash) + group.geometryHash.charCodeAt(i);
-                geometryHash = geometryHash & geometryHash;
-            }
-            this.scene.addInstancedMesh({
-                geometryId: Math.abs(geometryHash),
-                vertexBuffer,
-                indexBuffer,
-                indexCount: group.indices.length,
-                instanceBuffer,
-                instanceCount,
-                expressIdToInstanceIndex,
-                bindGroup,
-            });
-            totalInstances += instanceCount;
-        }
-        const regularMeshCount = this.scene.getMeshes().length;
-        this.scene.clearRegularMeshes();
-        console.log(`[Renderer] Converted ${meshDataArray.length} meshes to ${instancedData.length} instanced geometries ` +
-            `(${totalInstances} total instances, ${(totalInstances / instancedData.length).toFixed(1)}x deduplication). ` +
-            `Cleared ${regularMeshCount} regular meshes.`);
-    }
     /**
      * Ensure all meshes have GPU resources (call after adding meshes if pipeline wasn't ready)
      */
@@ -946,9 +793,6 @@ export class Renderer {
             this.device.configureContext();
             // Also resize the depth texture immediately
             this.pipeline.resize(width, height);
-            if (this.instancedPipeline) {
-                this.instancedPipeline.resize(width, height);
-            }
         }
         // Skip rendering if canvas is invalid
         if (this.canvas.width === 0 || this.canvas.height === 0) {
@@ -1078,9 +922,6 @@ export class Renderer {
         if (this.pipeline.needsResize(this.canvas.width, this.canvas.height)) {
             this.pipeline.resize(this.canvas.width, this.canvas.height);
         }
-        if (this.instancedPipeline?.needsResize(this.canvas.width, this.canvas.height)) {
-            this.instancedPipeline.resize(this.canvas.width, this.canvas.height);
-        }
         // Push a validation error scope to capture the EXACT error (for mobile debugging)
         // Only do this for the first few renders to avoid performance overhead
         const captureGpuError = this._renderCallCount <= 5;
@@ -1851,29 +1692,6 @@ export class Renderer {
                     }
                 }
             }
-            // Render instanced meshes (much more efficient for repeated geometry)
-            if (this.instancedPipeline) {
-                const instancedMeshes = this.scene.getInstancedMeshes();
-                if (instancedMeshes.length > 0) {
-                    // Update instanced pipeline uniforms
-                    this.instancedPipeline.updateUniforms(viewProj, sectionPlaneData
-                        ? { ...sectionPlaneData, flipped: options.sectionPlane?.flipped === true }
-                        : undefined);
-                    // Switch to instanced pipeline
-                    pass.setPipeline(this.instancedPipeline.getPipeline());
-                    for (const instancedMesh of instancedMeshes) {
-                        // Use cached bind group (created at mesh upload time)
-                        // Falls back to creating one if missing (shouldn't happen in normal flow)
-                        const bindGroup = instancedMesh.bindGroup ??
-                            this.instancedPipeline.createInstanceBindGroup(instancedMesh.instanceBuffer);
-                        pass.setBindGroup(0, bindGroup);
-                        pass.setVertexBuffer(0, instancedMesh.vertexBuffer);
-                        pass.setIndexBuffer(instancedMesh.indexBuffer, 'uint32');
-                        // Draw with instancing: indexCount, instanceCount
-                        pass.drawIndexed(instancedMesh.indexCount, instancedMesh.instanceCount, 0, 0, 0);
-                    }
-                }
-            }
             // Draw point clouds (IFCx inline + streamed LAS/LAZ).
             // Shares the depth buffer + section plane state with the mesh pipeline so
             // points occlude triangles and vice versa. The splat shader needs the
@@ -2427,8 +2245,6 @@ export class Renderer {
         // Render pipelines (textures + uniform buffers)
         this.pipeline?.destroy();
         this.pipeline = null;
-        this.instancedPipeline?.destroy();
-        this.instancedPipeline = null;
         // Picker GPU resources
         this.picker?.destroy();
         this.picker = null;