reze-engine 0.67.0 → 0.68.0

package/dist/shaders/shadow-api.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 3×3 PCF over one cascade's map, for a point already in that cascade's NDC.
+ *
+ * Shared with the materials, so an effect's shadow and her own shadow soften
+ * alike. The sampler is linear-filtered, which makes each tap a 2×2 bilinear
+ * compare. Unrolled — Safari's Metal backend doesn't unroll nested shadow
+ * loops reliably. The body expects `ndc` in scope and returns.
+ */
+export declare const pcf9: (map: string, ts: string, sampler?: string) => string;
+/** Bindings the real accessor takes, from `binding` upward. */
+export declare const SHADOW_API_BINDINGS = 5;
+/**
+ * `rzShadow(p)`: how much of the sun reaches world point `p` — 1 lit, 0 in a
+ * caster's shadow, soft in between.
+ *
+ * With `on`, declares five bindings from `binding`:
+ *   +0 the light uniform (the sun's direction, and in .w the shadow switch)
+ *   +1 the cascade view-projections, then the caster sphere
+ *   +2 the near cascade's map   +3 the far cascade's map
+ *   +4 the comparison sampler
+ *
+ * It takes a POINT and no normal. The materials' sampleShadow also rejects a
+ * surface facing away from the sun, which is right for skin and wrong for a
+ * blade of grass or a petal: those are thin, lit through, and shaded by their
+ * own N·L. The point is nudged toward the sun instead, which lifts a blade's
+ * root off a stage floor that casts into the same map.
+ */
+export declare function shadowApi(on: boolean, group: number, binding: number): string;
+//# sourceMappingURL=shadow-api.d.ts.map

package/dist/shaders/shadow-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-api.d.ts","sourceRoot":"","sources":["../../src/shaders/shadow-api.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,MAAM,EAAE,IAAI,MAAM,EAAE,gBAAyB,WActE,CAAA;AAED,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAyD7E"}

package/dist/shaders/shadow-api.js

