three-zoo 0.11.4 → 0.11.6

package/dist/index.js

@@ -319,7 +319,7 @@ class InstancedMeshInstance {
     }
 }
 
-const TEMP_ZERO_MATRIX = new Matrix4().makeScale(0, 0, 0);
+const TEMP_MATRIX = new Matrix4();
 class InstancedMeshPool {
     constructor(options) {
         var _a, _b;
@@ -330,29 +330,51 @@ class InstancedMeshPool {
     }
     allocate(geometry, material) {
         const entry = this._private_getOrCreateEntry(geometry, material);
-        if (entry.freeIndices.length === 0) {
+        if (entry.count === entry.capacity) {
             this._private_growEntry(entry);
         }
-        const index = entry.freeIndices.pop();
+        const index = entry.count;
+        entry.count++;
         const instance = new InstancedMeshInstance(this, entry, index);
-        // identity transform
         instance.setScale3f(1, 1, 1);
-        entry.instances.add(instance);
-        this._private_updateMeshCount(entry);
+        entry.instances.set(index, instance);
+        entry.mesh.count = entry.count;
         return instance;
     }
     deallocate(instance) {
         if (instance.index === -1)
             return;
         const entry = instance["entry"];
-        entry.instances.delete(instance);
-        entry.freeIndices.push(instance.index);
-        // hide instance
-        entry.mesh.setMatrixAt(instance.index, TEMP_ZERO_MATRIX);
+        const removedIndex = instance.index;
+        const lastIndex = entry.count - 1;
+        entry.instances.delete(removedIndex);
+        if (removedIndex !== lastIndex) {
+            // swap: move last to removed position
+            const lastInstance = entry.instances.get(lastIndex);
+            entry.mesh.getMatrixAt(lastIndex, TEMP_MATRIX);
+            entry.mesh.setMatrixAt(removedIndex, TEMP_MATRIX);
+            lastInstance.index = removedIndex;
+            entry.instances.delete(lastIndex);
+            entry.instances.set(removedIndex, lastInstance);
+        }
+        entry.count--;
+        entry.mesh.count = entry.count;
         instance.index = -1;
-        this._private_updateMeshCount(entry);
         this["notifyUpdate"](entry);
     }
+    sortMeshes(compare) {
+        const meshes = [];
+        for (const entry of this._private_meshes.values()) {
+            meshes.push(entry.mesh);
+        }
+        meshes.sort(compare);
+        for (const mesh of meshes) {
+            this._private_scene.remove(mesh);
+        }
+        for (const mesh of meshes) {
+            this._private_scene.add(mesh);
+        }
+    }
     _private_getOrCreateEntry(geometry, material) {
         const key = `${geometry.uuid}:${material.uuid}`;
         let entry = this._private_meshes.get(key);
@@ -366,8 +388,8 @@ class InstancedMeshPool {
                 geometry,
                 material,
                 capacity: this._private_initialCapacity,
-                instances: new Set(),
-                freeIndices: this._private_createIndexRange(0, this._private_initialCapacity),
+                count: 0,
+                instances: new Map(),
             };
             this._private_meshes.set(key, entry);
         }
@@ -377,40 +399,16 @@ class InstancedMeshPool {
         const newCapacity = entry.capacity + this._private_capacityStep;
         const newMesh = new InstancedMesh(entry.geometry, entry.material, newCapacity);
         newMesh.frustumCulled = false;
-        // copy existing matrix data
         const oldArray = entry.mesh.instanceMatrix.array;
         const newArray = newMesh.instanceMatrix.array;
         newArray.set(oldArray);
         newMesh.instanceMatrix.needsUpdate = true;
-        // swap meshes
         this._private_scene.remove(entry.mesh);
         entry.mesh.dispose();
         this._private_scene.add(newMesh);
-        // add new free indices
-        entry.freeIndices.push(...this._private_createIndexRange(entry.capacity, newCapacity));
         entry.mesh = newMesh;
         entry.capacity = newCapacity;
-        this._private_updateMeshCount(entry);
-    }
-    _private_updateMeshCount(entry) {
-        if (entry.instances.size === 0) {
-            entry.mesh.count = 0;
-            return;
-        }
-        let maxIndex = -1;
-        for (const inst of entry.instances) {
-            if (inst.index > maxIndex) {
-                maxIndex = inst.index;
-            }
-        }
-        entry.mesh.count = maxIndex + 1;
-    }
-    _private_createIndexRange(start, end) {
-        const result = [];
-        for (let i = start; i < end; i++) {
-            result.push(i);
-        }
-        return result;
+        entry.mesh.count = entry.count;
     }
     ["notifyUpdate"](entry) {
         entry.mesh.instanceMatrix.needsUpdate = true;