reze-engine 0.16.2 → 0.16.3

package/src/physics/physics.ts

@@ -50,6 +50,15 @@ export class RezePhysics {
   private kinRoot: Int32Array
   // Kinematic bodies whose target jumped discontinuously this frame.
   private teleportFlags: Uint8Array
+  // PMX mode-2 bodies jointed *directly* to a bone-follow body (breasts,
+  // chain roots). Only these get MMD's bone-position alignment: their bone's
+  // animated matrix is trustworthy, whereas deeper chain bones' animated
+  // matrices don't include the physics deflection of their parents, so
+  // pinning those would freeze the chain.
+  private alignPinned: Uint8Array
+  // Debug counter: frames on which a teleport (scrub/jump discontinuity)
+  // was detected and settled.
+  teleportCount = 0
 
   constructor(rigidbodies: Rigidbody[], joints: Joint[] = []) {
     this.rigidbodies = rigidbodies
@@ -66,6 +75,17 @@ export class RezePhysics {
     this.kinTargetAngVel = new Float32Array(this.store.count * 3)
     this.kinRoot = this.buildKinematicRoots()
     this.teleportFlags = new Uint8Array(this.store.count)
+
+    this.alignPinned = new Uint8Array(this.store.count)
+    const types = this.store.type
+    for (const c of this.constraints) {
+      const tA = types[c.bodyA]
+      const tB = types[c.bodyB]
+      const aFollows = tA === RigidbodyType.Static || tA === RigidbodyType.Kinematic
+      const bFollows = tB === RigidbodyType.Static || tB === RigidbodyType.Kinematic
+      if (aFollows && this.store.aligned[c.bodyB]) this.alignPinned[c.bodyB] = 1
+      if (bFollows && this.store.aligned[c.bodyA]) this.alignPinned[c.bodyA] = 1
+    }
   }
 
   // BFS over the joint graph from every kinematic body, assigning each
@@ -140,6 +160,13 @@ export class RezePhysics {
     if (this.firstFrame) return
     this.snapBodiesToBones(boneWorldMatrices)
     this.savePrevState() // prev == curr after a snap, so no interpolation jump
+    // Reseed kinematic targets from the snapped pose — otherwise the next
+    // step derives the target-trajectory velocity against the pre-reset
+    // targets and feeds one frame of enormous anchor velocity to the solver.
+    this.kinTargetPos.set(this.store.positions)
+    this.kinTargetOri.set(this.store.orientations)
+    this.kinTargetVel.fill(0)
+    this.kinTargetAngVel.fill(0)
     this.timeAccum = 0
   }
 
@@ -165,6 +192,7 @@ export class RezePhysics {
     // raw derived velocity is what used to explode the solver. Chains under
     // unaffected roots keep their momentum untouched.
     if (this.computeKinematicTargets(boneWorldMatrices, dt)) {
+      this.teleportCount++
       this.carryDynamicThroughTeleport()
       this.snapKinematicToTargets(true)
       this.savePrevState() // prev == curr so interpolation doesn't streak
@@ -197,6 +225,10 @@ export class RezePhysics {
       this.snapKinematicToTargets(false)
     }
 
+    // MMD mode-2 bone alignment for pinned (depth-1) bodies: position
+    // re-pins to the animated bone, rotation stays simulated.
+    this.alignPinnedBodiesToBones(boneWorldMatrices)
+
     // Fraction into the next (not-yet-taken) step; always in [0, 1).
     const alpha = this.fixedTimeStep > 0 ? this.timeAccum / this.fixedTimeStep : 0
     this.applyDynamicsToBones(boneWorldMatrices, alpha)
@@ -500,6 +532,32 @@ export class RezePhysics {
     }
   }
 
+  // Overwrite pinned mode-2 bodies' positions with boneWorld × bodyOffset
+  // from the animated bone pose, keeping simulated orientation and
+  // velocities. prevPositions follows so interpolation doesn't streak.
+  private alignPinnedBodiesToBones(boneWorldMatrices: Mat4[]): void {
+    const N = this.store.count
+    const pinned = this.alignPinned
+    const boneIdx = this.store.boneIndex
+    const offsets = this.store.bodyOffsetMatrix
+    const positions = this.store.positions
+    const prevPos = this.prevPositions
+
+    for (let i = 0; i < N; i++) {
+      if (!pinned[i]) continue
+      const b = boneIdx[i]
+      if (b < 0 || b >= boneWorldMatrices.length) continue
+      Mat4.multiplyArrays(boneWorldMatrices[b].values, 0, offsets, i * 16, _bodyMat, 0)
+      const i3 = i * 3
+      positions[i3 + 0] = _bodyMat[12]
+      positions[i3 + 1] = _bodyMat[13]
+      positions[i3 + 2] = _bodyMat[14]
+      prevPos[i3 + 0] = _bodyMat[12]
+      prevPos[i3 + 1] = _bodyMat[13]
+      prevPos[i3 + 2] = _bodyMat[14]
+    }
+  }
+
   // Backstop: if a dynamic body's state went non-finite despite the velocity
   // caps, restore its previous-substep pose with zero velocity instead of
   // letting NaNs spread through constraints and contacts. Runs after every
@@ -589,7 +647,16 @@ export class RezePhysics {
 
       // Sanity gate against NaN / extreme values — silently drop the update.
       if (Number.isFinite(_boneMat[0]) && Math.abs(_boneMat[0]) < 1e6) {
-        boneWorldMatrices[b].values.set(_boneMat)
+        const v = boneWorldMatrices[b].values
+        if (this.alignPinned[i]) {
+          // Pinned mode-2: the bone keeps its animated position, physics
+          // drives rotation only.
+          v[0] = _boneMat[0]; v[1] = _boneMat[1]; v[2] = _boneMat[2]
+          v[4] = _boneMat[4]; v[5] = _boneMat[5]; v[6] = _boneMat[6]
+          v[8] = _boneMat[8]; v[9] = _boneMat[9]; v[10] = _boneMat[10]
+        } else {
+          v.set(_boneMat)
+        }
       }
     }
   }

package/src/physics/solver.ts

@@ -182,12 +182,15 @@ function setupConstraint(
     tgt[i] = target
     act[i] = denom > 0 ? active : 0
     con.cacheLinLimitImp[i] = 0
-    if (con.springEnabled[i] && denom > 0) {
+    // A spring on a locked axis is redundant — the bilateral limit row
+    // already welds the DOF, and driving it twice overshoots every
+    // iteration (PMX rigs routinely put k=100000 springs on locked axes,
+    // which turned welded weight-bodies into energy pumps).
+    if (con.springEnabled[i] && denom > 0 && lo !== hi) {
       // Clamp k to the deadbeat limit: an explicit spring with k·dt² > 1
       // overshoots equilibrium every step and pumps energy — the classic
-      // pre-Spring2 Bullet 6dof instability this port inherited. (¼ margin
-      // for Gauss-Seidel coupling in chains.)
-      const k = Math.min(con.springStiffness[i], 0.25 * invDt * invDt)
+      // pre-Spring2 Bullet 6dof instability this port inherited.
+      const k = Math.min(con.springStiffness[i], invDt * invDt)
       const serr = curr - con.equilibriumPoint[i]
       con.cacheLinSpringTarget[i] = -k * serr * dt
       con.cacheLinSpringActive[i] = 1
@@ -238,9 +241,11 @@ function setupConstraint(
   const angAct = con.cacheAngActive
   for (let i = 0; i < 3; i++) {
     const idx = i + 3
-    if (con.springEnabled[idx] && angDenom > 0) {
+    // Springs on locked axes are skipped — the limit row welds those, and
+    // double-driving a DOF overshoots every iteration (see the linear loop).
+    if (con.springEnabled[idx] && angDenom > 0 && con.angularMin[i] !== con.angularMax[i]) {
       // Same deadbeat clamp as the linear springs.
-      const k = Math.min(con.springStiffness[idx], 0.25 * invDt * invDt)
+      const k = Math.min(con.springStiffness[idx], invDt * invDt)
       const serr = _angDiffScratch[i] - con.equilibriumPoint[idx]
       angTgt[i] = k * serr * dt
       angAct[i] = 1
@@ -388,9 +393,12 @@ function iterateConstraint(
     }
 
     // Spring row: velocity-target drive; the deadbeat k-clamp at setup
-    // bounds its aggression.
+    // bounds its aggression. relVel is refreshed with the limit impulse
+    // applied just above (j·denom = j / jac) — driving the spring off the
+    // stale value double-corrects the DOF and overshoots every iteration.
     if (sprAct[i]) {
-      j += (sprTgt[i] - relVel) * jac[i]
+      const relVelNow = j !== 0 ? relVel + j / jac[i] : relVel
+      j += (sprTgt[i] - relVelNow) * jac[i]
     }
 
     if (j === 0) continue

package/src/physics/types.ts

@@ -6,10 +6,15 @@ export enum RigidbodyShape {
   Capsule = 2,
 }
 
+// PMX physics mode: 0 = follow bone, 1 = physics, 2 = physics + bone-position
+// alignment. Mode 2 is DYNAMIC — the loader maps it to Dynamic with
+// `aligned: true` (bone gets rotation only, body position re-pins to the
+// animated bone each frame). Mapping the raw byte 1:1 onto this enum froze
+// mode-2 bodies (most modern cloth rigs, and every 胸_回転 breast body).
 export enum RigidbodyType {
-  Static = 0,
+  Static = 0, // follows bone (anchor)
   Dynamic = 1,
-  Kinematic = 2,
+  Kinematic = 2, // follows bone (legacy alias; loader no longer emits it)
 }
 
 export interface Rigidbody {
@@ -28,6 +33,9 @@ export interface Rigidbody {
   restitution: number
   friction: number
   type: RigidbodyType
+  // PMX mode 2: dynamic body whose bone takes rotation only; the body's
+  // position re-pins to the animated bone each frame.
+  aligned?: boolean
   bodyOffsetMatrixInverse: Mat4 // Inverse of body offset matrix, used to sync rigidbody to bone
   bodyOffsetMatrix?: Mat4 // Cached non-inverse for performance (computed once during initialization)
 }

package/src/physics/world.ts

@@ -14,6 +14,12 @@ export class World {
   readonly gravity: Vec3
   solverIterations = 10
 
+  // Per-body damping factors pow(1−damping, dt), cached because damping and
+  // the fixed dt never change — two Math.pow per body per substep otherwise.
+  private dampCacheDt = -1
+  private linDampFactor: Float32Array | null = null
+  private angDampFactor: Float32Array | null = null
+
   constructor(gravity: Vec3) {
     this.gravity = new Vec3(gravity.x, gravity.y, gravity.z)
   }
@@ -43,15 +49,26 @@ export class World {
 
     // 1. Predict — gravity + damping. The pow form (vs the linear
     //    1−damping·dt approximation) stays stable at high PMX damping
-    //    values like 0.99.
+    //    values like 0.99. Factors are cached (damping and dt are constant).
+    if (this.dampCacheDt !== dt || !this.linDampFactor || this.linDampFactor.length !== N) {
+      this.dampCacheDt = dt
+      this.linDampFactor = new Float32Array(N)
+      this.angDampFactor = new Float32Array(N)
+      for (let i = 0; i < N; i++) {
+        this.linDampFactor[i] = Math.pow(Math.max(0, 1 - ldamp[i]), dt)
+        this.angDampFactor[i] = Math.pow(Math.max(0, 1 - adamp[i]), dt)
+      }
+    }
+    const linDamp = this.linDampFactor
+    const angDamp = this.angDampFactor!
     for (let i = 0; i < N; i++) {
       if (types[i] !== RigidbodyType.Dynamic || invMass[i] <= 0) continue
       const i3 = i * 3
       lv[i3 + 0] += gx * dt
       lv[i3 + 1] += gy * dt
       lv[i3 + 2] += gz * dt
-      const ld = Math.pow(Math.max(0, 1 - ldamp[i]), dt)
-      const ad = Math.pow(Math.max(0, 1 - adamp[i]), dt)
+      const ld = linDamp[i]
+      const ad = angDamp[i]
       lv[i3 + 0] *= ld; lv[i3 + 1] *= ld; lv[i3 + 2] *= ld
       av[i3 + 0] *= ad; av[i3 + 1] *= ad; av[i3 + 2] *= ad
     }

package/src/pmx-loader.ts

@@ -37,11 +37,22 @@ export class PmxLoader {
   private vertexCount: number = 0
   private rigidbodies: Rigidbody[] = []
   private joints: Joint[] = []
+  private warnings: string[] = []
 
   private constructor(buffer: ArrayBuffer) {
     this.view = new DataView(buffer)
   }
 
+  // Parse problems are non-fatal (the mesh may still render), but they must
+  // be queryable afterwards — a rig whose rigidbody section failed to parse
+  // silently loses physics, and console.warn alone drowns in browser log
+  // limits. Collected warnings ship on the Model (getLoadWarnings()).
+  private warn(message: string, error?: unknown): void {
+    const full = error instanceof Error ? `${message}: ${error.message}` : message
+    this.warnings.push(full)
+    console.warn(message, error ?? "")
+  }
+
   static async load(url: string): Promise<Model> {
     return PmxLoader.loadFromReader(createFetchAssetReader(), url)
   }
@@ -82,7 +93,7 @@ export class PmxLoader {
     const version = this.getFloat32()
     if (version < 2.0 || version > 2.2) {
       // Continue, but warn for unexpected version
-      console.warn(`PMX version ${version} may not be fully supported`)
+      this.warn(`PMX version ${version} may not be fully supported`)
     }
 
     // PMX: globals count (uint8) followed by that many bytes describing encoding and index sizes
@@ -472,7 +483,7 @@ export class PmxLoader {
       }
       this.bones = bones
     } catch (e) {
-      console.warn("Error parsing bones:", e)
+      this.warn("Error parsing bones:", e)
       this.bones = []
     }
   }
@@ -487,7 +498,7 @@ export class PmxLoader {
       const count = this.getInt32()
       if (count < 0 || count > 100000) {
         // Suspicious count, likely corrupted
-        console.warn(`Suspicious morph count: ${count}`)
+        this.warn(`Suspicious morph count: ${count}`)
         this.morphs = []
         return
       }
@@ -623,11 +634,11 @@ export class PmxLoader {
           this.morphs.push(morph)
         } catch (e) {
           // If we fail to read a morph, skip it
-          console.warn(`Error reading morph ${i}:`, e)
+          this.warn(`Error reading morph ${i}:`, e)
         }
       }
     } catch (e) {
-      console.warn("Error parsing morphs:", e)
+      this.warn("Error parsing morphs:", e)
       this.morphs = []
     }
   }
@@ -669,13 +680,13 @@ export class PmxLoader {
           }
         } catch (e) {
           // If we fail to read a frame, stop skipping
-          console.warn(`Error reading display frame ${i}:`, e)
+          this.warn(`Error reading display frame ${i}:`, e)
           return false
         }
       }
       return true
     } catch (e) {
-      console.warn("Error skipping display frames:", e)
+      this.warn("Error skipping display frames:", e)
       return false
     }
   }
@@ -685,7 +696,7 @@ export class PmxLoader {
       // Note: morphs and display frames are already skipped in parse() before calling this
       // Check bounds before reading rigidbody count
       if (this.offset + 4 > this.view.buffer.byteLength) {
-        console.warn("Not enough bytes for rigidbody count")
+        this.warn("Not enough bytes for rigidbody count")
         this.rigidbodies = []
         return
       }
@@ -693,7 +704,7 @@ export class PmxLoader {
       const count = this.getInt32()
       if (count < 0 || count > 10000) {
         // Suspicious count
-        console.warn(`Suspicious rigidbody count: ${count}`)
+        this.warn(`Suspicious rigidbody count: ${count}`)
         this.rigidbodies = []
         return
       }
@@ -704,7 +715,7 @@ export class PmxLoader {
         try {
           // Check bounds before reading each rigidbody
           if (this.offset >= this.view.buffer.byteLength) {
-            console.warn(`Reached end of buffer while reading rigidbody ${i} of ${count}`)
+            this.warn(`Reached end of buffer while reading rigidbody ${i} of ${count}`)
             break
           }
 
@@ -737,7 +748,12 @@ export class PmxLoader {
           const angularDamping = this.getFloat32()
           const restitution = this.getFloat32()
           const friction = this.getFloat32()
-          const type = this.getUint8() // 0=static, 1=dynamic, 2=kinematic
+          // PMX physics mode: 0 = follow bone, 1 = physics,
+          // 2 = physics + bone-position alignment. Mode 2 is dynamic — it
+          // must NOT be cast onto RigidbodyType (2 = Kinematic there, which
+          // freezes the body to its bone and kills physics for most modern
+          // cloth rigs and every 胸_回転 breast body).
+          const mode = this.getUint8()
 
           this.rigidbodies.push({
             name,
@@ -754,17 +770,18 @@ export class PmxLoader {
             angularDamping,
             restitution,
             friction,
-            type: type as RigidbodyType,
+            type: mode === 0 ? RigidbodyType.Static : RigidbodyType.Dynamic,
+            aligned: mode === 2,
             bodyOffsetMatrixInverse: Mat4.identity(),
           })
         } catch (e) {
-          console.warn(`Error reading rigidbody ${i} of ${count}:`, e)
+          this.warn(`Error reading rigidbody ${i} of ${count}:`, e)
           // Stop parsing if we encounter an error
           break
         }
       }
     } catch (e) {
-      console.warn("Error parsing rigidbodies:", e)
+      this.warn("Error parsing rigidbodies:", e)
       this.rigidbodies = []
     }
   }
@@ -773,14 +790,14 @@ export class PmxLoader {
     try {
       // Check bounds before reading joint count
       if (this.offset + 4 > this.view.buffer.byteLength) {
-        console.warn("Not enough bytes for joint count")
+        this.warn("Not enough bytes for joint count")
         this.joints = []
         return
       }
 
       const count = this.getInt32()
       if (count < 0 || count > 10000) {
-        console.warn(`Suspicious joint count: ${count}`)
+        this.warn(`Suspicious joint count: ${count}`)
         this.joints = []
         return
       }
@@ -791,7 +808,7 @@ export class PmxLoader {
         try {
           // Check bounds before reading each joint
           if (this.offset >= this.view.buffer.byteLength) {
-            console.warn(`Reached end of buffer while reading joint ${i} of ${count}`)
+            this.warn(`Reached end of buffer while reading joint ${i} of ${count}`)
             break
           }
 
@@ -857,13 +874,13 @@ export class PmxLoader {
             springRotation: new Vec3(springRotX, springRotY, springRotZ), // Store as Vec3 (stiffness values)
           })
         } catch (e) {
-          console.warn(`Error reading joint ${i} of ${count}:`, e)
+          this.warn(`Error reading joint ${i} of ${count}:`, e)
           // Stop parsing if we encounter an error
           break
         }
       }
     } catch (e) {
-      console.warn("Error parsing joints:", e)
+      this.warn("Error parsing joints:", e)
       this.joints = []
     }
   }
@@ -1044,7 +1061,8 @@ export class PmxLoader {
       skinning,
       morphing,
       this.rigidbodies,
-      this.joints
+      this.joints,
+      this.warnings
     )
   }
 

package/src/shaders/materials/body.ts

@@ -1,92 +1,97 @@
-// M_Body — 仿深空之眼渲染预设v1.0_by_小绿毛猫 "M_Body". Toon + warm rim + rim1/rim2
-// stack mixed 50/50 against a Principled BSDF with noise-bumped normal.
-
-import { NODES_WGSL } from "./nodes"
-import { COMMON_MATERIAL_PRELUDE_WGSL } from "./common"
-
-export const BODY_SHADER_WGSL = /* wgsl */ `
-
-${NODES_WGSL}
-${COMMON_MATERIAL_PRELUDE_WGSL}
-
-const BODY_ROUGHNESS: f32 = 0.3;
-const BODY_SPECULAR: f32 = 0.5;
-const BODY_MIX_NPR: f32 = 0.5;
-const BODY_SPEC_CLAMP: f32 = 10.0;
-const BODY_RIM2_LAYER_BLEND: f32 = 0.20000000298023224;
-const BODY_RIM2_POW: f32 = 1.4300000667572021;
-const BODY_RIM2_BG: vec3f = vec3f(1.0, 0.4303792119026184, 0.3315804898738861);
-const BODY_WARM_STR: f32 = 0.30000001192092896;
-
-// smoothstep-based ramp: t*t*(3-2*t) between two color stops
-fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
-  let t = saturate((f - p0) / max(p1 - p0, 1e-6));
-  let ss = t * t * (3.0 - 2.0 * t);
-  return mix(c0, c1, ss);
-}
-
-@fragment fn fs(input: VertexOutput) -> FSOut {
-  let alpha = material.alpha;
-  if (alpha < 0.001) { discard; }
-
-  let n = normalize(input.normal);
-  let v = normalize(camera.viewPos - input.worldPos);
-  let l = -light.lights[0].direction.xyz;
-  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
-  let amb = light.ambientColor.xyz;
-  let shadow = sampleShadow(input.worldPos, n);
-
-  let tex_color = textureSample(diffuseTexture, diffuseSampler, input.uv).rgb;
-
-  // ═══ NPR STACK ═══
-  let ndotl_raw = shader_to_rgb_diffuse(n, l, sun, amb, shadow);
-  let toon = ramp_constant(ndotl_raw, 0.0, vec4f(0,0,0,1), 0.2966, vec4f(1,1,1,1)).r;
-
-  let shadow_tint = hue_sat_id(2.0, 0.3499999940395355, 1.0, tex_color);
-  let lit_tint = hue_sat_id(1.5, 1.0, 1.0, tex_color);
-  let toon_color = mix_blend(toon, shadow_tint, lit_tint);
-  let bc = bright_contrast(toon_color, 0.1, 0.2);
-
-  let emission3 = bc * 4.0;
-
-  let warm_input = clamp(toon + 0.5, 0.0, 1.0);
-  let warm_color = ramp_cardinal(warm_input, 0.2409,
-    vec4f(0.2426, 0.068, 0.0588, 1.0), 0.4663,
-    vec4f(0.6677, 0.5024, 0.5126, 1.0)).rgb;
-  let warm_emission = warm_color * BODY_WARM_STR;
-
-  let rim1_str = fresnel(2.0, n, v) * layer_weight_facing(0.24000005424022675, n, v);
-  let rim1 = vec3f(0.984157919883728, 0.6110184788703918, 0.5736401677131653) * rim1_str;
-
-  let facing_raw = layer_weight_facing(BODY_RIM2_LAYER_BLEND, n, v);
-  let facing_pow = math_power(facing_raw, BODY_RIM2_POW);
-  let rim2_fac = ramp_ease(facing_pow, 0.0, vec4f(0,0,0,1), 0.5052, vec4f(1,1,1,1)).r;
-  let rim2_mixed = mix(emission3, BODY_RIM2_BG, rim2_fac);
-
-  let npr_stack = rim1 + rim2_mixed + warm_emission;
-
-  // ═══ PRINCIPLED BSDF with noise bump ═══
-  // Mapping loc=rot=0 in the Blender graph folds to a plain scale multiply.
-  // Height in rest space (restPos) so the bump rides with the skin; geometric basis stays
-  // worldPos so the perturbed normal matches the world-space n (see face.ts note).
-  let noise_val = tex_noise_d2(input.restPos * vec3f(1.0, 1.0, 1.5), 1.0);
-  let noise_ramp = ramp_linear(noise_val, 0.0, vec4f(0,0,0,1), 1.0, vec4f(1,1,1,1)).r;
-  let bumped_n = bump_lh(0.324644535779953, noise_ramp, n, input.worldPos);
-
-  let principled_base = mix_blend(noise_ramp, bc, vec3f(0.6831911206245422, 0.19474034011363983, 0.13732507824897766));
-  let p_emission = bc * 0.2;
-
-  let principled = eval_principled(
-    PrincipledIn(principled_base, 0.0, BODY_SPECULAR, BODY_ROUGHNESS, BODY_SPEC_CLAMP, 0.0, 0.0),
-    bumped_n, l, v, sun, amb, shadow
-  ) + p_emission;
-
-  let final_color = mix(npr_stack, principled, BODY_MIX_NPR);
-
-  var out: FSOut;
-  out.color = vec4f(final_color, alpha);
-  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
-  return out;
-}
-
-`
+// M_Body — 仿深空之眼渲染预设v1.0_by_小绿毛猫 "M_Body". Toon + warm rim + rim1/rim2
+// stack mixed 50/50 against a Principled BSDF with noise-bumped normal.
+
+import { NODES_WGSL } from "./nodes"
+import { COMMON_MATERIAL_PRELUDE_WGSL } from "./common"
+
+export const BODY_SHADER_WGSL = /* wgsl */ `
+
+${NODES_WGSL}
+${COMMON_MATERIAL_PRELUDE_WGSL}
+
+const BODY_ROUGHNESS: f32 = 0.3;
+const BODY_SPECULAR: f32 = 0.5;
+const BODY_MIX_NPR: f32 = 0.5;
+const BODY_SPEC_CLAMP: f32 = 10.0;
+const BODY_RIM2_LAYER_BLEND: f32 = 0.20000000298023224;
+const BODY_RIM2_POW: f32 = 1.4300000667572021;
+const BODY_RIM2_BG: vec3f = vec3f(1.0, 0.4303792119026184, 0.3315804898738861);
+const BODY_WARM_STR: f32 = 0.30000001192092896;
+
+// smoothstep-based ramp: t*t*(3-2*t) between two color stops
+fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
+  let t = saturate((f - p0) / max(p1 - p0, 1e-6));
+  let ss = t * t * (3.0 - 2.0 * t);
+  return mix(c0, c1, ss);
+}
+
+@fragment fn fs(input: VertexOutput) -> FSOut {
+  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
+  // MMD alpha semantics: material alpha × texture alpha. Hair/lace/accessory
+  // textures cut their shapes in the alpha channel — ignoring it renders each
+  // card's full quad with the texture's padding color (white shimmer on dark
+  // hair for models whose textures pad with white).
+  let alpha = material.alpha * tex_s.a;
+  if (alpha < 0.001) { discard; }
+
+  let n = safe_normal(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let l = -light.lights[0].direction.xyz;
+  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
+  let amb = light.ambientColor.xyz;
+  let shadow = sampleShadow(input.worldPos, n);
+
+  let tex_color = tex_s.rgb;
+
+  // ═══ NPR STACK ═══
+  let ndotl_raw = shader_to_rgb_diffuse(n, l, sun, amb, shadow);
+  let toon = ramp_constant(ndotl_raw, 0.0, vec4f(0,0,0,1), 0.2966, vec4f(1,1,1,1)).r;
+
+  let shadow_tint = hue_sat_id(2.0, 0.3499999940395355, 1.0, tex_color);
+  let lit_tint = hue_sat_id(1.5, 1.0, 1.0, tex_color);
+  let toon_color = mix_blend(toon, shadow_tint, lit_tint);
+  let bc = bright_contrast(toon_color, 0.1, 0.2);
+
+  let emission3 = bc * 4.0;
+
+  let warm_input = clamp(toon + 0.5, 0.0, 1.0);
+  let warm_color = ramp_cardinal(warm_input, 0.2409,
+    vec4f(0.2426, 0.068, 0.0588, 1.0), 0.4663,
+    vec4f(0.6677, 0.5024, 0.5126, 1.0)).rgb;
+  let warm_emission = warm_color * BODY_WARM_STR;
+
+  let rim1_str = fresnel(2.0, n, v) * layer_weight_facing(0.24000005424022675, n, v);
+  let rim1 = vec3f(0.984157919883728, 0.6110184788703918, 0.5736401677131653) * rim1_str;
+
+  let facing_raw = layer_weight_facing(BODY_RIM2_LAYER_BLEND, n, v);
+  let facing_pow = math_power(facing_raw, BODY_RIM2_POW);
+  let rim2_fac = ramp_ease(facing_pow, 0.0, vec4f(0,0,0,1), 0.5052, vec4f(1,1,1,1)).r;
+  let rim2_mixed = mix(emission3, BODY_RIM2_BG, rim2_fac);
+
+  let npr_stack = rim1 + rim2_mixed + warm_emission;
+
+  // ═══ PRINCIPLED BSDF with noise bump ═══
+  // Mapping loc=rot=0 in the Blender graph folds to a plain scale multiply.
+  // Height in rest space (restPos) so the bump rides with the skin; geometric basis stays
+  // worldPos so the perturbed normal matches the world-space n (see face.ts note).
+  let noise_val = tex_noise_d2(input.restPos * vec3f(1.0, 1.0, 1.5), 1.0);
+  let noise_ramp = ramp_linear(noise_val, 0.0, vec4f(0,0,0,1), 1.0, vec4f(1,1,1,1)).r;
+  let bumped_n = bump_lh(0.324644535779953, noise_ramp, n, input.worldPos);
+
+  let principled_base = mix_blend(noise_ramp, bc, vec3f(0.6831911206245422, 0.19474034011363983, 0.13732507824897766));
+  let p_emission = bc * 0.2;
+
+  let principled = eval_principled(
+    PrincipledIn(principled_base, 0.0, BODY_SPECULAR, BODY_ROUGHNESS, BODY_SPEC_CLAMP, 0.0, 0.0),
+    bumped_n, l, v, sun, amb, shadow
+  ) + p_emission;
+
+  let final_color = mix(npr_stack, principled, BODY_MIX_NPR);
+
+  var out: FSOut;
+  out.color = vec4f(final_color, alpha);
+  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+  return out;
+}
+
+`

package/src/shaders/materials/cloth_rough.ts

@@ -20,7 +20,7 @@ const CLOTH_R_BUMP_STR: f32 = 1.0;
 const CLOTH_R_SPEC_CLAMP: f32 = 10.0;
 
 @fragment fn fs(input: VertexOutput) -> FSOut {
-  let n = normalize(input.normal);
+  let n = safe_normal(input.normal);
   let v = normalize(camera.viewPos - input.worldPos);
   let l = -light.lights[0].direction.xyz;
   let sun = light.lights[0].color.xyz * light.lights[0].color.w;

package/src/shaders/materials/cloth_smooth.ts

@@ -17,7 +17,7 @@ const NPR_EMIT_STR: f32 = 18.200000762939453;
 const NPR_MIX_SHADER_FAC: f32 = 0.8999999761581421;
 
 @fragment fn fs(input: VertexOutput) -> FSOut {
-  let n = normalize(input.normal);
+  let n = safe_normal(input.normal);
   let v = normalize(camera.viewPos - input.worldPos);
   let l = -light.lights[0].direction.xyz;
   let sun = light.lights[0].color.xyz * light.lights[0].color.w;
@@ -47,7 +47,7 @@ const NPR_MIX_SHADER_FAC: f32 = 0.8999999761581421;
   // ═══ PRINCIPLED BSDF ═══
   let principled_base = hue_sat_id(1.0, 0.800000011920929, 1.0, tex_rgb);
   let principled = eval_principled(
-    PrincipledIn(principled_base, 0.0, CLOTH_SPECULAR, CLOTH_ROUGHNESS, 1e30, 0.0, 0.0),
+    PrincipledIn(principled_base, 0.0, CLOTH_SPECULAR, CLOTH_ROUGHNESS, 10.0, 0.0, 0.0),
     n, l, v, sun, amb, shadow
   );