@needle-tools/engine 4.11.5-next.9fa3148 → 4.11.5-next.a900688

package/src/engine-components/RendererInstancing.ts

@@ -29,9 +29,8 @@ export class InstancingHandler {
      * (The instancing mesh renderer will grow x2 if the max instance count is reached)
      * @default 4
      * @returns The initial instance count
-     */
-    // @ts-ignore (ignore the unused parameter warning)
-    static getStartInstanceCount = (obj: Object3D) => {
+     * */
+    static getStartInstanceCount = (_obj: Object3D) => {
         return 4;
     };
 
@@ -46,24 +45,20 @@ export class InstancingHandler {
         if (res) {
             if (handlesArray === null) handlesArray = [];
             handlesArray.push(res);
-
-            // Load LOD for textures
-            const mat = res.object.material;
-            if(Array.isArray(mat)) {
-                mat.forEach(m => NEEDLE_progressive.assignTextureLOD(m, 0));
-            }
-            else {
-                NEEDLE_progressive.assignTextureLOD(mat, 0);
+            // load texture lods
+            NEEDLE_progressive.assignTextureLOD(res.renderer.material, 0);
+
+            // Load mesh lods
+            // TODO: technically for multi meshes we do this work multiple times (we search for meshes in children and then use the renderer sharedMeshes... that doesnt make sense)
+            for (let i = 0; i < renderer.sharedMeshes.length; i++) {
+                const mesh = renderer.sharedMeshes[i];
+                const geometry = mesh.geometry;
+                NEEDLE_progressive.assignMeshLOD(mesh, 0).then(lod => {
+                    if (lod && renderer.activeAndEnabled && geometry != lod) {
+                        res.setGeometry(lod);
+                    }
+                });
             }
-
-            // Load LOD for geometry
-            const mesh = res.object;
-            const geometry = mesh.geometry;
-            NEEDLE_progressive.assignMeshLOD(mesh, 0).then(lod => {
-                if (lod && geometry != lod) {
-                    res.setGeometry(lod);
-                }
-            });
         }
 
         else if (level <= 0 && obj.type !== "Mesh") {
@@ -354,7 +349,7 @@ class InstancedMeshRenderer {
     private _context: Context;
     private _batchedMesh: BatchedMesh;
     private _handles: (InstanceHandle | null)[] = [];
-    private _geometryIds = new WeakMap<BufferGeometry, number>();
+    private readonly _geometryIds: Map<BufferGeometry, number> = new Map();
     private _maxInstanceCount: number;
 
     private _currentInstanceCount = 0;
@@ -444,10 +439,6 @@ class InstancedMeshRenderer {
     private _needUpdateBounds: boolean = false;
     private _debugMaterial: MeshStandardMaterial | null = null;
 
-    private getBatchedMeshName() {
-        return this.name ? `${this.name} (BatchedMesh)` : "BatchedMesh";
-    }
-
     constructor(name: string, geo: BufferGeometry, material: Material, initialMaxCount: number, context: Context) {
         this.name = name;
         this.geometry = geo;
@@ -461,7 +452,6 @@ class InstancedMeshRenderer {
         this._maxVertexCount = estimate.vertexCount;
         this._maxIndexCount = estimate.indexCount;
         this._batchedMesh = new BatchedMesh(this._maxInstanceCount, this._maxVertexCount, this._maxIndexCount, this._debugMaterial ?? this.material);
-        this._batchedMesh.name = this.getBatchedMeshName();
         // this.inst = new InstancedMesh(geo, material, count);
         this._batchedMesh[$instancingAutoUpdateBounds] = true;
         // this.inst.count = 0;
@@ -485,7 +475,7 @@ class InstancedMeshRenderer {
         context.post_render_callbacks.push(this.onAfterRender);
 
         if (debugInstancing) {
-            console.log(`Instanced renderer (${this.name}) created with ${this._maxInstanceCount} instances, ${this._maxVertexCount} max vertices and ${this._maxIndexCount} max indices for \"${name}\"`)
+            console.log(`Instanced renderer created with ${this._maxInstanceCount} instances, ${this._maxVertexCount} max vertices and ${this._maxIndexCount} max indices for \"${name}\"`)
         }
     }
 
@@ -532,8 +522,7 @@ class InstancedMeshRenderer {
             return false;
         }
 
-        const newInstanceCount = this._currentInstanceCount + 1;
-        if (newInstanceCount > this._maxInstanceCount || this.mustGrow(geo)) {
+        if (this.mustGrow(geo)) {
             if (this.allowResize) {
                 this.grow(geo);
             }
@@ -655,42 +644,34 @@ class InstancedMeshRenderer {
     private mustGrow(geo?: BufferGeometry): boolean {
         if (this.count >= this._maxInstanceCount) return true;
         if (!geo || !geo.attributes) return false;
-
-        const isKnownGeometry = this._geometryIds.has(geo);
-        if (isKnownGeometry) return false;
-
         const meshInfo = getMeshInformation(geo);
         const newVertexCount = meshInfo.vertexCount;
         const newIndexCount = meshInfo.indexCount;
         return this._currentVertexCount + newVertexCount > this._maxVertexCount || this._currentIndexCount + newIndexCount > this._maxIndexCount;
     }
 
-    private _growId = 0;
     private grow(geometry: BufferGeometry) {
-        const id = ++this._growId;
         const growFactor = 2;
         const newSize = Math.ceil(this._maxInstanceCount * growFactor);
 
         // create a new BatchedMesh instance
-        // TODO: we should keep track of how many instances for each geometry we have and consider that when estimating new space
         const estimatedSpace = this.tryEstimateVertexCountSize(newSize, [geometry]);// geometry.attributes.position.count;
         // const indices = geometry.index ? geometry.index.count : 0;
         const newMaxVertexCount = Math.max(this._maxVertexCount, estimatedSpace.vertexCount);
-        const newMaxIndexCount = Math.max(this._maxIndexCount, estimatedSpace.indexCount);//, Math.ceil(this._maxVertexCount * growFactor));
+        const newMaxIndexCount = Math.max(this._maxIndexCount, estimatedSpace.indexCount, Math.ceil(this._maxVertexCount * growFactor));
 
         if (debugInstancing) {
             const geometryInfo = getMeshInformation(geometry);
-            console.warn(`[Instancing] Growing Buffer\nMesh: \"${this.name}${geometry.name?.length ? "/" + geometry.name : ""}\" (${geometryInfo.vertexCount.toLocaleString()} vertices, ${geometryInfo.indexCount.toLocaleString()} indices)\nMax count ${this._maxInstanceCount.toLocaleString()} → ${newSize.toLocaleString()}\nMax vertex count ${this._maxVertexCount.toLocaleString()} -> ${newMaxVertexCount.toLocaleString()}\nMax index count ${this._maxIndexCount.toLocaleString()} -> ${newMaxIndexCount.toLocaleString()}`);
+            console.warn(`[Instancing] Growing Buffer\nMesh: \"${this.name}${geometry.name?.length ? "/" + geometry.name : ""}\"\n${geometryInfo.vertexCount} vertices, ${geometryInfo.indexCount} indices\nMax count ${this._maxInstanceCount} → ${newSize}\nMax vertex count ${this._maxVertexCount} -> ${newMaxVertexCount}\nMax index count ${this._maxIndexCount} -> ${newMaxIndexCount}`);
             this._debugMaterial = createDebugMaterial();
         }
         else if (isDevEnvironment()) {
-            console.debug(`[Instancing] Growing Buffer\nMesh: \"${this.name}${geometry.name?.length ? "/" + geometry.name : ""}\"\nMax count ${this._maxInstanceCount} → ${newSize}\nMax vertex count ${this._maxVertexCount.toLocaleString()} -> ${newMaxVertexCount.toLocaleString()}\nMax index count ${this._maxIndexCount.toLocaleString()} -> ${newMaxIndexCount.toLocaleString()}`);
+            console.debug(`[Instancing] Growing Buffer\nMesh: \"${this.name}${geometry.name?.length ? "/" + geometry.name : ""}\"\nMax count ${this._maxInstanceCount} → ${newSize}\nMax vertex count ${this._maxVertexCount} -> ${newMaxVertexCount}\nMax index count ${this._maxIndexCount} -> ${newMaxIndexCount}`);
         }
 
         this._maxVertexCount = newMaxVertexCount;
         this._maxIndexCount = newMaxIndexCount;
         const newInst = new BatchedMesh(newSize, this._maxVertexCount, this._maxIndexCount, this._debugMaterial ?? this.material);
-        newInst.name = this.getBatchedMeshName();
         newInst.layers = this._batchedMesh.layers;
         newInst.castShadow = this._batchedMesh.castShadow;
         newInst.receiveShadow = this._batchedMesh.receiveShadow;
@@ -705,7 +686,7 @@ class InstancedMeshRenderer {
         // dispose the old batched mesh
         this._batchedMesh.dispose();
         this._batchedMesh.removeFromParent();
-        this._geometryIds = new WeakMap<BufferGeometry, number>();
+        this._geometryIds.clear();
 
         this._batchedMesh = newInst;
         this._maxInstanceCount = newSize;
@@ -717,11 +698,6 @@ class InstancedMeshRenderer {
         const original = [...this._handles];
         this._handles = [];
         for (const handle of original) {
-            if (id !== this._growId) {
-                // another grow happened in the meantime
-                if (debugInstancing) console.warn("[Instancing] Aborting grow since another grow happened in the meantime");
-                return;
-            }
             if (handle && handle.__instanceIndex >= 0) {
                 this.addGeometry(handle);
                 this._handles[handle.__instanceIndex] = handle;
@@ -746,31 +722,23 @@ class InstancedMeshRenderer {
                     entry.count += 1;
                 }
 
-                if (_newGeometries && _newGeometries?.length > 0) {
-                    const index = _newGeometries.indexOf(handle.object.geometry as BufferGeometry);
-                    if (index !== -1) {
-                        _newGeometries.splice(index, 1);
-                    }
-                }
             }
         }
 
         // then calculate the total vertex count
         let totalVertices = 0;
         let totalIndices = 0;
-        let totalGeometries = 0;
         // let maxVertices = 0;
         for (const [_geo, data] of usedGeometries) {
-            totalGeometries += 1;
-            totalVertices += data.vertexCount;
-            totalIndices += data.indexCount;
+            totalVertices += data.vertexCount * data.count;
+            totalIndices += data.indexCount * data.count;
             // maxVertices = Math.max(maxVertices, geo.attributes.position.count * count);
         }
         // we calculate the average to make an educated guess of how many vertices will be needed with the new buffer count
-        const averageVerts = Math.ceil(totalVertices / Math.max(1, totalGeometries));
-        let maxVertexCount = averageVerts * totalGeometries;
-        const averageIndices = Math.ceil(totalIndices / Math.max(1, totalGeometries));
-        let maxIndexCount = averageIndices * totalGeometries;
+        const averageVerts = Math.ceil(totalVertices / Math.max(1, this._currentInstanceCount));
+        let maxVertexCount = averageVerts * newMaxInstances;
+        const averageIndices = Math.ceil(totalIndices / Math.max(1, this._currentInstanceCount));
+        let maxIndexCount = averageIndices * newMaxInstances * 2;
 
         // if new geometries are provided we *know* that they will be added
         // so we make sure to include them in the calculation
@@ -785,10 +753,6 @@ class InstancedMeshRenderer {
             }
         }
 
-        if (debugInstancing) {
-            console.log(`[Instancing] Estimated size for new buffer ${this.name}\nGeometries: ${totalGeometries} (New: ${_newGeometries?.length || 0})\nInstances: ${newMaxInstances}\nEstimated Vertices: ${maxVertexCount.toLocaleString()}\nEstimated Indices: ${maxIndexCount.toLocaleString()}`);
-        }
-
         return { vertexCount: maxVertexCount, indexCount: maxIndexCount };
     }
 
@@ -806,16 +770,16 @@ class InstancedMeshRenderer {
         let geometryId = this._geometryIds.get(geo);
         if (geometryId === undefined || geometryId === null) {
             if (debugInstancing)
-                console.warn(`[Instancing] > ADD NEW GEOMETRY \"${handle.name} (${geo.name}; ${geo.uuid})\"\nCurrent Instances: ${this._currentInstanceCount}\nMax Vertices: ${handle.maxVertexCount.toLocaleString()}\nMax Indices: ${handle.maxIndexCount.toLocaleString()}\nMax Triangles: ${(handle.maxIndexCount / 3).toLocaleString()}`);
+                console.debug(`[Instancing] > ADD NEW GEOMETRY \"${handle.name} (${geo.name}; ${geo.uuid})\"\n${this._currentInstanceCount} instances, ${handle.maxVertexCount} max vertices, ${handle.maxIndexCount} max indices`);
 
             geometryId = this._batchedMesh.addGeometry(geo, handle.maxVertexCount, handle.maxIndexCount);
             this._geometryIds.set(geo, geometryId);
-            this._currentVertexCount += handle.maxVertexCount;
-            this._currentIndexCount += handle.maxIndexCount;
         }
         else {
             if (debugInstancing === "verbose") console.log(`[Instancing] > ADD INSTANCE \"${handle.name}\"\nGEOMETRY_ID=${geometryId}\n${this._currentInstanceCount} instances`);
         }
+        this._currentVertexCount += handle.maxVertexCount;
+        this._currentIndexCount += handle.maxIndexCount;
         const i = this._batchedMesh.addInstance(geometryId);
         handle.__geometryIndex = geometryId;
         handle.__instanceIndex = i;
@@ -823,7 +787,7 @@ class InstancedMeshRenderer {
         handle.__reservedIndexRange = handle.maxIndexCount;
         this._batchedMesh.setMatrixAt(i, handle.object.matrixWorld);
         if (debugInstancing)
-            console.debug(`[Instancing] > ADDED INSTANCE \"${handle.name}\"\nGEOMETRY_ID=${geometryId}\n${this._currentInstanceCount} instances\nIndex: ${handle.__instanceIndex}\nVertices: ${this._currentVertexCount.toLocaleString()}/${this._maxVertexCount.toLocaleString()},\nIndices: ${this._currentIndexCount.toLocaleString()}/${this._maxIndexCount.toLocaleString()}`);
+            console.debug(`[Instancing] > ADDED INSTANCE \"${handle.name}\"\nGEOMETRY_ID=${geometryId}\n${this._currentInstanceCount} instances\nIndex: ${handle.__instanceIndex}`);
 
     }
 
@@ -839,7 +803,7 @@ class InstancedMeshRenderer {
         //     this.inst.deleteGeometry(handle.__instanceIndex);
         // else 
         // this._batchedMesh.setVisibleAt(handle.__instanceIndex, false);
-        if (debugInstancing) {
+        if(debugInstancing) {
             console.debug(`[Instancing] < REMOVE INSTANCE \"${handle.name}\" at [${handle.__instanceIndex}]\nGEOMETRY_ID=${handle.__geometryIndex}\n${this._currentInstanceCount} instances\nIndex: ${handle.__instanceIndex}`);
         }
         this._batchedMesh.deleteInstance(handle.__instanceIndex);

package/lib/engine/debug/debug_spector.d.ts

@@ -1,16 +0,0 @@
-import type { Context } from "../engine_setup.js";
-declare global {
-    interface Window {
-        SPECTOR?: {
-            Spector: new () => Spector;
-        };
-    }
-    interface Spector {
-        displayUI: () => void;
-        setCanvas: (canvas: HTMLCanvasElement) => void;
-        spyCanvases: boolean;
-        startCaptureOnNextFrame: () => void;
-        captureCanvas: (canvas: HTMLCanvasElement) => any;
-    }
-}
-export declare function initSpectorIfAvailable(_context: Context, canvas: HTMLCanvasElement): void;

package/lib/engine/debug/debug_spector.js

@@ -1,28 +0,0 @@
-import { isDevEnvironment } from "./debug.js";
-export function initSpectorIfAvailable(_context, canvas) {
-    if (typeof window !== undefined && window.SPECTOR) {
-        console.log(window.SPECTOR);
-        const params = new URLSearchParams(window.location.search);
-        if (params.has("spector")) {
-            const frame = Number.parseInt(params.get("spector") || "0") || 0;
-            console.log("Scheduled Spector capture at frame #" + frame);
-            const spector = new window.SPECTOR.Spector();
-            spector.spyCanvases = true;
-            waitForFrameAndCapture();
-            return;
-            function waitForFrameAndCapture() {
-                if (frame > _context.time.frame)
-                    return window.requestAnimationFrame(() => waitForFrameAndCapture());
-                const res = spector.captureCanvas(canvas);
-                if (res && res instanceof Promise)
-                    res.then(() => spector.displayUI());
-                else
-                    spector.displayUI();
-            }
-        }
-        else if (isDevEnvironment()) {
-            console.debug("Spector available: Add '?spector=<frame>' to the URL to enable it and capture a frame.");
-        }
-    }
-}
-//# sourceMappingURL=debug_spector.js.map

package/lib/engine/debug/debug_spector.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug_spector.js","sourceRoot":"","sources":["../../../src/engine/debug/debug_spector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAkB9C,MAAM,UAAU,sBAAsB,CAAC,QAAiB,EAAE,MAAyB;IAC/E,IAAI,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,OAAO,EAAE;QAC/C,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC5B,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;YACvB,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;YACjE,OAAO,CAAC,GAAG,CAAC,sCAAsC,GAAG,KAAK,CAAC,CAAC;YAC5D,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC7C,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;YAC3B,sBAAsB,EAAE,CAAC;YACzB,OAAO;YAEP,SAAS,sBAAsB;gBAC3B,IAAI,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK;oBAAE,OAAO,MAAM,CAAC,qBAAqB,CAAC,GAAG,EAAE,CAAC,sBAAsB,EAAE,CAAC,CAAC;gBACrG,MAAM,GAAG,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;gBAC1C,IAAI,GAAG,IAAI,GAAG,YAAY,OAAO;oBAAE,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;;oBAClE,OAAO,CAAC,SAAS,EAAE,CAAC;YAC7B,CAAC;SACJ;aACI,IAAI,gBAAgB,EAAE,EAAE;YACzB,OAAO,CAAC,KAAK,CAAC,wFAAwF,CAAC,CAAC;SAC3G;KACJ;AACL,CAAC"}

package/src/engine/debug/debug_spector.ts

@@ -1,43 +0,0 @@
-import type { Context } from "../engine_setup.js";
-import { isDevEnvironment } from "./debug.js";
-
-declare global {
-    interface Window {
-        SPECTOR?: {
-            Spector: new () => Spector;
-        }
-    }
-    interface Spector {
-        displayUI: () => void;
-        setCanvas: (canvas: HTMLCanvasElement) => void;
-        spyCanvases: boolean;
-        startCaptureOnNextFrame: () => void;
-        captureCanvas: (canvas: HTMLCanvasElement) => any;
-    }
-}
-
-
-export function initSpectorIfAvailable(_context: Context, canvas: HTMLCanvasElement): void {
-    if (typeof window !== undefined && window.SPECTOR) {
-        console.log(window.SPECTOR);
-        const params = new URLSearchParams(window.location.search);
-        if (params.has("spector")) {
-            const frame = Number.parseInt(params.get("spector") || "0") || 0;
-            console.log("Scheduled Spector capture at frame #" + frame);
-            const spector = new window.SPECTOR.Spector();
-            spector.spyCanvases = true;
-            waitForFrameAndCapture();
-            return;
-
-            function waitForFrameAndCapture() {
-                if (frame > _context.time.frame) return window.requestAnimationFrame(() => waitForFrameAndCapture());
-                const res = spector.captureCanvas(canvas);
-                if (res && res instanceof Promise) res.then(() => spector.displayUI());
-                else spector.displayUI();
-            }
-        }
-        else if (isDevEnvironment()) {
-            console.debug("Spector available: Add '?spector=<frame>' to the URL to enable it and capture a frame.");
-        }
-    }
-}