lecodes-cli 0.17.1 → 0.17.2

package/runtime/sdk/gl/Shape.ts

@@ -28,6 +28,11 @@ export class Shape extends Aspect<"shape", Node> {
   cylinder?: { halfHeight: number, radius: number }
   /** Capsule aligned on Y: half-height of the cylinder section + radius. */
   capsule?: { halfHeight: number, radius: number }
+  /** The node's own triangles (a Mesh's geometry or a Model's GLB, world scale applied).
+   *  `true` = exact triangle mesh — static/kinematic bodies, triggers, characters' ground and picking
+   *  only (a dynamic body can't be a triangle mesh; Physics throws). `'convex'` = convex hull of the
+   *  vertices, works for dynamic bodies too. A Model uses its bind pose (skinned parts skipped). */
+  mesh?: boolean | "convex"
   /** Whether pointer rays can hit this shape (click / touchstart). Default true. */
   raycast = true
 
@@ -70,13 +75,44 @@ export class Shape extends Aspect<"shape", Node> {
     if (!this.raycast && this._bodyId) _creator.physicsSetPickable(this._bodyId, false)
   }
 
+  /** @internal true for an exact triangle mesh — Physics refuses a dynamic body on it. */
+  get _isTriangleMesh(): boolean { return this.mesh === true }
+
   private _build(): number {
+    if (this.mesh) return this._buildMesh(this.mesh === "convex")
     if (this.sphere !== undefined) return _creator.physicsBuildSphere(this.sphere)
     if (this.cylinder) return _creator.physicsBuildCylinder(this.cylinder.halfHeight, this.cylinder.radius)
     if (this.capsule) return _creator.physicsBuildCapsule(this.capsule.halfHeight, this.capsule.radius)
     if (this.box) return _creator.physicsBuildBox(cx(this.box), cy(this.box), cz(this.box))
+    return this._buildAutoBox()
+  }
+
+  // mesh: a Mesh node hands its CPU geometry over; anything else is tried as a GLB root (the host
+  // reads the asset's triangles itself — 0 if the node is neither). Always × world scale: the
+  // triangles are node-local, so the collider must follow the rendered size.
+  private _buildMesh(convex: boolean): number {
+    if (!_creator.physicsBuildMesh) {
+      console.warn("Shape { mesh } needs a newer host — falling back to a box")
+      return this._buildAutoBox()
+    }
+    const s = this.node.worldScale
+    const geom = this.node.geometry
+    let id = 0
+    if (geom) {
+      if (geom._meshKind !== 0) throw new Error("Shape { mesh } needs a triangle geometry (not edges/vertices)")
+      id = _creator.physicsBuildMesh(geom.vertices, Uint32Array.from(geom.indices), convex, s.x, s.y, s.z)
+    } else {
+      id = _creator.physicsBuildMeshFromEntity(this.node.id, convex, s.x, s.y, s.z)
+    }
+    if (!id) {
+      console.warn(`Shape { mesh } could not build a ${convex ? "convex hull" : "triangle mesh"} for "${this.node.name}" (no triangles / not a Mesh or Model) — falling back to a box`)
+      return this._buildAutoBox()
+    }
+    return id
+  }
 
-    // auto: a box from the mesh AABB × world scale (so the physical box matches the rendered size).
+  // auto: a box from the mesh AABB × world scale (so the physical box matches the rendered size).
+  private _buildAutoBox(): number {
     const s = this.node.worldScale
     let hx = 0.5, hy = 0.5, hz = 0.5
     const geom = this.node.geometry

package/runtime/sdk/gl/Trigger.ts

@@ -1,46 +1,50 @@
-// A trigger zone, as an aspect on a 3D Node. Requires a Shape (its geometry); creates a static SENSOR
-// body from it, so a physics body overlapping the zone fires the node's 'enter' / 'exit' events
-// instead of colliding. A trigger does not block movement, and is still pointer-pickable.
-//
-//   const goal = new Mesh(box(), material)
-//     .aspect(Shape, { box: [1, 2, 1] })
-//     .aspect(Trigger)
-//   goal.addEventListener('enter', other => win(other))
-//   goal.addEventListener('exit',  other => …)
-
-import { Aspect } from "../core/Aspect"
-import { cx, cy, cz, type Vec3Like } from "../math/vec"
-import { Shape } from "./Shape"
-import { ensurePhysicsEvents } from "./physicsEvents"
-import type { Node } from "./Node"
-
-export class Trigger extends Aspect<"trigger", Node> {
-  static readonly aspect = "trigger"
-
-  private _bodyId = 0
-  /** Native body id (0 if no physics support). */
-  get id(): number { return this._bodyId }
-
-  onAttach(): void {
-    if (!_creator.physicsHasSupport || !_creator.physicsHasSupport()) return
-    const shape = this.node.get(Shape)
-    if (!shape) {
-      throw new Error("Trigger requires a Shape aspect — add it first: node.aspect(Shape, {…}).aspect(Trigger)")
-    }
-    const shapeId = shape._claim()
-    this._bodyId = _creator.physicsCreateBody(this.node.id, shapeId, 0 /* static */, 0, true /* sensor */, false)
-    shape._ownBody(this._bodyId)
-    ensurePhysicsEvents() // routes overlap events → the node's 'enter' / 'exit'
-  }
-
-  onDetach(): void {
-    if (this._bodyId) { _creator.physicsRemoveBody(this._bodyId); this._bodyId = 0 }
-    this.node.get(Shape)?._recreatePickBody()
-  }
-
-  /** Reposition the trigger zone to a world point. */
-  moveTo(p: Vec3Like): this {
-    if (this._bodyId) _creator.physicsSetBodyPosition(this._bodyId, cx(p), cy(p), cz(p))
-    return this
-  }
-}
+// A trigger zone, as an aspect on a 3D Node. Requires a Shape (its geometry); creates a static SENSOR
+// body from it, so a physics body overlapping the zone fires the node's 'enter' / 'exit' events
+// instead of colliding. A trigger does not block movement, and is still pointer-pickable.
+//
+//   const goal = new Mesh(box(), material)
+//     .aspect(Shape, { box: [1, 2, 1] })
+//     .aspect(Trigger)
+//   goal.addEventListener('enter', other => win(other))
+//   goal.addEventListener('exit',  other => …)
+
+import { Aspect } from "../core/Aspect"
+import { cx, cy, cz, type Vec3Like } from "../math/vec"
+import { Shape } from "./Shape"
+import { ensurePhysicsEvents } from "./physicsEvents"
+import type { Node } from "./Node"
+
+export class Trigger extends Aspect<"trigger", Node> {
+  static readonly aspect = "trigger"
+
+  private _bodyId = 0
+  /** Native body id (0 if no physics support). */
+  get id(): number { return this._bodyId }
+
+  onAttach(): void {
+    if (!_creator.physicsHasSupport || !_creator.physicsHasSupport()) return
+    const shape = this.node.get(Shape)
+    if (!shape) {
+      throw new Error("Trigger requires a Shape aspect — add it first: node.aspect(Shape, {…}).aspect(Trigger)")
+    }
+    const shapeId = shape._claim()
+    this._bodyId = _creator.physicsCreateBody(this.node.id, shapeId, 0 /* static */, 0, true /* sensor */, false)
+    shape._ownBody(this._bodyId)
+    ensurePhysicsEvents() // routes overlap events → the node's 'enter' / 'exit'
+  }
+
+  onDetach(): void {
+    if (this._bodyId) { _creator.physicsRemoveBody(this._bodyId); this._bodyId = 0 }
+    const shape = this.node.get(Shape)
+    if (shape) {
+      shape._ownBody(0)          // the Shape held OUR body id — forget it, or its own detach removes it twice (native crash)
+      shape._recreatePickBody()
+    }
+  }
+
+  /** Reposition the trigger zone to a world point. */
+  moveTo(p: Vec3Like): this {
+    if (this._bodyId) _creator.physicsSetBodyPosition(this._bodyId, cx(p), cy(p), cz(p))
+    return this
+  }
+}