@ifc-lite/renderer 1.2.0 → 1.3.0

package/dist/index.js

@@ -14,6 +14,7 @@ export { SectionPlaneRenderer } from './section-plane.js';
 export { Raycaster } from './raycaster.js';
 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';
@@ -49,6 +50,9 @@ export class Renderer {
     bvhCache = null;
     // Performance constants
     BVH_THRESHOLD = 100;
+    // Error rate limiting (log at most once per second)
+    lastRenderErrorTime = 0;
+    RENDER_ERROR_THROTTLE_MS = 1000;
     constructor(canvas) {
         this.canvas = canvas;
         this.device = new WebGPUDevice();
@@ -76,9 +80,96 @@ export class Renderer {
         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.sectionPlaneRenderer = new SectionPlaneRenderer(this.device.getDevice(), this.device.getFormat(), this.pipeline.getSampleCount());
         this.camera.setAspect(width / height);
     }
+    /**
+     * Load geometry from GeometryResult or MeshData array
+     * This is the main entry point for loading IFC geometry into the renderer
+     *
+     * @param geometry - Either a GeometryResult from geometry.process() or an array of MeshData
+     */
+    loadGeometry(geometry) {
+        if (!this.device.isInitialized() || !this.pipeline) {
+            throw new Error('Renderer not initialized. Call init() first.');
+        }
+        const meshes = Array.isArray(geometry) ? geometry : geometry.meshes;
+        if (meshes.length === 0) {
+            console.warn('[Renderer] loadGeometry called with empty mesh array');
+            return;
+        }
+        // Use batched rendering for optimal performance
+        const device = this.device.getDevice();
+        this.scene.appendToBatches(meshes, device, this.pipeline, false);
+        // Calculate and store model bounds for fitToView
+        this.updateModelBounds(meshes);
+        console.log(`[Renderer] Loaded ${meshes.length} meshes`);
+    }
+    /**
+     * Add multiple meshes to the scene (convenience method for streaming)
+     *
+     * @param meshes - Array of MeshData to add
+     * @param isStreaming - If true, throttles batch rebuilding for better streaming performance
+     */
+    addMeshes(meshes, isStreaming = false) {
+        if (!this.device.isInitialized() || !this.pipeline) {
+            throw new Error('Renderer not initialized. Call init() first.');
+        }
+        if (meshes.length === 0)
+            return;
+        const device = this.device.getDevice();
+        this.scene.appendToBatches(meshes, device, this.pipeline, isStreaming);
+        // Update model bounds incrementally
+        this.updateModelBounds(meshes);
+    }
+    /**
+     * Update model bounds from mesh data
+     */
+    updateModelBounds(meshes) {
+        if (!this.modelBounds) {
+            this.modelBounds = {
+                min: { x: Infinity, y: Infinity, z: Infinity },
+                max: { x: -Infinity, y: -Infinity, z: -Infinity }
+            };
+        }
+        for (const mesh of meshes) {
+            const positions = mesh.positions;
+            for (let i = 0; i < positions.length; i += 3) {
+                const x = positions[i];
+                const y = positions[i + 1];
+                const z = positions[i + 2];
+                if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z)) {
+                    this.modelBounds.min.x = Math.min(this.modelBounds.min.x, x);
+                    this.modelBounds.min.y = Math.min(this.modelBounds.min.y, y);
+                    this.modelBounds.min.z = Math.min(this.modelBounds.min.z, z);
+                    this.modelBounds.max.x = Math.max(this.modelBounds.max.x, x);
+                    this.modelBounds.max.y = Math.max(this.modelBounds.max.y, y);
+                    this.modelBounds.max.z = Math.max(this.modelBounds.max.z, z);
+                }
+            }
+        }
+    }
+    /**
+     * Fit camera to view all loaded geometry
+     */
+    fitToView() {
+        if (!this.modelBounds) {
+            console.warn('[Renderer] fitToView called but no geometry loaded');
+            return;
+        }
+        const { min, max } = this.modelBounds;
+        // Calculate center and size
+        const center = {
+            x: (min.x + max.x) / 2,
+            y: (min.y + max.y) / 2,
+            z: (min.z + max.z) / 2
+        };
+        const size = Math.max(max.x - min.x, max.y - min.y, max.z - min.z);
+        // Position camera to see entire model
+        const distance = size * 1.5;
+        this.camera.setPosition(center.x + distance * 0.5, center.y + distance * 0.5, center.z + distance);
+        this.camera.setTarget(center.x, center.y, center.z);
+    }
     /**
      * Add mesh to scene with per-mesh GPU resources for unique colors
      */
