@relu-interactives/spatial-ecs 0.2.5 → 0.2.7

package/dist/systems/index.cjs

@@ -1325,6 +1325,7 @@ var DEFAULT_INSTANCED_MESH_PARAMETERS = {
   capsule: DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule,
   cube: DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
   cylinder: DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder,
+  model: DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
   plane: DEFAULT_MESH_GEOMETRY_PARAMETERS.plane,
   sphere: DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere
 };
@@ -1332,6 +1333,7 @@ var _InstancedMeshComponent = class _InstancedMeshComponent extends Component {
   constructor(meshKind = "cube", meshParameters, options) {
     super();
     this.meshKind = meshKind;
+    this.modelPath = options?.modelPath ?? "";
     this.meshParameters = {
       ...DEFAULT_INSTANCED_MESH_PARAMETERS[meshKind],
       ...meshParameters ?? {}
@@ -1374,6 +1376,8 @@ var _InstancedMeshComponent = class _InstancedMeshComponent extends Component {
           height: sanitize(p.height, MIN_DIM)
         };
       }
+      case "model":
+        return DEFAULT_MESH_GEOMETRY_PARAMETERS.cube;
     }
   }
 };
@@ -4133,6 +4137,32 @@ var _MeshGeometrySystem = class _MeshGeometrySystem {
 };
 __name(_MeshGeometrySystem, "MeshGeometrySystem");
 var MeshGeometrySystem = _MeshGeometrySystem;
+var DRACO_DECODER_PATH = resolveDracoDecoderPath();
+var loadGLTF = /* @__PURE__ */ __name((path) => {
+  return new Promise((resolve, reject) => {
+    const loader = new GLTFLoader_js.GLTFLoader();
+    try {
+      const dracoLoader = new DRACOLoader_js.DRACOLoader();
+      dracoLoader.setDecoderPath(DRACO_DECODER_PATH);
+      loader.setDRACOLoader(dracoLoader);
+    } catch (error) {
+      console.debug("DRACOLoader setup failed or unavailable", error);
+    }
+    loader.load(
+      path,
+      (gltf) => {
+        resolve(gltf);
+      },
+      void 0,
+      (error) => {
+        console.debug("GLTFLoader failed to load", error);
+        reject(error);
+      }
+    );
+  });
+}, "loadGLTF");
+
+// core/systems/InstancedMeshSystem.ts
 function buildGeometry(component) {
   const p = component.getSanitizedParameters();
   switch (component.meshKind) {
@@ -4156,6 +4186,8 @@ function buildGeometry(component) {
       const params = p;
       return new THREE13__namespace.CapsuleGeometry(params.radius, params.height, 4, 8);
     }
+    default:
+      return new THREE13__namespace.BoxGeometry(1, 1, 1);
   }
 }
 __name(buildGeometry, "buildGeometry");
@@ -4164,6 +4196,7 @@ var _quaternion = new THREE13__namespace.Quaternion();
 var _euler = new THREE13__namespace.Euler();
 var _scale = new THREE13__namespace.Vector3();
 var _matrix = new THREE13__namespace.Matrix4();
