reze-engine 0.66.3 → 0.66.5

package/src/engine.ts

@@ -79,7 +79,7 @@ import {
 } from "./shaders/lights"
 import { buildLightGrid } from "./light-grid"
 import { groundShaderWgsl, GROUND_NOISE_BAKE_WGSL, GROUND_NOISE_SIZE } from "./shaders/passes/ground"
-import { outlineShaderWgsl, RZ_OUTLINE_DISSOLVE_OFFSET } from "./shaders/passes/outline"
+import { outlineShaderWgsl, RZ_OUTLINE_COLOR_OFFSET, RZ_OUTLINE_DISSOLVE_OFFSET, RZ_OUTLINE_WIDTH_OFFSET } from "./shaders/passes/outline"
 import { transparentDepthPrepassWgsl } from "./shaders/passes/depth-prepass"
 import { SELECTION_MASK_SHADER_WGSL, SELECTION_EDGE_SHADER_WGSL } from "./shaders/passes/selection"
 import { GIZMO_SHADER_WGSL } from "./shaders/passes/gizmo"
@@ -3324,6 +3324,51 @@ export class Engine {
     this.bundlesDirty = true
   }
 
+  /**
+   * Every outline's width, as a multiple of what each PMX material asked for
+   * (its edgeSize): 1 is the author's own, 0 draws none. A multiplier rather
+   * than a width because a model's lines are not one width — the hair's rim
+   * and a sleeve's crease differ on purpose, and scaling keeps that.
+   *
+   * A write, not a re-record: one float in each hull's uniform, so a slider
+   * can drive it. Hulls built later take the current value at creation.
+   */
+  private outlineWidth = 1
+  setOutlineWidth(scale: number): void {
+    const v = Number.isFinite(scale) ? Math.max(0, scale) : 1
+    if (this.outlineWidth === v) return
+    this.outlineWidth = v
+    if (!this.device) return
+    const one = new Float32Array([v])
+    for (const inst of this.modelInstances.values()) {
+      for (const buffer of inst.outlineUniformBuffers) {
+        this.device.queue.writeBuffer(buffer, RZ_OUTLINE_WIDTH_OFFSET, one)
+      }
+    }
+  }
+
+  /**
+   * One colour for every outline, in place of each PMX material's edge colour;
+   * null hands each material its own back. Written as the edge colour is —
+   * the values a PMX would carry — so a picked black is MMD's black. The
+   * material's edge ALPHA is kept: only the hue is the scene's.
+   *
+   * A write, like setOutlineWidth: hulls built later take it at creation.
+   */
+  private outlineColor: [number, number, number, number] = [0, 0, 0, 0]
+  setOutlineColor(color: Vec3 | { x: number; y: number; z: number } | null): void {
+    const next: [number, number, number, number] = color ? [color.x, color.y, color.z, 1] : [0, 0, 0, 0]
+    if (next.every((v, i) => v === this.outlineColor[i])) return
+    this.outlineColor = next
+    if (!this.device) return
+    const data = new Float32Array(next)
+    for (const inst of this.modelInstances.values()) {
+      for (const buffer of inst.outlineUniformBuffers) {
+        this.device.queue.writeBuffer(buffer, RZ_OUTLINE_COLOR_OFFSET, data)
+      }
+    }
+  }
+
   /**
    * Draw the id attachment instead of the scene.
    *
@@ -9981,6 +10026,46 @@ export class Engine {
     if (this.cameraPoseOverride) this.camera.setVmdPose(this.cameraPoseOverride)
   }
 
+  /**
+   * The host's adjustment to a camera track, added to every pose it samples.
+   *
+   * A downloaded camera motion is framed for whoever it was made with: a
+   * shorter model wants it lower, a wider stage wants it further back. This
+   * moves the shot without touching its ANGLE — the motion's rotation and roll
+   * are its choreography, and they stay the track's.
+   *
+   * - `target`: world units, added to the look-at point, so the whole shot
+   *   slides with the angle unchanged.
+   * - `distance`: positive pulls the eye further back along its own line of
+   *   sight. VMD distances are signed (negative is behind the target, the usual
+   *   case), so "further" means away from zero on whichever side it is.
+   * - `fov`: radians, added to the track's lens, never below a sliver.
+   *
+   * Only a loaded track reads it: the orbit has its own sliders, and a pose
+   * forced through setCameraPose is a statement of where the camera IS.
+   */
+  private cameraTrackOffset = { target: new Vec3(0, 0, 0), distance: 0, fov: 0 }
+  setCameraTrackOffset(offset: { target?: { x: number; y: number; z: number }; distance?: number; fov?: number } | null): void {
+    const t = offset?.target
+    this.cameraTrackOffset = {
+      target: new Vec3(t?.x ?? 0, t?.y ?? 0, t?.z ?? 0),
+      distance: offset?.distance ?? 0,
+      fov: offset?.fov ?? 0,
+    }
+  }
+
+  /** A sampled track pose with the host's offset laid on. */
+  private offsetTrackPose(pose: CameraPose): CameraPose {
+    const o = this.cameraTrackOffset
+    if (o.distance === 0 && o.fov === 0 && o.target.x === 0 && o.target.y === 0 && o.target.z === 0) return pose
+    return {
+      target: new Vec3(pose.target.x + o.target.x, pose.target.y + o.target.y, pose.target.z + o.target.z),
+      rotation: pose.rotation,
+      distance: pose.distance + Math.sign(pose.distance || -1) * o.distance,
+      fov: Math.min(Math.PI * 0.95, Math.max(0.01, pose.fov + o.fov)),
+    }
+  }
+
   /** The pose currently forced from outside, or null when nothing is. */
   getCameraPoseOverride(): CameraPose | null {
     return this.cameraPoseOverride
@@ -10974,6 +11059,12 @@ export class Engine {
         { binding: 12, resource: { buffer: this.probeUniformBuffer } },
       ],
     })