@@ -308,6 +399,7 @@ export class Renderer {
         // Add to scene with identity transform (positions already in world space)
         this.scene.addMesh({
             expressId: meshData.expressId,
+            modelIndex: meshData.modelIndex, // Preserve modelIndex for multi-model selection
             vertexBuffer,
             indexBuffer,
             indexCount: meshData.indices.length,
@@ -459,50 +551,65 @@ export class Renderer {
             const allMeshes = [...opaqueMeshes, ...transparentMeshes];
             const selectedId = options.selectedId;
             const selectedIds = options.selectedIds;
-            // Calculate section plane parameters if enabled
+            const selectedModelIndex = options.selectedModelIndex;
+            // Calculate section plane parameters and model bounds
+            // Always calculate bounds when sectionPlane is provided (for preview and active mode)
             let sectionPlaneData;
-            if (options.sectionPlane?.enabled) {
-                // Calculate plane normal based on axis
-                const normal = [0, 0, 0];
-                if (options.sectionPlane.axis === 'x')
-                    normal[0] = 1;
-                else if (options.sectionPlane.axis === 'y')
-                    normal[1] = 1;
-                else
-                    normal[2] = 1;
-                // Get model bounds for calculating plane position and visual
+            if (options.sectionPlane) {
+                // Get model bounds from ALL geometry sources: individual meshes AND batched meshes
                 const boundsMin = { x: Infinity, y: Infinity, z: Infinity };
                 const boundsMax = { x: -Infinity, y: -Infinity, z: -Infinity };
-                if (meshes.length > 0) {
-                    for (const mesh of meshes) {
-                        if (mesh.bounds) {
-                            boundsMin.x = Math.min(boundsMin.x, mesh.bounds.min[0]);
-                            boundsMin.y = Math.min(boundsMin.y, mesh.bounds.min[1]);
-                            boundsMin.z = Math.min(boundsMin.z, mesh.bounds.min[2]);
-                            boundsMax.x = Math.max(boundsMax.x, mesh.bounds.max[0]);
-                            boundsMax.y = Math.max(boundsMax.y, mesh.bounds.max[1]);
-                            boundsMax.z = Math.max(boundsMax.z, mesh.bounds.max[2]);
-                        }
+                // Check individual meshes
+                for (const mesh of meshes) {
+                    if (mesh.bounds) {
+                        boundsMin.x = Math.min(boundsMin.x, mesh.bounds.min[0]);
+                        boundsMin.y = Math.min(boundsMin.y, mesh.bounds.min[1]);
+                        boundsMin.z = Math.min(boundsMin.z, mesh.bounds.min[2]);
+                        boundsMax.x = Math.max(boundsMax.x, mesh.bounds.max[0]);
+                        boundsMax.y = Math.max(boundsMax.y, mesh.bounds.max[1]);
+                        boundsMax.z = Math.max(boundsMax.z, mesh.bounds.max[2]);
                     }
-                    if (!Number.isFinite(boundsMin.x)) {
-                        boundsMin.x = boundsMin.y = boundsMin.z = -100;
-                        boundsMax.x = boundsMax.y = boundsMax.z = 100;
+                }
+                // Check batched meshes (most geometry is here!)
+                const batchedMeshes = this.scene.getBatchedMeshes();
+                for (const batch of batchedMeshes) {
+                    if (batch.bounds) {
+                        boundsMin.x = Math.min(boundsMin.x, batch.bounds.min[0]);
+                        boundsMin.y = Math.min(boundsMin.y, batch.bounds.min[1]);
+                        boundsMin.z = Math.min(boundsMin.z, batch.bounds.min[2]);
+                        boundsMax.x = Math.max(boundsMax.x, batch.bounds.max[0]);
+                        boundsMax.y = Math.max(boundsMax.y, batch.bounds.max[1]);
+                        boundsMax.z = Math.max(boundsMax.z, batch.bounds.max[2]);
                     }
                 }
-                else {
+                // Fallback if no bounds found
+                if (!Number.isFinite(boundsMin.x)) {
                     boundsMin.x = boundsMin.y = boundsMin.z = -100;
                     boundsMax.x = boundsMax.y = boundsMax.z = 100;
                 }
                 // Store bounds for section plane visual
                 this.modelBounds = { min: boundsMin, max: boundsMax };
-                // Get axis-specific range
-                const axisIdx = options.sectionPlane.axis === 'x' ? 'x' : options.sectionPlane.axis === 'y' ? 'y' : 'z';
-                const minVal = boundsMin[axisIdx];
-                const maxVal = boundsMax[axisIdx];
-                // Calculate plane distance from position percentage
-                const range = maxVal - minVal;
-                const distance = minVal + (options.sectionPlane.position / 100) * range;
-                sectionPlaneData = { normal, distance, enabled: true };
+                // Only calculate clipping data if section is enabled
+                if (options.sectionPlane.enabled) {
+                    // Calculate plane normal based on semantic axis
+                    // down = Y axis (horizontal cut), front = Z axis, side = X axis
+                    const normal = [0, 0, 0];
+                    if (options.sectionPlane.axis === 'side')
+                        normal[0] = 1; // X axis
+                    else if (options.sectionPlane.axis === 'down')
+                        normal[1] = 1; // Y axis (horizontal)
+                    else
+                        normal[2] = 1; // Z axis (front)
+                    // Get axis-specific range based on semantic axis
+                    // Use min/max overrides from sectionPlane if provided (storey-based range)
+                    const axisIdx = options.sectionPlane.axis === 'side' ? 'x' : options.sectionPlane.axis === 'down' ? 'y' : 'z';
+                    const minVal = options.sectionPlane.min ?? boundsMin[axisIdx];
+                    const maxVal = options.sectionPlane.max ?? boundsMax[axisIdx];
+                    // Calculate plane distance from position percentage
+                    const range = maxVal - minVal;
+                    const distance = minVal + (options.sectionPlane.position / 100) * range;
+                    sectionPlaneData = { normal, distance, enabled: true };
+                }
             }
             for (const mesh of allMeshes) {
                 if (mesh.uniformBuffer) {
@@ -512,7 +619,10 @@ export class Renderer {
                     buffer.set(viewProj, 0);
                     buffer.set(mesh.transform.m, 16);
                     // Check if mesh is selected (single or multi-selection)
-                    const isSelected = (selectedId !== undefined && selectedId !== null && mesh.expressId === selectedId)
+                    // For multi-model support: also check modelIndex if provided
+                    const expressIdMatch = mesh.expressId === selectedId;
+                    const modelIndexMatch = selectedModelIndex === undefined || mesh.modelIndex === selectedModelIndex;
+                    const isSelected = (selectedId !== undefined && selectedId !== null && expressIdMatch && modelIndexMatch)
                         || (selectedIds !== undefined && selectedIds.has(mesh.expressId));
                     // Apply selection highlight effect
                     if (isSelected) {
@@ -598,26 +708,33 @@ export class Renderer {
                 // need individual mesh rendering to show only the visible elements
                 const opaqueBatches = [];
                 const transparentBatches = [];
-                // Collect visible expressIds from partially visible batches
-                // These need individual mesh rendering instead of batch rendering
-                const partiallyVisibleExpressIds = new Set();
+                // PERFORMANCE FIX: Track partially visible batches for sub-batch rendering
+                // Instead of creating 10,000+ individual meshes, we create cached sub-batches
+                const partiallyVisibleBatches = [];
                 for (const batch of allBatchedMeshes) {
                     // Check visibility
                     if (hasVisibilityFiltering) {
                         const vis = batchVisibility.get(batch.colorKey);
                         if (!vis || !vis.visible)
                             continue; // Skip completely hidden batches
-                        // FIX: Skip partially visible batches - their visible elements
-                        // will be rendered individually below
+                        // Handle partially visible batches - create sub-batches instead of individual meshes
                         if (!vis.fullyVisible) {
                             // Collect the visible expressIds from this batch
+                            const visibleIds = new Set();
                             for (const expressId of batch.expressIds) {
                                 const isHidden = options.hiddenIds?.has(expressId) ?? false;
                                 const isIsolated = !hasIsolatedFilter || options.isolatedIds.has(expressId);
                                 if (!isHidden && isIsolated) {
-                                    partiallyVisibleExpressIds.add(expressId);
+                                    visibleIds.add(expressId);
                                 }
                             }
+                            if (visibleIds.size > 0) {
+                                partiallyVisibleBatches.push({
+                                    colorKey: batch.colorKey,
+                                    visibleIds,
+                                    color: batch.color,
+                                });
+                            }
                             continue; // Don't add batch to render list
                         }
                     }
@@ -680,77 +797,32 @@ export class Renderer {
                 for (const batch of opaqueBatches) {
                     renderBatch(batch);
                 }
-                // Render partially visible elements individually (from batches that had mixed visibility)
-                // This is the FIX for hide/isolate showing wrong batches
+                // PERFORMANCE FIX: Render partially visible batches as sub-batches (not individual meshes!)
+                // This is the key optimization: instead of 10,000+ individual draw calls,
+                // we create cached sub-batches with only visible elements and render them as single draw calls
                 const allMeshes = this.scene.getMeshes();
-                const existingMeshIds = new Set(allMeshes.map(m => m.expressId));
-                if (partiallyVisibleExpressIds.size > 0) {
-                    // Create GPU resources lazily for partially visible meshes
-                    for (const pvId of partiallyVisibleExpressIds) {
-                        if (!existingMeshIds.has(pvId) && this.scene.hasMeshData(pvId)) {
-                            const meshData = this.scene.getMeshData(pvId);
-                            this.createMeshFromData(meshData);
-                            existingMeshIds.add(pvId);
-                        }
-                    }
-                    // Get partially visible meshes and render them
-                    const partialMeshes = this.scene.getMeshes().filter(mesh => partiallyVisibleExpressIds.has(mesh.expressId));
-                    // Ensure partial meshes have uniform buffers and bind groups
-                    for (const mesh of partialMeshes) {
-                        if (!mesh.uniformBuffer && this.pipeline) {
-                            mesh.uniformBuffer = device.createBuffer({
-                                size: this.pipeline.getUniformBufferSize(),
-                                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-                            });
-                            mesh.bindGroup = device.createBindGroup({
-                                layout: this.pipeline.getBindGroupLayout(),
-                                entries: [
-                                    {
-                                        binding: 0,
-                                        resource: { buffer: mesh.uniformBuffer },
-                                    },
-                                ],
-                            });
-                        }
-                    }
-                    // Render partially visible meshes (not selected, normal rendering)
-                    for (const mesh of partialMeshes) {
-                        if (!mesh.bindGroup || !mesh.uniformBuffer) {
-                            continue;
-                        }
-                        const buffer = new Float32Array(48);
-                        const flagBuffer = new Uint32Array(buffer.buffer, 176, 4);
-                        buffer.set(viewProj, 0);
-                        buffer.set(mesh.transform.m, 16);
-                        buffer.set(mesh.color, 32);
-                        buffer[36] = mesh.material?.metallic ?? 0.0;
-                        buffer[37] = mesh.material?.roughness ?? 0.6;
-                        // Section plane data
-                        if (sectionPlaneData) {
-                            buffer[40] = sectionPlaneData.normal[0];
-                            buffer[41] = sectionPlaneData.normal[1];
-                            buffer[42] = sectionPlaneData.normal[2];
-                            buffer[43] = sectionPlaneData.distance;
-                        }
-                        // Flags (not selected)
-                        flagBuffer[0] = 0;
-                        flagBuffer[1] = sectionPlaneData?.enabled ? 1 : 0;
-                        flagBuffer[2] = 0;
-                        flagBuffer[3] = 0;
-                        device.queue.writeBuffer(mesh.uniformBuffer, 0, buffer);
-                        // Use opaque or transparent pipeline based on alpha
-                        const isTransparent = mesh.color[3] < 0.99;
-                        if (isTransparent) {
-                            pass.setPipeline(this.pipeline.getTransparentPipeline());
-                        }
-                        else {
-                            pass.setPipeline(this.pipeline.getPipeline());
+                // Track existing meshes by (expressId:modelIndex) to handle multi-model expressId collisions
+                // E.g., door #535 in model 0 vs beam #535 in model 1 need separate tracking
+                const existingMeshKeys = new Set(allMeshes.map(m => `${m.expressId}:${m.modelIndex ?? 'any'}`));
+                if (partiallyVisibleBatches.length > 0) {
+                    for (const { colorKey, visibleIds, color } of partiallyVisibleBatches) {
+                        // Get or create a cached sub-batch for this visibility state
+                        const subBatch = this.scene.getOrCreatePartialBatch(colorKey, visibleIds, device, this.pipeline);
+                        if (subBatch) {
+                            // Use opaque or transparent pipeline based on alpha
+                            const isTransparent = color[3] < 0.99;
+                            if (isTransparent) {
+                                pass.setPipeline(this.pipeline.getTransparentPipeline());
+                            }
+                            else {
+                                pass.setPipeline(this.pipeline.getPipeline());
+                            }
+                            // Render the sub-batch as a single draw call
+                            renderBatch(subBatch);
                         }
-                        pass.setBindGroup(0, mesh.bindGroup);
-                        pass.setVertexBuffer(0, mesh.vertexBuffer);
-                        pass.setIndexBuffer(mesh.indexBuffer, 'uint32');
-                        pass.drawIndexed(mesh.indexCount, 1, 0, 0, 0);
                     }
+                    // Reset to opaque pipeline for subsequent rendering
+                    pass.setPipeline(this.pipeline.getPipeline());
                 }
                 // Render selected meshes individually for proper highlighting
                 // First, check if we have Mesh objects for selected IDs
@@ -768,15 +840,26 @@ export class Renderer {
                     visibleSelectedIds.add(selId);
                 }
                 // Create GPU resources lazily for visible selected meshes that don't have them yet
+                // Pass selectedModelIndex to get mesh data from the correct model (for multi-model support)
+                // Use composite key to handle expressId collisions between models
                 for (const selId of visibleSelectedIds) {
-                    if (!existingMeshIds.has(selId) && this.scene.hasMeshData(selId)) {
-                        const meshData = this.scene.getMeshData(selId);
+                    const meshKey = `${selId}:${selectedModelIndex ?? 'any'}`;
+                    if (!existingMeshKeys.has(meshKey) && this.scene.hasMeshData(selId, selectedModelIndex)) {
+                        const meshData = this.scene.getMeshData(selId, selectedModelIndex);
                         this.createMeshFromData(meshData);
-                        existingMeshIds.add(selId);
+                        existingMeshKeys.add(meshKey);
                     }
                 }
                 // Now get selected meshes (only visible ones)
-                const selectedMeshes = this.scene.getMeshes().filter(mesh => visibleSelectedIds.has(mesh.expressId));
+                // For multi-model support: also filter by modelIndex if provided
+                const selectedMeshes = this.scene.getMeshes().filter(mesh => {
+                    if (!visibleSelectedIds.has(mesh.expressId))
+                        return false;
+                    // If selectedModelIndex is provided, also match modelIndex
+                    if (selectedModelIndex !== undefined && mesh.modelIndex !== selectedModelIndex)
+                        return false;
+                    return true;
+                });
                 // Ensure selected meshes have uniform buffers and bind groups
                 for (const mesh of selectedMeshes) {
                     if (!mesh.uniformBuffer && this.pipeline) {
@@ -919,24 +1002,30 @@ export class Renderer {
                     }
                 }
             }
-            pass.end();
-            // Render section plane visual if enabled
-            if (sectionPlaneData?.enabled && this.sectionPlaneRenderer && this.modelBounds) {
-                this.sectionPlaneRenderer.render(encoder, textureView, this.pipeline.getDepthTextureView(), {
+            // Draw section plane visual BEFORE pass.end() (within same MSAA render pass)
+            // Always show plane when sectionPlane options are provided (as preview or active)
+            if (options.sectionPlane && this.sectionPlaneRenderer && this.modelBounds) {
+                this.sectionPlaneRenderer.draw(pass, {
                     axis: options.sectionPlane.axis,
                     position: options.sectionPlane.position,
                     bounds: this.modelBounds,
                     viewProj,
+                    isPreview: !options.sectionPlane.enabled, // Preview mode when not enabled
+                    min: options.sectionPlane.min,
+                    max: options.sectionPlane.max,
                 });
             }
+            pass.end();
             device.queue.submit([encoder.finish()]);
         }
         catch (error) {
             // Handle WebGPU errors (e.g., device lost, invalid state)
             // Mark context as invalid so it gets reconfigured next frame
             this.device.invalidateContext();
-            // Only log occasional errors to avoid spam
-            if (Math.random() < 0.01) {
+            // Rate-limit error logging to avoid spam (max once per second)
+            const now = performance.now();
+            if (now - this.lastRenderErrorTime > this.RENDER_ERROR_THROTTLE_MS) {
+                this.lastRenderErrorTime = now;
                 console.warn('Render error (context will be reconfigured):', error);
             }
         }
@@ -944,6 +1033,7 @@ export class Renderer {
     /**
      * Pick object at screen coordinates
      * Respects visibility filtering so users can only select visible elements
+     * Returns PickResult with expressId and modelIndex for multi-model support
      */
     async pick(x, y, options) {
         if (!this.picker) {
@@ -967,19 +1057,27 @@ export class Renderer {
                     expressIds.add(expressId);
                 }
             }
-            // Track existing expressIds to avoid duplicates (using Set for O(1) lookup)
-            const existingExpressIds = new Set(meshes.map(m => m.expressId));
+            // Track existing meshes by (expressId:modelIndex) for multi-model support
+            // This handles expressId collisions (e.g., door #535 in model 0 vs beam #535 in model 1)
+            const existingMeshKeys = new Set(meshes.map(m => `${m.expressId}:${m.modelIndex ?? 'any'}`));
             // Count how many meshes we'd need to create for full GPU picking
+            // For multi-model, count all pieces with unique (expressId, modelIndex) pairs
             let toCreate = 0;
             for (const expressId of expressIds) {
-                if (existingExpressIds.has(expressId))
-                    continue;
                 if (options?.hiddenIds?.has(expressId))
                     continue;
                 if (options?.isolatedIds !== null && options?.isolatedIds !== undefined && !options.isolatedIds.has(expressId))
                     continue;
-                if (this.scene.hasMeshData(expressId))
-                    toCreate++;
+                // Get all pieces for this expressId (handles multi-model)
+                const pieces = this.scene.getMeshDataPieces(expressId);
+                if (pieces) {
+                    for (const piece of pieces) {
+                        const meshKey = `${expressId}:${piece.modelIndex ?? 'any'}`;
+                        if (!existingMeshKeys.has(meshKey)) {
+                            toCreate++;
+                        }
+                    }
+                }
             }
             // PERFORMANCE FIX: Use CPU raycasting for large models instead of creating GPU meshes
             // GPU picking requires individual mesh buffers; for 60K+ elements this is too slow
@@ -989,25 +1087,34 @@ export class Renderer {
                 // Use CPU raycasting fallback - works regardless of how many individual meshes exist
                 const ray = this.camera.unprojectToRay(x, y, this.canvas.width, this.canvas.height);
                 const hit = this.scene.raycast(ray.origin, ray.direction, options?.hiddenIds, options?.isolatedIds);
-                return hit ? hit.expressId : null;
+                if (!hit)
+                    return null;
+                // CPU raycasting returns expressId and modelIndex
+                return {
+                    expressId: hit.expressId,
+                    modelIndex: hit.modelIndex,
+                };
             }
             // For smaller models, create GPU meshes for picking
             // Only create meshes for VISIBLE elements (not hidden, and either no isolation or in isolated set)
+            // For multi-model support: create meshes for ALL (expressId, modelIndex) pairs
             for (const expressId of expressIds) {
-                // Skip if already exists
-                if (existingExpressIds.has(expressId))
-                    continue;
                 // Skip if hidden
                 if (options?.hiddenIds?.has(expressId))
                     continue;
                 // Skip if isolation is active and this entity is not isolated
                 if (options?.isolatedIds !== null && options?.isolatedIds !== undefined && !options.isolatedIds.has(expressId))
                     continue;
-                if (this.scene.hasMeshData(expressId)) {
-                    const meshData = this.scene.getMeshData(expressId);
-                    if (meshData) {
-                        this.createMeshFromData(meshData);
-                        existingExpressIds.add(expressId); // Track newly created mesh
+                // Get all pieces for this expressId (handles multi-model)
+                const pieces = this.scene.getMeshDataPieces(expressId);
+                if (pieces) {
+                    for (const piece of pieces) {
+                        const meshKey = `${piece.expressId}:${piece.modelIndex ?? 'any'}`;
+                        // Skip if mesh already exists for this (expressId, modelIndex) pair
+                        if (existingMeshKeys.has(meshKey))
+                            continue;
+                        this.createMeshFromData(piece);
+                        existingMeshKeys.add(meshKey);
                     }
                 }
             }
@@ -1119,6 +1226,108 @@ export class Renderer {
             return null;
         }
     }
+    /**
+     * Raycast with magnetic edge snapping behavior
+     * This provides the "stick and slide along edges" experience
+     */
+    raycastSceneMagnetic(x, y, currentEdgeLock, options) {
+        try {
+            // Create ray from screen coordinates
+            const ray = this.camera.unprojectToRay(x, y, this.canvas.width, this.canvas.height);
+            // Get all mesh data from scene
+            const allMeshData = [];
+            const meshes = this.scene.getMeshes();
+            const batchedMeshes = this.scene.getBatchedMeshes();
+            // Collect mesh data from regular meshes
+            for (const mesh of meshes) {
+                const meshData = this.scene.getMeshData(mesh.expressId);
+                if (meshData) {
+                    if (options?.hiddenIds?.has(meshData.expressId))
+                        continue;
+                    if (options?.isolatedIds !== null &&
+                        options?.isolatedIds !== undefined &&
+                        !options.isolatedIds.has(meshData.expressId)) {
+                        continue;
+                    }
+                    allMeshData.push(meshData);
+                }
+            }
+            // Collect mesh data from batched meshes
+            for (const batch of batchedMeshes) {
+                for (const expressId of batch.expressIds) {
+                    const meshData = this.scene.getMeshData(expressId);
+                    if (meshData) {
+                        if (options?.hiddenIds?.has(meshData.expressId))
+                            continue;
+                        if (options?.isolatedIds !== null &&
+                            options?.isolatedIds !== undefined &&
+                            !options.isolatedIds.has(meshData.expressId)) {
+                            continue;
+                        }
+                        allMeshData.push(meshData);
+                    }
+                }
+            }
+            if (allMeshData.length === 0) {
+                return {
+                    intersection: null,
+                    snapTarget: null,
+                    edgeLock: {
+                        edge: null,
+                        meshExpressId: null,
+                        edgeT: 0,
+                        shouldLock: false,
+                        shouldRelease: true,
+                        isCorner: false,
+                        cornerValence: 0,
+                    },
+                };
+            }
+            // Use BVH for performance if we have many meshes
+            let meshesToTest = allMeshData;
+            if (allMeshData.length > this.BVH_THRESHOLD) {
+                const needsRebuild = !this.bvhCache ||
+                    !this.bvhCache.isBuilt ||
+                    this.bvhCache.meshCount !== allMeshData.length;
+                if (needsRebuild) {
+                    this.bvh.build(allMeshData);
+                    this.bvhCache = {
+                        meshCount: allMeshData.length,
+                        meshData: allMeshData,
+                        isBuilt: true,
+                    };
+                }
+                const meshIndices = this.bvh.getMeshesForRay(ray, allMeshData);
+                meshesToTest = meshIndices.map(i => allMeshData[i]);
+            }
+            // Perform raycasting
+            const intersection = this.raycaster.raycast(ray, meshesToTest);
+            // Use magnetic snap detection
+            const cameraPos = this.camera.getPosition();
+            const cameraFov = this.camera.getFOV();
+            const magneticResult = this.snapDetector.detectMagneticSnap(ray, meshesToTest, intersection, { position: cameraPos, fov: cameraFov }, this.canvas.height, currentEdgeLock, options?.snapOptions || {});
+            return {
+                intersection,
+                ...magneticResult,
+            };
+        }
+        catch (error) {
+            console.error('Magnetic raycast error:', error);
+            return {
+                intersection: null,
+                snapTarget: null,
+                edgeLock: {
+                    edge: null,
+                    meshExpressId: null,
+                    edgeT: 0,
+                    shouldLock: false,
+                    shouldRelease: true,
+                    isCorner: false,
+                    cornerValence: 0,
+                },
+            };
+        }
+    }
     /**
      * Invalidate BVH cache (call when geometry changes)
      */