reze-engine 0.64.0 → 0.65.0

package/src/graph/slots.ts

@@ -191,7 +191,13 @@ function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: bo
   // painted sheet — is Blender's Emission shader, which no lamp reaches; adding
   // the lamps to it turned X340's floor shadow, a white-RGB picture at a soft
   // alpha, into a glowing disc under the spot above it.
-  const LIT = takesLight ? ` + rzLightsDiffuseOnce(input.worldPos, n) * albedo` : ""
+  //
+  // The model's fill (Engine.setModelFill) rides here too, as brightness: the
+  // surface colour times the fill, on every pixel of her alike. In the graph's
+  // ambient an NPR ramp would read it as LIGHT — sliding it would move her
+  // shadows, and under a hard step flip whole regions at once. After the graph
+  // it lifts her evenly and leaves every shadow where it is.
+  const LIT = takesLight ? ` + (rzLightsDiffuseOnce(input.worldPos, n) + objectLight.fill.rgb) * albedo` : ""
 
   const ALBEDO = `  let albedo = tex_color;
 `

package/src/index.ts

@@ -14,6 +14,7 @@ export {
   type BloomOptions,
   type DepthOfFieldOptions,
   type ViewTransformOptions,
+  type ViewTransformName,
   type LoadModelFromFilesOptions,
   type MaterialPreset,
   type MaterialPresetMap,

package/src/model.ts

@@ -3,6 +3,7 @@ import { Engine } from "./engine"
 import { joinAssetPath, type AssetReader } from "./asset-reader"
 import { Rigidbody, Joint } from "./physics"
 import { IKSolverSystem } from "./ik-solver"
+import { buildOutlineVertices } from "./outline-normals"
 import { VMDLoader, type VMDKeyFrame } from "./vmd-loader"
 import { VMDWriter, type VmdTrackSelection } from "./vmd-writer"
 import {
@@ -564,8 +565,10 @@ export class Model {
     morphing: Morphing,
     rigidbodies: Rigidbody[] = [],
     joints: Joint[] = [],
-    loadWarnings: string[] = []
+    loadWarnings: string[] = [],
+    edgeScales: Float32Array | null = null
   ) {
+    this.edgeScales = edgeScales
     // Store base vertex data (original positions before morphing)
     this.baseVertexData = new Float32Array(vertexData)
     this.vertexData = vertexData
@@ -1001,6 +1004,20 @@ export class Model {
     return this.vertexData
   }
 
+  /** PMX per-vertex edge scale, when the source had one. */
+  private edgeScales: Float32Array | null = null
+  private outlineVertices: Float32Array<ArrayBuffer> | null = null
+
+  /**
+   * The outline hull's own vertex stream: per vertex, the smoothed rest-pose
+   * normal (xyz) and the PMX edge scale (w). See outline-normals.ts. Built on
+   * first ask — only models with an edge-flagged material ever ask.
+   */
+  getOutlineVertices(): Float32Array<ArrayBuffer> {
+    this.outlineVertices ??= buildOutlineVertices(this.baseVertexData, VERTEX_STRIDE, this.indexData, this.edgeScales ?? undefined)
+    return this.outlineVertices
+  }
+
   getTextures(): Texture[] {
     return this.textures
   }

package/src/outline-normals.ts

@@ -0,0 +1,110 @@
+// The inverted hull's own push direction, one per vertex, built once at load.
+//
+// The hull is the model pushed out along a normal. Pushed along the MESH's
+// normals it tears wherever the mesh carries two vertices at one position —
+// every hard edge and every UV seam — because the two copies go two ways and
+// the gap between them shows the body through the line: the jaw, the finger
+// joints, the parting in the hair. Aether Gazer bakes a smoothed normal into
+// vertex colour for exactly this (Character/Debug.shader, pass "Outline"); a
+// PMX has nowhere to carry one, so it is computed here instead: the normals of
+// every vertex at one position, averaged, so the copies agree and the hull
+// stays closed.
+//
+// Each vertex's vote is weighted by the corner angles it owns, which is what
+// makes a hard corner come out as the corner's true bisector rather than
+// leaning toward whichever side happened to be cut into more triangles.
+//
+// Rest pose only, as the game's is: a morph moves the positions and leaves this
+// alone, and skinning turns it exactly as it turns the normal.
+
+/** Positions closer than this (model units) are one position. */
+export const OUTLINE_WELD_EPSILON = 1e-4
+
+/**
+ * Smoothed outline normals, packed with the PMX per-vertex edge scale:
+ * xyz = unit direction, w = edge scale — four floats per vertex.
+ *
+ * @param vertexData interleaved [pos3, normal3, uv2] per vertex
+ * @param indices    triangle list
+ * @param edgeScales per-vertex PMX edge scale, or omitted for 1
+ */
+export function buildOutlineVertices(
+  vertexData: ArrayLike<number>,
+  stride: number,
+  indices: ArrayLike<number>,
+  edgeScales?: ArrayLike<number>,
+): Float32Array<ArrayBuffer> {
+  const n = Math.floor(vertexData.length / stride)
+  const out = new Float32Array(n * 4)
+
+  // Corner angles each vertex owns. A vertex no triangle uses keeps a token
+  // weight, so it still has a direction of its own.
+  const weight = new Float32Array(n).fill(1e-6)
+  for (let t = 0; t + 2 < indices.length; t += 3) {
+    const a = indices[t], b = indices[t + 1], c = indices[t + 2]
+    if (a >= n || b >= n || c >= n) continue
+    weight[a] += cornerAngle(vertexData, stride, a, b, c)
+    weight[b] += cornerAngle(vertexData, stride, b, c, a)
+    weight[c] += cornerAngle(vertexData, stride, c, a, b)
+  }
+
+  // Weld by quantized position.
+  const inv = 1 / OUTLINE_WELD_EPSILON
+  const group = new Int32Array(n)
+  const ids = new Map<string, number>()
+  let groups = 0
+  for (let i = 0; i < n; i++) {
+    const o = i * stride
+    const key = `${Math.round(vertexData[o] * inv)},${Math.round(vertexData[o + 1] * inv)},${Math.round(vertexData[o + 2] * inv)}`
+    let g = ids.get(key)
+    if (g === undefined) {
+      g = groups++
+      ids.set(key, g)
+    }
+    group[i] = g
+  }
+
+  const sum = new Float32Array(groups * 3)
+  for (let i = 0; i < n; i++) {
+    const o = i * stride
+    const w = weight[i]
+    const g = group[i] * 3
+    sum[g] += vertexData[o + 3] * w
+    sum[g + 1] += vertexData[o + 4] * w
+    sum[g + 2] += vertexData[o + 5] * w
+  }
+
+  for (let i = 0; i < n; i++) {
+    const o = i * stride
+    const nx = vertexData[o + 3], ny = vertexData[o + 4], nz = vertexData[o + 5]
+    const g = group[i] * 3
+    let x = sum[g], y = sum[g + 1], z = sum[g + 2]
+    const len = Math.hypot(x, y, z)
+    // Two sheets back to back at one position (a double-sided skirt, a shell
+    // and its lining) cancel to nothing, or to a direction pointing INTO one of
+    // them. Either way the welded answer is wrong for this vertex, and its own
+    // normal is the honest one.
+    if (len < 1e-6 || x * nx + y * ny + z * nz <= 0) {
+      x = nx
+      y = ny
+      z = nz
+    }
+    const l = Math.hypot(x, y, z) || 1
+    out[i * 4] = x / l
+    out[i * 4 + 1] = y / l
+    out[i * 4 + 2] = z / l
+    out[i * 4 + 3] = edgeScales ? edgeScales[i] : 1
+  }
+  return out
+}
+
+/** The angle at vertex `a` of triangle (a, b, c), in radians. */
+function cornerAngle(v: ArrayLike<number>, stride: number, a: number, b: number, c: number): number {
+  const oa = a * stride, ob = b * stride, oc = c * stride
+  const ux = v[ob] - v[oa], uy = v[ob + 1] - v[oa + 1], uz = v[ob + 2] - v[oa + 2]
+  const wx = v[oc] - v[oa], wy = v[oc + 1] - v[oa + 1], wz = v[oc + 2] - v[oa + 2]
+  const lu = Math.hypot(ux, uy, uz), lw = Math.hypot(wx, wy, wz)
+  if (lu < 1e-12 || lw < 1e-12) return 0
+  const cos = (ux * wx + uy * wy + uz * wz) / (lu * lw)
+  return Math.acos(Math.max(-1, Math.min(1, cos)))
+}

package/src/pmx-loader.ts

@@ -36,6 +36,9 @@ export class PmxLoader {
   private inverseBindMatrices: Float32Array | null = null
   private joints0: Uint16Array | null = null
   private weights0: Uint8Array | null = null
+  /** PMX per-vertex edge scale — the outline's width multiplier, as the
+   *  game's outline takes vertex colour alpha. */
+  private edgeScales: Float32Array | null = null
   private morphs: Morph[] = []
   private vertexCount: number = 0
   private rigidbodies: Rigidbody[] = []
@@ -150,6 +153,7 @@ export class PmxLoader {
     // Prepare skinning arrays (4 influences per vertex)
     const joints = new Uint16Array(count * 4)
     const weights = new Uint8Array(count * 4) // UNORM8, will be normalized to 255
+    const edgeScales = new Float32Array(count)
 
     for (let i = 0; i < count; i++) {
       const px = this.getFloat32()
@@ -238,11 +242,12 @@ export class PmxLoader {
       } else {
         throw new Error(`Invalid bone weight type: ${type}`)
       }
-      this.offset += 4 // edge scale
+      edgeScales[i] = this.getFloat32()
     }
 
     this.joints0 = joints
     this.weights0 = weights
+    this.edgeScales = edgeScales
     return { positions, normals, uvs }
   }
 
@@ -1136,7 +1141,8 @@ export class PmxLoader {
       morphing,
       this.rigidbodies,
       this.joints,
-      this.warnings
+      this.warnings,
+      this.edgeScales
     )
   }
 

package/src/shaders/materials/common.ts

@@ -195,8 +195,10 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 //             layers, as the game lights them;
 //   ambient.x 1 while it has an ambient of its own (Engine.setModelAmbient),
 //             0 for the world's;
-//   sh        that ambient's irradiance, folded as the world's (ibl.ts).
-struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9> }
+//   sh        that ambient's irradiance, folded as the world's (ibl.ts);
+//   fill.rgb  its fill (Engine.setModelFill), added after its graph times its
+//             surface colour — zero for a model that has none.
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f }
 @group(1) @binding(1) var<uniform> objectLight: ObjectLight;
 
 /** The light arriving at a surface of this object facing n: its own ambient

package/src/shaders/passes/bloom.ts

@@ -1,7 +1,7 @@
-// EEVEE 3.6 bloom pyramid: blit (Karis prefilter) → 13-tap downsamples → 9-tap tent upsamples.
-// Mirrors source/blender/draw/engines/eevee/shaders/effect_bloom_frag.glsl. Firefly suppression
-// lives in the blit (Karis luminance-weighted 4-tap average). A single-pass Gaussian cannot
-// reproduce this — hot pixels dominate and produce the sparkle halo.
+// Bloom — Aether Gazer's own chain (AGSimPostFX.Bloom, URP-style): a soft-knee
+// prefilter to half size, a separable Gaussian down to a few pixels, then back
+// up level by level, each blend leaning toward the coarser level by `scatter`.
+// The composite adds the result × tint × intensity before the view transform.
 
 const FULLSCREEN_VS = /* wgsl */ `
 @vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
@@ -11,114 +11,86 @@ const FULLSCREEN_VS = /* wgsl */ `
 }
 `
 
-// Full-res HDR → half-res. Karis 4-tap firefly average + EEVEE quadratic knee threshold + clamp.
-export const BLOOM_BLIT_SHADER_WGSL = `${FULLSCREEN_VS}
+// Full-res HDR → half-res. The game takes ONE bilinear sample at the half-res
+// pixel's centre, which is the 2×2 box of the block under it; here the four
+// texels are loaded so each can be un-premultiplied (the scene target is
+// premultiplied; its alpha lives in the aux target's .g) and gated by the bloom
+// mask (.r) first.
+export const BLOOM_PREFILTER_SHADER_WGSL = `${FULLSCREEN_VS}
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
-@group(0) @binding(1) var<uniform> prefilter: vec4<f32>; // threshold, knee, clamp, _unused
+@group(0) @binding(1) var<uniform> params: vec4<f32>; // threshold, knee, clamp, scatter
 @group(0) @binding(2) var maskTex: texture_2d<f32>;
 
-fn luminance(c: vec3f) -> f32 {
-  return dot(max(c, vec3f(0.0)), vec3f(0.2126, 0.7152, 0.0722));
-}
-fn fetch(c: vec2<i32>, clampV: f32) -> vec3f {
+fn fetch(c: vec2<i32>) -> vec3f {
   let d = vec2<i32>(textureDimensions(hdrTex));
   let cc = clamp(c, vec2<i32>(0), d - vec2<i32>(1));
-  let s = textureLoad(hdrTex, cc, 0);
-  // hdrTex is rg11b10ufloat (no alpha channel). Alpha lives in maskTex.g, written
-  // alongside the bloom mask in .r by the scene pass. Scene uses src-alpha blend
-  // with clear alpha 0 → hdr rgb is premultiplied; divide by the aux alpha to
-  // recover straight color before the Karis luminance weighting.
   let aux = textureLoad(maskTex, cc, 0);
-  let mask = aux.r;
-  let rgb = max(s.rgb / max(aux.g, 1e-6), vec3f(0.0));
-  let masked = rgb * mask;
-  // Blender clamps each tap BEFORE Karis average (eevee_bloom: color = min(clampIntensity, color)).
-  return select(masked, min(masked, vec3f(clampV)), clampV > 0.0);
+  return max(textureLoad(hdrTex, cc, 0).rgb / max(aux.g, 1e-6), vec3f(0.0)) * aux.r;
 }
 
 @fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
-  let dst = vec2<i32>(p.xy - vec2f(0.5));
-  let base = dst * 2;
-  let clampV = prefilter.z;
-  let a = fetch(base + vec2<i32>(0, 0), clampV);
-  let b = fetch(base + vec2<i32>(1, 0), clampV);
-  let c = fetch(base + vec2<i32>(0, 1), clampV);
-  let d = fetch(base + vec2<i32>(1, 1), clampV);
-  // Karis partial average: weight each tap by 1/(1+luma) — suppresses fireflies.
-  let wa = 1.0 / (1.0 + luminance(a));
-  let wb = 1.0 / (1.0 + luminance(b));
-  let wc = 1.0 / (1.0 + luminance(c));
-  let wd = 1.0 / (1.0 + luminance(d));
-  let avg = (a * wa + b * wb + c * wc + d * wd) / max(wa + wb + wc + wd, 1e-6);
-  // EEVEE quadratic threshold (brightness = max-channel, then soft-knee curve).
-  let bright = max(avg.r, max(avg.g, avg.b));
-  let soft = clamp(bright - prefilter.x + prefilter.y, 0.0, 2.0 * prefilter.y);
-  let q = (soft * soft) / (4.0 * max(prefilter.y, 1e-4) + 1e-6);
-  let contrib = max(q, bright - prefilter.x) / max(bright, 1e-4);
-  return vec4f(max(avg * contrib, vec3f(0.0)), 1.0);
+  let base = vec2<i32>(p.xy - vec2f(0.5)) * 2;
+  let avg = (fetch(base) + fetch(base + vec2<i32>(1, 0)) + fetch(base + vec2<i32>(0, 1)) + fetch(base + vec2<i32>(1, 1))) * 0.25;
+  let c = min(avg, vec3f(params.z));
+  // URP's quadratic soft knee on the brightest channel.
+  let bright = max(c.r, max(c.g, c.b));
+  let knee = params.y;
+  let soft = clamp(bright - params.x + knee, 0.0, 2.0 * knee);
+  let curve = soft * soft / (4.0 * knee + 1e-4);
+  return vec4f(c * (max(curve, bright - params.x) / max(bright, 1e-4)), 1.0);
 }
 `
 
