@zephyr3d/scene 0.9.21 → 0.9.23

package/dist/shaders/ssgi.js

@@ -0,0 +1,63 @@
+/**
+ * Animated interleaved-gradient-noise pair used to decorrelate SSGI rays.
+ *
+ * Produces two low-discrepancy random numbers in [0, 1) for a given fragment,
+ * advanced per sample/frame through golden-ratio sequences so the temporal
+ * resolve pass converges the Monte-Carlo estimate.
+ *
+ * @param scope - The shader scope
+ * @param fragCoord - Fragment coordinate in pixels
+ * @param seed - Sequence index (frameIndex * sampleCount + sampleIndex)
+ * @returns A vec2 of pseudo random numbers in [0, 1)
+ *
+ * @internal
+ */ function SSGI_rand2(scope, fragCoord, seed) {
+    const pb = scope.$builder;
+    pb.func('SSGI_ign', [
+        pb.vec2('p')
+    ], function() {
+        this.$return(pb.fract(pb.mul(52.9829189, pb.fract(pb.add(pb.mul(0.06711056, this.p.x), pb.mul(0.00583715, this.p.y))))));
+    });
+    pb.func('SSGI_rand2', [
+        pb.vec2('fragCoord'),
+        pb.float('seed')
+    ], function() {
+        this.$l.n1 = this.SSGI_ign(this.fragCoord);
+        this.$l.n2 = this.SSGI_ign(pb.add(this.fragCoord, pb.vec2(5.588238, 5.588238)));
+        // Golden-ratio (and its square) sequences advance the pair every sample
+        this.$return(pb.fract(pb.add(pb.vec2(this.n1, this.n2), pb.mul(pb.vec2(0.61803398875, 0.38196601125), this.seed))));
+    });
+    return scope.SSGI_rand2(fragCoord, seed);
+}
+/**
+ * Cosine-weighted hemisphere sampling around a normal.
+ *
+ * With cosine-weighted sampling the Monte-Carlo estimator of the rendering
+ * equation's diffuse term reduces to the plain average of the sampled
+ * radiances, so the SSGI trace pass can simply accumulate hit colors.
+ *
+ * @param scope - The shader scope
+ * @param normal - Unit normal the hemisphere is oriented around
+ * @param rand - Two random numbers in [0, 1)
+ * @returns A unit direction inside the hemisphere
+ *
+ * @internal
+ */ function SSGI_cosineSampleHemisphere(scope, normal, rand) {
+    const pb = scope.$builder;
+    pb.func('SSGI_cosineSampleHemisphere', [
+        pb.vec3('n'),
+        pb.vec2('u')
+    ], function() {
+        this.$l.up = this.$choice(pb.lessThan(pb.abs(this.n.z), 0.999), pb.vec3(0, 0, 1), pb.vec3(1, 0, 0));
+        this.$l.tangent = pb.normalize(pb.cross(this.up, this.n));
+        this.$l.bitangent = pb.cross(this.n, this.tangent);
+        this.$l.r = pb.sqrt(this.u.x);
+        this.$l.phi = pb.mul(this.u.y, Math.PI * 2);
+        this.$l.dir = pb.add(pb.mul(this.tangent, pb.mul(this.r, pb.cos(this.phi))), pb.mul(this.bitangent, pb.mul(this.r, pb.sin(this.phi))), pb.mul(this.n, pb.sqrt(pb.max(0, pb.sub(1, this.u.x)))));
+        this.$return(pb.normalize(this.dir));
+    });
+    return scope.SSGI_cosineSampleHemisphere(normal, rand);
+}
+
+export { SSGI_cosineSampleHemisphere, SSGI_rand2 };
+//# sourceMappingURL=ssgi.js.map

