reze-engine 0.15.1 → 0.16.0

package/dist/shaders/passes/composite.d.ts

@@ -1,2 +1,2 @@
-export declare const COMPOSITE_SHADER_WGSL = "\n// Pipeline-override constant: the engine creates two composite pipelines, one\n// with APPLY_GAMMA=false (gamma=1 fast path) and one with APPLY_GAMMA=true.\n// The 'if (APPLY_GAMMA)' below is resolved at pipeline-compile time \u2014 the\n// dead branch is dropped by the shader compiler (no runtime branch, no pow\n// invocation on Safari's Metal backend in the common case).\noverride APPLY_GAMMA: bool = true;\n\n@group(0) @binding(0) var hdrTex: texture_2d<f32>;\n@group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)\n@group(0) @binding(2) var bloomSamp: sampler;\n@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 2>;\n// Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).\n// .g = accumulated canvas alpha (what hdr.a carried before the HDR format\n// became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then\n// re-premultiply the tonemapped color for output so the premultiplied canvas\n// alphaMode composites the WebGPU surface over the page background correctly.\n@group(0) @binding(4) var maskTex: texture_2d<f32>;\n// viewU[0] = (exposure, invGamma, _, _);  viewU[1] = (tint.rgb, intensity)\n// invGamma = 1/gamma precomputed on CPU \u2014 avoids a per-pixel divide.\n\nfn filmic(x: f32) -> f32 {\n  // Re-fit against Blender 3.6 Filmic MHC anchors (sobotka/filmic-blender\n  // look_medium-high-contrast.spi1d). Previous curve was compressed:\n  // midtones too bright, highlights too dim \u2014 flattened contrast, read\n  // as \"washed-out\" on saturated surfaces (hair especially).\n  // Reference checkpoints: linear 0.18 \u2192 ~0.395, linear 1.0 \u2192 ~0.83.\n  var lut = array<f32, 14>(\n    0.0028, 0.0068, 0.0151, 0.0313, 0.0610, 0.1120, 0.1920,\n    0.3060, 0.4590, 0.6310, 0.8200, 0.9070, 0.9620, 0.9890\n  );\n  let t = clamp(log2(max(x, 1e-10)) + 10.0, 0.0, 13.0);\n  let i = u32(t);\n  let j = min(i + 1u, 13u);\n  return mix(lut[i], lut[j], t - f32(i));\n}\n\n@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  let x = f32((vi & 1u) << 2u) - 1.0;\n  let y = f32((vi & 2u) << 1u) - 1.0;\n  return vec4f(x, y, 0.0, 1.0);\n}\n\n@fragment fn fs(@builtin(position) fragCoord: vec4f) -> @location(0) vec4f {\n  let coord = vec2<i32>(fragCoord.xy);\n  let hdr = textureLoad(hdrTex, coord, 0);\n  let alpha = textureLoad(maskTex, coord, 0).g;\n  let a = max(alpha, 1e-6);\n  let straight = hdr.rgb / a;\n  let fullSz = vec2f(textureDimensions(hdrTex));\n  // Bloom is at half-res (pyramid mip 0). Sampler interpolates back to full-res UVs.\n  // fragCoord.xy is already at pixel center (e.g. 0.5, 0.5 for first pixel).\n  let bloomUv = fragCoord.xy / max(fullSz, vec2f(1.0));\n  let tint = viewU[1].xyz;\n  let intensity = viewU[1].w;\n  let bloom = textureSampleLevel(bloomTex, bloomSamp, bloomUv, 0.0).rgb * tint * intensity;\n  let combined = straight + bloom;\n  let exposed = combined * exp2(viewU[0].x);\n  let tm = vec3f(filmic(exposed.r), filmic(exposed.g), filmic(exposed.b));\n  var disp = max(tm, vec3f(0.0));\n  if (APPLY_GAMMA) {\n    disp = pow(disp, vec3f(viewU[0].y));\n  }\n  return vec4f(disp * alpha, alpha);\n}\n";
+export declare const COMPOSITE_SHADER_WGSL = "\n// Pipeline-override constant: the engine creates two composite pipelines, one\n// with APPLY_GAMMA=false (gamma=1 fast path) and one with APPLY_GAMMA=true.\n// The 'if (APPLY_GAMMA)' below is resolved at pipeline-compile time \u2014 the\n// dead branch is dropped by the shader compiler (no runtime branch, no pow\n// invocation on Safari's Metal backend in the common case).\noverride APPLY_GAMMA: bool = true;\n\n@group(0) @binding(0) var hdrTex: texture_2d<f32>;\n@group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)\n@group(0) @binding(2) var bloomSamp: sampler;\n@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 2>;\n// Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).\n// .g = accumulated canvas alpha (what hdr.a carried before the HDR format\n// became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then\n// re-premultiply the tonemapped color for output so the premultiplied canvas\n// alphaMode composites the WebGPU surface over the page background correctly.\n@group(0) @binding(4) var maskTex: texture_2d<f32>;\n// Filmic tone curve baked to a WIDTH\u00D71 r16float LUT (bakeFilmicLut on the CPU side).\n// Domain: log2(linear) mapped to [0,13]. Replaces the old array<f32,14> that was indexed\n// by a runtime u32 (a Metal-backend smell \u2014 dynamic local-array indexing lowers to a\n// per-invocation copy/switch) and interpolated piecewise-linearly (C0, so segment slope\n// discontinuities showed as Mach bands in smooth skin/shadow gradients). The LUT is a\n// monotone-cubic (Fritsch\u2013Carlson) fit through the same 14 anchors \u2014 same values, C1\n// continuity kills the banding \u2014 sampled with hardware linear filtering.\n@group(0) @binding(5) var filmicLut: texture_2d<f32>;\n// viewU[0] = (exposure, invGamma, _, _);  viewU[1] = (tint.rgb, intensity)\n// invGamma = 1/gamma precomputed on CPU \u2014 avoids a per-pixel divide.\n\n// Must match FILMIC_LUT_WIDTH in engine.ts (bakeFilmicLut).\nconst FILMIC_LUT_W: f32 = 256.0;\n\nfn filmic(x: f32) -> f32 {\n  // Reference checkpoints (Blender 3.6 Filmic MHC, sobotka/filmic-blender\n  // look_medium-high-contrast.spi1d): linear 0.18 \u2192 ~0.395, linear 1.0 \u2192 ~0.83.\n  // NOTE: version-pinned to Blender 3.6 \u2014 4.x defaults to AgX, not Filmic.\n  let t = clamp(log2(max(x, 1e-10)) + 10.0, 0.0, 13.0);\n  // Map t\u2208[0,13] to the texel-center of baked sample j = t\u00B7(W-1)/13.\n  let u = (t * (FILMIC_LUT_W - 1.0) / 13.0 + 0.5) / FILMIC_LUT_W;\n  // textureSampleLevel (explicit LOD, no derivatives) is legal in non-uniform flow.\n  return textureSampleLevel(filmicLut, bloomSamp, vec2f(u, 0.5), 0.0).r;\n}\n\n@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  let x = f32((vi & 1u) << 2u) - 1.0;\n  let y = f32((vi & 2u) << 1u) - 1.0;\n  return vec4f(x, y, 0.0, 1.0);\n}\n\n@fragment fn fs(@builtin(position) fragCoord: vec4f) -> @location(0) vec4f {\n  let coord = vec2<i32>(fragCoord.xy);\n  let hdr = textureLoad(hdrTex, coord, 0);\n  let alpha = textureLoad(maskTex, coord, 0).g;\n  let a = max(alpha, 1e-6);\n  let straight = hdr.rgb / a;\n  let fullSz = vec2f(textureDimensions(hdrTex));\n  // Bloom is at half-res (pyramid mip 0). Sampler interpolates back to full-res UVs.\n  // fragCoord.xy is already at pixel center (e.g. 0.5, 0.5 for first pixel).\n  let bloomUv = fragCoord.xy / max(fullSz, vec2f(1.0));\n  let tint = viewU[1].xyz;\n  let intensity = viewU[1].w;\n  let bloom = textureSampleLevel(bloomTex, bloomSamp, bloomUv, 0.0).rgb * tint * intensity;\n  let combined = straight + bloom;\n  let exposed = combined * exp2(viewU[0].x);\n  let tm = vec3f(filmic(exposed.r), filmic(exposed.g), filmic(exposed.b));\n  var disp = max(tm, vec3f(0.0));\n  if (APPLY_GAMMA) {\n    disp = pow(disp, vec3f(viewU[0].y));\n  }\n  return vec4f(disp * alpha, alpha);\n}\n";
 //# sourceMappingURL=composite.d.ts.map

