lecodes-sdk 2.4.1 → 2.4.3

package/src/gl/animation/IK.ts

@@ -79,8 +79,6 @@ abstract class Chain<Name extends string> extends Aspect<Name, Node> {
     this._ik = 0
     this._rig = undefined
   }
-  onReconfigure(): void { this.push() }
-
   protected params(): Float32Array {
     const p = new Float32Array(P.COUNT)
     p[P.WEIGHT] = this._weight

package/src/gl/nav/NavAgent.ts

@@ -74,26 +74,26 @@ export class NavAgent extends Aspect<"agent", Node, NavAgentEvents> {
 
   /** Agent radius (metres). Defaults to the navmesh's. */
   get radius(): number { return this._radius }
-  set radius(v: number) { this._radius = v; this._dirty = true }
+  set radius(v: number) { this._radius = v; this.dirty() }
   get height(): number { return this._height }
-  set height(v: number) { this._height = v; this._dirty = true }
+  set height(v: number) { this._height = v; this.dirty() }
   /** Top speed (m/s). */
   get speed(): number { return this._speed }
-  set speed(v: number) { this._speed = v; this._dirty = true }
+  set speed(v: number) { this._speed = v; this.dirty() }
   get acceleration(): number { return this._acceleration }
-  set acceleration(v: number) { this._acceleration = v; this._dirty = true }
+  set acceleration(v: number) { this._acceleration = v; this.dirty() }
   /** Local (agent-vs-agent) avoidance quality. */
   get avoidance(): NavAgentAvoidance { return this._avoidance }
-  set avoidance(v: NavAgentAvoidance) { this._avoidance = v; this._dirty = true }
+  set avoidance(v: NavAgentAvoidance) { this._avoidance = v; this.dirty() }
   /** Separation force weight (0 = none). */
   get separation(): number { return this._separation }
-  set separation(v: number) { this._separation = v; this._dirty = true }
+  set separation(v: number) { this._separation = v; this.dirty() }
   /** Area names this agent may walk (default: all). */
   get include(): string[] | undefined { return this._include }
-  set include(v: string[] | undefined) { this._include = v; this._dirty = true }
+  set include(v: string[] | undefined) { this._include = v; this.dirty() }
   /** Area names this agent never enters. */
   get exclude(): string[] | undefined { return this._exclude }
-  set exclude(v: string[] | undefined) { this._exclude = v; this._dirty = true }
+  set exclude(v: string[] | undefined) { this._exclude = v; this.dirty() }
 
   state: NavAgentState = "idle"
   /** The current velocity after avoidance (m/s). */
@@ -111,7 +111,6 @@ export class NavAgent extends Aspect<"agent", Node, NavAgentEvents> {
   private _target: Vec3 | null = null
   /** velocity-driven (`move`) rather than target-driven */
   private _steering = false
-  private _dirty = false
   private _faceX = 0
   private _faceZ = -1
   private _retryAt = 0
@@ -125,7 +124,12 @@ export class NavAgent extends Aspect<"agent", Node, NavAgentEvents> {
     this._join()
   }
 
-  onReconfigure(): void { this._dirty = true }
+  /** A parameter changed: push the agent's params to the crowd (a no-op until it has a slot —
+   *  `_join` sends them with the add). */
+  protected flush(): void {
+    const crowd = this._crowd
+    if (crowd && this._slot >= 0 && crowd._mesh === NavMesh.active) _creatorNav.crowdSetParams(crowd._id, this._slot, this.params())
+  }
 
   onDetach(): void {
     this._leave()
@@ -216,7 +220,6 @@ export class NavAgent extends Aspect<"agent", Node, NavAgentEvents> {
     if (slot < 0) { this._retryAt = crowd._step + JOIN_RETRY_STEPS; return false }
     this._crowd = crowd
     this._slot = slot
-    this._dirty = false
     this._lastSeen = -1
     crowd._agents.add(this)
     if (this._target && !_creatorNav.crowdSetTarget(crowd._id, slot, this._target.x, this._target.y, this._target.z)) this._target = null
@@ -253,7 +256,6 @@ export class NavAgent extends Aspect<"agent", Node, NavAgentEvents> {
     }
     const crowd = this._crowd!
     if (crowd._mesh !== NavMesh.active) { this._leave(); return }
-    if (this._dirty) { this._dirty = false; _creatorNav.crowdSetParams(crowd._id, this._slot, this.params()) }
     if (crowd._step === this._lastSeen) return   // the crowd has not advanced since (a frame with no step)
     this._lastSeen = crowd._step
     const b = crowd._buf

package/src/gl/physics/Physics.ts

@@ -72,11 +72,10 @@ export class Physics extends Aspect<"physics", Node> implements CompWriter {
    * `1`, ice `0.02`. A Vehicle's tires read the GROUND body's value, so this is the single number
    * that decides how well a car corners.
    *
-   * Change it at runtime by re-configuring — `floor.aspect(Physics, { friction: 0.02 })` (an ice
-   * patch) — or by assigning `floor.physics.friction = 0.02`; either way the setter pushes the new
-   * surface to the live body at once. (chisel keeps an instance setter whose name appears as an
-   * object-literal key anywhere in the bundle, so the config-object route survives tree-shaking
-   * even when no code reads `.friction`.)
+   * Live: `floor.physics.friction = 0.02` (an ice patch) pushes the new surface to the body at
+   * once. (chisel keeps an instance setter whose name appears as an object-literal key anywhere in
+   * the bundle, so `aspect(Physics, { friction })` at build survives tree-shaking even when no code
+   * reads `.friction`.)
    */
   get friction(): number { return this._friction }
   set friction(v: number) {

package/src/gl/physics/Shape.ts

@@ -18,6 +18,7 @@
 // (which follows the sim), rather than relying on the pick body.
 
 import { Aspect } from "../../core/Aspect"
+import type { FieldMeta } from "../../core/fields"
 import { cx, cy, cz, type Vec3Like } from "../../math/vec"
 import type { Node } from "../Node"
 
@@ -51,23 +52,42 @@ const dim = (v: number): number => Math.max(MIN_HALF, r4(v))
 export class Shape extends Aspect<"shape", Node> {
   static readonly aspect = "shape"
 
+  // Every dimension is LIVE and applies AT ONCE: a write rebuilds the geometry in place, the body
+  // keeping its id, velocity and place (a crouch, a live editor edit) — synchronous, because the
+  // caller reads the result back right away (`controller.resizing`, the node's height). A write that
+  // leaves the geometry's signature unchanged does nothing. `fit()` writes every field and rebuilds once.
+  private _box?: Vec3Like
+  private _sphere?: number
+  private _cylinder?: { halfHeight: number, radius: number }
+  private _capsule?: { halfHeight: number, radius: number }
+  private _mesh?: boolean | "convex"
+  private _heightfield?: boolean
+  private _origin?: Vec3Like
+  private _raycast = true
+
   /** Box half-extents [hx, hy, hz] (world units). */
-  box?: Vec3Like
+  get box(): Vec3Like | undefined { return this._box }
+  set box(v: Vec3Like | undefined) { this._box = v; this._changed() }
   /** Sphere radius. */
-  sphere?: number
+  get sphere(): number | undefined { return this._sphere }
+  set sphere(v: number | undefined) { this._sphere = v; this._changed() }
   /** Cylinder aligned on Y: half-height + radius. */
-  cylinder?: { halfHeight: number, radius: number }
+  get cylinder(): { halfHeight: number, radius: number } | undefined { return this._cylinder }
+  set cylinder(v: { halfHeight: number, radius: number } | undefined) { this._cylinder = v; this._changed() }
   /** Capsule aligned on Y: half-height of the cylinder section + radius. */
-  capsule?: { halfHeight: number, radius: number }
+  get capsule(): { halfHeight: number, radius: number } | undefined { return this._capsule }
+  set capsule(v: { halfHeight: number, radius: number } | undefined) { this._capsule = v; this._changed() }
   /** 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"
+  get mesh(): boolean | "convex" | undefined { return this._mesh }
+  set mesh(v: boolean | "convex" | undefined) { this._mesh = v; this._changed() }
   /** The node's terrain (`Terrain.create(...).node`) as a Jolt height field — the exact drawn grid,
    *  holes included (docs/terrain-plan.md). Static / kinematic / picking / character ground only,
    *  like `mesh: true`. `terrain.commit()` pushes edits into the live shape. */
-  heightfield?: boolean
+  get heightfield(): boolean | undefined { return this._heightfield }
+  set heightfield(v: boolean | undefined) { this._heightfield = v; this._changed() }
   /**
    * The shape's centre, relative to the node's origin — world units in the node's ROTATED frame
    * (the node's scale is ignored, exactly like the explicit dimensions above). Default [0, 0, 0].
@@ -81,15 +101,22 @@ export class Shape extends Aspect<"shape", Node> {
    * you would expect. With no `origin` an auto shape (`{}`) still centres itself on the node's own
    * mesh bounds — only explicit dimensions sit on the pivot by default.
    */
-  origin?: Vec3Like
-  /** Whether pointer rays can hit this shape (click / touchstart). Default true. */
-  raycast = true
+  get origin(): Vec3Like | undefined { return this._origin }
+  set origin(v: Vec3Like | undefined) { this._origin = v; this._changed() }
+  /** Whether pointer rays can hit this shape (click / touchstart). Default true. Live, at once. */
+  get raycast(): boolean { return this._raycast }
+  set raycast(v: boolean) { this._raycast = v; if (this._bodyId) _creator.physicsSetPickable(this._bodyId, v) }
+
+  /** Scene-editor inspector: the geometry fields (accessors, so they are listed here by name). */
+  static fields: FieldMeta<Shape> = {
+    box: {}, sphere: {}, cylinder: {}, capsule: {}, mesh: {}, heightfield: {}, origin: {}, raycast: {},
+  }
 
   private _shapeId = 0
   private _bodyId = 0
   /** Centre the "auto" box measured for itself — used when `origin` isn't set explicitly. */
   private _autoOrigin: [number, number, number] | null = null
-  /** Geometry props as of the last build (see onReconfigure). */
+  /** Geometry props as of the last build (see _changed). */
   private _sig = ""
 
   /** @internal native shape id (0 if the build has no physics). */
@@ -110,11 +137,10 @@ export class Shape extends Aspect<"shape", Node> {
     this.node._xfKind = 0
   }
 
-  /** Re-configuring (`node.aspect(Shape, { origin })`) rebuilds the geometry when a dimension, the
-   *  kind or the origin changed, and re-applies pickability. The body keeps its id and velocity. */
-  onReconfigure(): void {
-    if (this._signature() !== this._sig) this._rebuild()
-    if (this._bodyId) _creator.physicsSetPickable(this._bodyId, this.raycast)
+  /** A dimension, the kind or the origin was written: rebuild the geometry when it actually changed.
+   *  The body keeps its id and velocity. */
+  private _changed(): void {
+    if (this._shapeId && this._signature() !== this._sig) this._rebuild()
   }
 
   /**
@@ -134,14 +160,14 @@ export class Shape extends Aspect<"shape", Node> {
       console.warn(`Shape.fit: "${this.node.name}" has no geometry to measure yet (a model still loading, or a node with no mesh)`)
       return this
     }
-    this.box = f.box
-    this.sphere = f.sphere
-    this.cylinder = f.cylinder
-    this.capsule = f.capsule
-    if (kind === "mesh") this.mesh = true
-    else if (kind === "convex") this.mesh = "convex"
-    else if (kind !== undefined) this.mesh = undefined
-    this.origin = f.origin
+    this._box = f.box
+    this._sphere = f.sphere
+    this._cylinder = f.cylinder
+    this._capsule = f.capsule
+    if (kind === "mesh") this._mesh = true
+    else if (kind === "convex") this._mesh = "convex"
+    else if (kind !== undefined) this._mesh = undefined
+    this._origin = f.origin
     this._rebuild()
     return this
   }