@@ -0,0 +1,112 @@
+import { SHADOW_CASCADES } from "../shadow-cascades";
+// The sun's shadow, as an effect author sees it.
+//
+// A lawn standing in a character's shadow has to darken where the floor under
+// it does, or the figure floats: the ground catcher draws her shadow, and the
+// blades drawn over it hide it. The map is already there — the materials and
+// the ground read it every frame — so this hands the same lookup to effects.
+//
+// Bound for real in the particle SHADING stage only. That is where geometry an
+// effect draws inside the scene pass is shaded, and the shadow pass has already
+// run by then. Every other module that compiles the author's file gets the
+// stub, which answers 1: lit is what a point with no occlusion information is,
+// the same answer sampleShadow gives outside every cascade.
+/**
+ * 3×3 PCF over one cascade's map, for a point already in that cascade's NDC.
+ *
+ * Shared with the materials, so an effect's shadow and her own shadow soften
+ * alike. The sampler is linear-filtered, which makes each tap a 2×2 bilinear
+ * compare. Unrolled — Safari's Metal backend doesn't unroll nested shadow
+ * loops reliably. The body expects `ndc` in scope and returns.
+ */
+export const pcf9 = (map, ts, sampler = "shadowSampler") => /* wgsl */ `
+  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+  let cmpZ = ndc.z - 0.001;
+  let ts = ${ts};
+  let s00 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, -ts), cmpZ);
+  let s10 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0, -ts), cmpZ);
+  let s20 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, -ts), cmpZ);
+  let s01 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, 0.0), cmpZ);
+  let s11 = textureSampleCompareLevel(${map}, ${sampler}, suv, cmpZ);
+  let s21 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, 0.0), cmpZ);
+  let s02 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts,  ts), cmpZ);
+  let s12 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0,  ts), cmpZ);
+  let s22 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts,  ts), cmpZ);
+  return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
+`;
+/** Bindings the real accessor takes, from `binding` upward. */
+export const SHADOW_API_BINDINGS = 5;
+/**
+ * `rzShadow(p)`: how much of the sun reaches world point `p` — 1 lit, 0 in a
+ * caster's shadow, soft in between.
+ *
+ * With `on`, declares five bindings from `binding`:
+ *   +0 the light uniform (the sun's direction, and in .w the shadow switch)
+ *   +1 the cascade view-projections, then the caster sphere
+ *   +2 the near cascade's map   +3 the far cascade's map
+ *   +4 the comparison sampler
+ *
+ * It takes a POINT and no normal. The materials' sampleShadow also rejects a
+ * surface facing away from the sun, which is right for skin and wrong for a
+ * blade of grass or a petal: those are thin, lit through, and shaded by their
+ * own N·L. The point is nudged toward the sun instead, which lifts a blade's
+ * root off a stage floor that casts into the same map.
+ */
+export function shadowApi(on, group, binding) {
+    if (!on) {
+        return /* wgsl */ `
+fn rzShadow(p: vec3f) -> f32 { return 1.0; }
+`;
+    }
+    const n = SHADOW_CASCADES.length;
+    return /* wgsl */ `
+// The first two vec4s of the light uniform: world ambient, then the sun.
+struct _RzShadowSun { ambient: vec4f, direction: vec4f, }
+// The cascades' matrices, inner to outer, then every caster in one sphere
+// (x, y, z, radius): radius 0 = nothing casts, negative = do not test.
+struct _RzShadowBlock { viewProj: array<mat4x4f, ${n}>, casters: vec4f, }
+@group(${group}) @binding(${binding}) var<uniform> _rzShadowSun: _RzShadowSun;
+@group(${group}) @binding(${binding + 1}) var<uniform> _rzShadowVP: _RzShadowBlock;
+@group(${group}) @binding(${binding + 2}) var _rzShadowNear: texture_depth_2d;
+@group(${group}) @binding(${binding + 3}) var _rzShadowFar: texture_depth_2d;
+@group(${group}) @binding(${binding + 4}) var _rzShadowCmp: sampler_comparison;
+
+fn _rzShadowNearTaps(ndc: vec3f) -> f32 {
+${pcf9("_rzShadowNear", `1.0 / ${SHADOW_CASCADES[0].mapSize}.0`, "_rzShadowCmp")}
+}
+
+fn _rzShadowFarTaps(ndc: vec3f) -> f32 {
+${pcf9("_rzShadowFar", `1.0 / ${SHADOW_CASCADES[n - 1].mapSize}.0`, "_rzShadowCmp")}
+}
+
+fn rzShadow(p: vec3f) -> f32 {
+  // The scene's one shadow switch, on the sun — see sampleShadow.
+  let castAmt = _rzShadowSun.direction.w;
+  if (castAmt <= 0.0) { return 1.0; }
+  let toSun = normalize(-_rzShadowSun.direction.xyz);
+  // Can anything cast onto this point at all? The ground's test, for the same
+  // two reasons: most of a lawn is nowhere near her, and a scene with no
+  // models never renders the map, whose untouched zeroes compare as shadowed.
+  let cs = _rzShadowVP.casters;
+  if (cs.w == 0.0) { return 1.0; }
+  if (cs.w > 0.0) {
+    let toCaster = cs.xyz - p;
+    let along = dot(toCaster, toSun);
+    let perp = length(toCaster - toSun * along);
+    if (along <= -cs.w || perp > cs.w) { return 1.0; }
+  }
+  let q = p + toSun * 0.08;
+  let c0 = _rzShadowVP.viewProj[0] * vec4f(q, 1.0);
+  let n0 = c0.xyz / max(c0.w, 1e-6);
+  if (all(abs(n0.xy) < vec2f(0.98)) && n0.z > 0.0 && n0.z < 1.0) {
+    return mix(1.0, _rzShadowNearTaps(n0), castAmt);
+  }
+  let c1 = _rzShadowVP.viewProj[${n - 1}] * vec4f(q, 1.0);
+  let n1 = c1.xyz / max(c1.w, 1e-6);
+  if (all(abs(n1.xy) < vec2f(0.98)) && n1.z > 0.0 && n1.z < 1.0) {
+    return mix(1.0, _rzShadowFarTaps(n1), castAmt);
+  }
+  return 1.0;
+}
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.67.0",
+  "version": "0.68.0",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/camera.ts

@@ -74,7 +74,8 @@ export class Camera {
 
   // Camera settings
   angularSensitivity: number = 0.005
-  panSensitivity: number = 0.0002 // Sensitivity for right-click panning
+  panSensitivity: number = 0.0003 // Sensitivity for right-click panning
+  static readonly PAN_REF_RADIUS = 33
   wheelPrecision: number = 0.01
   pinchPrecision: number = 0.05
   minZ: number = 0.05
@@ -335,10 +336,13 @@ export class Camera {
   private panCamera(deltaX: number, deltaY: number) {
     const { right, up } = this.getCameraVectors()
 
-    // Calculate pan distance based on camera distance
-    // The pan amount is proportional to the camera distance (radius) for consistent feel
-    // This makes panning feel natural at all zoom levels
-    const panDistance = this.radius * this.panSensitivity
+    // Pan scales with camera distance, so a drag covers the same share of the
+    // frame at every zoom from PAN_REF_RADIUS out. Closer in it shrinks slower
+    // than the distance (power 0.7): a close-up pans a little faster across the
+    // frame — 1.4x at distance 10, 1.8x at 5 — instead of crawling.
+    const r = this.radius
+    const ref = Camera.PAN_REF_RADIUS
+    const panDistance = (r >= ref ? r : ref * Math.pow(Math.max(r, 0) / ref, 0.7)) * this.panSensitivity
 
     // Horizontal movement: drag right pans left (opposite direction)
     // Vertical movement: drag up pans up (positive up vector)

package/src/engine.ts

@@ -17144,28 +17144,25 @@ export class Engine {
           py += pos.y
           pz += pos.z
         }
-        px += this.cameraTargetOffset.x
-        py += this.cameraTargetOffset.y
-        pz += this.cameraTargetOffset.z
         const tau = this.cameraFollowSmoothing
+        const f = this.cameraFollowPos
         if (tau > 0 && this.cameraFollowSeeded) {
           // Exponential lag toward the bone: the handheld-camera feel. The
           // orbit pivot trails the target and eases in, never snapping.
           const k = 1 - Math.exp(-deltaTime / tau)
-          const f = this.cameraFollowPos
           f.x += (px - f.x) * k
           f.y += (py - f.y) * k
           f.z += (pz - f.z) * k
-          this.camera.target.x = f.x
-          this.camera.target.y = f.y
-          this.camera.target.z = f.z
         } else {
-          this.cameraFollowPos.setXYZ(px, py, pz)
+          f.setXYZ(px, py, pz)
           this.cameraFollowSeeded = true
-          this.camera.target.x = px
-          this.camera.target.y = py
-          this.camera.target.z = pz
         }
+        // The offset goes on AFTER the lag. A pan writes the offset (panSink),
+        // and the lag is for the bone's motion: eased with it, a pan glided
+        // on after the hand let go while an orbit stopped dead.
+        this.camera.target.x = f.x + this.cameraTargetOffset.x
+        this.camera.target.y = f.y + this.cameraTargetOffset.y
+        this.camera.target.z = f.z + this.cameraTargetOffset.z
       }
     }
 

package/src/physics/contact.ts

@@ -1397,7 +1397,10 @@ function flipOneNormal(c: Contact): void {
 // see RigidBodyStore.getCollisionPairs. SAP / dynamic AABB tree pay off
 // above ~500 bodies; below that this flat sweep wins on cache locality.
 export function findContacts(store: RigidBodyStore, pool: ContactPool): void {
-  store.updateAabbs()
+  // Inflated by the contact margin and no more: a narrowphase only ever makes
+  // a contact within CONTACT_MARGIN, so a fatter box only bought SAT tests on
+  // pairs that could never touch — at 0.5 that was most of the collision cost.
+  store.updateAabbs(CONTACT_MARGIN + 0.01)
   const pairs = store.getCollisionPairs()
   for (let p = 0; p < pairs.length; p += 2) {
     const i = pairs[p]

package/src/physics/physics.ts

@@ -24,8 +24,18 @@ export class RezePhysics {
   private contacts: ContactPool
   private firstFrame = true
   private timeAccum = 0
-  private readonly fixedTimeStep = 1 / 60
-  private readonly maxSubSteps = 6
+  // Two 120 Hz steps of 5 iterations where MMD takes one 60 Hz step of 10.
+  // Contacts and joints converge against each other far better in two small
+  // steps: a thin skirt lattice pressed on the legs shook 58% less and sat
+  // inside them a third as often. Collision runs every step — reusing one
+  // contact set across steps missed contacts that began between detections,
+  // and the late push-out shook worse than the single step ever did.
+  private readonly fixedTimeStep = 1 / 120
+  private readonly maxSubSteps = 12
+  private static readonly ITERATIONS = 5
+  // One 60 Hz frame of simulated time — what load shedding may never cut
+  // below, the guarantee the single 1/60 step always gave.
+  private static readonly MIN_STEPS = 2
   /** EMA of one world.step's CPU cost; drives catch-up load shedding. */
   private stepCostEmaMs = 0.5
   /**
@@ -131,6 +141,7 @@ export class RezePhysics {
     this.groundBody = gi
     this.store.groundIndex = gi
     this.world = new World(new Vec3(0, -98, 0))
+    this.world.solverIterations = RezePhysics.ITERATIONS
     this.constraints = buildConstraints(rigidbodies, joints)
     this.solverCache = new SolverCache(this.constraints)
     this.contacts = new ContactPool()
@@ -307,7 +318,7 @@ export class RezePhysics {
       this.stepBudgetMaxMs,
       Math.max(this.stepBudgetMinMs, dt * 1000 * this.stepBudgetFraction),
     )
-    const affordable = Math.max(1, Math.floor(budgetMs / Math.max(0.05, this.stepCostEmaMs)))
+    const affordable = Math.max(RezePhysics.MIN_STEPS, Math.floor(budgetMs / Math.max(0.05, this.stepCostEmaMs)))
     if (nSub > affordable) nSub = affordable
     for (let k = 0; k < nSub; k++) {
       this.savePrevState()

package/src/physics/solver.ts

@@ -37,7 +37,12 @@ const BOUNCE_THRESHOLD = 2.0
 // pushes apart; separated (depth < 0, a speculative row) it ALLOWS approach at
 // the rate that closes the gap, which is what keeps those rows inert until the
 // body would really arrive.
-const CONTACT_ERP = 0.2
+//
+// 0.1, half Bullet's 0.2: at 120 Hz each step closes a tenth of the overlap,
+// the same correction per second as MMD's 0.2 at 60 Hz, and a light cloth body
+// pressed between its joints and a collider stops being kicked out harder than
+// the joints can take back (skirt shake −20% on its own).
+const CONTACT_ERP = 0.1
 
 // btContactSolverInfo's SOLVER_RANDMIZE_ORDER. Gauss-Seidel is order-biased —
 // rows solved first win — which on a cross-linked lattice shows up as a lean or
@@ -119,6 +124,11 @@ const LIMIT_SOFTNESS_ANGULAR = 0.5
 // ratio (ζ = 0.7); ported in isolation the motor form measured 0.0015 mean
 // reversal at jerk 0.5, the calmest joint-side result recorded.
 const SPRING_DAMPING = 1.0
+// The motor's velocity gain at the rate PMX rigs are authored against — MMD's
+// Bullet at 60 Hz with 10 iterations. Bullet's form divides by the step's fps
+// and iteration count; at any other substep rate that retunes every spring,
+// so the gain is pinned here and the substep rate stays a solver choice.
+const SPRING_VEL_FACTOR = (60 * SPRING_DAMPING) / 10
 // btConstraintInfo2::erp, from infoGlobal.m_erp — used only by getMotorFactor.
 const INFO_ERP = 0.2
 
@@ -543,7 +553,7 @@ function setupConstraint(
       const k = con.springStiffness[i]
       const serr = curr - con.equilibriumPoint[i]
       const force = serr * k
-      const velFactor = (invDt * SPRING_DAMPING) / iterations
+      const velFactor = SPRING_VEL_FACTOR
       const target = -velFactor * force
       // getMotorFactor's `vel` is Bullet's tag_vel: −targetVelocity for a
       // linear axis, which in our sign convention is the target itself.
@@ -625,7 +635,7 @@ function setupConstraint(
       const k = con.springStiffness[idx]
       const serr = _angDiffScratch[i] - con.equilibriumPoint[idx]
       const force = -serr * k
-      const velFactor = (invDt * SPRING_DAMPING) / iterations
+      const velFactor = SPRING_VEL_FACTOR
       const target = -velFactor * force
       // tag_vel for a rotational axis is Bullet's targetVelocity, i.e. −ours.
       const motFact = getMotorFactor(_angDiffScratch[i], con.angularMin[i], con.angularMax[i], -target, invDt * INFO_ERP)