reze-engine 0.15.0 → 0.16.0

package/src/pmx-loader.ts

@@ -1017,43 +1017,10 @@ export class PmxLoader {
       skinning = { joints, weights }
     }
 
-    // Create morphing data structure
-    const morphCount = this.morphs.length
-    // Dense buffer: morphCount * vertexCount * 3 floats (one vec3 per morph per vertex)
-    const offsetsBuffer = new Float32Array(morphCount * this.vertexCount * 3)
-
-    // Initialize all offsets to zero
-    offsetsBuffer.fill(0)
-
-    // Fill in actual offsets for vertex morphs
-    for (let morphIdx = 0; morphIdx < morphCount; morphIdx++) {
-      const morph = this.morphs[morphIdx]
-      if (morph.type === 1) {
-        // Vertex morph
-        // Store offsets in dense buffer: [morph0_v0, morph0_v1, ..., morph1_v0, ...]
-        // Each vec3 is 3 consecutive floats
-        for (const offset of morph.vertexOffsets) {
-          // Calculate index in the dense buffer
-          // Layout: morphIdx * (vertexCount * 3) + vertexIndex * 3
-          // This gives us the starting float index for this morph's vertex offset
-          const bufferIdx = morphIdx * this.vertexCount * 3 + offset.vertexIndex * 3
-          if (
-            bufferIdx >= 0 &&
-            bufferIdx + 2 < offsetsBuffer.length &&
-            offset.vertexIndex >= 0 &&
-            offset.vertexIndex < this.vertexCount
-          ) {
-            offsetsBuffer[bufferIdx] = offset.positionOffset[0]
-            offsetsBuffer[bufferIdx + 1] = offset.positionOffset[1]
-            offsetsBuffer[bufferIdx + 2] = offset.positionOffset[2]
-          }
-        }
-      }
-    }
-
+    // Morphs are applied from the sparse per-morph vertexOffsets lists (see
+    // Model.applyMorphs); no dense morphCount*vertexCount buffer is needed.
     const morphing: Morphing = {
       morphs: this.morphs,
-      offsetsBuffer,
     }
 
     return new Model(

package/src/shaders/materials/body.ts

@@ -67,7 +67,9 @@ fn ramp_ease(f: f32, p0: f32, c0: vec4f, p1: f32, c1: vec4f) -> vec4f {
 
   // ═══ PRINCIPLED BSDF with noise bump ═══
   // Mapping loc=rot=0 in the Blender graph folds to a plain scale multiply.
-  let noise_val = tex_noise_d2(input.worldPos * vec3f(1.0, 1.0, 1.5), 1.0);
+  // 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);
 

package/src/shaders/materials/cloth_rough.ts

@@ -48,7 +48,9 @@ const CLOTH_R_SPEC_CLAMP: f32 = 10.0;
   let npr_emission = npr_rgb * CLOTH_R_EMIT_STR;
 
   // ═══ PRINCIPLED BSDF with noise bump (live in this preset) ═══
-  let noise_val = tex_noise_d2(input.worldPos, CLOTH_R_NOISE_SCALE);
+  // Height in rest space (restPos) so the weave doesn't swim; 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, CLOTH_R_NOISE_SCALE);
   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(CLOTH_R_BUMP_STR, noise_ramp, n, input.worldPos);
 

package/src/shaders/materials/common.ts

@@ -51,6 +51,13 @@ struct VertexOutput {
   @location(0) normal: vec3f,
   @location(1) uv: vec2f,
   @location(2) worldPos: vec3f,
+  // Bind-pose object-space position (the raw pre-skin vertex attribute). Procedural
+  // textures (noise bump, sparkle, Generated-coord gradients) key off this instead of
+  // worldPos so the pattern rides with the surface — otherwise the mesh swims through a
+  // world-static noise field under any skinning deformation or root (センター) motion.
+  // At rest skinMats are identity so restPos == worldPos, which is why existing noise-
+  // scale constants stay valid without retuning.
+  @location(3) restPos: vec3f,
 };
 
 struct LightVP { viewProj: mat4x4f, };
@@ -129,6 +136,7 @@ export const COMMON_VS_WGSL = /* wgsl */ `
   output.normal = skinnedNrm;
   output.uv = uv;
   output.worldPos = skinnedPos.xyz;
+  output.restPos = position;
   return output;
 }
 

package/src/shaders/materials/face.ts

@@ -66,7 +66,10 @@ const FACE_BRIGHT_TEX_THRESH: f32 = 0.9300000071525574;
   let npr_stack = rim1 + rim2_mixed + bright_emit + warm_emission;
 
   // ═══ PRINCIPLED BSDF with noise bump ═══
-  let noise_val = tex_noise_d2(input.worldPos * vec3f(1.0, 1.0, 1.5), 1.0);
+  // Height sampled in rest space (restPos) so the micro-bump doesn't swim under motion;
+  // bump_lh's geometric basis stays in worldPos so the perturbed normal lands in the same
+  // world frame as n (screen-space height gradient still pairs correctly with it).
+  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);
 

package/src/shaders/materials/stockings.ts

@@ -22,15 +22,19 @@ const STOCK_RAMP002_P1: f32 = 0.9565;  // EASE [0→black, 0.9565→white]
 const STOCK_RAMPFACE_P1: f32 = 0.5435; // EASE [0→black, 0.5435→white]
 const STOCK_LW_BLEND: f32 = 0.4;       // Layer Weight Blend
 
-// Wyman & McGuire "Hashed Alpha Testing" (2017) — world-space hash with derivative-aware
+// Wyman & McGuire "Hashed Alpha Testing" (2017) — object-space hash with derivative-aware
 // pixel-scale selection, matches Blender EEVEE prepass_frag.glsl::hashed_alpha_threshold.
-// Key property: dither pattern is stable in object/world space (doesn't swim) and stays
-// at one-pixel frequency regardless of view distance, which makes it tolerable without TAA.
-fn _hash_wm(a: vec2f) -> f32 {
-  return fract(1e4 * sin(17.0 * a.x + 0.1 * a.y) * (0.1 + abs(sin(13.0 * a.y + a.x))));
-}
+// Key property: dither pattern is stable in object space (doesn't swim) and stays at
+// one-pixel frequency regardless of view distance, which makes it tolerable without TAA.
+// The hash grid is fed the bind-pose restPos (not worldPos), so the dots stay pinned to
+// the fabric even under root (センター) motion — worldPos would crawl across the surface.
+// Since MMD skinning is rigid, length(dpdx(restPos)) == length(dpdx(worldPos)), so the
+// pixel-scale selection is unaffected by the space change.
+// Grid samples reuse the PCG _hash33 from nodes.ts (integer-lattice inputs, Metal-friendly)
+// instead of a fract(sin()) hash — sin compiles to a slow transcendental on Apple's Metal
+// backend and this runs per-fragment on every stockings pixel.
 fn _hash3d_wm(a: vec3f) -> f32 {
-  return _hash_wm(vec2f(_hash_wm(a.xy), a.z));
+  return _hash33(a).x * 0.5 + 0.5;
 }
 fn hashed_alpha_threshold(co: vec3f) -> f32 {
   let alphaHashScale: f32 = 1.0;
@@ -72,12 +76,12 @@ fn ramp_ease_s(f: f32, p0: f32, p1: f32) -> f32 {
   let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
   let tex_rgb = tex_s.rgb;
   // Alpha HASHED (Blender EEVEE "Hashed" blend mode) per preset author's note — self-overlap
-  // on the stockings produces sort cracks under alpha blend. Wyman-style worldPos hash +
+  // on the stockings produces sort cracks under alpha blend. Wyman-style object-space hash +
   // depth-write is sort-independent. NOTE: Principled.Alpha=0.95 from the dump is DROPPED;
   // it relies on TAA to smooth the 5%-everywhere dither, and without TAA it shows as a
   // pervasive dot pattern. Hash now gates only on texture/material alpha.
   let combined_alpha = material.alpha * tex_s.a;
-  if (combined_alpha < hashed_alpha_threshold(input.worldPos)) { discard; }
+  if (combined_alpha < hashed_alpha_threshold(input.restPos)) { discard; }
 
   // ═══ NPR MASK ═══ TEX_COORD.Generated → Mapping(Rot=0,π/2,π/2, Loc=(1,1,1)) → Gradient.
   // The Blender mapping reduces to gradient.x = 1 - input.y (rot swaps axes, loc offsets).

package/src/shaders/passes/composite.ts

@@ -19,23 +19,29 @@ override APPLY_GAMMA: bool = true;
 // re-premultiply the tonemapped color for output so the premultiplied canvas
 // alphaMode composites the WebGPU surface over the page background correctly.
 @group(0) @binding(4) var maskTex: texture_2d<f32>;
+// Filmic tone curve baked to a WIDTH×1 r16float LUT (bakeFilmicLut on the CPU side).
+// Domain: log2(linear) mapped to [0,13]. Replaces the old array<f32,14> that was indexed
+// by a runtime u32 (a Metal-backend smell — dynamic local-array indexing lowers to a
+// per-invocation copy/switch) and interpolated piecewise-linearly (C0, so segment slope
+// discontinuities showed as Mach bands in smooth skin/shadow gradients). The LUT is a
+// monotone-cubic (Fritsch–Carlson) fit through the same 14 anchors — same values, C1
+// continuity kills the banding — sampled with hardware linear filtering.
+@group(0) @binding(5) var filmicLut: texture_2d<f32>;
 // viewU[0] = (exposure, invGamma, _, _);  viewU[1] = (tint.rgb, intensity)
 // invGamma = 1/gamma precomputed on CPU — avoids a per-pixel divide.
 
+// Must match FILMIC_LUT_WIDTH in engine.ts (bakeFilmicLut).
+const FILMIC_LUT_W: f32 = 256.0;
+
 fn filmic(x: f32) -> f32 {
-  // Re-fit against Blender 3.6 Filmic MHC anchors (sobotka/filmic-blender
-  // look_medium-high-contrast.spi1d). Previous curve was compressed:
-  // midtones too bright, highlights too dim — flattened contrast, read
-  // as "washed-out" on saturated surfaces (hair especially).
-  // Reference checkpoints: linear 0.18 → ~0.395, linear 1.0 → ~0.83.
-  var lut = array<f32, 14>(
-    0.0028, 0.0068, 0.0151, 0.0313, 0.0610, 0.1120, 0.1920,
-    0.3060, 0.4590, 0.6310, 0.8200, 0.9070, 0.9620, 0.9890
-  );
+  // Reference checkpoints (Blender 3.6 Filmic MHC, sobotka/filmic-blender
+  // look_medium-high-contrast.spi1d): linear 0.18 → ~0.395, linear 1.0 → ~0.83.
+  // NOTE: version-pinned to Blender 3.6 — 4.x defaults to AgX, not Filmic.
   let t = clamp(log2(max(x, 1e-10)) + 10.0, 0.0, 13.0);
-  let i = u32(t);
-  let j = min(i + 1u, 13u);
-  return mix(lut[i], lut[j], t - f32(i));
+  // Map t∈[0,13] to the texel-center of baked sample j = t·(W-1)/13.
+  let u = (t * (FILMIC_LUT_W - 1.0) / 13.0 + 0.5) / FILMIC_LUT_W;
+  // textureSampleLevel (explicit LOD, no derivatives) is legal in non-uniform flow.
+  return textureSampleLevel(filmicLut, bloomSamp, vec2f(u, 0.5), 0.0).r;
 }
 
 @vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {

package/src/shaders/passes/morph.ts

@@ -0,0 +1,50 @@
+// GPU vertex-morph compute pass. Produces per-vertex morphed positions and writes them
+// straight into the interleaved vertex buffer (stride 8: pos3 + normal3 + uv2), so every
+// downstream pass (main / shadow / outline / pick) sees the morphed geometry with no VS
+// change. Runs once per frame only when a model's morph weights changed.
+//
+// Morph data is a CSR (compressed sparse row) inversion of the per-morph vertex-offset
+// lists: for vertex v, its entries live in [rowStart[v], rowStart[v+1]); each entry is a
+// (morphIndex, xyz-offset) pair, ordered by ascending morph index — the same accumulation
+// order the CPU path used, so results match. Group morphs are resolved to effective
+// weights on the CPU and uploaded in `weights`.
+
+export const MORPH_COMPUTE_WGSL = /* wgsl */ `
+struct Params { vertexCount: u32 };
+
+@group(0) @binding(0) var<storage, read> basePos: array<f32>;      // vertexCount * 3
+@group(0) @binding(1) var<storage, read> rowStart: array<u32>;     // vertexCount + 1
+@group(0) @binding(2) var<storage, read> colMorph: array<u32>;     // entryCount
+@group(0) @binding(3) var<storage, read> colOffset: array<f32>;    // entryCount * 3
+@group(0) @binding(4) var<storage, read> weights: array<f32>;      // morphCount (effective)
+@group(0) @binding(5) var<storage, read_write> vtx: array<f32>;    // vertexCount * 8
+@group(0) @binding(6) var<uniform> params: Params;
+
+@compute @workgroup_size(64)
+fn cs(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let v = gid.x;
+  if (v >= params.vertexCount) { return; }
+
+  let b3 = v * 3u;
+  var px = basePos[b3];
+  var py = basePos[b3 + 1u];
+  var pz = basePos[b3 + 2u];
+
+  let s = rowStart[v];
+  let e = rowStart[v + 1u];
+  for (var i = s; i < e; i = i + 1u) {
+    let w = weights[colMorph[i]];
+    if (w != 0.0) {
+      let o3 = i * 3u;
+      px = px + w * colOffset[o3];
+      py = py + w * colOffset[o3 + 1u];
+      pz = pz + w * colOffset[o3 + 2u];
+    }
+  }
+
+  let vo = v * 8u; // VERTEX_STRIDE — write only the position slots
+  vtx[vo] = px;
+  vtx[vo + 1u] = py;
+  vtx[vo + 2u] = pz;
+}
+`

package/dist/physics-debug.d.ts

@@ -1,30 +0,0 @@
-import type { RezePhysics } from "./physics";
-export declare class PhysicsDebugRenderer {
-    private device;
-    private bindGroup;
-    private wirePipelineSphere;
-    private wirePipelineBox;
-    private wirePipelineCapsule;
-    private wireSphereBuffer;
-    private wireBoxBuffer;
-    private wireCapsuleBuffer;
-    private wireSphereCount;
-    private wireBoxCount;
-    private wireCapsuleCount;
-    private solidPipelineSphere;
-    private solidPipelineBox;
-    private solidPipelineCapsule;
-    private solidSphereBuffer;
-    private solidBoxBuffer;
-    private solidCapsuleBuffer;
-    private solidSphereCount;
-    private solidBoxCount;
-    private solidCapsuleCount;
-    private instanceBuffer;
-    private instanceData;
-    private instanceCapacity;
-    constructor(device: GPUDevice, cameraUniformBuffer: GPUBuffer, presentationFormat: GPUTextureFormat);
-    render(pass: GPURenderPassEncoder, physics: RezePhysics): void;
-    destroy(): void;
-}
-//# sourceMappingURL=physics-debug.d.ts.map

package/dist/physics-debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../src/physics-debug.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAmB5C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAc;IAG/B,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAW;IACnC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAIhC,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,oBAAoB,CAAmB;IAC/C,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,gBAAgB,CAAQ;gBAG9B,MAAM,EAAE,SAAS,EACjB,mBAAmB,EAAE,SAAS,EAC9B,kBAAkB,EAAE,gBAAgB;IA2HtC,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAmI9D,OAAO,IAAI,IAAI;CAShB"}