-// Jimenez/COD 13-tap dual-box — 5 weighted 2×2 averages, rejects nyquist ringing.
-export const BLOOM_DOWNSAMPLE_SHADER_WGSL = `${FULLSCREEN_VS}
+// Horizontal 9-tap Gaussian (σ ≈ 2 at the destination's scale), its taps two
+// SOURCE texels apart: the destination is half the source, so this both halves
+// and blurs. Each tap lands on a texel boundary, so bilinear averages pairs.
+export const BLOOM_BLUR_H_SHADER_WGSL = `${FULLSCREEN_VS}
 @group(0) @binding(0) var srcTex: texture_2d<f32>;
 @group(0) @binding(1) var srcSamp: sampler;
 
-fn samp(uv: vec2f, off: vec2f) -> vec3f {
-  return textureSampleLevel(srcTex, srcSamp, uv + off, 0.0).rgb;
+@fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
+  let srcDims = vec2f(textureDimensions(srcTex));
+  let dstDims = max(floor(srcDims * 0.5), vec2f(1.0));
+  let uv = p.xy / dstDims;
+  let dx = vec2f(2.0 / srcDims.x, 0.0);
+  var w = array<f32, 5>(0.22702703, 0.19459459, 0.12162162, 0.05405405, 0.01621622);
+  var o = textureSampleLevel(srcTex, srcSamp, uv, 0.0).rgb * w[0];
+  for (var i = 1; i < 5; i++) {
+    let off = dx * f32(i);
+    o += (textureSampleLevel(srcTex, srcSamp, uv - off, 0.0).rgb + textureSampleLevel(srcTex, srcSamp, uv + off, 0.0).rgb) * w[i];
+  }
+  return vec4f(o, 1.0);
 }
