@ifc-lite/renderer 1.15.1 → 1.15.3

package/dist/scene.d.ts

@@ -4,10 +4,7 @@
 import type { Mesh, InstancedMesh, BatchedMesh, Vec3 } from './types.js';
 import type { MeshData } from '@ifc-lite/geometry';
 import type { RenderPipeline } from './pipeline.js';
-interface BoundingBox {
-    min: Vec3;
-    max: Vec3;
-}
+import { type BoundingBox, type RaycastHit } from './scene-raycaster.js';
 export declare class Scene {
     private meshes;
     private instancedMeshes;
@@ -196,9 +193,8 @@ export declare class Scene {
      */
     private createBatchedMesh;
     /**
-     * Merge multiple mesh geometries into single vertex/index buffers
-     *
-     * OPTIMIZATION: Uses efficient loops and bulk index adjustment
+     * Merge multiple mesh geometries into single vertex/index buffers.
+     * Delegates to the extracted mergeGeometry() utility.
      */
     private mergeGeometry;
     /**
@@ -206,12 +202,8 @@ export declare class Scene {
      */
     private getMaxBufferSize;
     /**
-     * Split a meshDataArray into chunks where each chunk's largest buffer
-     * (vertex or index) stays within maxBufferSize.
-     *
-     * Each mesh is kept intact — we never split a single element's geometry.
-     * If a single mesh exceeds the limit on its own it is placed in a solo chunk
-     * (WebGPU will clamp or error, but we don't silently drop geometry).
+     * Split a meshDataArray into chunks that fit within GPU buffer limits.
+     * Delegates to the extracted splitMeshDataForBufferLimit() utility.
      */
     private splitMeshDataForBufferLimit;
     /**
@@ -294,32 +286,10 @@ export declare class Scene {
      */
     getEntityBoundingBox(expressId: number): BoundingBox | null;
     /**
-     * Ray-box intersection test (slab method).
-     * Handles zero ray direction components (axis-aligned rays) safely.
-     */
-    private rayIntersectsBox;
-    /**
-     * Ray-box intersection returning entry distance (tNear).
-     * Returns null if no intersection, otherwise the distance along the ray
-     * to the entry point (clamped to 0 if the ray originates inside the box).
-     * Handles zero ray direction components (axis-aligned rays) safely.
+     * CPU raycast against all mesh data.
+     * Returns expressId and modelIndex of closest hit, or null.
+     * Delegates to extracted raycaster utilities.
      */
-    private rayBoxDistance;
-    /**
-     * Möller–Trumbore ray-triangle intersection
-     * Returns distance to intersection or null if no hit
-     */
-    private rayTriangleIntersect;
-    /**
-     * CPU raycast against all mesh data
-     * Returns expressId and modelIndex of closest hit, or null
-     * For multi-model support: tracks which model's geometry was hit
-     */
-    raycast(rayOrigin: Vec3, rayDir: Vec3, hiddenIds?: Set<number>, isolatedIds?: Set<number> | null): {
-        expressId: number;
-        distance: number;
-        modelIndex?: number;
-    } | null;
+    raycast(rayOrigin: Vec3, rayDir: Vec3, hiddenIds?: Set<number>, isolatedIds?: Set<number> | null): RaycastHit | null;
 }
-export {};
 //# sourceMappingURL=scene.d.ts.map

package/dist/scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"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"}

package/dist/scene.js

@@ -1,10 +1,9 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-import { MathUtils } from './math.js';
 import { BATCH_CONSTANTS } from './constants.js';
