reze-engine 0.61.6 → 0.62.0

package/src/shaders/passes/particles.ts

@@ -12,6 +12,7 @@ import { sceneIdFieldWgsl, sceneIdPadWgsl } from "./scene-contract"
 import { idApi } from "../id-api"
 import { sceneLightApi } from "../scene-light-api"
 import { pointsApi } from "../points-api"
+import { textureApi } from "../texture-api"
 // GPU particles for user effects: a compute step and an instanced quad draw.
 //
 // Its own shader MODULE rather than more source spliced into composite.ts, for
@@ -115,6 +116,9 @@ type ParticleSource = {
    *  bending where a foot pressed is the whole case: the bend has to persist and
    *  recover, which is memory, and memory is what the grid is for. */
   gridSize: number
+  /** `#textures N`: pictures the shading samples (rzTexture), bound only when
+   *  N > 0 — see texture-api.ts. Omitted = 0. */
+  textures?: number
 }
 
 /** Where the shading stage's five scene-light bindings start — see scene-light-api.ts. */
@@ -126,6 +130,10 @@ export const PARTICLE_POINTS_BINDING = 15
  *  (6, count, 0, 0), so the draw reads at byte 16. */
 export const PARTICLE_INDIRECT_BINDING = 16
 export const PARTICLE_INDIRECT_BYTES = 32
+/** `#textures`: the pictures at 17..20 and their one sampler at 21, render
+ *  stage only — see texture-api.ts. */
+export const PARTICLE_TEXTURE_BINDING = 17
+export const PARTICLE_TEXTURE_SAMPLER_BINDING = 21
 export const PARTICLE_INDIRECT_DRAW_OFFSET = 16
 
 /** Bytes per particle. Explicitly padded — see the struct below. */
@@ -234,6 +242,9 @@ ${src.paramsDecl}
     idApi(false, 0, 0) + castDistanceStub() + sceneLightApi(false, 0, 0) +
     // The named points, for real: particleInit is where a flame is put on a wick.
     pointsApi(true, 0, PARTICLE_POINTS_BINDING) +
+    // Stubs: textureSample is fragment-only, and a spawn rule has no use for a
+    // picture. The names resolve so the file compiles here.
+    textureApi(0) +
     (src.live
       ? `@group(0) @binding(${PARTICLE_INDIRECT_BINDING}) var<storage, read_write> _rzIndirect: array<u32, 8>;\n`
       : "") +
@@ -333,6 +344,8 @@ ${src.paramsDecl}
     // run by the time this draws, inside the scene pass. See scene-light-api.ts.
     sceneLightApi(true, 0, PARTICLE_LIGHT_BINDING) +
     pointsApi(true, 0, PARTICLE_POINTS_BINDING) +
