@ifc-lite/renderer 1.2.1 → 1.4.0

package/dist/index.js

@@ -11,9 +11,11 @@ export { Scene } from './scene.js';
 export { Picker } from './picker.js';
 export { MathUtils } from './math.js';
 export { SectionPlaneRenderer } from './section-plane.js';
+export { Section2DOverlayRenderer } from './section-2d-overlay.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';
@@ -24,6 +26,7 @@ import { Scene } from './scene.js';
 import { Picker } from './picker.js';
 import { FrustumUtils } from '@ifc-lite/spatial';
 import { SectionPlaneRenderer } from './section-plane.js';
+import { Section2DOverlayRenderer } from './section-2d-overlay.js';
 import { deduplicateMeshes } from '@ifc-lite/geometry';
 import { MathUtils } from './math.js';
 import { Raycaster } from './raycaster.js';
@@ -41,6 +44,7 @@ export class Renderer {
     picker = null;
     canvas;
     sectionPlaneRenderer = null;
+    section2DOverlayRenderer = null;
     modelBounds = null;
     raycaster;
     snapDetector;
@@ -49,6 +53,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();
@@ -77,8 +84,96 @@ export class Renderer {
         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());
         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 +403,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,
@@ -356,11 +452,13 @@ export class Renderer {
         if (!this.device.isInitialized() || !this.pipeline)
             return;
         // Validate canvas dimensions
+        // Align width to 64 pixels for WebGPU texture row alignment (256 bytes / 4 bytes per pixel)
         const rect = this.canvas.getBoundingClientRect();
-        const width = Math.max(1, Math.floor(rect.width));
+        const rawWidth = Math.max(1, Math.floor(rect.width));
+        const width = Math.max(64, Math.floor(rawWidth / 64) * 64);
         const height = Math.max(1, Math.floor(rect.height));
         // Skip rendering if canvas is too small
-        if (width < 10 || height < 10)
+        if (width < 64 || height < 10)
             return;
         // Update canvas pixel dimensions if needed
         const dimensionsChanged = this.canvas.width !== width || this.canvas.height !== height;
@@ -459,6 +557,7 @@ export class Renderer {
             const allMeshes = [...opaqueMeshes, ...transparentMeshes];
             const selectedId = options.selectedId;
             const selectedIds = options.selectedIds;
+            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;
@@ -526,7 +625,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) {
@@ -612,26 +714,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
                         }
                     }
@@ -694,77 +803,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
@@ -782,15 +846,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) {
@@ -945,6 +1020,17 @@ export class Renderer {
                     min: options.sectionPlane.min,
                     max: options.sectionPlane.max,
                 });
+                // Draw 2D section overlay on the section plane (when section is active, not preview)
+                if (options.sectionPlane.enabled && this.section2DOverlayRenderer?.hasGeometry()) {
+                    this.section2DOverlayRenderer.draw(pass, {
+                        axis: options.sectionPlane.axis,
+                        position: options.sectionPlane.position,
+                        bounds: this.modelBounds,
+                        viewProj,
+                        min: options.sectionPlane.min,
+                        max: options.sectionPlane.max,
+                    });
+                }
             }
             pass.end();
             device.queue.submit([encoder.finish()]);
@@ -953,8 +1039,10 @@ export class Renderer {
             // 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);
             }
         }
@@ -962,6 +1050,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) {
@@ -985,19 +1074,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
@@ -1007,25 +1104,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);
                     }
                 }
             }
@@ -1278,6 +1384,43 @@ export class Renderer {
     getScene() {
         return this.scene;
     }
+    /**
+     * Upload 2D section drawing data for 3D overlay rendering
+     * Call this when a 2D drawing is generated to display it on the section plane
+     * Uses same position calculation as section plane: sectionRange min/max if provided, else modelBounds
+     */
+    uploadSection2DOverlay(polygons, lines, axis, position, // 0-100 percentage
+    sectionRange, // Same storey-based range as section plane
+    flipped = false) {
+        if (!this.section2DOverlayRenderer)
+            return;
+        // Use EXACTLY same calculation as section plane in render() method:
+        // minVal = options.sectionPlane.min ?? boundsMin[axisIdx]
+        // maxVal = options.sectionPlane.max ?? boundsMax[axisIdx]
+        const axisIdx = axis === 'side' ? 'x' : axis === 'down' ? 'y' : 'z';
+        // Allow upload if either sectionRange has both values, or modelBounds exists as fallback
+        const hasFullRange = sectionRange?.min !== undefined && sectionRange?.max !== undefined;
+        if (!hasFullRange && !this.modelBounds)
+            return;
+        const minVal = sectionRange?.min ?? this.modelBounds.min[axisIdx];
+        const maxVal = sectionRange?.max ?? this.modelBounds.max[axisIdx];
+        const planePosition = minVal + (position / 100) * (maxVal - minVal);
+        this.section2DOverlayRenderer.uploadDrawing(polygons, lines, axis, planePosition, flipped);
+    }
+    /**
+     * Clear the 2D section overlay
+     */
+    clearSection2DOverlay() {
+        if (this.section2DOverlayRenderer) {
+            this.section2DOverlayRenderer.clearGeometry();
+        }
+    }
+    /**
+     * Check if 2D section overlay has geometry to render
+     */
+    hasSection2DOverlay() {
+        return this.section2DOverlayRenderer?.hasGeometry() ?? false;
+    }
     /**
      * Get render pipeline (for batching)
      */
@@ -1299,5 +1442,35 @@ export class Renderer {
         }
         return this.device.getDevice();
     }
+    /**
+     * Capture a screenshot of the current view
+     * Waits for GPU work to complete and captures exactly what's displayed
+     * @returns PNG data URL or null if capture failed
+     */
+    async captureScreenshot() {
+        if (!this.device.isInitialized()) {
+            console.warn('[Renderer] Cannot capture screenshot: not initialized');
+            return null;
+        }
+        try {
+            // Wait for any pending GPU work to complete before capturing
+            // This ensures we capture the fully rendered frame
+            const device = this.device.getDevice();
+            await device.queue.onSubmittedWorkDone();
+            // Capture exactly what's displayed on the canvas
+            const dataUrl = this.canvas.toDataURL('image/png');
+            return dataUrl;
+        }
+        catch (error) {
+            console.error('[Renderer] Screenshot capture failed:', error);
+            return null;
+        }
+    }
+    /**
+     * Get the canvas element
+     */
+    getCanvas() {
+        return this.canvas;
+    }
 }
 //# sourceMappingURL=index.js.map