+    // The recorded phases bind these groups by value (sceneView), so a rebuild
+    // they never hear about leaves them drawing with the old one: the first
+    // light cookie landed on the ground (re-bound each frame) and not on the
+    // cast, and a swapped sky kept reflecting the one it replaced. Only init,
+    // a world install and the first cookie get here, so re-recording is cheap.
+    this.bundlesDirty = true
     return true
   }
 
@@ -15458,8 +15549,14 @@ export class Engine {
           // block's layout would be 32 bytes of padding per outlined material
           // to carry one float. See RZ_OUTLINE_DISSOLVE_OFFSET.
           1,
+          // The scene's width multiplier, at RZ_OUTLINE_WIDTH_OFFSET.
+          this.outlineWidth,
           0,
-          0,
+          // The scene's colour override, at RZ_OUTLINE_COLOR_OFFSET.
+          this.outlineColor[0],
+          this.outlineColor[1],
+          this.outlineColor[2],
+          this.outlineColor[3],
         ])
         const outlineUniformBuffer = this.createUniformBuffer(`${prefix}outline: ${mat.name}`, materialUniformData)
         inst.gpuBuffers.push(outlineUniformBuffer)
@@ -17035,7 +17132,7 @@ export class Engine {
     } else if (this.camera.vmdDriven && this.cameraAnimation) {
       // Drive the shot from the camera VMD (synced to the animated model's clock).
       const pose = this.cameraAnimation.sample(this.transportTime())
-      if (pose) this.camera.setVmdPose(pose)
+      if (pose) this.camera.setVmdPose(this.offsetTrackPose(pose))
     }
 
     // Before the cast is written, which carries every subject's dissolve to the

package/src/graph/registry.ts

@@ -683,6 +683,21 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
     emit: (a) => `rz_glossy_direct(${a.normal}, l, v, sun, shadow, input.worldPos, 1.0 - (${a.smoothness}))`,
     takesLight: true,
   },
