@relu-interactives/spatial-ecs 0.2.4 → 0.2.6

package/dist/systems/index.cjs

@@ -1251,6 +1251,138 @@ var _Postprocessing = class _Postprocessing extends Component {
 };
 __name(_Postprocessing, "Postprocessing");
 var Postprocessing = _Postprocessing;
+var DEFAULT_MESH_GEOMETRY_PARAMETERS = {
+  capsule: { radius: 0.5, height: 1 },
+  cube: { width: 1, height: 1, depth: 1 },
+  cylinder: { radius: 0.5, height: 1 },
+  plane: { width: 100, height: 100 },
+  sphere: { radius: 0.5 }
+};
+var GEOMETRY_TYPE_BY_KIND = {
+  capsule: "CapsuleGeometry",
+  cube: "BoxGeometry",
+  cylinder: "CylinderGeometry",
+  model: "Model",
+  plane: "PlaneGeometry",
+  sphere: "SphereGeometry"
+};
+var _MeshGeometryComponent = class _MeshGeometryComponent extends Component {
+  constructor(kind, object, parameters, options) {
+    super();
+    this.kind = kind;
+    this.geometryType = GEOMETRY_TYPE_BY_KIND[kind];
+    this.object = object;
+    this.modelName = options?.modelName ?? "";
+    this.castShadow = options?.castShadow ?? false;
+    this.receiveShadow = options?.receiveShadow ?? false;
+    switch (kind) {
+      case "cube":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
+          ...parameters
+        };
+        break;
+      case "plane":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.plane,
+          ...parameters
+        };
+        break;
+      case "sphere":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere,
+          ...parameters
+        };
+        break;
+      case "cylinder":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder,
+          ...parameters
+        };
+        break;
+      case "capsule":
+        this.parameters = {
+          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule,
+          ...parameters
+        };
+        break;
+      case "model":
+        this.parameters = {};
+        break;
+    }
+  }
+};
+__name(_MeshGeometryComponent, "MeshGeometryComponent");
+var MeshGeometryComponent = _MeshGeometryComponent;
+
+// core/components/InstancedMesh.ts
+var DEFAULT_INSTANCE_TRANSFORM = {
+  position: { x: 0, y: 0, z: 0 },
+  rotation: { x: 0, y: 0, z: 0 },
+  scale: { x: 1, y: 1, z: 1 }
+};
+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
+};
+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 ?? {}
+    };
+    this.castShadow = options?.castShadow ?? false;
+    this.receiveShadow = options?.receiveShadow ?? false;
+    this.instances = options?.instances && options.instances.length > 0 ? options.instances : [{ ...DEFAULT_INSTANCE_TRANSFORM }];
+    this.instancedMesh = null;
+  }
+  /** Sanitize and return a copy of the current mesh parameters with valid values. */
+  getSanitizedParameters() {
+    const MIN_DIM = 0.01;
+    const MIN_RAD = 1e-3;
+    const sanitize = /* @__PURE__ */ __name((v, min) => Number.isFinite(v) ? Math.max(min, v) : min, "sanitize");
+    switch (this.meshKind) {
+      case "cube": {
+        const p = this.meshParameters;
+        return {
+          width: sanitize(p.width, MIN_DIM),
+          height: sanitize(p.height, MIN_DIM),
+          depth: sanitize(p.depth, MIN_DIM)
+        };
+      }
+      case "plane": {
+        const p = this.meshParameters;
+        return {
+          width: sanitize(p.width, MIN_DIM),
+          height: sanitize(p.height, MIN_DIM)
+        };
+      }
+      case "sphere": {
+        const p = this.meshParameters;
+        return { radius: sanitize(p.radius, MIN_RAD) };
+      }
+      case "cylinder":
+      case "capsule": {
+        const p = this.meshParameters;
+        return {
+          radius: sanitize(p.radius, MIN_RAD),
+          height: sanitize(p.height, MIN_DIM)
+        };
+      }
+      case "model":
+        return DEFAULT_MESH_GEOMETRY_PARAMETERS.cube;
+    }
+  }
+};
+__name(_InstancedMeshComponent, "InstancedMeshComponent");
+var InstancedMeshComponent = _InstancedMeshComponent;
 
 // core/components/Physics.ts
 var DEFAULT_RIGIDBODY_STATE = {
@@ -1611,69 +1743,6 @@ var _MaterialComponent = class _MaterialComponent extends Component {
 };
 __name(_MaterialComponent, "MaterialComponent");
 var MaterialComponent = _MaterialComponent;
-var DEFAULT_MESH_GEOMETRY_PARAMETERS = {
-  capsule: { radius: 0.5, height: 1 },
-  cube: { width: 1, height: 1, depth: 1 },
-  cylinder: { radius: 0.5, height: 1 },
-  plane: { width: 100, height: 100 },
-  sphere: { radius: 0.5 }
-};
-var GEOMETRY_TYPE_BY_KIND = {
-  capsule: "CapsuleGeometry",
-  cube: "BoxGeometry",
-  cylinder: "CylinderGeometry",
-  model: "Model",
-  plane: "PlaneGeometry",
-  sphere: "SphereGeometry"
-};
-var _MeshGeometryComponent = class _MeshGeometryComponent extends Component {
-  constructor(kind, object, parameters, options) {
-    super();
-    this.kind = kind;
-    this.geometryType = GEOMETRY_TYPE_BY_KIND[kind];
-    this.object = object;
-    this.modelName = options?.modelName ?? "";
-    this.castShadow = options?.castShadow ?? false;
-    this.receiveShadow = options?.receiveShadow ?? false;
-    switch (kind) {
-      case "cube":
-        this.parameters = {
-          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cube,
-          ...parameters
-        };
-        break;
-      case "plane":
-        this.parameters = {
-          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.plane,
-          ...parameters
-        };
-        break;
-      case "sphere":
-        this.parameters = {
-          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.sphere,
-          ...parameters
-        };
-        break;
-      case "cylinder":
-        this.parameters = {
-          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.cylinder,
-          ...parameters
-        };
-        break;
-      case "capsule":
-        this.parameters = {
-          ...DEFAULT_MESH_GEOMETRY_PARAMETERS.capsule,
-          ...parameters
-        };
-        break;
-      case "model":
-        this.parameters = {};
-        break;
-    }
-  }
-};
-__name(_MeshGeometryComponent, "MeshGeometryComponent");
-var MeshGeometryComponent = _MeshGeometryComponent;
 
 // core/components/Model.ts
 var _ModelComponent = class _ModelComponent extends Component {
@@ -4068,6 +4137,276 @@ 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) {
+    case "cube": {
+      const params = p;
+      return new THREE13__namespace.BoxGeometry(params.width, params.height, params.depth);
+    }
+    case "plane": {
+      const params = p;
+      return new THREE13__namespace.PlaneGeometry(params.width, params.height);
+    }
+    case "sphere": {
+      const params = p;
+      return new THREE13__namespace.SphereGeometry(params.radius, 24, 24);
+    }
+    case "cylinder": {
+      const params = p;
+      return new THREE13__namespace.CylinderGeometry(params.radius, params.radius, params.height, 20);
+    }
+    case "capsule": {
+      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");
+var _position = new THREE13__namespace.Vector3();
+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");
+  _quaternion.setFromEuler(_euler);
+  _scale.set(inst.scale.x, inst.scale.y, inst.scale.z);
+  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();
+    /** Entities whose GLTF model is currently loading. Prevents duplicate load triggers. */
+    this.loadingEntities = /* @__PURE__ */ new Set();
+    /** 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);
+    }
+    for (const trackedId of this.loadingEntities) {
+      if (!alive.has(trackedId)) this.loadingEntities.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;
+      const objectRef = world.getComponent(entityId, Object3DRef);
+      const anchor = objectRef?.object ?? null;
+      if (!anchor) continue;
+      const instanceCount = comp.instances.length;
+      const geometrySignature = comp.meshKind === "model" ? `model:${comp.modelPath}:${instanceCount}` : `${comp.meshKind}:${JSON.stringify(comp.meshParameters)}:${instanceCount}`;
+      const needsRebuild = comp.instancedMesh === null || this.geometrySignatures.get(entityId) !== geometrySignature;
+      if (needsRebuild) {
+        if (comp.instancedMesh) {
+          anchor.remove(comp.instancedMesh);
+          if (comp.instancedMesh.isInstancedMesh) {
+            disposePrimitiveInstancedMesh(comp.instancedMesh);
+          } else {
+            disposeModelGroup(comp.instancedMesh);
+          }
+          comp.instancedMesh = null;
+        }
+        this.loadingEntities.delete(entityId);
+        this.modelMeshEntries.delete(entityId);
+        if (comp.meshKind === "model") {
+          if (comp.modelPath && !this.loadingEntities.has(entityId)) {
+            this.loadingEntities.add(entityId);
+            const targetSignature = geometrySignature;
+            const targetEntityId = entityId;
+            loadGLTF(comp.modelPath).then((gltf) => {
+              if (!world.hasEntity(targetEntityId)) {
+                this.loadingEntities.delete(targetEntityId);
+                return;
+              }
+              const currentComp = world.getComponent(
+                targetEntityId,
+                InstancedMeshComponent
+              );
+              if (!currentComp) {
+                this.loadingEntities.delete(targetEntityId);
+                return;
+              }
+              const currentSig = `model:${currentComp.modelPath}:${currentComp.instances.length}`;
+              if (currentSig !== targetSignature) {
+                this.loadingEntities.delete(targetEntityId);
+                return;
+              }
+              const currentRef = world.getComponent(targetEntityId, Object3DRef);
+              const currentAnchor = currentRef?.object ?? null;
+              if (!currentAnchor) {
+                this.loadingEntities.delete(targetEntityId);
+                return;
+              }
+              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.loadingEntities.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.loadingEntities.delete(targetEntityId);
+            }).catch(() => {
+              this.loadingEntities.delete(targetEntityId);
+            });
+          }
+          continue;
+        }
+        const count = Math.max(1, instanceCount);
+        const geometry = buildGeometry(comp);
+        const material = new THREE13__namespace.MeshStandardMaterial({ color: "#ffffff" });
+        const instancedMesh = new THREE13__namespace.InstancedMesh(geometry, material, count);
+        instancedMesh.castShadow = comp.castShadow;
+        instancedMesh.receiveShadow = comp.receiveShadow;
+        for (let i = 0; i < count; i++) {
+          const inst = comp.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);
+          instancedMesh.setMatrixAt(i, _matrix);
+        }
+        instancedMesh.instanceMatrix.needsUpdate = true;
+        anchor.add(instancedMesh);
+        comp.instancedMesh = instancedMesh;
+        this.geometrySignatures.set(entityId, geometrySignature);
+      } else {
+        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;
+        }
+      }
+    }
+  }
+};
+__name(_InstancedMeshSystem, "InstancedMeshSystem");
+var InstancedMeshSystem = _InstancedMeshSystem;
 
 // core/systems/RenderSystem.ts
 var _RenderSystem = class _RenderSystem {
@@ -5103,6 +5442,7 @@ exports.AudioSystem = AudioSystem;
 exports.CameraSyncSystem = CameraSyncSystem;
 exports.EnvironmentSyncSystem = EnvironmentSyncSystem;
 exports.InputSystem = InputSystem;
+exports.InstancedMeshSystem = InstancedMeshSystem;
 exports.KeyboardKeys = KeyboardKeys;
 exports.LightSyncSystem = LightSyncSystem;
 exports.MaterialSyncSystem = MaterialSyncSystem;