+    // The host's pictures, for real — see texture-api.ts.
+    textureApi(src.textures ?? 0, 0, PARTICLE_TEXTURE_BINDING, PARTICLE_TEXTURE_SAMPLER_BINDING) +
     "\n// ── user effect ──\n" +
     src.wgsl +
     /* wgsl */ `

package/src/shaders/passes/scene-contract.ts

@@ -138,7 +138,7 @@ const ADD_BOTH: GPUBlendState = {
  * OVER for something that arrives ALREADY premultiplied: take the source whole
  * and let it displace the destination by its own coverage.
  *
- * The ground needs this and nothing else does. Every other class writes a
+ * The ground, the mirror and particles need it. The other classes write a
  * straight colour and an alpha, and the src-alpha factor premultiplies it once
  * on the way in. The ground cannot: its coverage is the SUM of a lit surface
  * and a colourless shadow-catcher layer, so it has to weight its own colour by
@@ -194,7 +194,11 @@ const BLENDS: Record<Exclude<SceneRenderClass, "depth-prepass">, [GPUBlendState,
   // everything else, and coverage is what the blend applies.
   ground: [PREMULTIPLIED_OVER, ALPHA_OVER],
   outline: [ALPHA_OVER, ALPHA_OVER],
-  particle: [ALPHA_OVER, ALPHA_OVER],
+  // PREMULTIPLIED colour: the particle fragment weights its colour by its own
+  // alpha before it writes (passes/particles.ts), so the src-alpha blend would
+  // weight it a second time — a splash at alpha 0.1 arrived at a hundredth of
+  // its colour instead of a tenth. The aux mask is written straight, as ever.
+  particle: [PREMULTIPLIED_OVER, ALPHA_OVER],
   "particle-additive": [ADD_KEEP_ALPHA, ADD_BOTH],
   trail: [ADD_PREMULTIPLIED, ALPHA_OVER],
 }

package/src/shaders/passes/trails.ts

@@ -12,6 +12,7 @@ import { sceneIdFieldWgsl, sceneIdPadWgsl } from "./scene-contract"
 import { idApi } from "../id-api"
 import { sceneLightApi } from "../scene-light-api"
 import { pointsApi } from "../points-api"
+import { textureApi } from "../texture-api"
 // Ribbons along a bone's recorded path, drawn as geometry.
 //
 // This is the effect the whole geometry path was built for. As a fullscreen
@@ -303,7 +304,7 @@ fn rzTurnRadius(a: vec3f, b: vec3f, c: vec3f) -> f32 {
     gridReadApi(0, 8, 9, src.gridSize) +
     // Stubbed: this module cannot read an attachment the scene pass writes — see
     // id-api.ts. The author's whole file compiles here, so the names must exist.
-    idApi(false, 0, 0) + castDistanceStub() + sceneLightApi(false, 0, 0) + pointsApi(false) +
+    idApi(false, 0, 0) + castDistanceStub() + sceneLightApi(false, 0, 0) + pointsApi(false) + textureApi(0) +
     "\n// ── user effect ──\n" +
     src.wgsl +
     /* wgsl */ `

package/src/shaders/texture-api.ts

@@ -0,0 +1,56 @@
+// Pictures an effect is handed by its host — `#textures N`.
+//
+//     #textures 2
+//
+// gives the PARTICLE SHADING rzTexture(i, uv) and rzTextureLod(i, uv, lod) over
+// N images the host passes with the install (setEffects' `textures`, slot i =
+// picture i). uv (0,0) is the image's top-left row, the style graph's
+// tex_image convention, and it repeats. A slot the host left empty reads white.
+//
+// WHY: a game's splash is a picture on a card, and an effect that may only draw
+// procedurally can only ever guess at it — shape, coverage, veins, each a guess
+// to be corrected. A converted stage carries the game's own textures, and this
+// is how its particles draw them.
+//
+// Fragment-only, because textureSample is: the compute stage and every other
+// module the author's file is spliced into get STUBS returning zero, so one
+// effect file compiles in every mount it has.
+
+/** How many pictures one effect can read. */
+export const MAX_EFFECT_TEXTURES = 4
+
+/**
+ * rzTexture / rzTextureLod. `count` is the effect's `#textures` (0 = stubs);
+ * the textures take bindings first..first+count-1 in `group` and the one
+ * sampler `sampler`.
+ */
+export function textureApi(count: number, group = 0, first = 0, sampler = 0): string {
+  if (count <= 0) {
+    return /* wgsl */ `
+fn rzTexture(i: u32, uv: vec2f) -> vec4f { return vec4f(0.0); }
+fn rzTextureLod(i: u32, uv: vec2f, lod: f32) -> vec4f { return vec4f(0.0); }
+`
+  }
+  const n = Math.min(count, MAX_EFFECT_TEXTURES)
+  let decl = `@group(${group}) @binding(${sampler}) var _rzTexSampler: sampler;\n`
+  for (let k = 0; k < n; k++) decl += `@group(${group}) @binding(${first + k}) var _rzTex${k}: texture_2d<f32>;\n`
+  // Every slot is sampled unconditionally and the one asked for is selected:
+  // textureSample must be reached in uniform control flow, and a switch on a
+  // per-fragment index is not.
+  const pick = (call: (k: number) => string) => {
+    let body = "  var c = vec4f(0.0);\n"
+    for (let k = 0; k < n; k++) body += `  let s${k} = ${call(k)};\n  if (i == ${k}u) { c = s${k}; }\n`
+    return body + "  return c;\n"
+  }
+  return (
+    decl +
+    /* wgsl */ `
+/** Picture i of the effect's #textures, at uv ((0,0) top-left, repeating). */
+fn rzTexture(i: u32, uv: vec2f) -> vec4f {
+${pick((k) => `textureSample(_rzTex${k}, _rzTexSampler, uv)`)}}
+/** The same at an explicit mip level — usable where derivatives are not. */
+fn rzTextureLod(i: u32, uv: vec2f, lod: f32) -> vec4f {
+${pick((k) => `textureSampleLevel(_rzTex${k}, _rzTexSampler, uv, lod)`)}}
+`
+  )
+}