+  /**
+   * The lamps, handed to the graph — Shader Graph's Additional Lights: their
+   * diffuse at `normal`, and a Blinn-Phong highlight pow(N·H, exponent), both
+   * untinted. A graph that reads them combines them as its shader does (the
+   * game's water adds the diffuse into its body before its colour, and glints
+   * each lamp at exponent 128·smoothness), and owns the lamps' diffuse: the
+   * layer the engine otherwise adds after the graph is not added.
+   */
+  additional_lights: {
+    inputs: { exponent: F(64), normal: { type: "vector", contextDefault: "n" } },
+    outputs: { diffuse: "color", specular: "color" },
+    outputSelect: { diffuse: ".d", specular: ".s" },
+    emit: (a) => `rz_additional_lights(input.worldPos, ${a.normal}, v, ${a.exponent})`,
+    takesLight: true,
+  },
   reflection_probe: {
     inputs: {
       vector: { type: "vector", contextDefault: "reflect(-v, n)" },

package/src/shaders/materials/nodes.ts

@@ -1193,6 +1193,81 @@ fn rzLampsSpecular(p: vec3f, n: vec3f, v: vec3f, roughness: f32) -> vec3f {
   return s;
 }
 
+// ─── Additional lights, handed to the graph ─────────────
+//
+// Shader Graph's "Additional Lights" idiom: every lamp's diffuse and a
+// Blinn-Phong highlight, pow(N·H, e), for the graph to combine the way its
+// shader does. The game's water adds the diffuse into its body BEFORE tinting
+// it by its own colour and glints each lamp on that lobe — neither of which
+// the epilogue's layer (lamps × the slot-0 picture, added after) can say. So a
+// graph that reads them owns the lamps' diffuse and the epilogue adds none.
+//
+// Same reach as _rzLightOne: bulb, window, squared cone, cookie. A point
+// behind the surface gets neither term, as the game's step(N·L ≥ 0) has it.
+
+fn _rzAddLightOne(i: u32, p: vec3f, n: vec3f, v: vec3f, e: f32) -> _RzLampPair {
+  var out = _RzLampPair(vec3f(0.0), vec3f(0.0));
+  if (!_rzLightReaches(i)) { return out; }
+  let pr = _rzLightVec(i, 0u);
+  let d = pr.xyz - p;
+  let dist = length(d);
+  if (dist >= pr.w) { return out; }
+  let toLight = d / max(dist, 1e-4);
+  let ndl = dot(n, toLight);
+  if (ndl < 0.0) { return out; }
+  let t = clamp(dist / max(pr.w, 1e-4), 0.0, 1.0);
+  let t2 = t * t;
+  let window = 1.0 - t2 * t2;
+  let bulb = rzLightNear(i);
+  let falloff = window * window / max(dist * dist, bulb * bulb);
+  let cone = rzLightCone(i);
+  let aim = clamp((dot(-toLight, rzLightAim(i)) - cone.x) / max(cone.y - cone.x, 1e-4), 0.0, 1.0);
+  let reach = rzLightColor(i) * rzLightCookie(i, toLight) * (falloff * aim * aim);
+  out.d = reach * ndl;
+  out.s = reach * pow(saturate(dot(n, normalize(toLight + v))), e);
+  return out;
+}
+
+fn _rzAddLightWord(bits0: u32, base: u32, p: vec3f, n: vec3f, v: vec3f, e: f32) -> _RzLampPair {
+  var acc = _RzLampPair(vec3f(0.0), vec3f(0.0));
+  var bits = bits0;
+  loop {
+    if (bits == 0u) { break; }
+    let i = base + firstTrailingBit(bits);
+    bits = bits & (bits - 1u);
+    let one = _rzAddLightOne(i, p, n, v, e);
+    acc.d = acc.d + one.d;
+    acc.s = acc.s + one.s;
+  }
+  return acc;
+}
+
+fn rz_additional_lights(p: vec3f, n: vec3f, v: vec3f, e: f32) -> _RzLampPair {
+  var acc = _RzLampPair(vec3f(0.0), vec3f(0.0));
+  let count = rzLightCount();
+  let docs = _rzLightDocCount();
+  if (docs > 0u) {
+    let m = _rzLightCellMask(p);
+    let w0 = _rzAddLightWord(m.lo.x, 0u, p, n, v, e);
+    let w1 = _rzAddLightWord(m.lo.y, 32u, p, n, v, e);
+    let w2 = _rzAddLightWord(m.lo.z, 64u, p, n, v, e);
+    let w3 = _rzAddLightWord(m.lo.w, 96u, p, n, v, e);
+    let w4 = _rzAddLightWord(m.hi.x, 128u, p, n, v, e);
+    let w5 = _rzAddLightWord(m.hi.y, 160u, p, n, v, e);
+    let w6 = _rzAddLightWord(m.hi.z, 192u, p, n, v, e);
+    let w7 = _rzAddLightWord(m.hi.w, 224u, p, n, v, e);
+    acc.d = w0.d + w1.d + w2.d + w3.d + w4.d + w5.d + w6.d + w7.d;
+    acc.s = w0.s + w1.s + w2.s + w3.s + w4.s + w5.s + w6.s + w7.s;
+  }
+  for (var i = docs; i < count; i = i + 1u) {
+    let one = _rzAddLightOne(i, p, n, v, e);
+    acc.d = acc.d + one.d;
+    acc.s = acc.s + one.s;
+  }
+  _rzLampDiffuseTaken = true;
+  return acc;
+}
+
 // ─── Lit: URP's PBR, term for term ─────────────
 //
 // What Unity's Lit shader (URP's UniversalFragmentPBR) computes, so a

package/src/shaders/passes/outline.ts

@@ -27,6 +27,12 @@ import { DISSOLVE_WGSL } from "../materials/common"
  * edgeSize 16..20, so this is 20.
  */
 export const RZ_OUTLINE_DISSOLVE_OFFSET = 20
+/** Where the scene-wide width multiplier sits, in bytes — the float after
+ *  dissolve (Engine.setOutlineWidth). */
+export const RZ_OUTLINE_WIDTH_OFFSET = 24
+/** Where the scene-wide colour override sits, in bytes: rgb and a weight, 0
+ *  for the material's own edge colour (Engine.setOutlineColor). */
+export const RZ_OUTLINE_COLOR_OFFSET = 32
 
 export function outlineShaderWgsl(): string {
   return /* wgsl */ `
@@ -40,7 +46,7 @@ struct CameraUniforms {
   viewportHeight: f32,
 };
 
-// THE HULL'S OWN BLOCK, not the material's. 32 bytes of edge data, which is all
+// THE HULL'S OWN BLOCK, not the material's. 48 bytes of edge data, which is all
 // this pass shades with — and dissolve, which it has to obey.
 //
 // It reached for the material block's own layout first, declaring the skipped
@@ -53,8 +59,14 @@ struct MaterialUniforms {
   edgeColor: vec4f,
   edgeSize: f32,
   dissolve: f32,
-  _padding2: f32,
+  /** The scene's width multiplier (setOutlineWidth), the same on every hull:
+   *  scales the author's edgeSize rather than replacing it, so a model's thin
+   *  and thick lines keep their proportion. */
+  widthScale: f32,
   _padding3: f32,
+  /** The scene's colour in place of edgeColor.rgb, by .a (0 or 1). The
+   *  material's own alpha still holds — a line its author made sheer stays so. */
+  colorOverride: vec4f,
 };
 
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
@@ -158,7 +170,7 @@ const RZ_OUTLINE_MIN_PX = 1.5;
   // multiplies it all, as vertex colour alpha does in the game.
   let w = max(clipPos.w, 1e-4);
   let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
-  let nearNdc = viewNormal.xy * (material.edgeSize * outlineNormal.w * 4.0 / refViewport);
+  let nearNdc = viewNormal.xy * (material.edgeSize * material.widthScale * outlineNormal.w * 4.0 / refViewport);
   var ndc = nearNdc * (min(w, breakDepth) / w);
 
   // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
@@ -212,7 +224,8 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
   // alpha above), it is drawn right after the surface it traces so what lies
   // under a faded line is already there, and 4× MSAA would quantize a fade to
   // four steps.
-  out.color = vec4f(material.edgeColor.rgb, material.edgeColor.a * texA * input.coverage);
+  let rgb = mix(material.edgeColor.rgb, material.colorOverride.rgb, material.colorOverride.a);
+  out.color = vec4f(rgb, material.edgeColor.a * texA * input.coverage);
   out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
 ${sceneIdPadWgsl("out")}  return out;
 }