package/dist/shaders/passes/composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,mnGAiEjC,CAAA"}
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,s0HAuEjC,CAAA"}

package/dist/shaders/passes/composite.js

@@ -18,23 +18,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/dist/shaders/passes/morph.d.ts

@@ -0,0 +1,2 @@
+export declare const MORPH_COMPUTE_WGSL = "\nstruct Params { vertexCount: u32 };\n\n@group(0) @binding(0) var<storage, read> basePos: array<f32>;      // vertexCount * 3\n@group(0) @binding(1) var<storage, read> rowStart: array<u32>;     // vertexCount + 1\n@group(0) @binding(2) var<storage, read> colMorph: array<u32>;     // entryCount\n@group(0) @binding(3) var<storage, read> colOffset: array<f32>;    // entryCount * 3\n@group(0) @binding(4) var<storage, read> weights: array<f32>;      // morphCount (effective)\n@group(0) @binding(5) var<storage, read_write> vtx: array<f32>;    // vertexCount * 8\n@group(0) @binding(6) var<uniform> params: Params;\n\n@compute @workgroup_size(64)\nfn cs(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let v = gid.x;\n  if (v >= params.vertexCount) { return; }\n\n  let b3 = v * 3u;\n  var px = basePos[b3];\n  var py = basePos[b3 + 1u];\n  var pz = basePos[b3 + 2u];\n\n  let s = rowStart[v];\n  let e = rowStart[v + 1u];\n  for (var i = s; i < e; i = i + 1u) {\n    let w = weights[colMorph[i]];\n    if (w != 0.0) {\n      let o3 = i * 3u;\n      px = px + w * colOffset[o3];\n      py = py + w * colOffset[o3 + 1u];\n      pz = pz + w * colOffset[o3 + 2u];\n    }\n  }\n\n  let vo = v * 8u; // VERTEX_STRIDE \u2014 write only the position slots\n  vtx[vo] = px;\n  vtx[vo + 1u] = py;\n  vtx[vo + 2u] = pz;\n}\n";
+//# sourceMappingURL=morph.d.ts.map