package/dist/graph/presets/pool_floor.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const POOL_FLOOR_GRAPH: ShaderGraph;
-//# sourceMappingURL=pool_floor.d.ts.map

package/dist/graph/presets/pool_floor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool_floor.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/pool_floor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,gBAAgB,EAAE,WA6B9B,CAAA"}

package/dist/graph/presets/pool_floor.js

@@ -1,42 +0,0 @@
-// Pool floor — the tiled bottom seen through water, with caustics on it.
-//
-// The other half of a pool, and the half that does most of the work. A water
-// surface can be tuned for a long time without the shot reading as a pool;
-// putting the focused-light web on the FLOOR is what settles it, because that
-// is the cue a photograph actually carries. It is a floor material, so it is
-// applied to the tile under the water rather than to the water itself.
-//
-// Caustics land between the albedo and the shading deliberately: they are
-// light, so they should still be dimmed by the floor's own shadow rather than
-// glowing through it. That is the difference between water-focused sun and a
-// decal.
-export const POOL_FLOOR_GRAPH = {
-    version: 1,
-    name: "Pool floor",
-    tags: ["stage", "water", "pool"],
-    nodes: [
-        { id: "tex", type: "texture" },
-        { id: "mat", type: "material_diffuse" },
-        { id: "base", type: "mix/multiply", inputs: { fac: 1.0 } },
-        { id: "caust", type: "caustics" },
-        {
-            id: "principled",
-            type: "principled",
-            inputs: { metallic: 0.0, specular_ior_level: 0.4, roughness: 0.45, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
-        },
-    ],
-    links: [
-        { from: { node: "tex", socket: "color" }, to: { node: "base", socket: "a" } },
-        { from: { node: "mat", socket: "color" }, to: { node: "base", socket: "b" } },
-        { from: { node: "base", socket: "color" }, to: { node: "caust", socket: "color" } },
-        { from: { node: "caust", socket: "color" }, to: { node: "principled", socket: "base_color" } },
-    ],
-    output: { node: "principled", socket: "color" },
-    params: [
-        { id: "tint", label: "Light tint", target: { node: "caust", socket: "tint" }, kind: "color", default: [1.0, 1.0, 1.0] },
-        { id: "scale", label: "Caustic scale", target: { node: "caust", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.12 },
-        { id: "speed", label: "Caustic speed", target: { node: "caust", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.15 },
-        { id: "strength", label: "Caustic strength", target: { node: "caust", socket: "strength" }, kind: "float", min: 0, max: 3, default: 0.6 },
-        { id: "fade", label: "Depth fade", target: { node: "caust", socket: "fade" }, kind: "float", min: 1, max: 200, default: 30 },
-    ],
-};

package/dist/graph/presets/water.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const WATER_GRAPH: ShaderGraph;
-//# sourceMappingURL=water.d.ts.map

package/dist/graph/presets/water.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"water.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/water.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,WAAW,EAAE,WAgBzB,CAAA"}

package/dist/graph/presets/water.js

@@ -1,31 +0,0 @@
-// Water — a planar reflection, rippled, seen through Fresnel.
-//
-// Put a stage's water materials in a style group carrying this graph and the
-// pool starts reflecting. The reflection itself is the engine's mirror pass,
-// which this is the only graph to read; everything else here is the shaping
-// that keeps it from reading as a mirror laid flat in the floor.
-//
-// The exposed params are the ones worth a slider while judging a shot. Scale
-// and speed are the ripple; a real pool's surface is slow and broad, so both
-// defaults sit low. Tint is the water's own colour — a game rip carries that
-// in its material, and the converter hands it straight over.
-//
-// How see-through the water is belongs to the MATERIAL's alpha, not to this
-// graph, which is where every other group's coverage comes from too.
-export const WATER_GRAPH = {
-    version: 1,
-    name: "Water",
-    tags: ["water", "stage"],
-    nodes: [{ id: "water", type: "water" }],
-    links: [],
-    output: { node: "water", socket: "color" },
-    params: [
-        { id: "tint", label: "Tint", target: { node: "water", socket: "tint" }, kind: "color", default: [0.04, 0.62, 0.66] },
-        { id: "scale", label: "Ripple scale", target: { node: "water", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.18 },
-        { id: "speed", label: "Ripple speed", target: { node: "water", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.12 },
-        { id: "strength", label: "Ripple depth", target: { node: "water", socket: "strength" }, kind: "float", min: 0, max: 2, default: 0.7 },
-        { id: "blur", label: "Reflection blur", target: { node: "water", socket: "blur" }, kind: "float", min: 0, max: 1, default: 0.25 },
-        { id: "mirroring", label: "Mirroring", target: { node: "water", socket: "mirroring" }, kind: "float", min: 0, max: 1, default: 0.20 },
-        { id: "sparkle", label: "Sparkle", target: { node: "water", socket: "sparkle" }, kind: "float", min: 0, max: 4, default: 1.0 },
-    ],
-};

package/dist/physics/autofit.d.ts

@@ -1,147 +0,0 @@
-import { type Rigidbody } from "./types";
-import type { Skinning } from "../model";
-/**
- * Supplementary colliders fitted to the mesh a PMX rigid body fails to cover.
- *
- * PMX body proxies are bodies of revolution — 下半身 is a capsule lying
- * transversely across the hips, so its cross-section is a circle. A pelvis seen
- * from the side is not a circle, and across every rig measured the butt sits
- * 0.18–0.71 units OUTSIDE that capsule while the front is flush or inside. That
- * gap is where a skirt goes through a character: the cloth is resting correctly
- * on the collider it was given, and the collider stops half a unit short of the
- * skin.
- *
- * A rest offset cannot close it (see RigidBodyStore.restOffset) — it is one
- * scalar on a radially symmetric shape, and the error is asymmetric. Measured
- * on 托特's run cycle, the offset that clears the butt is 0.5, which is simply
- * the size of the missing geometry, and at that value the skirt stands off the
- * front and hips by the same 0.5.
- *
- * So fit the missing piece instead: take each bone-following body's own skinned
- * vertices, find the ones that escape its shape in a concentrated lobe, and fit
- * a capsule to that lobe. That is the fix riggers apply by hand, derived from
- * the mesh rather than guessed.
- *
- * Measured on 托特's run cycle, counting butt vertices swallowed by a cloth
- * body: 32.4 per frame with nothing, 30.9 with a 0.02 rest offset, 12.4 with
- * this pass, 10.4 with both.
- */
-export interface AutoFitOptions {
-    /** A vertex counts as protruding past this much (model units). Below it the
-     *  mesh is within authoring tolerance of the proxy and needs no help. */
-    minProtrusion?: number;
-    /**
-     * Ignore vertices further out than this multiple of the source shape's
-     * RADIUS (its smallest characteristic dimension).
-     *
-     * A coarse first cut at keeping hair and loose clothing out — anything
-     * standing further off the proxy than the proxy is wide is not skin. The
-     * discriminator that actually does the work is minConcentration.
-     */
-    maxProtrusionRatio?: number;
-    /** Fewer protruding vertices than this and it is a spike, not a region. */
-    minVertices?: number;
-    /**
-     * Per-axis quantile the fitted lobe's extent is clipped to, each end. A
-     * handful of stray vertices (a weight-painting slip, a seam) would otherwise
-     * stretch the capsule far past the surface everyone can see.
-     */
-    quantile?: number;
-    /** Skip the fit unless the capsule actually reaches this far past what is
-     *  already covered — otherwise it adds solver rows for nothing. */
-    minGain?: number;
-    /** How tightly the kept lobe's outward directions must agree, 0–1. A loose
-     *  sanity check; the real discriminator is minConcentration. */
-    minDirectionality?: number;
-    /** Vertices outside the dominant lobe, by this cosine, are not part of the
-     *  feature being fitted. */
-    lobeCos?: number;
-    /**
-     * How much deeper the fitted lobe must be than protrusion typically is on
-     * this body, averaged over the vertices that protrude at all.
-     *
-     * This is the guard that separates "the proxy is missing a lobe" from "the
-     * proxy is not a proxy for this mesh at all". A pelvis escapes its capsule by
-     * 0.53 at the back and 0.14 at the front, so the back lobe stands well clear
-     * of the average. Hair escapes the skull by a similar depth in every
-     * direction, so its deepest lobe is no deeper than typical and the ratio sits
-     * near 1. See the note at the meanProtrusion computation for what this
-     * deliberately refuses to fit.
-     *
-     * Without it the pass fits the hairstyle — measured on 托特, 頭 reports
-     * 3653 of 4669 vertices outside its capsule, and the fitted shape was a crate
-     * around the whole head. No threshold on depth or vertex count tells those
-     * two cases apart; concentration does.
-     */
-    minConcentration?: number;
-    /**
-     * How many capsules may be fitted to one body, each against what the previous
-     * ones already cover.
-     *
-     * One capsule inscribed in a lobe does not fill it — on 托特's butt a single
-     * fit removed 58% of the clipping and left the rest at the edges the capsule
-     * could not reach. Each further pass re-measures protrusion against the
-     * original shape UNION everything fitted so far, so it lands on whatever is
-     * still exposed instead of re-fitting the same bulge.
-     */
-    maxShapesPerBody?: number;
-    /**
-     * Quantile of the lobe's perpendicular spread used as the capsule radius.
-     *
-     * The clip-versus-float dial, and the one to reach for if a result looks
-     * wrong. Lower hugs the body: less standoff in idle, more clipping left. 1.0
-     * encloses the lobe entirely, which is what produced a visibly hovering
-     * skirt on 托特.
-     */
-    radiusQuantile?: number;
-    /**
-     * Fit only the deepest part of each lobe: points at least this fraction of
-     * the lobe's own maximum protrusion.
-     *
-     * A lobe tapers to nothing at its edges, and a capsule sized to span the
-     * whole thing has to be fat enough to reach the edges too. Fitting the deep
-     * core keeps each capsule small and lets a later pass handle the shallows
-     * with its own, which is both tighter and closer to what the surface is
-     * actually doing.
-     */
-    lobeDepthFraction?: number;
-}
-/** What the pass decided for one source body — surfaced so a rig can be
- *  inspected rather than silently rebuilt underneath its author. */
-export interface AutoFitResult {
-    /** Index of the body in the input array that this supplements. */
-    sourceIndex: number;
-    sourceName: string;
-    /** Vertices dominated by that body's bone, and how many were outside it. */
-    vertexCount: number;
-    protrudingCount: number;
-    /** Furthest any kept vertex sat outside the source shape. */
-    maxProtrusion: number;
-    /** How far the fitted capsule reaches past what was already covered. */
-    gain: number;
-    /** Length of the kept lobe's mean outward direction, 0–1. */
-    directionality: number;
-    /** Lobe depth over the body's average protrusion. See minConcentration. */
-    concentration: number;
-    /**
-     * Furthest the capsule's newly exposed surface sits from the skin it was
-     * fitted to — the amount cloth resting on it will stand off the body at the
-     * worst point, and the number to watch if a result looks puffy. Only the part
-     * reaching outside the source shape is measured; the rest is buried.
-     */
-    overshoot: number;
-    body: Rigidbody;
-}
-/**
- * Fit supplementary colliders for every bone-following body whose own mesh
- * escapes it.
- *
- * `vertices` is the model's interleaved vertex buffer (stride 8, position
- * first) and `skinning` its joints/weights — both in PMX bind pose, the same
- * space as `shapePosition` / `shapeRotation`, so nothing has to be skinned.
- *
- * Returns one entry per body it chose to supplement; the caller appends
- * `.body` to the rigid body list before constructing RezePhysics.
- */
-export declare function fitSupplementaryColliders(rigidbodies: Rigidbody[], vertices: Float32Array, skinning: Skinning, options?: AutoFitOptions): AutoFitResult[];
-//# sourceMappingURL=autofit.d.ts.map

package/dist/physics/autofit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"autofit.d.ts","sourceRoot":"","sources":["../../src/physics/autofit.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,cAAc;IAC7B;6EACyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;uEACmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;oEACgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;gCAC4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AA2BD;oEACoE;AACpE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,EAAE,EACxB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,cAAmB,GAC3B,aAAa,EAAE,CA4CjB"}