package/dist/shaders/ssgi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssgi.js","sources":["../../src/shaders/ssgi.ts"],"sourcesContent":["import type { PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\n\n/**\n * Animated interleaved-gradient-noise pair used to decorrelate SSGI rays.\n *\n * Produces two low-discrepancy random numbers in [0, 1) for a given fragment,\n * advanced per sample/frame through golden-ratio sequences so the temporal\n * resolve pass converges the Monte-Carlo estimate.\n *\n * @param scope - The shader scope\n * @param fragCoord - Fragment coordinate in pixels\n * @param seed - Sequence index (frameIndex * sampleCount + sampleIndex)\n * @returns A vec2 of pseudo random numbers in [0, 1)\n *\n * @internal\n */\nexport function SSGI_rand2(scope: PBInsideFunctionScope, fragCoord: PBShaderExp, seed: PBShaderExp) {\n  const pb = scope.$builder;\n  pb.func('SSGI_ign', [pb.vec2('p')], function () {\n    this.$return(\n      pb.fract(\n        pb.mul(52.9829189, pb.fract(pb.add(pb.mul(0.06711056, this.p.x), pb.mul(0.00583715, this.p.y))))\n      )\n    );\n  });\n  pb.func('SSGI_rand2', [pb.vec2('fragCoord'), pb.float('seed')], function () {\n    this.$l.n1 = this.SSGI_ign(this.fragCoord);\n    this.$l.n2 = this.SSGI_ign(pb.add(this.fragCoord, pb.vec2(5.588238, 5.588238)));\n    // Golden-ratio (and its square) sequences advance the pair every sample\n    this.$return(\n      pb.fract(pb.add(pb.vec2(this.n1, this.n2), pb.mul(pb.vec2(0.61803398875, 0.38196601125), this.seed)))\n    );\n  });\n  return scope.SSGI_rand2(fragCoord, seed);\n}\n\n/**\n * Cosine-weighted hemisphere sampling around a normal.\n *\n * With cosine-weighted sampling the Monte-Carlo estimator of the rendering\n * equation's diffuse term reduces to the plain average of the sampled\n * radiances, so the SSGI trace pass can simply accumulate hit colors.\n *\n * @param scope - The shader scope\n * @param normal - Unit normal the hemisphere is oriented around\n * @param rand - Two random numbers in [0, 1)\n * @returns A unit direction inside the hemisphere\n *\n * @internal\n */\nexport function SSGI_cosineSampleHemisphere(\n  scope: PBInsideFunctionScope,\n  normal: PBShaderExp,\n  rand: PBShaderExp\n) {\n  const pb = scope.$builder;\n  pb.func('SSGI_cosineSampleHemisphere', [pb.vec3('n'), pb.vec2('u')], function () {\n    this.$l.up = this.$choice(pb.lessThan(pb.abs(this.n.z), 0.999), pb.vec3(0, 0, 1), pb.vec3(1, 0, 0));\n    this.$l.tangent = pb.normalize(pb.cross(this.up, this.n));\n    this.$l.bitangent = pb.cross(this.n, this.tangent);\n    this.$l.r = pb.sqrt(this.u.x);\n    this.$l.phi = pb.mul(this.u.y, Math.PI * 2);\n    this.$l.dir = pb.add(\n      pb.mul(this.tangent, pb.mul(this.r, pb.cos(this.phi))),\n      pb.mul(this.bitangent, pb.mul(this.r, pb.sin(this.phi))),\n      pb.mul(this.n, pb.sqrt(pb.max(0, pb.sub(1, this.u.x))))\n    );\n    this.$return(pb.normalize(this.dir));\n  });\n  return scope.SSGI_cosineSampleHemisphere(normal, rand);\n}\n"],"names":["SSGI_rand2","scope","fragCoord","seed","pb","$builder","func","vec2","$return","fract","mul","add","p","x","y","float","$l","n1","SSGI_ign","n2","SSGI_cosineSampleHemisphere","normal","rand","vec3","up","$choice","lessThan","abs","n","z","tangent","normalize","cross","bitangent","r","sqrt","u","phi","Math","PI","dir","cos","sin","max","sub"],"mappings":"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"}

package/dist/shaders/ssgi_reprojection.js

@@ -0,0 +1,118 @@
+import { Matrix4x4 } from '@zephyr3d/base';
+
+/**
+ * Shared helpers for validating SSGI temporal history across frames.
+ *
+ * SSGI stores the surface depth of a frame as that frame's view-space Z (the
+ * distance along the camera forward axis, in world units). Comparing such a
+ * value against the *current* frame's view-space Z is only meaningful while the
+ * camera is still: rotating the camera turns the forward axis, so a static world
+ * point changes its view-space Z by roughly
+ *
+ *   dz ~ dTheta * viewZ * tan(halfFovX) * |ndc.x|
+ *
+ * which is zero at the screen center and grows with both depth and screen
+ * eccentricity. At a plain mouse-look rate that already exceeds any reasonable
+ * absolute tolerance for distant off-center pixels, so history gets rejected in
+ * screen-edge bands even though it is perfectly valid. Every consumer therefore
+ * has to convert the current depth into the *previous* frame's view space before
+ * comparing.
+ *
+ * @internal
+ */ /**
+ * Relative share of the compared depth added to the absolute tolerance. 2% keeps
+ * a 10m surface within 0.2m, comfortably above rgba16f depth quantization while
+ * still separating surfaces that a bounce should not share.
+ * @internal
+ */ const SSGI_DEPTH_TOLERANCE_SLOPE = 0.02;
+/**
+ * `prevVP * inverse(currentVP)`: maps a current-frame clip position onto the
+ * previous frame's clip space, where `w` is the previous view-space Z.
+ *
+ * The current half uses the jittered inverse VP because every consumer
+ * reconstructs from a depth buffer that was rasterized with jitter applied.
+ * Jitter only shifts clip x/y, so pairing it with the unjittered `prevVPMatrix`
+ * still produces the correct `w`.
+ *
+ * Falls back to the current VP before any previous transform exists, which
+ * degenerates into comparing the current depth against itself - harmless,
+ * because the history textures are empty on that frame anyway.
+ *
+ * @param ctx - Current draw context
+ * @returns The reprojection matrix
+ * @internal
+ */ function ssgiCurrentToPrevClipMatrix(ctx) {
+    const camera = ctx.camera;
+    const prevVP = camera.prevVPMatrix ?? camera.viewProjectionMatrix;
+    return Matrix4x4.multiply(prevVP, camera.jitteredInvVPMatrix);
+}
+/**
+ * Converts the current frame's linear depth at `uv` into the view-space Z it
+ * would have had in the previous frame, so it can be compared against the depth
+ * stored in the SSGI surface history.
+ *
+ * `currentToPrevClipMatrix` must be `prevViewProjection * inverse(currentViewProjection)`,
+ * mapping a current-frame clip position onto the previous frame's clip space. In
+ * a perspective projection the resulting `w` is exactly the previous view-space
+ * Z in world units, which is the quantity the surface pass wrote.
+ *
+ * @param scope - Current shader scope
+ * @param currentToPrevClipMatrix - `prevVP * invCurrentVP`, as a mat4
+ * @param uv - Screen uv of the pixel being validated
+ * @param linearDepth - Normalized linear depth (viewZ / far) at `uv`
+ * @param nearFar - Camera near and far planes
+ * @returns Previous-frame view-space Z, in world units
+ * @internal
+ */ function ssgiPreviousViewDepth(scope, currentToPrevClipMatrix, uv, linearDepth, nearFar) {
+    const pb = scope.$builder;
+    const funcName = 'Z_ssgiPreviousViewDepth';
+    pb.func(funcName, [
+        pb.mat4('toPrevClip'),
+        pb.vec2('uv'),
+        pb.float('linearDepth'),
+        pb.vec2('nearFar')
+    ], function() {
+        // Invert the perspective depth mapping. `linearDepth` is the normalized
+        // viewZ / far that the depth prepass stored, so the non-linear depth is
+        // (near / linearDepth - far) / (near - far) - identical to the
+        // reconstruction in SSGI_getPosition. Operating on the normalized value
+        // directly matters: converting to world-unit viewZ first and reusing the
+        // same expression silently drops a factor of `far`, which pins every
+        // pixel at the far plane and rejects all history.
+        this.$l.safeLinearDepth = pb.max(this.linearDepth, 1e-6);
+        this.$l.ndcZ = pb.div(pb.sub(pb.div(this.nearFar.x, this.safeLinearDepth), this.nearFar.y), pb.sub(this.nearFar.x, this.nearFar.y));
+        this.$l.clipPos = pb.vec4(pb.sub(pb.mul(this.uv, 2), pb.vec2(1)), pb.sub(pb.mul(pb.clamp(this.ndcZ, 0, 1), 2), 1), 1);
+        // clipPos is already normalized (w = 1 after the NDC divide), so the
+        // reprojected w is directly the previous view-space Z.
+        this.$return(pb.mul(this.toPrevClip, this.clipPos).w);
+    });
+    return scope[funcName](currentToPrevClipMatrix, uv, linearDepth, nearFar);
+}
+/**
+ * Depth tolerance for a history comparison at a given depth.
+ *
+ * A single absolute tolerance cannot serve the whole depth range: it is far too
+ * loose next to the camera, where a few centimetres separate distinct surfaces,
+ * and too tight in the distance, where depth precision and residual reprojection
+ * error both scale with viewZ. Scaling the floor by depth keeps the test at a
+ * roughly constant relative strictness.
+ *
+ * @param scope - Current shader scope
+ * @param baseTolerance - Configured absolute tolerance, in world units
+ * @param viewDepth - View-space Z the comparison happens at, in world units
+ * @returns Effective tolerance, in world units
+ * @internal
+ */ function ssgiDepthTolerance(scope, baseTolerance, viewDepth) {
+    const pb = scope.$builder;
+    const funcName = 'Z_ssgiDepthTolerance';
+    pb.func(funcName, [
+        pb.float('baseTolerance'),
+        pb.float('viewDepth')
+    ], function() {
+        this.$return(pb.max(pb.max(this.baseTolerance, 1e-4), pb.mul(pb.abs(this.viewDepth), SSGI_DEPTH_TOLERANCE_SLOPE)));
+    });
+    return scope[funcName](baseTolerance, viewDepth);
+}
+
+export { SSGI_DEPTH_TOLERANCE_SLOPE, ssgiCurrentToPrevClipMatrix, ssgiDepthTolerance, ssgiPreviousViewDepth };
+//# sourceMappingURL=ssgi_reprojection.js.map

package/dist/shaders/ssgi_reprojection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssgi_reprojection.js","sources":["../../src/shaders/ssgi_reprojection.ts"],"sourcesContent":["import { Matrix4x4 } from '@zephyr3d/base';\nimport type { PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\nimport type { DrawContext } from '../render/drawable';\n\n/**\n * Shared helpers for validating SSGI temporal history across frames.\n *\n * SSGI stores the surface depth of a frame as that frame's view-space Z (the\n * distance along the camera forward axis, in world units). Comparing such a\n * value against the *current* frame's view-space Z is only meaningful while the\n * camera is still: rotating the camera turns the forward axis, so a static world\n * point changes its view-space Z by roughly\n *\n *   dz ~ dTheta * viewZ * tan(halfFovX) * |ndc.x|\n *\n * which is zero at the screen center and grows with both depth and screen\n * eccentricity. At a plain mouse-look rate that already exceeds any reasonable\n * absolute tolerance for distant off-center pixels, so history gets rejected in\n * screen-edge bands even though it is perfectly valid. Every consumer therefore\n * has to convert the current depth into the *previous* frame's view space before\n * comparing.\n *\n * @internal\n */\n\n/**\n * Relative share of the compared depth added to the absolute tolerance. 2% keeps\n * a 10m surface within 0.2m, comfortably above rgba16f depth quantization while\n * still separating surfaces that a bounce should not share.\n * @internal\n */\nexport const SSGI_DEPTH_TOLERANCE_SLOPE = 0.02;\n\n/**\n * `prevVP * inverse(currentVP)`: maps a current-frame clip position onto the\n * previous frame's clip space, where `w` is the previous view-space Z.\n *\n * The current half uses the jittered inverse VP because every consumer\n * reconstructs from a depth buffer that was rasterized with jitter applied.\n * Jitter only shifts clip x/y, so pairing it with the unjittered `prevVPMatrix`\n * still produces the correct `w`.\n *\n * Falls back to the current VP before any previous transform exists, which\n * degenerates into comparing the current depth against itself - harmless,\n * because the history textures are empty on that frame anyway.\n *\n * @param ctx - Current draw context\n * @returns The reprojection matrix\n * @internal\n */\nexport function ssgiCurrentToPrevClipMatrix(ctx: DrawContext): Matrix4x4 {\n  const camera = ctx.camera;\n  const prevVP = camera.prevVPMatrix ?? camera.viewProjectionMatrix;\n  return Matrix4x4.multiply(prevVP, camera.jitteredInvVPMatrix);\n}\n\n/**\n * Converts the current frame's linear depth at `uv` into the view-space Z it\n * would have had in the previous frame, so it can be compared against the depth\n * stored in the SSGI surface history.\n *\n * `currentToPrevClipMatrix` must be `prevViewProjection * inverse(currentViewProjection)`,\n * mapping a current-frame clip position onto the previous frame's clip space. In\n * a perspective projection the resulting `w` is exactly the previous view-space\n * Z in world units, which is the quantity the surface pass wrote.\n *\n * @param scope - Current shader scope\n * @param currentToPrevClipMatrix - `prevVP * invCurrentVP`, as a mat4\n * @param uv - Screen uv of the pixel being validated\n * @param linearDepth - Normalized linear depth (viewZ / far) at `uv`\n * @param nearFar - Camera near and far planes\n * @returns Previous-frame view-space Z, in world units\n * @internal\n */\nexport function ssgiPreviousViewDepth(\n  scope: PBInsideFunctionScope,\n  currentToPrevClipMatrix: PBShaderExp,\n  uv: PBShaderExp,\n  linearDepth: PBShaderExp,\n  nearFar: PBShaderExp\n): PBShaderExp {\n  const pb = scope.$builder;\n  const funcName = 'Z_ssgiPreviousViewDepth';\n  pb.func(\n    funcName,\n    [pb.mat4('toPrevClip'), pb.vec2('uv'), pb.float('linearDepth'), pb.vec2('nearFar')],\n    function () {\n      // Invert the perspective depth mapping. `linearDepth` is the normalized\n      // viewZ / far that the depth prepass stored, so the non-linear depth is\n      // (near / linearDepth - far) / (near - far) - identical to the\n      // reconstruction in SSGI_getPosition. Operating on the normalized value\n      // directly matters: converting to world-unit viewZ first and reusing the\n      // same expression silently drops a factor of `far`, which pins every\n      // pixel at the far plane and rejects all history.\n      this.$l.safeLinearDepth = pb.max(this.linearDepth, 1e-6);\n      this.$l.ndcZ = pb.div(\n        pb.sub(pb.div(this.nearFar.x, this.safeLinearDepth), this.nearFar.y),\n        pb.sub(this.nearFar.x, this.nearFar.y)\n      );\n      this.$l.clipPos = pb.vec4(\n        pb.sub(pb.mul(this.uv, 2), pb.vec2(1)),\n        pb.sub(pb.mul(pb.clamp(this.ndcZ, 0, 1), 2), 1),\n        1\n      );\n      // clipPos is already normalized (w = 1 after the NDC divide), so the\n      // reprojected w is directly the previous view-space Z.\n      this.$return(pb.mul(this.toPrevClip, this.clipPos).w);\n    }\n  );\n  return scope[funcName](currentToPrevClipMatrix, uv, linearDepth, nearFar) as PBShaderExp;\n}\n\n/**\n * Depth tolerance for a history comparison at a given depth.\n *\n * A single absolute tolerance cannot serve the whole depth range: it is far too\n * loose next to the camera, where a few centimetres separate distinct surfaces,\n * and too tight in the distance, where depth precision and residual reprojection\n * error both scale with viewZ. Scaling the floor by depth keeps the test at a\n * roughly constant relative strictness.\n *\n * @param scope - Current shader scope\n * @param baseTolerance - Configured absolute tolerance, in world units\n * @param viewDepth - View-space Z the comparison happens at, in world units\n * @returns Effective tolerance, in world units\n * @internal\n */\nexport function ssgiDepthTolerance(\n  scope: PBInsideFunctionScope,\n  baseTolerance: PBShaderExp,\n  viewDepth: PBShaderExp\n): PBShaderExp {\n  const pb = scope.$builder;\n  const funcName = 'Z_ssgiDepthTolerance';\n  pb.func(funcName, [pb.float('baseTolerance'), pb.float('viewDepth')], function () {\n    this.$return(\n      pb.max(pb.max(this.baseTolerance, 1e-4), pb.mul(pb.abs(this.viewDepth), SSGI_DEPTH_TOLERANCE_SLOPE))\n    );\n  });\n  return scope[funcName](baseTolerance, viewDepth) as PBShaderExp;\n}\n"],"names":["SSGI_DEPTH_TOLERANCE_SLOPE","ssgiCurrentToPrevClipMatrix","ctx","camera","prevVP","prevVPMatrix","viewProjectionMatrix","Matrix4x4","multiply","jitteredInvVPMatrix","ssgiPreviousViewDepth","scope","currentToPrevClipMatrix","uv","linearDepth","nearFar","pb","$builder","funcName","func","mat4","vec2","float","$l","safeLinearDepth","max","ndcZ","div","sub","x","y","clipPos","vec4","mul","clamp","$return","toPrevClip","w","ssgiDepthTolerance","baseTolerance","viewDepth","abs"],"mappings":"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"}