package/dist/shaders/passes/morph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"morph.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/morph.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kBAAkB,2yCAsC9B,CAAA"}

package/dist/shaders/passes/morph.js

@@ -0,0 +1,49 @@
+// 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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "reze-engine",
-    "version": "0.15.1",
+    "version": "0.16.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

@@ -37,6 +37,10 @@ export class Camera {
   lowerBetaLimit: number = 0.001
   upperBetaLimit: number = Math.PI - 0.001
 
+  // Reused each frame so getViewMatrix/getProjectionMatrix don't allocate a Mat4 per call.
+  private _viewMat = new Mat4(new Float32Array(16))
+  private _projMat = new Mat4(new Float32Array(16))
+
   constructor(alpha: number, beta: number, radius: number, target: Vec3, fov: number = Math.PI / 4) {
     this.alpha = alpha
     this.beta = beta
@@ -66,8 +70,9 @@ export class Camera {
 
   getViewMatrix(): Mat4 {
     const eye = this.getPosition()
-    const up = new Vec3(0, 1, 0)
-    return Mat4.lookAt(eye, this.target, up)
+    const t = this.target
+    Mat4.lookAtInto(this._viewMat.values, eye.x, eye.y, eye.z, t.x, t.y, t.z, 0, 1, 0)
+    return this._viewMat
   }
 
   // Get camera's right and up vectors for panning
@@ -139,7 +144,8 @@ export class Camera {
 
   getProjectionMatrix(): Mat4 {
     this.updateFarFromRadius()
-    return Mat4.perspective(this.fov, this.aspect, this.near, this.far)
+    Mat4.perspectiveInto(this._projMat.values, this.fov, this.aspect, this.near, this.far)
+    return this._projMat
   }
 
   attachControl(canvas: HTMLCanvasElement) {