@series-inc/rundot-3d-engine 0.5.20 → 0.6.1

package/dist/systems/index.d.ts

@@ -299,24 +299,34 @@ declare class SphereColliderComponent extends Component {
 type MeshColliderType = "bounding_box" | "convex_hull";
 interface MeshColliderJSON extends ComponentJSON {
     type: "mesh_collider";
-    colliderType: MeshColliderType;
+    colliderType?: MeshColliderType;
     bodyType?: "static" | "kinematic" | "dynamic";
     isSensor?: boolean;
     enableCollisionEvents?: boolean;
+    excludeChildren?: boolean;
+    /** nodeOverrides wraps properties inside a `data` object */
+    data?: {
+        colliderType?: MeshColliderType;
+        bodyType?: "static" | "kinematic" | "dynamic";
+        isSensor?: boolean;
+        enableCollisionEvents?: boolean;
+        excludeChildren?: boolean;
+    };
 }
 declare class MeshColliderComponent extends Component {
-    static fromPrefabJSON(json: MeshColliderJSON, node: PrefabNode): MeshColliderComponent | null;
+    static fromPrefabJSON(json: MeshColliderJSON, node: PrefabNode | null): MeshColliderComponent | null;
     private rigidBody;
     private readonly meshName;
     private readonly colliderType;
     private readonly bodyType;
     private readonly isSensor?;
     private readonly enableCollisionEvents?;
-    constructor(meshName: string, colliderType?: MeshColliderType, bodyType?: RigidBodyType, isSensor?: boolean, enableCollisionEvents?: boolean);
+    private readonly excludeChildren;
+    constructor(meshName: string | null, colliderType?: MeshColliderType, bodyType?: RigidBodyType, isSensor?: boolean, enableCollisionEvents?: boolean, excludeChildren?: boolean);
+    /** Iterate meshes, optionally only direct children */
+    private static forEachMesh;
     /**
-     * Collect all vertex positions from a mesh group, including the root's own transform.
-     * Matches the editor's getAllVerticesFromStowMesh which uses parentWorldMatrixInverse
-     * (for a detached group, that's identity — so we just use child.matrixWorld directly).
+     * Collect all vertex positions from a mesh group.
      * Returns a flat Float32Array of [x,y,z, x,y,z, ...].
      */
     private static collectVertices;
@@ -328,6 +338,7 @@ declare class MeshColliderComponent extends Component {
      */
     private static computeBounds;
     protected onCreate(): void;
+    private createCollider;
     getRigidBody(): RigidBodyComponentThree | null;
 }
 

package/dist/systems/index.js

@@ -158,18 +158,25 @@ SphereColliderComponent = __decorateClass([
 import * as THREE3 from "three";
 var MeshColliderComponent = class extends Component {
   static fromPrefabJSON(json, node) {
-    const colliderType = json.colliderType ?? "bounding_box";
+    const props = json.data ?? json;
+    const colliderType = props.colliderType ?? "bounding_box";
     if (colliderType !== "bounding_box" && colliderType !== "convex_hull") {
-      console.warn(`Unknown mesh collider type: ${json.colliderType}`);
+      console.warn(`Unknown mesh collider type: ${props.colliderType}`);
       return null;
     }
+    const bodyType = props.bodyType ?? "static" /* STATIC */;
+    const isSensor = props.isSensor;
+    const enableCollisionEvents = props.enableCollisionEvents;
+    const excludeChildren = props.excludeChildren ?? false;
+    if (!node) {
+      return new MeshColliderComponent(null, colliderType, bodyType, isSensor, enableCollisionEvents, excludeChildren);
+    }
     const stowMeshComponent = node.components.find((c) => c.type === "stow_mesh");
     if (!stowMeshComponent) {
       console.warn("MeshColliderComponent requires a stow_mesh component on the same node");
       return null;
     }
-    const bodyType = json.bodyType ?? "static" /* STATIC */;
-    return new MeshColliderComponent(stowMeshComponent.mesh.assetId, colliderType, bodyType, json.isSensor, json.enableCollisionEvents);
+    return new MeshColliderComponent(stowMeshComponent.mesh.assetId, colliderType, bodyType, isSensor, enableCollisionEvents, excludeChildren);
   }
   rigidBody = null;
   meshName;
@@ -177,37 +184,48 @@ var MeshColliderComponent = class extends Component {
   bodyType;
   isSensor;
   enableCollisionEvents;
-  constructor(meshName, colliderType = "bounding_box", bodyType = "static" /* STATIC */, isSensor, enableCollisionEvents) {
+  excludeChildren;
+  constructor(meshName, colliderType = "bounding_box", bodyType = "static" /* STATIC */, isSensor, enableCollisionEvents, excludeChildren = false) {
     super();
     this.meshName = meshName;
     this.colliderType = colliderType;
     this.bodyType = bodyType;
     this.isSensor = isSensor;
     this.enableCollisionEvents = enableCollisionEvents;
+    this.excludeChildren = excludeChildren;
+  }
+  /** Iterate meshes, optionally only direct children */
+  static forEachMesh(root, excludeChildren, fn) {
+    if (excludeChildren) {
+      for (const child of root.children) {
+        if (child.isMesh) fn(child);
+      }
+    } else {
+      root.traverse((child) => {
+        if (child.isMesh) fn(child);
+      });
+    }
   }
   /**
-   * Collect all vertex positions from a mesh group, including the root's own transform.
-   * Matches the editor's getAllVerticesFromStowMesh which uses parentWorldMatrixInverse
-   * (for a detached group, that's identity — so we just use child.matrixWorld directly).
+   * Collect all vertex positions from a mesh group.
    * Returns a flat Float32Array of [x,y,z, x,y,z, ...].
    */
-  static collectVertices(meshGroup, scale) {
+  static collectVertices(meshGroup, scale, excludeChildren = false) {
     meshGroup.updateMatrixWorld(true);
     const allVertices = [];
     const vertex = new THREE3.Vector3();
-    meshGroup.traverse((child) => {
-      if (child instanceof THREE3.Mesh && child.geometry) {
-        const posAttr = child.geometry.getAttribute("position");
-        if (!posAttr) return;
-        for (let i = 0; i < posAttr.count; i++) {
-          vertex.fromBufferAttribute(posAttr, i);
-          vertex.applyMatrix4(child.matrixWorld);
-          allVertices.push(
-            vertex.x * scale.x,
-            vertex.y * scale.y,
-            vertex.z * scale.z
-          );
-        }
+    MeshColliderComponent.forEachMesh(meshGroup, excludeChildren, (mesh) => {
+      if (!mesh.geometry) return;
+      const posAttr = mesh.geometry.getAttribute("position");
+      if (!posAttr) return;
+      for (let i = 0; i < posAttr.count; i++) {
+        vertex.fromBufferAttribute(posAttr, i);
+        vertex.applyMatrix4(mesh.matrixWorld);
+        allVertices.push(
+          vertex.x * scale.x,
+          vertex.y * scale.y,
+          vertex.z * scale.z
+        );
       }
     });
     return new Float32Array(allVertices);
@@ -218,21 +236,20 @@ var MeshColliderComponent = class extends Component {
    * detached cached mesh group is equivalent to identity. So we use child.matrixWorld
    * directly, which includes the mesh group root's own transform — exactly as the editor does.
    */
-  static computeBounds(meshGroup, scale) {
+  static computeBounds(meshGroup, scale, excludeChildren = false) {
     meshGroup.updateMatrixWorld(true);
     const box = new THREE3.Box3();
     let foundMesh = false;
-    meshGroup.traverse((child) => {
-      if (child instanceof THREE3.Mesh && child.geometry) {
-        foundMesh = true;
-        if (!child.geometry.boundingBox) {
-          child.geometry.computeBoundingBox();
-        }
-        if (child.geometry.boundingBox) {
-          const tempBox = child.geometry.boundingBox.clone();
-          tempBox.applyMatrix4(child.matrixWorld);
-          box.union(tempBox);
-        }
+    MeshColliderComponent.forEachMesh(meshGroup, excludeChildren, (mesh) => {
+      if (!mesh.geometry) return;
+      foundMesh = true;
+      if (!mesh.geometry.boundingBox) {
+        mesh.geometry.computeBoundingBox();
+      }
+      if (mesh.geometry.boundingBox) {
+        const tempBox = mesh.geometry.boundingBox.clone();
+        tempBox.applyMatrix4(mesh.matrixWorld);
+        box.union(tempBox);
       }
     });
     if (!foundMesh || box.isEmpty()) return null;
@@ -245,40 +262,47 @@ var MeshColliderComponent = class extends Component {
     return { size, center };
   }
   onCreate() {
-    const stowkit = StowKitSystem.getInstance();
-    stowkit.getMesh(this.meshName).then((meshGroup) => {
-      if (!this.isAttached()) return;
-      const scale = this.gameObject.scale.clone();
-      if (this.colliderType === "convex_hull") {
-        const vertices = MeshColliderComponent.collectVertices(meshGroup, scale);
-        if (vertices.length < 9) {
-          console.warn("MeshColliderComponent: Not enough vertices for convex hull");
-          return;
-        }
+    if (this.meshName) {
+      const stowkit = StowKitSystem.getInstance();
+      stowkit.getMesh(this.meshName).then((meshGroup) => {
+        if (!this.isAttached()) return;
+        this.createCollider(meshGroup);
+      });
+    } else {
+      this.createCollider(this.gameObject);
+    }
+  }
+  createCollider(meshRoot) {
+    const scale = this.gameObject.scale.clone();
+    if (this.colliderType === "convex_hull") {
+      const vertices = MeshColliderComponent.collectVertices(meshRoot, scale, this.excludeChildren);
+      if (vertices.length < 9) {
+        console.warn("MeshColliderComponent: Not enough vertices for convex hull");
+        return;
+      }
+      this.rigidBody = new RigidBodyComponentThree({
+        type: this.bodyType,
+        shape: "convex_hull" /* CONVEX_HULL */,
+        vertices,
+        centerOffset: new THREE3.Vector3(0, 0, 0),
+        isSensor: this.isSensor,
+        enableCollisionEvents: this.enableCollisionEvents
+      });
+      this.gameObject.addComponent(this.rigidBody);
+    } else {
+      const bounds = MeshColliderComponent.computeBounds(meshRoot, scale, this.excludeChildren);
+      if (bounds) {
         this.rigidBody = new RigidBodyComponentThree({
           type: this.bodyType,
-          shape: "convex_hull" /* CONVEX_HULL */,
-          vertices,
-          centerOffset: new THREE3.Vector3(0, 0, 0),
+          shape: "box" /* BOX */,
+          size: bounds.size,
+          centerOffset: bounds.center,
           isSensor: this.isSensor,
           enableCollisionEvents: this.enableCollisionEvents
         });
         this.gameObject.addComponent(this.rigidBody);
-      } else {
-        const bounds = MeshColliderComponent.computeBounds(meshGroup, scale);
-        if (bounds) {
-          this.rigidBody = new RigidBodyComponentThree({
-            type: this.bodyType,
-            shape: "box" /* BOX */,
-            size: bounds.size,
-            centerOffset: bounds.center,
-            isSensor: this.isSensor,
-            enableCollisionEvents: this.enableCollisionEvents
-          });
-          this.gameObject.addComponent(this.rigidBody);
-        }
       }
-    });
+    }
   }
   getRigidBody() {
     return this.rigidBody;