+`
+
+// Vertical pass at the same size: the same 9-tap Gaussian as five bilinear taps.
+export const BLOOM_BLUR_V_SHADER_WGSL = `${FULLSCREEN_VS}
+@group(0) @binding(0) var srcTex: texture_2d<f32>;
+@group(0) @binding(1) var srcSamp: sampler;
 
 @fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
-  let srcDims = vec2f(textureDimensions(srcTex));
-  let t = 1.0 / srcDims;
-  // fragCoord.xy reports pixel centers (e.g. 0.5,0.5 for first pixel) — divide by dst dims directly.
-  let dstDims = srcDims * 0.5;
-  let uv = p.xy / max(dstDims, vec2f(1.0));
-  let A = samp(uv, t * vec2f(-2.0, -2.0));
-  let B = samp(uv, t * vec2f( 0.0, -2.0));
-  let C = samp(uv, t * vec2f( 2.0, -2.0));
-  let D = samp(uv, t * vec2f(-1.0, -1.0));
-  let E = samp(uv, t * vec2f( 1.0, -1.0));
-  let F = samp(uv, t * vec2f(-2.0,  0.0));
-  let G = samp(uv, t * vec2f( 0.0,  0.0));
-  let H = samp(uv, t * vec2f( 2.0,  0.0));
-  let I = samp(uv, t * vec2f(-1.0,  1.0));
-  let J = samp(uv, t * vec2f( 1.0,  1.0));
-  let K = samp(uv, t * vec2f(-2.0,  2.0));
-  let L = samp(uv, t * vec2f( 0.0,  2.0));
-  let M = samp(uv, t * vec2f( 2.0,  2.0));
-  var o = (D + E + I + J) * (0.5 / 4.0);
-  o = o + (A + B + G + F) * (0.125 / 4.0);
-  o = o + (B + C + H + G) * (0.125 / 4.0);
-  o = o + (F + G + L + K) * (0.125 / 4.0);
-  o = o + (G + H + M + L) * (0.125 / 4.0);
+  let dims = vec2f(textureDimensions(srcTex));
+  let uv = p.xy / dims;
+  let near = vec2f(0.0, 1.3846154 / dims.y);
+  let far = vec2f(0.0, 3.2307692 / dims.y);
+  var o = textureSampleLevel(srcTex, srcSamp, uv, 0.0).rgb * 0.22702703;
+  o += (textureSampleLevel(srcTex, srcSamp, uv - near, 0.0).rgb + textureSampleLevel(srcTex, srcSamp, uv + near, 0.0).rgb) * 0.31621623;
+  o += (textureSampleLevel(srcTex, srcSamp, uv - far, 0.0).rgb + textureSampleLevel(srcTex, srcSamp, uv + far, 0.0).rgb) * 0.07027027;
   return vec4f(o, 1.0);
 }
 `
 
-// 9-tap tent, progressively added to matching downsample mip. Blender radius = sample scale.
+// One level up: this level's blur leaned toward the coarser one by scatter.
 export const BLOOM_UPSAMPLE_SHADER_WGSL = `${FULLSCREEN_VS}
