lecodes-cli 0.18.0 → 0.18.2

package/runtime/sdk/gl/Shape.ts

@@ -98,6 +98,8 @@ export class Shape extends Aspect<"shape", Node> {
   onDetach(): void {
     if (this._bodyId) { _creator.physicsRemoveBody(this._bodyId); this._bodyId = 0 }
     if (this._shapeId) { _creator.physicsDestroyShape(this._shapeId); this._shapeId = 0 }
+    this.node._xf = 0
+    this.node._xfKind = 0
   }
 
   /** Re-configuring (`node.aspect(Shape, { origin })`) rebuilds the geometry when a dimension, the
@@ -206,14 +208,20 @@ export class Shape extends Aspect<"shape", Node> {
 
   // ---- body/shape lifetime --------------------------------------------------------------------
 
-  /** @internal Physics/Trigger take over: drop the pick body and hand back the shape id. */
+  /** @internal Physics/Trigger/CharacterController/Vehicle take over: drop the pick body and hand back
+   *  the shape id. The node's transform owner goes with the body (the new owner sets its own). */
   _claim(): number {
     if (this._bodyId) { _creator.physicsRemoveBody(this._bodyId); this._bodyId = 0 }
+    this.node._xf = 0
+    this.node._xfKind = 0
     return this._shapeId
   }
-  /** @internal Physics/Trigger report the body they created, so Shape owns its lifetime + pickability. */
+  /** @internal Physics/Trigger report the body they created, so Shape owns its lifetime + pickability.
+   *  0 = they are detaching and no longer own it. */
   _ownBody(bodyId: number): void {
     this._bodyId = bodyId
+    this.node._xf = bodyId          // route node.position writes to the body (see Node._setOwnedPosition)
+    this.node._xfKind = bodyId ? 2 : 0
     if (!this.raycast && bodyId) _creator.physicsSetPickable(bodyId, false)
   }
   /** @internal restore a pick-only body when Physics/Trigger detach but the Shape remains. */
@@ -223,6 +231,10 @@ export class Shape extends Aspect<"shape", Node> {
 
   private _createPickBody(): void {
     this._bodyId = _creator.physicsCreateBody(this.node.id, this._shapeId, 0, 0, false, /*pickOnly*/ true)
+    // Route position writes here too: the pick body is a static snapshot, so without this a moved node
+    // would keep taking its clicks at the old place.
+    this.node._xf = this._bodyId
+    this.node._xfKind = this._bodyId ? 2 : 0
     if (!this.raycast && this._bodyId) _creator.physicsSetPickable(this._bodyId, false)
   }
 
@@ -235,18 +247,45 @@ export class Shape extends Aspect<"shape", Node> {
   private _rebuild(): void {
     if (!this._shapeId) return               // never attached, or a build without physics
     const previous = this._shapeId
+    const previousSig = this._sig
     const id = this._build()
     if (!id) return                          // build failed — keep what works
+
+    // A CharacterController owns its shape and can REFUSE the swap: standing up under a pipe doesn't
+    // fit. Nothing is half-applied on refusal, so the fix is to stay UNCOMMITTED — leave `_sig` on the
+    // old geometry, and the next `node.aspect(Shape, …)` with the same dimensions sees a difference
+    // and tries again. That retry is the headroom test, and it is exact (the real capsule, not a ray).
+    const charId = this.node._xfKind === 1 ? this.node._xf : 0
+    if (charId) {
+      if (_creator.characterSetShape?.(charId, id)) {
+        this._shapeId = id
+        this._resizeRefused = false
+        _creator.physicsDestroyShape(previous)
+      } else {
+        _creator.physicsDestroyShape(id)     // drop what we just built; the old collider stays live
+        this._sig = previousSig
+        this._resizeRefused = !!_creator.characterSetShape
+        if (!_creator.characterSetShape) {
+          console.warn(`Shape: this host can't resize a live CharacterController — "${this.node.name}" keeps its current collider`)
+        }
+      }
+      return
+    }
+
     this._shapeId = id
     if (this._bodyId) {
       if (_creator.physicsSetBodyShape) _creator.physicsSetBodyShape(this._bodyId, id, true)
       else console.warn("Shape: this host can't re-shape a live body — the new dimensions apply from the next attach")
     } else {
-      console.warn(`Shape: "${this.node.name}"'s geometry is owned by a CharacterController / Vehicle — re-attach it to pick up the new dimensions`)
+      console.warn(`Shape: "${this.node.name}"'s geometry is owned by a Vehicle — re-attach it to pick up the new dimensions`)
     }
     _creator.physicsDestroyShape(previous)
   }
 
+  /** @internal True while a requested resize has been refused — the fields say one thing, the engine
+   *  is still using another. Surfaced as `controller.resizing`. */
+  _resizeRefused = false
+
   private _build(): number {
     this._autoOrigin = null
     this._sig = this._signature()

package/runtime/sdk/gl/Trigger.ts

@@ -1,50 +1,45 @@
-// 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
-  }
-}
+// 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 { 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()
+    }
+  }
+
+  // No moveTo(): `node.position = p` moves the node AND the sensor body it owns (see Node._xf).
+}