reze-engine 0.68.18 → 0.68.19
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/engine.d.ts +9 -9
- package/dist/engine.d.ts.map +1 -1
- package/dist/engine.js +15 -12
- package/dist/graph/presets/pool_floor.d.ts +3 -0
- package/dist/graph/presets/pool_floor.d.ts.map +1 -0
- package/dist/graph/presets/pool_floor.js +42 -0
- package/dist/graph/presets/water.d.ts +3 -0
- package/dist/graph/presets/water.d.ts.map +1 -0
- package/dist/graph/presets/water.js +31 -0
- package/dist/graph/slots.d.ts.map +1 -1
- package/dist/graph/slots.js +8 -2
- package/dist/physics/autofit.d.ts +147 -0
- package/dist/physics/autofit.d.ts.map +1 -0
- package/dist/physics/autofit.js +501 -0
- package/dist/shaders/agx-lut.d.ts +11 -0
- package/dist/shaders/agx-lut.d.ts.map +1 -0
- package/dist/shaders/agx-lut.js +29 -0
- package/dist/shaders/dfg_lut.d.ts +3 -0
- package/dist/shaders/dfg_lut.d.ts.map +1 -0
- package/dist/shaders/dfg_lut.js +129 -0
- package/dist/shaders/ltc_mag_lut.d.ts +3 -0
- package/dist/shaders/ltc_mag_lut.d.ts.map +1 -0
- package/dist/shaders/ltc_mag_lut.js +1033 -0
- package/dist/shaders/materials/common.d.ts.map +1 -1
- package/dist/shaders/materials/common.js +36 -0
- package/dist/shaders/materials/nodes.d.ts +1 -1
- package/dist/shaders/materials/nodes.d.ts.map +1 -1
- package/dist/shaders/materials/nodes.js +1 -2
- package/dist/shaders/passes/field-blit.d.ts +26 -0
- package/dist/shaders/passes/field-blit.d.ts.map +1 -0
- package/dist/shaders/passes/field-blit.js +65 -0
- package/dist/shaders/passes/ghosts.d.ts +22 -0
- package/dist/shaders/passes/ghosts.d.ts.map +1 -0
- package/dist/shaders/passes/ghosts.js +75 -0
- package/dist/shaders/passes/ground-noise.d.ts +7 -0
- package/dist/shaders/passes/ground-noise.d.ts.map +1 -0
- package/dist/shaders/passes/ground-noise.js +88 -0
- package/dist/shaders/passes/sim.d.ts +34 -0
- package/dist/shaders/passes/sim.d.ts.map +1 -0
- package/dist/shaders/passes/sim.js +169 -0
- package/dist/shaders/score-api.d.ts +10 -0
- package/dist/shaders/score-api.d.ts.map +1 -0
- package/dist/shaders/score-api.js +114 -0
- package/dist/shaders/shadow-api.d.ts +29 -0
- package/dist/shaders/shadow-api.d.ts.map +1 -0
- package/dist/shaders/shadow-api.js +112 -0
- package/package.json +1 -1
- package/src/engine.ts +15 -12
- package/src/graph/slots.ts +8 -2
- package/src/shaders/materials/common.ts +36 -0
- package/src/shaders/materials/nodes.ts +1 -2
- package/dist/_dbg-loader.mjs +0 -1100
|
@@ -0,0 +1,112 @@
|
|
|
1
|
+
import { SHADOW_CASCADES } from "../shadow-cascades";
|
|
2
|
+
// The sun's shadow, as an effect author sees it.
|
|
3
|
+
//
|
|
4
|
+
// A lawn standing in a character's shadow has to darken where the floor under
|
|
5
|
+
// it does, or the figure floats: the ground catcher draws her shadow, and the
|
|
6
|
+
// blades drawn over it hide it. The map is already there — the materials and
|
|
7
|
+
// the ground read it every frame — so this hands the same lookup to effects.
|
|
8
|
+
//
|
|
9
|
+
// Bound for real in the particle SHADING stage only. That is where geometry an
|
|
10
|
+
// effect draws inside the scene pass is shaded, and the shadow pass has already
|
|
11
|
+
// run by then. Every other module that compiles the author's file gets the
|
|
12
|
+
// stub, which answers 1: lit is what a point with no occlusion information is,
|
|
13
|
+
// the same answer sampleShadow gives outside every cascade.
|
|
14
|
+
/**
|
|
15
|
+
* 3×3 PCF over one cascade's map, for a point already in that cascade's NDC.
|
|
16
|
+
*
|
|
17
|
+
* Shared with the materials, so an effect's shadow and her own shadow soften
|
|
18
|
+
* alike. The sampler is linear-filtered, which makes each tap a 2×2 bilinear
|
|
19
|
+
* compare. Unrolled — Safari's Metal backend doesn't unroll nested shadow
|
|
20
|
+
* loops reliably. The body expects `ndc` in scope and returns.
|
|
21
|
+
*/
|
|
22
|
+
export const pcf9 = (map, ts, sampler = "shadowSampler") => /* wgsl */ `
|
|
23
|
+
let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
|
|
24
|
+
let cmpZ = ndc.z - 0.001;
|
|
25
|
+
let ts = ${ts};
|
|
26
|
+
let s00 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, -ts), cmpZ);
|
|
27
|
+
let s10 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0, -ts), cmpZ);
|
|
28
|
+
let s20 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, -ts), cmpZ);
|
|
29
|
+
let s01 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, 0.0), cmpZ);
|
|
30
|
+
let s11 = textureSampleCompareLevel(${map}, ${sampler}, suv, cmpZ);
|
|
31
|
+
let s21 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, 0.0), cmpZ);
|
|
32
|
+
let s02 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, ts), cmpZ);
|
|
33
|
+
let s12 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0, ts), cmpZ);
|
|
34
|
+
let s22 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, ts), cmpZ);
|
|
35
|
+
return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
|
|
36
|
+
`;
|
|
37
|
+
/** Bindings the real accessor takes, from `binding` upward. */
|
|
38
|
+
export const SHADOW_API_BINDINGS = 5;
|
|
39
|
+
/**
|
|
40
|
+
* `rzShadow(p)`: how much of the sun reaches world point `p` — 1 lit, 0 in a
|
|
41
|
+
* caster's shadow, soft in between.
|
|
42
|
+
*
|
|
43
|
+
* With `on`, declares five bindings from `binding`:
|
|
44
|
+
* +0 the light uniform (the sun's direction, and in .w the shadow switch)
|
|
45
|
+
* +1 the cascade view-projections, then the caster sphere
|
|
46
|
+
* +2 the near cascade's map +3 the far cascade's map
|
|
47
|
+
* +4 the comparison sampler
|
|
48
|
+
*
|
|
49
|
+
* It takes a POINT and no normal. The materials' sampleShadow also rejects a
|
|
50
|
+
* surface facing away from the sun, which is right for skin and wrong for a
|
|
51
|
+
* blade of grass or a petal: those are thin, lit through, and shaded by their
|
|
52
|
+
* own N·L. The point is nudged toward the sun instead, which lifts a blade's
|
|
53
|
+
* root off a stage floor that casts into the same map.
|
|
54
|
+
*/
|
|
55
|
+
export function shadowApi(on, group, binding) {
|
|
56
|
+
if (!on) {
|
|
57
|
+
return /* wgsl */ `
|
|
58
|
+
fn rzShadow(p: vec3f) -> f32 { return 1.0; }
|
|
59
|
+
`;
|
|
60
|
+
}
|
|
61
|
+
const n = SHADOW_CASCADES.length;
|
|
62
|
+
return /* wgsl */ `
|
|
63
|
+
// The first two vec4s of the light uniform: world ambient, then the sun.
|
|
64
|
+
struct _RzShadowSun { ambient: vec4f, direction: vec4f, }
|
|
65
|
+
// The cascades' matrices, inner to outer, then every caster in one sphere
|
|
66
|
+
// (x, y, z, radius): radius 0 = nothing casts, negative = do not test.
|
|
67
|
+
struct _RzShadowBlock { viewProj: array<mat4x4f, ${n}>, casters: vec4f, }
|
|
68
|
+
@group(${group}) @binding(${binding}) var<uniform> _rzShadowSun: _RzShadowSun;
|
|
69
|
+
@group(${group}) @binding(${binding + 1}) var<uniform> _rzShadowVP: _RzShadowBlock;
|
|
70
|
+
@group(${group}) @binding(${binding + 2}) var _rzShadowNear: texture_depth_2d;
|
|
71
|
+
@group(${group}) @binding(${binding + 3}) var _rzShadowFar: texture_depth_2d;
|
|
72
|
+
@group(${group}) @binding(${binding + 4}) var _rzShadowCmp: sampler_comparison;
|
|
73
|
+
|
|
74
|
+
fn _rzShadowNearTaps(ndc: vec3f) -> f32 {
|
|
75
|
+
${pcf9("_rzShadowNear", `1.0 / ${SHADOW_CASCADES[0].mapSize}.0`, "_rzShadowCmp")}
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
fn _rzShadowFarTaps(ndc: vec3f) -> f32 {
|
|
79
|
+
${pcf9("_rzShadowFar", `1.0 / ${SHADOW_CASCADES[n - 1].mapSize}.0`, "_rzShadowCmp")}
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
fn rzShadow(p: vec3f) -> f32 {
|
|
83
|
+
// The scene's one shadow switch, on the sun — see sampleShadow.
|
|
84
|
+
let castAmt = _rzShadowSun.direction.w;
|
|
85
|
+
if (castAmt <= 0.0) { return 1.0; }
|
|
86
|
+
let toSun = normalize(-_rzShadowSun.direction.xyz);
|
|
87
|
+
// Can anything cast onto this point at all? The ground's test, for the same
|
|
88
|
+
// two reasons: most of a lawn is nowhere near her, and a scene with no
|
|
89
|
+
// models never renders the map, whose untouched zeroes compare as shadowed.
|
|
90
|
+
let cs = _rzShadowVP.casters;
|
|
91
|
+
if (cs.w == 0.0) { return 1.0; }
|
|
92
|
+
if (cs.w > 0.0) {
|
|
93
|
+
let toCaster = cs.xyz - p;
|
|
94
|
+
let along = dot(toCaster, toSun);
|
|
95
|
+
let perp = length(toCaster - toSun * along);
|
|
96
|
+
if (along <= -cs.w || perp > cs.w) { return 1.0; }
|
|
97
|
+
}
|
|
98
|
+
let q = p + toSun * 0.08;
|
|
99
|
+
let c0 = _rzShadowVP.viewProj[0] * vec4f(q, 1.0);
|
|
100
|
+
let n0 = c0.xyz / max(c0.w, 1e-6);
|
|
101
|
+
if (all(abs(n0.xy) < vec2f(0.98)) && n0.z > 0.0 && n0.z < 1.0) {
|
|
102
|
+
return mix(1.0, _rzShadowNearTaps(n0), castAmt);
|
|
103
|
+
}
|
|
104
|
+
let c1 = _rzShadowVP.viewProj[${n - 1}] * vec4f(q, 1.0);
|
|
105
|
+
let n1 = c1.xyz / max(c1.w, 1e-6);
|
|
106
|
+
if (all(abs(n1.xy) < vec2f(0.98)) && n1.z > 0.0 && n1.z < 1.0) {
|
|
107
|
+
return mix(1.0, _rzShadowFarTaps(n1), castAmt);
|
|
108
|
+
}
|
|
109
|
+
return 1.0;
|
|
110
|
+
}
|
|
111
|
+
`;
|
|
112
|
+
}
|
package/package.json
CHANGED
package/src/engine.ts
CHANGED
|
@@ -11709,15 +11709,15 @@ export class Engine {
|
|
|
11709
11709
|
}
|
|
11710
11710
|
|
|
11711
11711
|
/**
|
|
11712
|
-
* The cast's shadow on a stage
|
|
11713
|
-
*
|
|
11714
|
-
*
|
|
11715
|
-
*
|
|
11716
|
-
*
|
|
11717
|
-
*
|
|
11718
|
-
*
|
|
11719
|
-
* the
|
|
11720
|
-
*
|
|
11712
|
+
* The cast's shadow on a stage the sun cannot reach: the characters drawn
|
|
11713
|
+
* into a map of their own from `direction` (the way TO the light, this
|
|
11714
|
+
* engine's axes), and every graph-drawn stage surface multiplied toward
|
|
11715
|
+
* `color` (linear) by amount × how much of the cast stands in the way —
|
|
11716
|
+
* where the stage roofs her from the sun (rzRoofedCastShadow). Under open
|
|
11717
|
+
* sky the sun's own map lays her shadow and this adds nothing; under a
|
|
11718
|
+
* ceiling, where the lamps cast none, it is the only shadow she has. Without
|
|
11719
|
+
* a `direction` it falls along the sun. A scene without a stage is
|
|
11720
|
+
* untouched. Null turns it off.
|
|
11721
11721
|
*/
|
|
11722
11722
|
setStageCastShadow(opts: StageCastShadow | null): void {
|
|
11723
11723
|
this.castShadow = opts
|
|
@@ -15418,11 +15418,14 @@ export class Engine {
|
|
|
15418
15418
|
|
|
15419
15419
|
// Its ObjectLight: the world's ambient, and the layers its kind draws on —
|
|
15420
15420
|
// the cast on the character layer as well as the default one. Words:
|
|
15421
|
-
// layers [0..3]
|
|
15422
|
-
//
|
|
15421
|
+
// layers [0..3] (y: a stage, which takes the cast's shadow —
|
|
15422
|
+
// rzRoofedCastShadow), ambient flag [4..7], SH [8..43], fill [44..47],
|
|
15423
|
+
// jelly eyes [48..71] — see materials/common.ts.
|
|
15423
15424
|
const objectLight = new Float32Array(96)
|
|
15424
|
-
new Uint32Array(objectLight.buffer)
|
|
15425
|
+
const objectLayers = new Uint32Array(objectLight.buffer)
|
|
15426
|
+
objectLayers[0] =
|
|
15425
15427
|
isStage || isPlane || isProp ? RENDERING_LAYER_DEFAULT : (RENDERING_LAYER_DEFAULT | RENDERING_LAYER_CHARACTER) >>> 0
|
|
15428
|
+
objectLayers[1] = isStage ? 1 : 0
|
|
15426
15429
|
const lightBuffer = this.device.createBuffer({
|
|
15427
15430
|
label: `${name}: object light`,
|
|
15428
15431
|
size: objectLight.byteLength,
|
package/src/graph/slots.ts
CHANGED
|
@@ -204,6 +204,12 @@ function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: bo
|
|
|
204
204
|
// shadows, and under a hard step flip whole regions at once. After the graph
|
|
205
205
|
// it lifts her evenly and leaves every shadow where it is.
|
|
206
206
|
const LIT = takesLight ? ` + (rzLightsDiffuseOnce(input.worldPos, n) + objectLight.fill.rgb) * albedo` : ""
|
|
207
|
+
// The cast's shadow on a stage the sun cannot reach under its roof
|
|
208
|
+
// (rzRoofedCastShadow), over everything the surface took — the lamps
|
|
209
|
+
// included, since they are what light a closed room. Zero off a stage.
|
|
210
|
+
const CAST = takesLight
|
|
211
|
+
? ` out.color = vec4f(out.color.rgb * mix(vec3f(1.0), light.castShadow.rgb, rzRoofedCastShadow(input.worldPos) * light.castShadow.w), out.color.a);\n`
|
|
212
|
+
: ""
|
|
207
213
|
|
|
208
214
|
const ALBEDO = ` let albedo = tex_color;
|
|
209
215
|
`
|
|
@@ -244,13 +250,13 @@ ${ID_WRITE} return out;
|
|
|
244
250
|
|
|
245
251
|
var out: FSOut;
|
|
246
252
|
out.color = vec4f(final_color${LIT}${BURN}, outAlpha);
|
|
247
|
-
${FOG} out.mask = vec4f(1.0, 1.0, _rzSubsurface, out.color.a);
|
|
253
|
+
${CAST}${FOG} out.mask = vec4f(1.0, 1.0, _rzSubsurface, out.color.a);
|
|
248
254
|
${ID_WRITE} return out;
|
|
249
255
|
`
|
|
250
256
|
}
|
|
251
257
|
return `${ALBEDO} var out: FSOut;
|
|
252
258
|
out.color = vec4f(final_color${LIT}${BURN}, ${alphaBase});
|
|
253
|
-
${FOG} out.mask = vec4f(1.0, 1.0, _rzSubsurface, out.color.a);
|
|
259
|
+
${CAST}${FOG} out.mask = vec4f(1.0, 1.0, _rzSubsurface, out.color.a);
|
|
254
260
|
${ID_WRITE} return out;
|
|
255
261
|
`
|
|
256
262
|
}
|
|
@@ -390,6 +390,42 @@ fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
|
|
|
390
390
|
return mix(1.0, _rzSunTaps(a), castAmt);
|
|
391
391
|
}
|
|
392
392
|
|
|
393
|
+
/**
|
|
394
|
+
* The cast's shadow on a stage surface where the stage ROOFS the cast from the
|
|
395
|
+
* sun, 0–1 — setStageCastShadow on a graph-drawn stage (a GLB's). Under open
|
|
396
|
+
* sky the sun's own map already lays the cast's shadow, and laying this one too
|
|
397
|
+
* doubled it; under a ceiling the sun reaches neither the floor nor her, the
|
|
398
|
+
* lamps cast nothing, and she stood on the floor with no shadow at all. So
|
|
399
|
+
* per pixel: find the point of the cast that throws this shadow (the cast
|
|
400
|
+
* map's nearest depth, walked back toward the light along the map's z row),
|
|
401
|
+
* step off her toward the light, and ask the sun's map whether it reaches
|
|
402
|
+
* there. Lit: the sun shadow has it, answer 0. Shadowed: this is the only
|
|
403
|
+
* shadow she gets. Zero on everything that is not a stage (objectLight
|
|
404
|
+
* layers.y).
|
|
405
|
+
*/
|
|
406
|
+
fn rzRoofedCastShadow(wp: vec3f) -> f32 {
|
|
407
|
+
if (light.castShadow.w <= 0.0 || objectLight.layers.y == 0u) { return 0.0; }
|
|
408
|
+
let cover = _rzCastShadow(wp);
|
|
409
|
+
if (cover <= 0.0) { return 0.0; }
|
|
410
|
+
let ndc = (light.castVP * vec4f(wp, 1.0)).xyz;
|
|
411
|
+
let size = vec2i(textureDimensions(castShadowMap));
|
|
412
|
+
let px = vec2i(vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5) * vec2f(size));
|
|
413
|
+
// The nearest of her over the filter's footprint: a penumbra texel's own
|
|
414
|
+
// depth may be the cleared 1.
|
|
415
|
+
var occ = 1.0;
|
|
416
|
+
for (var y = -2; y <= 2; y += 2) {
|
|
417
|
+
for (var x = -2; x <= 2; x += 2) {
|
|
418
|
+
occ = min(occ, textureLoad(castShadowMap, clamp(px + vec2i(x, y), vec2i(0), size - 1), 0));
|
|
419
|
+
}
|
|
420
|
+
}
|
|
421
|
+
if (occ >= ndc.z) { return 0.0; }
|
|
422
|
+
// Orthographic: depth grows away from the light at |g| per unit.
|
|
423
|
+
let g = vec3f(light.castVP[0].z, light.castVP[1].z, light.castVP[2].z);
|
|
424
|
+
let k = length(g);
|
|
425
|
+
let q = wp - (g / k) * ((ndc.z - occ) / k + 0.5);
|
|
426
|
+
return cover * (1.0 - rzSunOcclusion(q, vec3f(0.0)));
|
|
427
|
+
}
|
|
428
|
+
|
|
393
429
|
`;
|
|
394
430
|
|
|
395
431
|
// ─── Skinning vertex shader ─────────────────────────────────────────
|
|
@@ -1703,8 +1703,7 @@ fn urp_lit(base: vec3f, metallic: f32, smoothness: f32, spec: f32, occlusion: f3
|
|
|
1703
1703
|
let direct = diffuse * (sun_rgb * (NL * shadow) + lampDiff) + directSpec;
|
|
1704
1704
|
let indirect = diffuse * amb_rgb * ao
|
|
1705
1705
|
+ rzProbeSpecular(reflect(-V, N), wp, r) * ao * urp_env_brdf(specular, r, sm, reflectivity, NV);
|
|
1706
|
-
|
|
1707
|
-
lit = lit * mix(vec3f(1.0), light.castShadow.rgb, _rzCastShadow(wp) * light.castShadow.w);
|
|
1706
|
+
let lit = direct + indirect;
|
|
1708
1707
|
return vec4f(lit + max(emission, vec3f(0.0)), a * oneMinusReflectivity + reflectivity);
|
|
1709
1708
|
}
|
|
1710
1709
|
|