-@group(0) @binding(0) var srcTex: texture_2d<f32>;   // coarser accumulator
-@group(0) @binding(1) var baseTex: texture_2d<f32>;  // matching downsample mip
+@group(0) @binding(0) var highTex: texture_2d<f32>;  // down[i]
+@group(0) @binding(1) var lowTex: texture_2d<f32>;   // coarser: down[i+1] at the top, up[i+1] after
 @group(0) @binding(2) var srcSamp: sampler;
-@group(0) @binding(3) var<uniform> upU: vec4<f32>;   // sampleScale, _, _, _
+@group(0) @binding(3) var<uniform> params: vec4<f32>; // threshold, knee, clamp, scatter
 
 @fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
-  let srcDims = vec2f(textureDimensions(srcTex));
-  let baseDims = vec2f(textureDimensions(baseTex));
-  let uv = p.xy / max(baseDims, vec2f(1.0));
-  let t = upU.x / srcDims;
-  var o = textureSampleLevel(srcTex, srcSamp, uv + t * vec2f(-1.0, -1.0), 0.0).rgb * 1.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 0.0, -1.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 1.0, -1.0), 0.0).rgb * 1.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f(-1.0,  0.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 0.0,  0.0), 0.0).rgb * 4.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 1.0,  0.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f(-1.0,  1.0), 0.0).rgb * 1.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 0.0,  1.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 1.0,  1.0), 0.0).rgb * 1.0;
-  o = o * (1.0 / 16.0);
-  let base = textureSampleLevel(baseTex, srcSamp, uv, 0.0).rgb;
-  return vec4f(o + base, 1.0);
+  let uv = p.xy / vec2f(textureDimensions(highTex));
+  let high = textureSampleLevel(highTex, srcSamp, uv, 0.0).rgb;
+  let low = textureSampleLevel(lowTex, srcSamp, uv, 0.0).rgb;
+  return vec4f(mix(high, low, params.w), 1.0);
 }
 `