-const MAX_ENCODED_ENTITY_ID = 0xFFFFFF;
-let warnedEntityIdRange = false;
+import { prepareRayDirInv, raycastBoundingBoxes, raycastTriangles, } from './scene-raycaster.js';
+import { mergeGeometry, splitMeshDataForBufferLimit } from './scene-geometry.js';
 export class Scene {
     meshes = [];
     instancedMeshes = [];
@@ -469,8 +468,8 @@ export class Scene {
         // This preserves the per-frame time budget while cutting appendToBatches()
         // overhead and front-of-array churn during huge desktop streams.
         const MAX_MESHES_PER_FLUSH = 4096;
-        const MESHES_PER_APPEND = 128;
-        const FLUSH_BUDGET_MS = 10;
+        const MESHES_PER_APPEND = 512;
+        const FLUSH_BUDGET_MS = 12;
         const start = performance.now();
         let processed = 0;
         while (this.meshQueueReadIndex < this.meshQueue.length && processed < MAX_MESHES_PER_FLUSH) {
@@ -983,17 +982,23 @@ export class Scene {
         const merged = this.mergeGeometry(meshDataArray);
         const expressIds = meshDataArray.map(m => m.expressId);
         // Create vertex buffer (interleaved positions + normals)
+        // Use mappedAtCreation to avoid a separate writeBuffer IPC round-trip
+        // (significant win on Chrome/Dawn where each writeBuffer is a Mojo IPC call)
         const vertexBuffer = device.createBuffer({
             size: merged.vertexData.byteLength,
             usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true,
         });
-        device.queue.writeBuffer(vertexBuffer, 0, merged.vertexData);
+        new Float32Array(vertexBuffer.getMappedRange()).set(merged.vertexData);
+        vertexBuffer.unmap();
         // Create index buffer
         const indexBuffer = device.createBuffer({
             size: merged.indices.byteLength,
             usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: true,
         });
-        device.queue.writeBuffer(indexBuffer, 0, merged.indices);
+        new Uint32Array(indexBuffer.getMappedRange()).set(merged.indices);
+        indexBuffer.unmap();
         // Create uniform buffer for this batch
         const uniformBuffer = device.createBuffer({
             size: pipeline.getUniformBufferSize(),
@@ -1023,89 +1028,11 @@ export class Scene {
         };
     }
     /**
-     * Merge multiple mesh geometries into single vertex/index buffers
-     *
-     * OPTIMIZATION: Uses efficient loops and bulk index adjustment
+     * Merge multiple mesh geometries into single vertex/index buffers.
+     * Delegates to the extracted mergeGeometry() utility.
      */
     mergeGeometry(meshDataArray) {
-        let totalVertices = 0;
-        let totalIndices = 0;
-        // Calculate total sizes
-        for (const mesh of meshDataArray) {
-            totalVertices += mesh.positions.length / 3;
-            totalIndices += mesh.indices.length;
-        }
-        // Create merged buffers
-        const vertexBufferRaw = new ArrayBuffer(totalVertices * 7 * 4);
-        const vertexData = new Float32Array(vertexBufferRaw); // position + normal
-        const vertexDataU32 = new Uint32Array(vertexBufferRaw); // entityId lane
-        const indices = new Uint32Array(totalIndices);
-        // Track bounds during merge (avoids a second pass)
-        let minX = Infinity, minY = Infinity, minZ = Infinity;
-        let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-        let indexOffset = 0;
-        let vertexBase = 0;
-        for (const mesh of meshDataArray) {
-            const positions = mesh.positions;
-            const normals = mesh.normals;
-            const vertexCount = positions.length / 3;
-            // Interleave vertex data (position + normal + entityId)
-            // This loop is O(n) per mesh and unavoidable for interleaving
-            let outIdx = vertexBase * 7;
-            const perVertexEntityIds = mesh.entityIds; // color-merged batches
-            let entityId = mesh.expressId >>> 0;
-            if (!perVertexEntityIds && entityId > MAX_ENCODED_ENTITY_ID) {
-                if (!warnedEntityIdRange) {
-                    warnedEntityIdRange = true;
-                    console.warn('[Renderer] expressId exceeds 24-bit seam-ID encoding range; seam lines may collide.');
-                }
-                entityId = entityId & MAX_ENCODED_ENTITY_ID;
-            }
-            const hasNormals = normals.length > 0;
-            for (let i = 0; i < vertexCount; i++) {
-                const srcIdx = i * 3;
-                const px = positions[srcIdx];
-                const py = positions[srcIdx + 1];
-                const pz = positions[srcIdx + 2];
-                vertexData[outIdx++] = px;
-                vertexData[outIdx++] = py;
-                vertexData[outIdx++] = pz;
-                vertexData[outIdx++] = hasNormals ? normals[srcIdx] : 0;
-                vertexData[outIdx++] = hasNormals ? normals[srcIdx + 1] : 0;
-                vertexData[outIdx++] = hasNormals ? normals[srcIdx + 2] : 0;
-                vertexDataU32[outIdx++] = perVertexEntityIds ? (perVertexEntityIds[i] >>> 0) : entityId;
-                // Update bounds
-                if (px < minX)
-                    minX = px;
-                if (py < minY)
-                    minY = py;
-                if (pz < minZ)
-                    minZ = pz;
-                if (px > maxX)
-                    maxX = px;
-                if (py > maxY)
-                    maxY = py;
-                if (pz > maxZ)
-                    maxZ = pz;
-            }
-            // Copy indices with vertex base offset
-            // Use subarray for slightly better cache locality
-            const meshIndices = mesh.indices;
-            const indexCount = meshIndices.length;
-            for (let i = 0; i < indexCount; i++) {
-                indices[indexOffset + i] = meshIndices[i] + vertexBase;
-            }
-            vertexBase += vertexCount;
-            indexOffset += indexCount;
-        }
-        return {
-            vertexData,
-            indices,
-            bounds: {
-                min: [minX, minY, minZ],
-                max: [maxX, maxY, maxZ],
-            },
-        };
+        return mergeGeometry(meshDataArray);
     }
     /**
      * Get the effective max buffer size for this GPU device, with a safety margin.
@@ -1115,50 +1042,11 @@ export class Scene {
         return Math.floor(deviceMax * BATCH_CONSTANTS.BUFFER_SIZE_SAFETY_FACTOR);
     }
     /**
-     * Split a meshDataArray into chunks where each chunk's largest buffer
-     * (vertex or index) stays within maxBufferSize.
-     *
-     * Each mesh is kept intact — we never split a single element's geometry.
-     * If a single mesh exceeds the limit on its own it is placed in a solo chunk
-     * (WebGPU will clamp or error, but we don't silently drop geometry).
+     * Split a meshDataArray into chunks that fit within GPU buffer limits.
+     * Delegates to the extracted splitMeshDataForBufferLimit() utility.
      */
     splitMeshDataForBufferLimit(meshDataArray, maxBufferSize) {
-        // Fast path: estimate total size — if it fits, no splitting needed
-        let totalVertexBytes = 0;
-        let totalIndexBytes = 0;
-        for (const mesh of meshDataArray) {
-            totalVertexBytes += (mesh.positions.length / 3) * BATCH_CONSTANTS.BYTES_PER_VERTEX;
-            totalIndexBytes += mesh.indices.length * BATCH_CONSTANTS.BYTES_PER_INDEX;
-        }
-        if (totalVertexBytes <= maxBufferSize && totalIndexBytes <= maxBufferSize) {
-            return [meshDataArray];
-        }
-        // Slow path: partition into chunks
-        const chunks = [];
-        let currentChunk = [];
-        let currentVertexBytes = 0;
-        let currentIndexBytes = 0;
-        for (const mesh of meshDataArray) {
-            const meshVertexBytes = (mesh.positions.length / 3) * BATCH_CONSTANTS.BYTES_PER_VERTEX;
-            const meshIndexBytes = mesh.indices.length * BATCH_CONSTANTS.BYTES_PER_INDEX;
-            // Would adding this mesh exceed the limit? Start a new chunk.
-            // (Skip check when chunk is empty — a single mesh must always be included.)
-            if (currentChunk.length > 0 &&
-                (currentVertexBytes + meshVertexBytes > maxBufferSize ||
-                    currentIndexBytes + meshIndexBytes > maxBufferSize)) {
-                chunks.push(currentChunk);
-                currentChunk = [];
-                currentVertexBytes = 0;
-                currentIndexBytes = 0;
-            }
-            currentChunk.push(mesh);
-            currentVertexBytes += meshVertexBytes;
-            currentIndexBytes += meshIndexBytes;
-        }
-        if (currentChunk.length > 0) {
-            chunks.push(currentChunk);
-        }
-        return chunks;
+        return splitMeshDataForBufferLimit(meshDataArray, maxBufferSize);
     }
     /**
      * Resolve which bucket a mesh should be added to.
@@ -1537,224 +1425,18 @@ export class Scene {
         return bbox;
     }
     /**
-     * Ray-box intersection test (slab method).
-     * Handles zero ray direction components (axis-aligned rays) safely.
-     */
-    rayIntersectsBox(rayOrigin, rayDirInv, // 1/rayDir for efficiency
-    rayDirSign, box) {
-        const bounds = [box.min, box.max];
-        let tmin = -Infinity;
-        let tmax = Infinity;
-        // X axis
-        if (!isFinite(rayDirInv.x)) {
-            if (rayOrigin.x < box.min.x || rayOrigin.x > box.max.x)
-                return false;
-        }
-        else {
-            tmin = (bounds[rayDirSign[0]].x - rayOrigin.x) * rayDirInv.x;
-            tmax = (bounds[1 - rayDirSign[0]].x - rayOrigin.x) * rayDirInv.x;
-        }
-        // Y axis
-        if (!isFinite(rayDirInv.y)) {
-            if (rayOrigin.y < box.min.y || rayOrigin.y > box.max.y)
-                return false;
-        }
-        else {
-            const tymin = (bounds[rayDirSign[1]].y - rayOrigin.y) * rayDirInv.y;
-            const tymax = (bounds[1 - rayDirSign[1]].y - rayOrigin.y) * rayDirInv.y;
-            if (tmin > tymax || tymin > tmax)
-                return false;
-            if (tymin > tmin)
-                tmin = tymin;
-            if (tymax < tmax)
-                tmax = tymax;
-        }
-        // Z axis
-        if (!isFinite(rayDirInv.z)) {
-            if (rayOrigin.z < box.min.z || rayOrigin.z > box.max.z)
-                return false;
-        }
-        else {
-            const tzmin = (bounds[rayDirSign[2]].z - rayOrigin.z) * rayDirInv.z;
-            const tzmax = (bounds[1 - rayDirSign[2]].z - rayOrigin.z) * rayDirInv.z;
-            if (tmin > tzmax || tzmin > tmax)
-                return false;
-            if (tzmin > tmin)
-                tmin = tzmin;
-            if (tzmax < tmax)
-                tmax = tzmax;
-        }
-        return tmax >= 0;
-    }
-    /**
-     * Ray-box intersection returning entry distance (tNear).
-     * Returns null if no intersection, otherwise the distance along the ray
-     * to the entry point (clamped to 0 if the ray originates inside the box).
-     * Handles zero ray direction components (axis-aligned rays) safely.
-     */
-    rayBoxDistance(rayOrigin, rayDirInv, rayDirSign, box) {
-        const bounds = [box.min, box.max];
-        let tmin = -Infinity;
-        let tmax = Infinity;
-        // X axis
-        if (!isFinite(rayDirInv.x)) {
-            // Ray parallel to X: miss if origin outside X slab
-            if (rayOrigin.x < box.min.x || rayOrigin.x > box.max.x)
-                return null;
-        }
-        else {
-            const t1 = (bounds[rayDirSign[0]].x - rayOrigin.x) * rayDirInv.x;
-            const t2 = (bounds[1 - rayDirSign[0]].x - rayOrigin.x) * rayDirInv.x;
-            tmin = t1;
-            tmax = t2;
-        }
-        // Y axis
-        if (!isFinite(rayDirInv.y)) {
-            if (rayOrigin.y < box.min.y || rayOrigin.y > box.max.y)
-                return null;
-        }
-        else {
-            const tymin = (bounds[rayDirSign[1]].y - rayOrigin.y) * rayDirInv.y;
-            const tymax = (bounds[1 - rayDirSign[1]].y - rayOrigin.y) * rayDirInv.y;
-            if (tmin > tymax || tymin > tmax)
-                return null;
-            if (tymin > tmin)
-                tmin = tymin;
-            if (tymax < tmax)
-                tmax = tymax;
-        }
-        // Z axis
-        if (!isFinite(rayDirInv.z)) {
-            if (rayOrigin.z < box.min.z || rayOrigin.z > box.max.z)
-                return null;
-        }
-        else {
-            const tzmin = (bounds[rayDirSign[2]].z - rayOrigin.z) * rayDirInv.z;
-            const tzmax = (bounds[1 - rayDirSign[2]].z - rayOrigin.z) * rayDirInv.z;
-            if (tmin > tzmax || tzmin > tmax)
-                return null;
-            if (tzmin > tmin)
-                tmin = tzmin;
-            if (tzmax < tmax)
-                tmax = tzmax;
-        }
-        if (tmax < 0)
-            return null;
-        return tmin < 0 ? 0 : tmin;
-    }
-    /**
-     * Möller–Trumbore ray-triangle intersection
-     * Returns distance to intersection or null if no hit
-     */
-    rayTriangleIntersect(rayOrigin, rayDir, v0, v1, v2) {
-        const EPSILON = 1e-7;
-        const edge1 = MathUtils.subtract(v1, v0);
-        const edge2 = MathUtils.subtract(v2, v0);
-        const h = MathUtils.cross(rayDir, edge2);
-        const a = MathUtils.dot(edge1, h);
-        if (a > -EPSILON && a < EPSILON)
-            return null; // Ray parallel to triangle
-        const f = 1.0 / a;
-        const s = MathUtils.subtract(rayOrigin, v0);
-        const u = f * MathUtils.dot(s, h);
-        if (u < 0.0 || u > 1.0)
-            return null;
-        const q = MathUtils.cross(s, edge1);
-        const v = f * MathUtils.dot(rayDir, q);
-        if (v < 0.0 || u + v > 1.0)
-            return null;
-        const t = f * MathUtils.dot(edge2, q);
-        if (t > EPSILON)
-            return t; // Ray intersection
-        return null;
-    }
-    /**
-     * CPU raycast against all mesh data
-     * Returns expressId and modelIndex of closest hit, or null
-     * For multi-model support: tracks which model's geometry was hit
+     * CPU raycast against all mesh data.
+     * Returns expressId and modelIndex of closest hit, or null.
+     * Delegates to extracted raycaster utilities.
      */
     raycast(rayOrigin, rayDir, hiddenIds, isolatedIds) {
-        // Precompute ray direction inverse and signs for box tests
-        const rayDirInv = {
-            x: rayDir.x !== 0 ? 1.0 / rayDir.x : Infinity,
-            y: rayDir.y !== 0 ? 1.0 / rayDir.y : Infinity,
-            z: rayDir.z !== 0 ? 1.0 / rayDir.z : Infinity,
-        };
-        const rayDirSign = [
-            rayDirInv.x < 0 ? 1 : 0,
-            rayDirInv.y < 0 ? 1 : 0,
-            rayDirInv.z < 0 ? 1 : 0,
-        ];
-        let closestHit = null;
-        let closestDistance = Infinity;
+        const { rayDirInv, rayDirSign } = prepareRayDirInv(rayDir);
         // When geometry data has been released, use bounding-box-only raycast.
-        // This is less accurate but uses only the precomputed bounding boxes.
-        // For precise picking, callers should use GPU picking instead.
         if (this.geometryReleased) {
-            for (const [expressId, bbox] of this.boundingBoxes) {
-                if (hiddenIds?.has(expressId))
-                    continue;
-                if (isolatedIds !== null && isolatedIds !== undefined && !isolatedIds.has(expressId))
-                    continue;
-                const tNear = this.rayBoxDistance(rayOrigin, rayDirInv, rayDirSign, bbox);
-                if (tNear !== null && tNear < closestDistance) {
-                    closestDistance = tNear;
-                    closestHit = { expressId, distance: tNear };
-                }
-            }
-            return closestHit;
-        }
-        // First pass: filter by bounding box (fast)
-        const candidates = [];
-        for (const expressId of this.meshDataMap.keys()) {
-            // Skip hidden elements
-            if (hiddenIds?.has(expressId))
-                continue;
-            // Skip non-isolated elements if isolation is active
-            if (isolatedIds !== null && isolatedIds !== undefined && !isolatedIds.has(expressId))
-                continue;
-            const bbox = this.getEntityBoundingBox(expressId);
-            if (!bbox)
-                continue;
-            if (this.rayIntersectsBox(rayOrigin, rayDirInv, rayDirSign, bbox)) {
-                candidates.push(expressId);
-            }
-        }
-        // Second pass: test triangles for candidates (accurate)
-        for (const expressId of candidates) {
-            const pieces = this.meshDataMap.get(expressId);
-            if (!pieces)
-                continue;
-            for (const piece of pieces) {
-                const positions = piece.positions;
-                const indices = piece.indices;
-                const pieceEntityIds = piece.entityIds; // per-vertex IDs for merged meshes
-                // Test each triangle
-                for (let i = 0; i < indices.length; i += 3) {
-                    // For color-merged meshes, skip triangles that don't belong to
-                    // this entity.  Without this check, hitting ANY triangle in the
-                    // merged batch would attribute it to the candidate expressId.
-                    if (pieceEntityIds) {
-                        const vertIdx = indices[i];
-                        if (pieceEntityIds[vertIdx] !== expressId)
-                            continue;
-                    }
-                    const i0 = indices[i] * 3;
-                    const i1 = indices[i + 1] * 3;
-                    const i2 = indices[i + 2] * 3;
-                    const v0 = { x: positions[i0], y: positions[i0 + 1], z: positions[i0 + 2] };
-                    const v1 = { x: positions[i1], y: positions[i1 + 1], z: positions[i1 + 2] };
-                    const v2 = { x: positions[i2], y: positions[i2 + 1], z: positions[i2 + 2] };
-                    const t = this.rayTriangleIntersect(rayOrigin, rayDir, v0, v1, v2);
-                    if (t !== null && t < closestDistance) {
-                        closestDistance = t;
-                        // Track modelIndex from the piece that was actually hit
-                        closestHit = { expressId, distance: t, modelIndex: piece.modelIndex };
-                    }
-                }
-            }
+            return raycastBoundingBoxes(rayOrigin, rayDirInv, rayDirSign, this.boundingBoxes, hiddenIds, isolatedIds);
         }
-        return closestHit;
+        // Full triangle-level raycast with bounding-box pre-filter
+        return raycastTriangles(rayOrigin, rayDir, rayDirInv, rayDirSign, this.meshDataMap, (id) => this.getEntityBoundingBox(id), hiddenIds, isolatedIds);
     }
 }
 //# sourceMappingURL=scene.js.map