three-zoo 0.11.3 → 0.11.4

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export { DualFovCamera } from "./DualFovCamera";
+export { InstancedMeshGroup } from "./instancedMeshPool/InstancedMeshGroup";
+export { InstancedMeshInstance } from "./instancedMeshPool/InstancedMeshInstance";
+export { InstancedMeshPool } from "./instancedMeshPool/InstancedMeshPool";
 export { BasicToPhysicalConverter } from "./materialConverters/BasicToPhysicalConverter";
 export { StandardToBasicConverter } from "./materialConverters/StandardToBasicConverter";
 export { StandardToLambertConverter } from "./materialConverters/StandardToLambertConverter";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { PerspectiveCamera, MathUtils, Vector3, MeshPhysicalMaterial, Color, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshToonMaterial, Mesh, BufferAttribute, AnimationMixer, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical } from 'three';
+import { PerspectiveCamera, MathUtils, Vector3, Object3D, Matrix4, Quaternion, InstancedMesh, MeshPhysicalMaterial, Color, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshToonMaterial, Mesh, BufferAttribute, AnimationMixer, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical } from 'three';
 
 /** Default horizontal field of view in degrees */
 const DEFAULT_HORIZONTAL_FOV = 90;
@@ -242,6 +242,181 @@ class DualFovCamera extends PerspectiveCamera {
     }
 }
 
+class InstancedMeshGroup extends Object3D {
+    constructor(_private_instances) {
+        super();
+        this._private_instances = _private_instances;
+    }
+    flushTransform() {
+        this.updateWorldMatrix(true, false);
+        for (const instance of this._private_instances) {
+            instance.setTransform(this.matrixWorld);
+        }
+    }
+    destroy() {
+        for (const instance of this._private_instances) {
+            instance.destroy();
+        }
+    }
+}
+
+class InstancedMeshInstance {
+    constructor(pool, entry, index) {
+        this._private_pool = pool;
+        this["entry"] = entry;
+        this.index = index;
+        this._private_matrix = new Matrix4();
+        this._private_position = new Vector3();
+        this._private_quaternion = new Quaternion();
+        this._private_scale = new Vector3(1, 1, 1);
+    }
+    setPosition(v) {
+        this._private_position.copy(v);
+        this._private_apply();
+        return this;
+    }
+    setPosition3f(x, y, z) {
+        this._private_position.set(x, y, z);
+        this._private_apply();
+        return this;
+    }
+    setQuaternion(q) {
+        this._private_quaternion.copy(q);
+        this._private_apply();
+        return this;
+    }
+    setQuaternion4f(x, y, z, w) {
+        this._private_quaternion.set(x, y, z, w);
+        this._private_apply();
+        return this;
+    }
+    setScale(v) {
+        this._private_scale.copy(v);
+        this._private_apply();
+        return this;
+    }
+    setScale3f(x, y, z) {
+        this._private_scale.set(x, y, z);
+        this._private_apply();
+        return this;
+    }
+    setTransform(m) {
+        m.decompose(this._private_position, this._private_quaternion, this._private_scale);
+        this._private_apply();
+        return this;
+    }
+    destroy() {
+        if (this.index === -1)
+            return;
+        this._private_pool.deallocate(this);
+    }
+    _private_apply() {
+        if (this.index === -1)
+            return;
+        this._private_matrix.compose(this._private_position, this._private_quaternion, this._private_scale);
+        this["entry"].mesh.setMatrixAt(this.index, this._private_matrix);
+        this._private_pool["notifyUpdate"](this["entry"]);
+    }
+}
+
+const TEMP_ZERO_MATRIX = new Matrix4().makeScale(0, 0, 0);
+class InstancedMeshPool {
+    constructor(options) {
+        var _a, _b;
+        this._private_scene = options.scene;
+        this._private_initialCapacity = (_a = options.initialCapacity) !== null && _a !== void 0 ? _a : 16;
+        this._private_capacityStep = (_b = options.capacityStep) !== null && _b !== void 0 ? _b : this._private_initialCapacity;
+        this._private_meshes = new Map();
+    }
+    allocate(geometry, material) {
+        const entry = this._private_getOrCreateEntry(geometry, material);
+        if (entry.freeIndices.length === 0) {
+            this._private_growEntry(entry);
+        }
+        const index = entry.freeIndices.pop();
+        const instance = new InstancedMeshInstance(this, entry, index);
+        // identity transform
+        instance.setScale3f(1, 1, 1);
+        entry.instances.add(instance);
+        this._private_updateMeshCount(entry);
+        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);
+        instance.index = -1;
+        this._private_updateMeshCount(entry);
+        this["notifyUpdate"](entry);
+    }
+    _private_getOrCreateEntry(geometry, material) {
+        const key = `${geometry.uuid}:${material.uuid}`;
+        let entry = this._private_meshes.get(key);
+        if (!entry) {
+            const mesh = new InstancedMesh(geometry, material, this._private_initialCapacity);
+            mesh.count = 0;
+            mesh.frustumCulled = false;
+            this._private_scene.add(mesh);
+            entry = {
+                mesh,
+                geometry,
+                material,
+                capacity: this._private_initialCapacity,
+                instances: new Set(),
+                freeIndices: this._private_createIndexRange(0, this._private_initialCapacity),
+            };
+            this._private_meshes.set(key, entry);
+        }
+        return entry;
+    }
+    _private_growEntry(entry) {
+        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;
+    }
+    ["notifyUpdate"](entry) {
+        entry.mesh.instanceMatrix.needsUpdate = true;
+    }
+}
+
 class BasicToPhysicalConverter {
     static convert(material, options = {}) {
         const config = Object.assign({ preserveName: true, copyUserData: true, disposeOriginal: false }, options);
@@ -1765,5 +1940,5 @@ class Sun extends DirectionalLight {
     }
 }
 
-export { BasicToPhysicalConverter, DualFovCamera, SceneTraversal, SkinnedMeshBaker, SkyLight, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun };
+export { BasicToPhysicalConverter, DualFovCamera, InstancedMeshGroup, InstancedMeshInstance, InstancedMeshPool, SceneTraversal, SkinnedMeshBaker, SkyLight, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun };
 //# sourceMappingURL=index.js.map