+var _modelMatrix = new THREE13__namespace.Matrix4();
 function instanceTransformToMatrix4(inst, out) {
   _position.set(inst.position.x, inst.position.y, inst.position.z);
   _euler.set(inst.rotation.x, inst.rotation.y, inst.rotation.z, "XYZ");
@@ -4172,51 +4205,165 @@ function instanceTransformToMatrix4(inst, out) {
   out.compose(_position, _quaternion, _scale);
 }
 __name(instanceTransformToMatrix4, "instanceTransformToMatrix4");
+function disposePrimitiveInstancedMesh(mesh) {
+  mesh.geometry.dispose();
+  if (Array.isArray(mesh.material)) {
+    for (const m of mesh.material) {
+      m.dispose();
+    }
+  } else {
+    mesh.material.dispose();
+  }
+}
+__name(disposePrimitiveInstancedMesh, "disposePrimitiveInstancedMesh");
+function disposeModelGroup(group) {
+  group.traverse((child) => {
+    const im = child;
+    if (im.isInstancedMesh) {
+      im.geometry.dispose();
+      if (Array.isArray(im.material)) {
+        for (const m of im.material) {
+          m.dispose();
+        }
+      } else {
+        im.material.dispose();
+      }
+    }
+  });
+}
+__name(disposeModelGroup, "disposeModelGroup");
 var _InstancedMeshSystem = class _InstancedMeshSystem {
   constructor() {
     /** Signature tracking for geometry + instance count changes. */
     this.geometrySignatures = /* @__PURE__ */ new Map();
+    /** Signature being loaded per entity. Maps entityId → geometrySignature in-flight.
+     * Prevents re-dispatching a load every frame while comp.instancedMesh is still null. */
+    this.loadingSignatures = /* @__PURE__ */ new Map();
+    /** Per-mesh data for model kind, populated after GLTF load. */
+    this.modelMeshEntries = /* @__PURE__ */ new Map();
   }
   update(world) {
     const entityIds = world.query(InstancedMeshComponent);
     const alive = new Set(entityIds);
     for (const trackedId of this.geometrySignatures.keys()) {
-      if (!alive.has(trackedId)) {
-        this.geometrySignatures.delete(trackedId);
-      }
+      if (!alive.has(trackedId)) this.geometrySignatures.delete(trackedId);
+    }
+    for (const trackedId of this.loadingSignatures.keys()) {
+      if (!alive.has(trackedId)) this.loadingSignatures.delete(trackedId);
+    }
+    for (const trackedId of this.modelMeshEntries.keys()) {
+      if (!alive.has(trackedId)) this.modelMeshEntries.delete(trackedId);
     }
     for (const entityId of entityIds) {
       const comp = world.getComponent(
         entityId,
         InstancedMeshComponent
       );
-      if (!comp) {
-        continue;
-      }
-      let anchor = null;
+      if (!comp) continue;
       const objectRef = world.getComponent(entityId, Object3DRef);
-      if (objectRef?.object) {
-        anchor = objectRef.object;
-      }
-      if (!anchor) {
-        continue;
-      }
+      const anchor = objectRef?.object ?? null;
+      if (!anchor) continue;
       const instanceCount = comp.instances.length;
-      const geometrySignature = `${comp.meshKind}:${JSON.stringify(comp.meshParameters)}:${instanceCount}`;
-      const needsRebuild = comp.instancedMesh === null || this.geometrySignatures.get(entityId) !== geometrySignature;
+      const geometrySignature = comp.meshKind === "model" ? `model:${comp.modelPath}:${instanceCount}` : `${comp.meshKind}:${JSON.stringify(comp.meshParameters)}:${instanceCount}`;
+      const pendingLoadSignature = this.loadingSignatures.get(entityId);
+      const needsRebuild = (comp.instancedMesh === null || this.geometrySignatures.get(entityId) !== geometrySignature) && pendingLoadSignature !== geometrySignature;
       if (needsRebuild) {
         if (comp.instancedMesh) {
           anchor.remove(comp.instancedMesh);
-          comp.instancedMesh.geometry.dispose();
-          if (Array.isArray(comp.instancedMesh.material)) {
-            for (const m of comp.instancedMesh.material) {
-              m.dispose();
-            }
+          if (comp.instancedMesh.isInstancedMesh) {
+            disposePrimitiveInstancedMesh(comp.instancedMesh);
           } else {
-            comp.instancedMesh.material.dispose();
+            disposeModelGroup(comp.instancedMesh);
           }
           comp.instancedMesh = null;
         }
+        if (pendingLoadSignature !== void 0 && pendingLoadSignature !== geometrySignature) {
+          this.loadingSignatures.delete(entityId);
+          this.modelMeshEntries.delete(entityId);
+        }
+        if (comp.meshKind === "model") {
+          if (comp.modelPath && !this.loadingSignatures.has(entityId)) {
+            this.loadingSignatures.set(entityId, geometrySignature);
+            const targetSignature = geometrySignature;
+            const targetEntityId = entityId;
+            loadGLTF(comp.modelPath).then((gltf) => {
+              if (!world.hasEntity(targetEntityId)) {
+                this.loadingSignatures.delete(targetEntityId);
+                return;
+              }
+              const currentComp = world.getComponent(
+                targetEntityId,
+                InstancedMeshComponent
+              );
+              if (!currentComp) {
+                this.loadingSignatures.delete(targetEntityId);
+                return;
+              }
+              const currentSig = `model:${currentComp.modelPath}:${currentComp.instances.length}`;
+              if (currentSig !== targetSignature) {
+                this.loadingSignatures.delete(targetEntityId);
+                return;
+              }
+              const currentRef = world.getComponent(targetEntityId, Object3DRef);
+              const currentAnchor = currentRef?.object ?? null;
+              if (!currentAnchor) {
+                this.loadingSignatures.delete(targetEntityId);
+                return;
+              }
+              if (currentComp.instancedMesh) {
+                currentAnchor.remove(currentComp.instancedMesh);
+                disposeModelGroup(currentComp.instancedMesh);
+                currentComp.instancedMesh = null;
+              }
+              const count2 = Math.max(1, currentComp.instances.length);
+              const entries = [];
+              gltf.scene.updateWorldMatrix(true, true);
+              gltf.scene.traverse((child) => {
+                const meshChild = child;
+                if (!meshChild.isMesh) return;
+                const geometry2 = meshChild.geometry.clone();
+                const sourceMaterial = Array.isArray(meshChild.material) ? meshChild.material.map((m) => m.clone()) : meshChild.material.clone();
+                meshChild.updateWorldMatrix(true, false);
+                const localMatrix = meshChild.matrixWorld.clone();
+                const instancedMesh2 = new THREE13__namespace.InstancedMesh(
+                  geometry2,
+                  Array.isArray(sourceMaterial) ? sourceMaterial : sourceMaterial,
+                  count2
+                );
+                instancedMesh2.castShadow = currentComp.castShadow;
+                instancedMesh2.receiveShadow = currentComp.receiveShadow;
+                for (let i = 0; i < count2; i++) {
+                  const inst = currentComp.instances[i] ?? {
+                    position: { x: 0, y: 0, z: 0 },
+                    rotation: { x: 0, y: 0, z: 0 },
+                    scale: { x: 1, y: 1, z: 1 }
+                  };
+                  instanceTransformToMatrix4(inst, _matrix);
+                  _modelMatrix.multiplyMatrices(_matrix, localMatrix);
+                  instancedMesh2.setMatrixAt(i, _modelMatrix);
+                }
+                instancedMesh2.instanceMatrix.needsUpdate = true;
+                entries.push({ localMatrix, instancedMesh: instancedMesh2 });
+              });
+              if (entries.length === 0) {
+                this.loadingSignatures.delete(targetEntityId);
+                return;
+              }
+              const group = new THREE13__namespace.Group();
+              for (const entry of entries) {
+                group.add(entry.instancedMesh);
+              }
+              currentAnchor.add(group);
+              currentComp.instancedMesh = group;
+              this.modelMeshEntries.set(targetEntityId, entries);
+              this.geometrySignatures.set(targetEntityId, targetSignature);
+              this.loadingSignatures.delete(targetEntityId);
+            }).catch(() => {
+              this.loadingSignatures.delete(targetEntityId);
+            });
+          }
+          continue;
+        }
         const count = Math.max(1, instanceCount);
         const geometry = buildGeometry(comp);
         const material = new THREE13__namespace.MeshStandardMaterial({ color: "#ffffff" });
@@ -4237,15 +4384,32 @@ var _InstancedMeshSystem = class _InstancedMeshSystem {
         comp.instancedMesh = instancedMesh;
         this.geometrySignatures.set(entityId, geometrySignature);
       } else {
-        const im = comp.instancedMesh;
-        const count = comp.instances.length;
-        for (let i = 0; i < count; i++) {
-          instanceTransformToMatrix4(comp.instances[i], _matrix);
-          im.setMatrixAt(i, _matrix);
+        if (comp.meshKind === "model") {
+          const entries = this.modelMeshEntries.get(entityId);
+          if (entries) {
+            const count = comp.instances.length;
+            for (const entry of entries) {
+              for (let i = 0; i < count; i++) {
+                instanceTransformToMatrix4(comp.instances[i], _matrix);
+                _modelMatrix.multiplyMatrices(_matrix, entry.localMatrix);
+                entry.instancedMesh.setMatrixAt(i, _modelMatrix);
+              }
+              entry.instancedMesh.instanceMatrix.needsUpdate = true;
+              entry.instancedMesh.castShadow = comp.castShadow;
+              entry.instancedMesh.receiveShadow = comp.receiveShadow;
+            }
+          }
+        } else {
+          const im = comp.instancedMesh;
+          const count = comp.instances.length;
+          for (let i = 0; i < count; i++) {
+            instanceTransformToMatrix4(comp.instances[i], _matrix);
+            im.setMatrixAt(i, _matrix);
+          }
+          im.instanceMatrix.needsUpdate = true;
+          im.castShadow = comp.castShadow;
+          im.receiveShadow = comp.receiveShadow;
         }
-        im.instanceMatrix.needsUpdate = true;
-        im.castShadow = comp.castShadow;
-        im.receiveShadow = comp.receiveShadow;
       }
     }
   }