@aura3d/rendering 3.0.1 → 4.0.2

package/dist/post/shaders/fxaa.glsl.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PRD-03 §6.5 — the FXAA finalize shader.
+ *
+ * `FXAA_185_FRAGMENT_GLSL` is a verbatim port of three r185
+ * `node_modules/three/examples/jsm/shaders/FXAAShader.js` (MIT; Jasper Flick's
+ * Catlike Coding FXAA, GLSL port by Dave Hoskins — NOT the NVIDIA FXAA 3.11
+ * Quality preset 12). It is *not* a fragment inside the present uber-shader:
+ * the old `u_hasFxaa` path re-ran `finalColorAt` (the whole tone/grade stack)
+ * for every tap, which produced the blur-AA complaint. This program samples a
+ * completed LDR image instead.
+ *
+ * Uniforms: `u_source` (the RGBA8 intermediate), `u_texelSize` (1/source dims,
+ * the FXAA tap step), `u_outputTexel` (1/output dims — the base uv, so the
+ * present-stage stretch stays intact). `triangularDither` runs on the last
+ * write to the 8-bit output (PRD-03 S12).
+ */
+/**
+ * The FXAA function set, shared by the standalone Phase-1 program and the v2
+ * fused finalize. `AURA_LUMA_ALPHA` selects the luminance source: `0`
+ * recomputes luma per tap from `.rgb` (legacy LDR path, where alpha is
+ * coverage), `1` reads the luma the S10b display-grade writes into `.a`
+ * (§8.12, so v2 FXAA never re-evaluates the grade).
+ */
+export declare const FXAA_185_FNS_GLSL = "#define EDGE_STEP_COUNT 6\n#define EDGE_GUESS 8.0\n#define EDGE_STEPS 1.0, 1.5, 2.0, 2.0, 2.0, 4.0\nconst float edgeSteps[EDGE_STEP_COUNT] = float[EDGE_STEP_COUNT]( EDGE_STEPS );\n\nfloat _ContrastThreshold = 0.0312;\nfloat _RelativeThreshold = 0.063;\nfloat _SubpixelBlending = 1.0;\n\n#ifndef AURA_FXAA_SAMPLE\n#define AURA_FXAA_SAMPLE(tex, uv) texture(tex, uv)\n#endif\n\nvec4 Sample( sampler2D tex2D, vec2 uv ) {\n  return AURA_FXAA_SAMPLE( tex2D, uv );\n}\n\nfloat SampleLuminance( sampler2D tex2D, vec2 uv ) {\n#if AURA_LUMA_ALPHA\n  return AURA_FXAA_SAMPLE( tex2D, uv ).a;\n#else\n  return dot( Sample( tex2D, uv ).rgb, vec3( 0.3, 0.59, 0.11 ) );\n#endif\n}\n\nfloat SampleLuminance( sampler2D tex2D, vec2 texSize, vec2 uv, float uOffset, float vOffset ) {\n  uv += texSize * vec2(uOffset, vOffset);\n  return SampleLuminance(tex2D, uv);\n}\n\nstruct LuminanceData {\n  float m, n, e, s, w;\n  float ne, nw, se, sw;\n  float highest, lowest, contrast;\n};\n\nLuminanceData SampleLuminanceNeighborhood( sampler2D tex2D, vec2 texSize, vec2 uv ) {\n  LuminanceData l;\n  l.m = SampleLuminance( tex2D, uv );\n  l.n = SampleLuminance( tex2D, texSize, uv,  0.0,  1.0 );\n  l.e = SampleLuminance( tex2D, texSize, uv,  1.0,  0.0 );\n  l.s = SampleLuminance( tex2D, texSize, uv,  0.0, -1.0 );\n  l.w = SampleLuminance( tex2D, texSize, uv, -1.0,  0.0 );\n\n  l.ne = SampleLuminance( tex2D, texSize, uv,  1.0,  1.0 );\n  l.nw = SampleLuminance( tex2D, texSize, uv, -1.0,  1.0 );\n  l.se = SampleLuminance( tex2D, texSize, uv,  1.0, -1.0 );\n  l.sw = SampleLuminance( tex2D, texSize, uv, -1.0, -1.0 );\n\n  l.highest = max( max( max( max( l.n, l.e ), l.s ), l.w ), l.m );\n  l.lowest = min( min( min( min( l.n, l.e ), l.s ), l.w ), l.m );\n  l.contrast = l.highest - l.lowest;\n  return l;\n}\n\nbool ShouldSkipPixel( LuminanceData l ) {\n  float threshold = max( _ContrastThreshold, _RelativeThreshold * l.highest );\n  return l.contrast < threshold;\n}\n\nfloat DeterminePixelBlendFactor( LuminanceData l ) {\n  float f = 2.0 * ( l.n + l.e + l.s + l.w );\n  f += l.ne + l.nw + l.se + l.sw;\n  f *= 1.0 / 12.0;\n  f = abs( f - l.m );\n  f = clamp( f / l.contrast, 0.0, 1.0 );\n\n  float blendFactor = smoothstep( 0.0, 1.0, f );\n  return blendFactor * blendFactor * _SubpixelBlending;\n}\n\nstruct EdgeData {\n  bool isHorizontal;\n  float pixelStep;\n  float oppositeLuminance, gradient;\n};\n\nEdgeData DetermineEdge( vec2 texSize, LuminanceData l ) {\n  EdgeData e;\n  float horizontal =\n    abs( l.n + l.s - 2.0 * l.m ) * 2.0 +\n    abs( l.ne + l.se - 2.0 * l.e ) +\n    abs( l.nw + l.sw - 2.0 * l.w );\n  float vertical =\n    abs( l.e + l.w - 2.0 * l.m ) * 2.0 +\n    abs( l.ne + l.nw - 2.0 * l.n ) +\n    abs( l.se + l.sw - 2.0 * l.s );\n  e.isHorizontal = horizontal >= vertical;\n\n  float pLuminance = e.isHorizontal ? l.n : l.e;\n  float nLuminance = e.isHorizontal ? l.s : l.w;\n  float pGradient = abs( pLuminance - l.m );\n  float nGradient = abs( nLuminance - l.m );\n\n  e.pixelStep = e.isHorizontal ? texSize.y : texSize.x;\n\n  if (pGradient < nGradient) {\n    e.pixelStep = -e.pixelStep;\n    e.oppositeLuminance = nLuminance;\n    e.gradient = nGradient;\n  } else {\n    e.oppositeLuminance = pLuminance;\n    e.gradient = pGradient;\n  }\n\n  return e;\n}\n\nfloat DetermineEdgeBlendFactor( sampler2D tex2D, vec2 texSize, LuminanceData l, EdgeData e, vec2 uv ) {\n  vec2 uvEdge = uv;\n  vec2 edgeStep;\n  if (e.isHorizontal) {\n    uvEdge.y += e.pixelStep * 0.5;\n    edgeStep = vec2( texSize.x, 0.0 );\n  } else {\n    uvEdge.x += e.pixelStep * 0.5;\n    edgeStep = vec2( 0.0, texSize.y );\n  }\n\n  float edgeLuminance = ( l.m + e.oppositeLuminance ) * 0.5;\n  float gradientThreshold = e.gradient * 0.25;\n\n  vec2 puv = uvEdge + edgeStep * edgeSteps[0];\n  float pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n  bool pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n\n  for ( int i = 1; i < EDGE_STEP_COUNT && !pAtEnd; i++ ) {\n    puv += edgeStep * edgeSteps[i];\n    pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n    pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n  }\n\n  if ( !pAtEnd ) {\n    puv += edgeStep * EDGE_GUESS;\n  }\n\n  vec2 nuv = uvEdge - edgeStep * edgeSteps[0];\n  float nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n  bool nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n\n  for ( int i = 1; i < EDGE_STEP_COUNT && !nAtEnd; i++ ) {\n    nuv -= edgeStep * edgeSteps[i];\n    nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n    nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n  }\n\n  if ( !nAtEnd ) {\n    nuv -= edgeStep * EDGE_GUESS;\n  }\n\n  float pDistance, nDistance;\n  if ( e.isHorizontal ) {\n    pDistance = puv.x - uv.x;\n    nDistance = uv.x - nuv.x;\n  } else {\n    pDistance = puv.y - uv.y;\n    nDistance = uv.y - nuv.y;\n  }\n\n  float shortestDistance;\n  bool deltaSign;\n  if ( pDistance <= nDistance ) {\n    shortestDistance = pDistance;\n    deltaSign = pLuminanceDelta >= 0.0;\n  } else {\n    shortestDistance = nDistance;\n    deltaSign = nLuminanceDelta >= 0.0;\n  }\n\n  if ( deltaSign == ( l.m - edgeLuminance >= 0.0 ) ) {\n    return 0.0;\n  }\n\n  return 0.5 - shortestDistance / ( pDistance + nDistance );\n}\n\nvec4 ApplyFXAA( sampler2D tex2D, vec2 texSize, vec2 uv ) {\n  LuminanceData luminance = SampleLuminanceNeighborhood( tex2D, texSize, uv );\n  if ( ShouldSkipPixel( luminance ) ) {\n    return Sample( tex2D, uv );\n  }\n\n  float pixelBlend = DeterminePixelBlendFactor( luminance );\n  EdgeData edge = DetermineEdge( texSize, luminance );\n  float edgeBlend = DetermineEdgeBlendFactor( tex2D, texSize, luminance, edge, uv );\n  float finalBlend = max( pixelBlend, edgeBlend );\n\n  if (edge.isHorizontal) {\n    uv.y += edge.pixelStep * finalBlend;\n  } else {\n    uv.x += edge.pixelStep * finalBlend;\n  }\n\n  return Sample( tex2D, uv );\n}\n";
+export declare const FXAA_185_FRAGMENT_GLSL = "#version 300 es\nprecision highp float;\n#define AURA_LUMA_ALPHA 0\nuniform sampler2D u_source;\nuniform vec2 u_texelSize;\nuniform vec2 u_outputTexel;\nout vec4 outColor;\n\n#define EDGE_STEP_COUNT 6\n#define EDGE_GUESS 8.0\n#define EDGE_STEPS 1.0, 1.5, 2.0, 2.0, 2.0, 4.0\nconst float edgeSteps[EDGE_STEP_COUNT] = float[EDGE_STEP_COUNT]( EDGE_STEPS );\n\nfloat _ContrastThreshold = 0.0312;\nfloat _RelativeThreshold = 0.063;\nfloat _SubpixelBlending = 1.0;\n\n#ifndef AURA_FXAA_SAMPLE\n#define AURA_FXAA_SAMPLE(tex, uv) texture(tex, uv)\n#endif\n\nvec4 Sample( sampler2D tex2D, vec2 uv ) {\n  return AURA_FXAA_SAMPLE( tex2D, uv );\n}\n\nfloat SampleLuminance( sampler2D tex2D, vec2 uv ) {\n#if AURA_LUMA_ALPHA\n  return AURA_FXAA_SAMPLE( tex2D, uv ).a;\n#else\n  return dot( Sample( tex2D, uv ).rgb, vec3( 0.3, 0.59, 0.11 ) );\n#endif\n}\n\nfloat SampleLuminance( sampler2D tex2D, vec2 texSize, vec2 uv, float uOffset, float vOffset ) {\n  uv += texSize * vec2(uOffset, vOffset);\n  return SampleLuminance(tex2D, uv);\n}\n\nstruct LuminanceData {\n  float m, n, e, s, w;\n  float ne, nw, se, sw;\n  float highest, lowest, contrast;\n};\n\nLuminanceData SampleLuminanceNeighborhood( sampler2D tex2D, vec2 texSize, vec2 uv ) {\n  LuminanceData l;\n  l.m = SampleLuminance( tex2D, uv );\n  l.n = SampleLuminance( tex2D, texSize, uv,  0.0,  1.0 );\n  l.e = SampleLuminance( tex2D, texSize, uv,  1.0,  0.0 );\n  l.s = SampleLuminance( tex2D, texSize, uv,  0.0, -1.0 );\n  l.w = SampleLuminance( tex2D, texSize, uv, -1.0,  0.0 );\n\n  l.ne = SampleLuminance( tex2D, texSize, uv,  1.0,  1.0 );\n  l.nw = SampleLuminance( tex2D, texSize, uv, -1.0,  1.0 );\n  l.se = SampleLuminance( tex2D, texSize, uv,  1.0, -1.0 );\n  l.sw = SampleLuminance( tex2D, texSize, uv, -1.0, -1.0 );\n\n  l.highest = max( max( max( max( l.n, l.e ), l.s ), l.w ), l.m );\n  l.lowest = min( min( min( min( l.n, l.e ), l.s ), l.w ), l.m );\n  l.contrast = l.highest - l.lowest;\n  return l;\n}\n\nbool ShouldSkipPixel( LuminanceData l ) {\n  float threshold = max( _ContrastThreshold, _RelativeThreshold * l.highest );\n  return l.contrast < threshold;\n}\n\nfloat DeterminePixelBlendFactor( LuminanceData l ) {\n  float f = 2.0 * ( l.n + l.e + l.s + l.w );\n  f += l.ne + l.nw + l.se + l.sw;\n  f *= 1.0 / 12.0;\n  f = abs( f - l.m );\n  f = clamp( f / l.contrast, 0.0, 1.0 );\n\n  float blendFactor = smoothstep( 0.0, 1.0, f );\n  return blendFactor * blendFactor * _SubpixelBlending;\n}\n\nstruct EdgeData {\n  bool isHorizontal;\n  float pixelStep;\n  float oppositeLuminance, gradient;\n};\n\nEdgeData DetermineEdge( vec2 texSize, LuminanceData l ) {\n  EdgeData e;\n  float horizontal =\n    abs( l.n + l.s - 2.0 * l.m ) * 2.0 +\n    abs( l.ne + l.se - 2.0 * l.e ) +\n    abs( l.nw + l.sw - 2.0 * l.w );\n  float vertical =\n    abs( l.e + l.w - 2.0 * l.m ) * 2.0 +\n    abs( l.ne + l.nw - 2.0 * l.n ) +\n    abs( l.se + l.sw - 2.0 * l.s );\n  e.isHorizontal = horizontal >= vertical;\n\n  float pLuminance = e.isHorizontal ? l.n : l.e;\n  float nLuminance = e.isHorizontal ? l.s : l.w;\n  float pGradient = abs( pLuminance - l.m );\n  float nGradient = abs( nLuminance - l.m );\n\n  e.pixelStep = e.isHorizontal ? texSize.y : texSize.x;\n\n  if (pGradient < nGradient) {\n    e.pixelStep = -e.pixelStep;\n    e.oppositeLuminance = nLuminance;\n    e.gradient = nGradient;\n  } else {\n    e.oppositeLuminance = pLuminance;\n    e.gradient = pGradient;\n  }\n\n  return e;\n}\n\nfloat DetermineEdgeBlendFactor( sampler2D tex2D, vec2 texSize, LuminanceData l, EdgeData e, vec2 uv ) {\n  vec2 uvEdge = uv;\n  vec2 edgeStep;\n  if (e.isHorizontal) {\n    uvEdge.y += e.pixelStep * 0.5;\n    edgeStep = vec2( texSize.x, 0.0 );\n  } else {\n    uvEdge.x += e.pixelStep * 0.5;\n    edgeStep = vec2( 0.0, texSize.y );\n  }\n\n  float edgeLuminance = ( l.m + e.oppositeLuminance ) * 0.5;\n  float gradientThreshold = e.gradient * 0.25;\n\n  vec2 puv = uvEdge + edgeStep * edgeSteps[0];\n  float pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n  bool pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n\n  for ( int i = 1; i < EDGE_STEP_COUNT && !pAtEnd; i++ ) {\n    puv += edgeStep * edgeSteps[i];\n    pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n    pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n  }\n\n  if ( !pAtEnd ) {\n    puv += edgeStep * EDGE_GUESS;\n  }\n\n  vec2 nuv = uvEdge - edgeStep * edgeSteps[0];\n  float nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n  bool nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n\n  for ( int i = 1; i < EDGE_STEP_COUNT && !nAtEnd; i++ ) {\n    nuv -= edgeStep * edgeSteps[i];\n    nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n    nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n  }\n\n  if ( !nAtEnd ) {\n    nuv -= edgeStep * EDGE_GUESS;\n  }\n\n  float pDistance, nDistance;\n  if ( e.isHorizontal ) {\n    pDistance = puv.x - uv.x;\n    nDistance = uv.x - nuv.x;\n  } else {\n    pDistance = puv.y - uv.y;\n    nDistance = uv.y - nuv.y;\n  }\n\n  float shortestDistance;\n  bool deltaSign;\n  if ( pDistance <= nDistance ) {\n    shortestDistance = pDistance;\n    deltaSign = pLuminanceDelta >= 0.0;\n  } else {\n    shortestDistance = nDistance;\n    deltaSign = nLuminanceDelta >= 0.0;\n  }\n\n  if ( deltaSign == ( l.m - edgeLuminance >= 0.0 ) ) {\n    return 0.0;\n  }\n\n  return 0.5 - shortestDistance / ( pDistance + nDistance );\n}\n\nvec4 ApplyFXAA( sampler2D tex2D, vec2 texSize, vec2 uv ) {\n  LuminanceData luminance = SampleLuminanceNeighborhood( tex2D, texSize, uv );\n  if ( ShouldSkipPixel( luminance ) ) {\n    return Sample( tex2D, uv );\n  }\n\n  float pixelBlend = DeterminePixelBlendFactor( luminance );\n  EdgeData edge = DetermineEdge( texSize, luminance );\n  float edgeBlend = DetermineEdgeBlendFactor( tex2D, texSize, luminance, edge, uv );\n  float finalBlend = max( pixelBlend, edgeBlend );\n\n  if (edge.isHorizontal) {\n    uv.y += edge.pixelStep * finalBlend;\n  } else {\n    uv.x += edge.pixelStep * finalBlend;\n  }\n\n  return Sample( tex2D, uv );\n}\n\n\n\nfloat linearizeDepth(float d, float n, float f, bool ortho) {\n  float z = d * 2.0 - 1.0;\n  return ortho ? mix(n, f, d) : (2.0 * n * f) / (f + n - z * (f - n));\n}\n\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfloat triangularDither(vec2 fragCoord, float frame) {\n  uvec2 seed = uvec2(fragCoord) + uvec2(uint(frame) * 747796405u);\n  vec2 rand = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n\nvoid main() {\n  vec2 uv = gl_FragCoord.xy * u_outputTexel;\n  vec4 color = ApplyFXAA( u_source, u_texelSize, uv );\n  // S12: the triangular-PDF dither belongs to the last write to the 8-bit\n  // output \u2014 on the legacy present this program IS the last write; on the v2\n  // unfused tail S12-finalize follows, so it compiles with AURA_FXAA_NO_DITHER.\n  outColor = vec4(color.rgb\n#if !defined(AURA_FXAA_NO_DITHER)\n    + triangularDither(gl_FragCoord.xy, 0.0)\n#endif\n    , color.a);\n}\n";
+//# sourceMappingURL=fxaa.glsl.d.ts.map

package/dist/post/shaders/fxaa.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fxaa.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/fxaa.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,szLAmM7B,CAAC;AAEF,eAAO,MAAM,sBAAsB,opOAwBlC,CAAC"}

package/dist/post/shaders/fxaa.glsl.js

@@ -0,0 +1,246 @@
+/**
+ * PRD-03 §6.5 — the FXAA finalize shader.
+ *
+ * `FXAA_185_FRAGMENT_GLSL` is a verbatim port of three r185
+ * `node_modules/three/examples/jsm/shaders/FXAAShader.js` (MIT; Jasper Flick's
+ * Catlike Coding FXAA, GLSL port by Dave Hoskins — NOT the NVIDIA FXAA 3.11
+ * Quality preset 12). It is *not* a fragment inside the present uber-shader:
+ * the old `u_hasFxaa` path re-ran `finalColorAt` (the whole tone/grade stack)
+ * for every tap, which produced the blur-AA complaint. This program samples a
+ * completed LDR image instead.
+ *
+ * Uniforms: `u_source` (the RGBA8 intermediate), `u_texelSize` (1/source dims,
+ * the FXAA tap step), `u_outputTexel` (1/output dims — the base uv, so the
+ * present-stage stretch stays intact). `triangularDither` runs on the last
+ * write to the 8-bit output (PRD-03 S12).
+ */
+import { POST_COMMON_GLSL } from "./common.glsl.js";
+/**
+ * The FXAA function set, shared by the standalone Phase-1 program and the v2
+ * fused finalize. `AURA_LUMA_ALPHA` selects the luminance source: `0`
+ * recomputes luma per tap from `.rgb` (legacy LDR path, where alpha is
+ * coverage), `1` reads the luma the S10b display-grade writes into `.a`
+ * (§8.12, so v2 FXAA never re-evaluates the grade).
+ */
+export const FXAA_185_FNS_GLSL = /* glsl */ `#define EDGE_STEP_COUNT 6
+#define EDGE_GUESS 8.0
+#define EDGE_STEPS 1.0, 1.5, 2.0, 2.0, 2.0, 4.0
+const float edgeSteps[EDGE_STEP_COUNT] = float[EDGE_STEP_COUNT]( EDGE_STEPS );
+
+float _ContrastThreshold = 0.0312;
+float _RelativeThreshold = 0.063;
+float _SubpixelBlending = 1.0;
+
+#ifndef AURA_FXAA_SAMPLE
+#define AURA_FXAA_SAMPLE(tex, uv) texture(tex, uv)
+#endif
+
+vec4 Sample( sampler2D tex2D, vec2 uv ) {
+  return AURA_FXAA_SAMPLE( tex2D, uv );
+}
+
+float SampleLuminance( sampler2D tex2D, vec2 uv ) {
+#if AURA_LUMA_ALPHA
+  return AURA_FXAA_SAMPLE( tex2D, uv ).a;
+#else
+  return dot( Sample( tex2D, uv ).rgb, vec3( 0.3, 0.59, 0.11 ) );
+#endif
+}
+
+float SampleLuminance( sampler2D tex2D, vec2 texSize, vec2 uv, float uOffset, float vOffset ) {
+  uv += texSize * vec2(uOffset, vOffset);
+  return SampleLuminance(tex2D, uv);
+}
+
+struct LuminanceData {
+  float m, n, e, s, w;
+  float ne, nw, se, sw;
+  float highest, lowest, contrast;
+};
+
+LuminanceData SampleLuminanceNeighborhood( sampler2D tex2D, vec2 texSize, vec2 uv ) {
+  LuminanceData l;
+  l.m = SampleLuminance( tex2D, uv );
+  l.n = SampleLuminance( tex2D, texSize, uv,  0.0,  1.0 );
+  l.e = SampleLuminance( tex2D, texSize, uv,  1.0,  0.0 );
+  l.s = SampleLuminance( tex2D, texSize, uv,  0.0, -1.0 );
+  l.w = SampleLuminance( tex2D, texSize, uv, -1.0,  0.0 );
+
+  l.ne = SampleLuminance( tex2D, texSize, uv,  1.0,  1.0 );
+  l.nw = SampleLuminance( tex2D, texSize, uv, -1.0,  1.0 );
+  l.se = SampleLuminance( tex2D, texSize, uv,  1.0, -1.0 );
+  l.sw = SampleLuminance( tex2D, texSize, uv, -1.0, -1.0 );
+
+  l.highest = max( max( max( max( l.n, l.e ), l.s ), l.w ), l.m );
+  l.lowest = min( min( min( min( l.n, l.e ), l.s ), l.w ), l.m );
+  l.contrast = l.highest - l.lowest;
+  return l;
+}
+
+bool ShouldSkipPixel( LuminanceData l ) {
+  float threshold = max( _ContrastThreshold, _RelativeThreshold * l.highest );
+  return l.contrast < threshold;
+}
+
+float DeterminePixelBlendFactor( LuminanceData l ) {
+  float f = 2.0 * ( l.n + l.e + l.s + l.w );
+  f += l.ne + l.nw + l.se + l.sw;
+  f *= 1.0 / 12.0;
+  f = abs( f - l.m );
+  f = clamp( f / l.contrast, 0.0, 1.0 );
+
+  float blendFactor = smoothstep( 0.0, 1.0, f );
+  return blendFactor * blendFactor * _SubpixelBlending;
+}
+
+struct EdgeData {
+  bool isHorizontal;
+  float pixelStep;
+  float oppositeLuminance, gradient;
+};
+
+EdgeData DetermineEdge( vec2 texSize, LuminanceData l ) {
+  EdgeData e;
+  float horizontal =
+    abs( l.n + l.s - 2.0 * l.m ) * 2.0 +
+    abs( l.ne + l.se - 2.0 * l.e ) +
+    abs( l.nw + l.sw - 2.0 * l.w );
+  float vertical =
+    abs( l.e + l.w - 2.0 * l.m ) * 2.0 +
+    abs( l.ne + l.nw - 2.0 * l.n ) +
+    abs( l.se + l.sw - 2.0 * l.s );
+  e.isHorizontal = horizontal >= vertical;
+
+  float pLuminance = e.isHorizontal ? l.n : l.e;
+  float nLuminance = e.isHorizontal ? l.s : l.w;
+  float pGradient = abs( pLuminance - l.m );
+  float nGradient = abs( nLuminance - l.m );
+
+  e.pixelStep = e.isHorizontal ? texSize.y : texSize.x;
+
+  if (pGradient < nGradient) {
+    e.pixelStep = -e.pixelStep;
+    e.oppositeLuminance = nLuminance;
+    e.gradient = nGradient;
+  } else {
+    e.oppositeLuminance = pLuminance;
+    e.gradient = pGradient;
+  }
+
+  return e;
+}
+
+float DetermineEdgeBlendFactor( sampler2D tex2D, vec2 texSize, LuminanceData l, EdgeData e, vec2 uv ) {
+  vec2 uvEdge = uv;
+  vec2 edgeStep;
+  if (e.isHorizontal) {
+    uvEdge.y += e.pixelStep * 0.5;
+    edgeStep = vec2( texSize.x, 0.0 );
+  } else {
+    uvEdge.x += e.pixelStep * 0.5;
+    edgeStep = vec2( 0.0, texSize.y );
+  }
+
+  float edgeLuminance = ( l.m + e.oppositeLuminance ) * 0.5;
+  float gradientThreshold = e.gradient * 0.25;
+
+  vec2 puv = uvEdge + edgeStep * edgeSteps[0];
+  float pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;
+  bool pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;
+
+  for ( int i = 1; i < EDGE_STEP_COUNT && !pAtEnd; i++ ) {
+    puv += edgeStep * edgeSteps[i];
+    pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;
+    pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;
+  }
+
+  if ( !pAtEnd ) {
+    puv += edgeStep * EDGE_GUESS;
+  }
+
+  vec2 nuv = uvEdge - edgeStep * edgeSteps[0];
+  float nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;
+  bool nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;
+
+  for ( int i = 1; i < EDGE_STEP_COUNT && !nAtEnd; i++ ) {
+    nuv -= edgeStep * edgeSteps[i];
+    nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;
+    nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;
+  }
+
+  if ( !nAtEnd ) {
+    nuv -= edgeStep * EDGE_GUESS;
+  }
+
+  float pDistance, nDistance;
+  if ( e.isHorizontal ) {
+    pDistance = puv.x - uv.x;
+    nDistance = uv.x - nuv.x;
+  } else {
+    pDistance = puv.y - uv.y;
+    nDistance = uv.y - nuv.y;
+  }
+
+  float shortestDistance;
+  bool deltaSign;
+  if ( pDistance <= nDistance ) {
+    shortestDistance = pDistance;
+    deltaSign = pLuminanceDelta >= 0.0;
+  } else {
+    shortestDistance = nDistance;
+    deltaSign = nLuminanceDelta >= 0.0;
+  }
+
+  if ( deltaSign == ( l.m - edgeLuminance >= 0.0 ) ) {
+    return 0.0;
+  }
+
+  return 0.5 - shortestDistance / ( pDistance + nDistance );
+}
+
+vec4 ApplyFXAA( sampler2D tex2D, vec2 texSize, vec2 uv ) {
+  LuminanceData luminance = SampleLuminanceNeighborhood( tex2D, texSize, uv );
+  if ( ShouldSkipPixel( luminance ) ) {
+    return Sample( tex2D, uv );
+  }
+
+  float pixelBlend = DeterminePixelBlendFactor( luminance );
+  EdgeData edge = DetermineEdge( texSize, luminance );
+  float edgeBlend = DetermineEdgeBlendFactor( tex2D, texSize, luminance, edge, uv );
+  float finalBlend = max( pixelBlend, edgeBlend );
+
+  if (edge.isHorizontal) {
+    uv.y += edge.pixelStep * finalBlend;
+  } else {
+    uv.x += edge.pixelStep * finalBlend;
+  }
+
+  return Sample( tex2D, uv );
+}
+`;
+export const FXAA_185_FRAGMENT_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+#define AURA_LUMA_ALPHA 0
+uniform sampler2D u_source;
+uniform vec2 u_texelSize;
+uniform vec2 u_outputTexel;
+out vec4 outColor;
+
+${FXAA_185_FNS_GLSL}
+
+${POST_COMMON_GLSL}
+
+void main() {
+  vec2 uv = gl_FragCoord.xy * u_outputTexel;
+  vec4 color = ApplyFXAA( u_source, u_texelSize, uv );
+  // S12: the triangular-PDF dither belongs to the last write to the 8-bit
+  // output — on the legacy present this program IS the last write; on the v2
+  // unfused tail S12-finalize follows, so it compiles with AURA_FXAA_NO_DITHER.
+  outColor = vec4(color.rgb
+#if !defined(AURA_FXAA_NO_DITHER)
+    + triangularDither(gl_FragCoord.xy, 0.0)
+#endif
+    , color.a);
+}
+`;
+//# sourceMappingURL=fxaa.glsl.js.map

package/dist/post/shaders/fxaa.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fxaa.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/fxaa.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmM3C,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;EAQ/C,iBAAiB;;EAEjB,gBAAgB;;;;;;;;;;;;;;CAcjB,CAAC"}

package/dist/post/shaders/fxaa.wgsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * PRD-03 §6.5 Phase 7 — FXAA WGSL twins (three r185 FXAAShader, Catlike
+ * Coding / Dave Hoskins port — NOT the NVIDIA FXAA 3.11 preset).
+ *
+ * `FXAA_185_FNS_WGSL` is the shared function set. GLSL's two macro hooks map
+ * to consumer-provided WGSL items (each including module must define them):
+ *   - `AURA_FXAA_SAMPLE(tex, uv)` → the consumer defines
+ *     `fn fxaa_sample(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32>`
+ *   - `AURA_LUMA_ALPHA` → the consumer declares
+ *     `override FXAA_LUMA_ALPHA: i32 = 0 | 1`
+ * Standalone (`FXAA_185_FRAGMENT_WGSL`) uses `textureSampleLevel` and
+ * `FXAA_LUMA_ALPHA = 0`; the §6.1 fused finalize declares 1 (luma rides in
+ * `.a`, written by S10b) and injects the display-grade sample.
+ */
+export declare const FXAA_185_FNS_WGSL = "const EDGE_STEP_COUNT: i32 = 6;\nconst EDGE_GUESS: f32 = 8.0;\nconst EDGE_STEPS = array<f32, 6>(1.0, 1.5, 2.0, 2.0, 2.0, 4.0);\n\nconst CONTRAST_THRESHOLD: f32 = 0.0312;\nconst RELATIVE_THRESHOLD: f32 = 0.063;\nconst SUBPIXEL_BLENDING: f32 = 1.0;\n\nfn fxaa_sample_color(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {\n  return fxaa_sample(tex, smp, uv);\n}\n\nfn fxaa_sample_luminance(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> f32 {\n  if (FXAA_LUMA_ALPHA == 1) {\n    return fxaa_sample(tex, smp, uv).a;\n  }\n  return dot(fxaa_sample_color(tex, smp, uv).rgb, vec3<f32>(0.3, 0.59, 0.11));\n}\n\nfn fxaa_sample_luminance_offset(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>, u_offset: f32, v_offset: f32) -> f32 {\n  return fxaa_sample_luminance(tex, smp, uv + tex_size * vec2<f32>(u_offset, v_offset));\n}\n\nstruct LuminanceData {\n  m: f32,\n  n: f32,\n  e: f32,\n  s: f32,\n  w: f32,\n  ne: f32,\n  nw: f32,\n  se: f32,\n  sw: f32,\n  highest: f32,\n  lowest: f32,\n  contrast: f32,\n};\n\nfn sample_luminance_neighborhood(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>) -> LuminanceData {\n  var l: LuminanceData;\n  l.m = fxaa_sample_luminance(tex, smp, uv);\n  l.n = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, 1.0);\n  l.e = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 0.0);\n  l.s = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, -1.0);\n  l.w = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 0.0);\n\n  l.ne = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 1.0);\n  l.nw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 1.0);\n  l.se = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, -1.0);\n  l.sw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, -1.0);\n\n  l.highest = max(max(max(max(l.n, l.e), l.s), l.w), l.m);\n  l.lowest = min(min(min(min(l.n, l.e), l.s), l.w), l.m);\n  l.contrast = l.highest - l.lowest;\n  return l;\n}\n\nfn should_skip_pixel(l: LuminanceData) -> bool {\n  let threshold = max(CONTRAST_THRESHOLD, RELATIVE_THRESHOLD * l.highest);\n  return l.contrast < threshold;\n}\n\nfn determine_pixel_blend_factor(l: LuminanceData) -> f32 {\n  var f = 2.0 * (l.n + l.e + l.s + l.w);\n  f = f + l.ne + l.nw + l.se + l.sw;\n  f = f * (1.0 / 12.0);\n  f = abs(f - l.m);\n  f = clamp(f / l.contrast, 0.0, 1.0);\n\n  let blend_factor = smoothstep(0.0, 1.0, f);\n  return blend_factor * blend_factor * SUBPIXEL_BLENDING;\n}\n\nstruct EdgeData {\n  is_horizontal: bool,\n  pixel_step: f32,\n  opposite_luminance: f32,\n  gradient: f32,\n};\n\nfn determine_edge(tex_size: vec2<f32>, l: LuminanceData) -> EdgeData {\n  var e: EdgeData;\n  let horizontal =\n    abs(l.n + l.s - 2.0 * l.m) * 2.0 +\n    abs(l.ne + l.se - 2.0 * l.e) +\n    abs(l.nw + l.sw - 2.0 * l.w);\n  let vertical =\n    abs(l.e + l.w - 2.0 * l.m) * 2.0 +\n    abs(l.ne + l.nw - 2.0 * l.n) +\n    abs(l.se + l.sw - 2.0 * l.s);\n  e.is_horizontal = horizontal >= vertical;\n\n  let p_luminance = select(l.e, l.n, e.is_horizontal);\n  let n_luminance = select(l.w, l.s, e.is_horizontal);\n  let p_gradient = abs(p_luminance - l.m);\n  let n_gradient = abs(n_luminance - l.m);\n\n  e.pixel_step = select(tex_size.x, tex_size.y, e.is_horizontal);\n\n  if (p_gradient < n_gradient) {\n    e.pixel_step = -e.pixel_step;\n    e.opposite_luminance = n_luminance;\n    e.gradient = n_gradient;\n  } else {\n    e.opposite_luminance = p_luminance;\n    e.gradient = p_gradient;\n  }\n\n  return e;\n}\n\nfn determine_edge_blend_factor(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, l: LuminanceData, e: EdgeData, uv: vec2<f32>) -> f32 {\n  var uv_edge = uv;\n  var edge_step: vec2<f32>;\n  if (e.is_horizontal) {\n    uv_edge.y = uv_edge.y + e.pixel_step * 0.5;\n    edge_step = vec2<f32>(tex_size.x, 0.0);\n  } else {\n    uv_edge.x = uv_edge.x + e.pixel_step * 0.5;\n    edge_step = vec2<f32>(0.0, tex_size.y);\n  }\n\n  let edge_luminance = (l.m + e.opposite_luminance) * 0.5;\n  let gradient_threshold = e.gradient * 0.25;\n\n  var puv = uv_edge + edge_step * EDGE_STEPS[0];\n  var p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;\n  var p_at_end = abs(p_luminance_delta) >= gradient_threshold;\n\n  for (var i = 1; i < EDGE_STEP_COUNT && !p_at_end; i = i + 1) {\n    puv = puv + edge_step * EDGE_STEPS[i];\n    p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;\n    p_at_end = abs(p_luminance_delta) >= gradient_threshold;\n  }\n\n  if (!p_at_end) {\n    puv = puv + edge_step * EDGE_GUESS;\n  }\n\n  var nuv = uv_edge - edge_step * EDGE_STEPS[0];\n  var n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;\n  var n_at_end = abs(n_luminance_delta) >= gradient_threshold;\n\n  for (var i = 1; i < EDGE_STEP_COUNT && !n_at_end; i = i + 1) {\n    nuv = nuv - edge_step * EDGE_STEPS[i];\n    n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;\n    n_at_end = abs(n_luminance_delta) >= gradient_threshold;\n  }\n\n  if (!n_at_end) {\n    nuv = nuv - edge_step * EDGE_GUESS;\n  }\n\n  var p_distance: f32;\n  var n_distance: f32;\n  if (e.is_horizontal) {\n    p_distance = puv.x - uv.x;\n    n_distance = uv.x - nuv.x;\n  } else {\n    p_distance = puv.y - uv.y;\n    n_distance = uv.y - nuv.y;\n  }\n\n  var shortest_distance: f32;\n  var delta_sign: bool;\n  if (p_distance <= n_distance) {\n    shortest_distance = p_distance;\n    delta_sign = p_luminance_delta >= 0.0;\n  } else {\n    shortest_distance = n_distance;\n    delta_sign = n_luminance_delta >= 0.0;\n  }\n\n  if (delta_sign == (l.m - edge_luminance >= 0.0)) {\n    return 0.0;\n  }\n\n  return 0.5 - shortest_distance / (p_distance + n_distance);\n}\n\nfn apply_fxaa(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv_in: vec2<f32>) -> vec4<f32> {\n  let luminance = sample_luminance_neighborhood(tex, smp, tex_size, uv_in);\n  if (should_skip_pixel(luminance)) {\n    return fxaa_sample_color(tex, smp, uv_in);\n  }\n\n  let pixel_blend = determine_pixel_blend_factor(luminance);\n  let edge = determine_edge(tex_size, luminance);\n  let edge_blend = determine_edge_blend_factor(tex, smp, tex_size, luminance, edge, uv_in);\n  let final_blend = max(pixel_blend, edge_blend);\n\n  var uv = uv_in;\n  if (edge.is_horizontal) {\n    uv.y = uv.y + edge.pixel_step * final_blend;\n  } else {\n    uv.x = uv.x + edge.pixel_step * final_blend;\n  }\n\n  return fxaa_sample_color(tex, smp, uv);\n}\n";
+export declare const FXAA_185_FRAGMENT_WGSL = "// FXAA_NO_DITHER \u2014 pipeline-overridable: the v2 unfused tail compiles with\n// true so S12 finalize's single triangular dither isn't doubled.\noverride FXAA_NO_DITHER: bool = false;\noverride FXAA_LUMA_ALPHA: i32 = 0;\n\nstruct FxaaParams {\n  texel_size: vec2<f32>,   // 1 / source dims (the FXAA tap step)\n  output_texel: vec2<f32>, // 1 / output dims (base uv)\n};\n\n@group(0) @binding(0) var<uniform> u_params: FxaaParams;\n@group(0) @binding(1) var u_source_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_source_smp: sampler;\n\n// AURA_FXAA_SAMPLE for the standalone pass: a plain LOD-0 filtered fetch.\nfn fxaa_sample(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {\n  return textureSampleLevel(tex, smp, uv, 0.0);\n}\n\nconst EDGE_STEP_COUNT: i32 = 6;\nconst EDGE_GUESS: f32 = 8.0;\nconst EDGE_STEPS = array<f32, 6>(1.0, 1.5, 2.0, 2.0, 2.0, 4.0);\n\nconst CONTRAST_THRESHOLD: f32 = 0.0312;\nconst RELATIVE_THRESHOLD: f32 = 0.063;\nconst SUBPIXEL_BLENDING: f32 = 1.0;\n\nfn fxaa_sample_color(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {\n  return fxaa_sample(tex, smp, uv);\n}\n\nfn fxaa_sample_luminance(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> f32 {\n  if (FXAA_LUMA_ALPHA == 1) {\n    return fxaa_sample(tex, smp, uv).a;\n  }\n  return dot(fxaa_sample_color(tex, smp, uv).rgb, vec3<f32>(0.3, 0.59, 0.11));\n}\n\nfn fxaa_sample_luminance_offset(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>, u_offset: f32, v_offset: f32) -> f32 {\n  return fxaa_sample_luminance(tex, smp, uv + tex_size * vec2<f32>(u_offset, v_offset));\n}\n\nstruct LuminanceData {\n  m: f32,\n  n: f32,\n  e: f32,\n  s: f32,\n  w: f32,\n  ne: f32,\n  nw: f32,\n  se: f32,\n  sw: f32,\n  highest: f32,\n  lowest: f32,\n  contrast: f32,\n};\n\nfn sample_luminance_neighborhood(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>) -> LuminanceData {\n  var l: LuminanceData;\n  l.m = fxaa_sample_luminance(tex, smp, uv);\n  l.n = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, 1.0);\n  l.e = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 0.0);\n  l.s = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, -1.0);\n  l.w = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 0.0);\n\n  l.ne = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 1.0);\n  l.nw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 1.0);\n  l.se = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, -1.0);\n  l.sw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, -1.0);\n\n  l.highest = max(max(max(max(l.n, l.e), l.s), l.w), l.m);\n  l.lowest = min(min(min(min(l.n, l.e), l.s), l.w), l.m);\n  l.contrast = l.highest - l.lowest;\n  return l;\n}\n\nfn should_skip_pixel(l: LuminanceData) -> bool {\n  let threshold = max(CONTRAST_THRESHOLD, RELATIVE_THRESHOLD * l.highest);\n  return l.contrast < threshold;\n}\n\nfn determine_pixel_blend_factor(l: LuminanceData) -> f32 {\n  var f = 2.0 * (l.n + l.e + l.s + l.w);\n  f = f + l.ne + l.nw + l.se + l.sw;\n  f = f * (1.0 / 12.0);\n  f = abs(f - l.m);\n  f = clamp(f / l.contrast, 0.0, 1.0);\n\n  let blend_factor = smoothstep(0.0, 1.0, f);\n  return blend_factor * blend_factor * SUBPIXEL_BLENDING;\n}\n\nstruct EdgeData {\n  is_horizontal: bool,\n  pixel_step: f32,\n  opposite_luminance: f32,\n  gradient: f32,\n};\n\nfn determine_edge(tex_size: vec2<f32>, l: LuminanceData) -> EdgeData {\n  var e: EdgeData;\n  let horizontal =\n    abs(l.n + l.s - 2.0 * l.m) * 2.0 +\n    abs(l.ne + l.se - 2.0 * l.e) +\n    abs(l.nw + l.sw - 2.0 * l.w);\n  let vertical =\n    abs(l.e + l.w - 2.0 * l.m) * 2.0 +\n    abs(l.ne + l.nw - 2.0 * l.n) +\n    abs(l.se + l.sw - 2.0 * l.s);\n  e.is_horizontal = horizontal >= vertical;\n\n  let p_luminance = select(l.e, l.n, e.is_horizontal);\n  let n_luminance = select(l.w, l.s, e.is_horizontal);\n  let p_gradient = abs(p_luminance - l.m);\n  let n_gradient = abs(n_luminance - l.m);\n\n  e.pixel_step = select(tex_size.x, tex_size.y, e.is_horizontal);\n\n  if (p_gradient < n_gradient) {\n    e.pixel_step = -e.pixel_step;\n    e.opposite_luminance = n_luminance;\n    e.gradient = n_gradient;\n  } else {\n    e.opposite_luminance = p_luminance;\n    e.gradient = p_gradient;\n  }\n\n  return e;\n}\n\nfn determine_edge_blend_factor(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, l: LuminanceData, e: EdgeData, uv: vec2<f32>) -> f32 {\n  var uv_edge = uv;\n  var edge_step: vec2<f32>;\n  if (e.is_horizontal) {\n    uv_edge.y = uv_edge.y + e.pixel_step * 0.5;\n    edge_step = vec2<f32>(tex_size.x, 0.0);\n  } else {\n    uv_edge.x = uv_edge.x + e.pixel_step * 0.5;\n    edge_step = vec2<f32>(0.0, tex_size.y);\n  }\n\n  let edge_luminance = (l.m + e.opposite_luminance) * 0.5;\n  let gradient_threshold = e.gradient * 0.25;\n\n  var puv = uv_edge + edge_step * EDGE_STEPS[0];\n  var p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;\n  var p_at_end = abs(p_luminance_delta) >= gradient_threshold;\n\n  for (var i = 1; i < EDGE_STEP_COUNT && !p_at_end; i = i + 1) {\n    puv = puv + edge_step * EDGE_STEPS[i];\n    p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;\n    p_at_end = abs(p_luminance_delta) >= gradient_threshold;\n  }\n\n  if (!p_at_end) {\n    puv = puv + edge_step * EDGE_GUESS;\n  }\n\n  var nuv = uv_edge - edge_step * EDGE_STEPS[0];\n  var n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;\n  var n_at_end = abs(n_luminance_delta) >= gradient_threshold;\n\n  for (var i = 1; i < EDGE_STEP_COUNT && !n_at_end; i = i + 1) {\n    nuv = nuv - edge_step * EDGE_STEPS[i];\n    n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;\n    n_at_end = abs(n_luminance_delta) >= gradient_threshold;\n  }\n\n  if (!n_at_end) {\n    nuv = nuv - edge_step * EDGE_GUESS;\n  }\n\n  var p_distance: f32;\n  var n_distance: f32;\n  if (e.is_horizontal) {\n    p_distance = puv.x - uv.x;\n    n_distance = uv.x - nuv.x;\n  } else {\n    p_distance = puv.y - uv.y;\n    n_distance = uv.y - nuv.y;\n  }\n\n  var shortest_distance: f32;\n  var delta_sign: bool;\n  if (p_distance <= n_distance) {\n    shortest_distance = p_distance;\n    delta_sign = p_luminance_delta >= 0.0;\n  } else {\n    shortest_distance = n_distance;\n    delta_sign = n_luminance_delta >= 0.0;\n  }\n\n  if (delta_sign == (l.m - edge_luminance >= 0.0)) {\n    return 0.0;\n  }\n\n  return 0.5 - shortest_distance / (p_distance + n_distance);\n}\n\nfn apply_fxaa(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv_in: vec2<f32>) -> vec4<f32> {\n  let luminance = sample_luminance_neighborhood(tex, smp, tex_size, uv_in);\n  if (should_skip_pixel(luminance)) {\n    return fxaa_sample_color(tex, smp, uv_in);\n  }\n\n  let pixel_blend = determine_pixel_blend_factor(luminance);\n  let edge = determine_edge(tex_size, luminance);\n  let edge_blend = determine_edge_blend_factor(tex, smp, tex_size, luminance, edge, uv_in);\n  let final_blend = max(pixel_blend, edge_blend);\n\n  var uv = uv_in;\n  if (edge.is_horizontal) {\n    uv.y = uv.y + edge.pixel_step * final_blend;\n  } else {\n    uv.x = uv.x + edge.pixel_step * final_blend;\n  }\n\n  return fxaa_sample_color(tex, smp, uv);\n}\n\n\nfn pcg2d(v_in: vec2<u32>) -> vec2<u32> {\n  var v = v_in * vec2<u32>(1664525u) + vec2<u32>(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  return v;\n}\n\nfn triangular_dither(frag_coord: vec2<f32>, frame: f32) -> f32 {\n  let seed = vec2<u32>(frag_coord) + vec2<u32>(u32(frame) * 747796405u);\n  let rand = vec2<f32>(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n@fragment\nfn fs_fxaa(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let uv = frag_coord.xy * u_params.output_texel;\n  let color = apply_fxaa(u_source_tex, u_source_smp, u_params.texel_size, uv);\n  // S12: the triangular-PDF dither belongs to the last write to the 8-bit\n  // output \u2014 on the legacy present this program IS the last write; on the v2\n  // unfused tail S12-finalize follows, so it compiles with FXAA_NO_DITHER.\n  var rgb = color.rgb;\n  if (!FXAA_NO_DITHER) {\n    rgb = rgb + vec3<f32>(triangular_dither(frag_coord.xy, 0.0));\n  }\n  return vec4<f32>(rgb, color.a);\n}\n";
+//# sourceMappingURL=fxaa.wgsl.d.ts.map

package/dist/post/shaders/fxaa.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fxaa.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/fxaa.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,iBAAiB,u4MAwM7B,CAAC;AAEF,eAAO,MAAM,sBAAsB,2xQAmDlC,CAAC"}

package/dist/post/shaders/fxaa.wgsl.js

@@ -0,0 +1,268 @@
+/**
+ * PRD-03 §6.5 Phase 7 — FXAA WGSL twins (three r185 FXAAShader, Catlike
+ * Coding / Dave Hoskins port — NOT the NVIDIA FXAA 3.11 preset).
+ *
+ * `FXAA_185_FNS_WGSL` is the shared function set. GLSL's two macro hooks map
+ * to consumer-provided WGSL items (each including module must define them):
+ *   - `AURA_FXAA_SAMPLE(tex, uv)` → the consumer defines
+ *     `fn fxaa_sample(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32>`
+ *   - `AURA_LUMA_ALPHA` → the consumer declares
+ *     `override FXAA_LUMA_ALPHA: i32 = 0 | 1`
+ * Standalone (`FXAA_185_FRAGMENT_WGSL`) uses `textureSampleLevel` and
+ * `FXAA_LUMA_ALPHA = 0`; the §6.1 fused finalize declares 1 (luma rides in
+ * `.a`, written by S10b) and injects the display-grade sample.
+ */
+export const FXAA_185_FNS_WGSL = /* wgsl */ `const EDGE_STEP_COUNT: i32 = 6;
+const EDGE_GUESS: f32 = 8.0;
+const EDGE_STEPS = array<f32, 6>(1.0, 1.5, 2.0, 2.0, 2.0, 4.0);
+
+const CONTRAST_THRESHOLD: f32 = 0.0312;
+const RELATIVE_THRESHOLD: f32 = 0.063;
+const SUBPIXEL_BLENDING: f32 = 1.0;
+
+fn fxaa_sample_color(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {
+  return fxaa_sample(tex, smp, uv);
+}
+
+fn fxaa_sample_luminance(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> f32 {
+  if (FXAA_LUMA_ALPHA == 1) {
+    return fxaa_sample(tex, smp, uv).a;
+  }
+  return dot(fxaa_sample_color(tex, smp, uv).rgb, vec3<f32>(0.3, 0.59, 0.11));
+}
+
+fn fxaa_sample_luminance_offset(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>, u_offset: f32, v_offset: f32) -> f32 {
+  return fxaa_sample_luminance(tex, smp, uv + tex_size * vec2<f32>(u_offset, v_offset));
+}
+
+struct LuminanceData {
+  m: f32,
+  n: f32,
+  e: f32,
+  s: f32,
+  w: f32,
+  ne: f32,
+  nw: f32,
+  se: f32,
+  sw: f32,
+  highest: f32,
+  lowest: f32,
+  contrast: f32,
+};
+
+fn sample_luminance_neighborhood(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>) -> LuminanceData {
+  var l: LuminanceData;
+  l.m = fxaa_sample_luminance(tex, smp, uv);
+  l.n = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, 1.0);
+  l.e = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 0.0);
+  l.s = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, -1.0);
+  l.w = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 0.0);
+
+  l.ne = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 1.0);
+  l.nw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 1.0);
+  l.se = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, -1.0);
+  l.sw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, -1.0);
+
+  l.highest = max(max(max(max(l.n, l.e), l.s), l.w), l.m);
+  l.lowest = min(min(min(min(l.n, l.e), l.s), l.w), l.m);
+  l.contrast = l.highest - l.lowest;
+  return l;
+}
+
+fn should_skip_pixel(l: LuminanceData) -> bool {
+  let threshold = max(CONTRAST_THRESHOLD, RELATIVE_THRESHOLD * l.highest);
+  return l.contrast < threshold;
+}
+
+fn determine_pixel_blend_factor(l: LuminanceData) -> f32 {
+  var f = 2.0 * (l.n + l.e + l.s + l.w);
+  f = f + l.ne + l.nw + l.se + l.sw;
+  f = f * (1.0 / 12.0);
+  f = abs(f - l.m);
+  f = clamp(f / l.contrast, 0.0, 1.0);
+
+  let blend_factor = smoothstep(0.0, 1.0, f);
+  return blend_factor * blend_factor * SUBPIXEL_BLENDING;
+}
+
+struct EdgeData {
+  is_horizontal: bool,
+  pixel_step: f32,
+  opposite_luminance: f32,
+  gradient: f32,
+};
+
+fn determine_edge(tex_size: vec2<f32>, l: LuminanceData) -> EdgeData {
+  var e: EdgeData;
+  let horizontal =
+    abs(l.n + l.s - 2.0 * l.m) * 2.0 +
+    abs(l.ne + l.se - 2.0 * l.e) +
+    abs(l.nw + l.sw - 2.0 * l.w);
+  let vertical =
+    abs(l.e + l.w - 2.0 * l.m) * 2.0 +
+    abs(l.ne + l.nw - 2.0 * l.n) +
+    abs(l.se + l.sw - 2.0 * l.s);
+  e.is_horizontal = horizontal >= vertical;
+
+  let p_luminance = select(l.e, l.n, e.is_horizontal);
+  let n_luminance = select(l.w, l.s, e.is_horizontal);
+  let p_gradient = abs(p_luminance - l.m);
+  let n_gradient = abs(n_luminance - l.m);
+
+  e.pixel_step = select(tex_size.x, tex_size.y, e.is_horizontal);
+
+  if (p_gradient < n_gradient) {
+    e.pixel_step = -e.pixel_step;
+    e.opposite_luminance = n_luminance;
+    e.gradient = n_gradient;
+  } else {
+    e.opposite_luminance = p_luminance;
+    e.gradient = p_gradient;
+  }
+
+  return e;
+}
+
+fn determine_edge_blend_factor(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, l: LuminanceData, e: EdgeData, uv: vec2<f32>) -> f32 {
+  var uv_edge = uv;
+  var edge_step: vec2<f32>;
+  if (e.is_horizontal) {
+    uv_edge.y = uv_edge.y + e.pixel_step * 0.5;
+    edge_step = vec2<f32>(tex_size.x, 0.0);
+  } else {
+    uv_edge.x = uv_edge.x + e.pixel_step * 0.5;
+    edge_step = vec2<f32>(0.0, tex_size.y);
+  }
+
+  let edge_luminance = (l.m + e.opposite_luminance) * 0.5;
+  let gradient_threshold = e.gradient * 0.25;
+
+  var puv = uv_edge + edge_step * EDGE_STEPS[0];
+  var p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;
+  var p_at_end = abs(p_luminance_delta) >= gradient_threshold;
+
+  for (var i = 1; i < EDGE_STEP_COUNT && !p_at_end; i = i + 1) {
+    puv = puv + edge_step * EDGE_STEPS[i];
+    p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;
+    p_at_end = abs(p_luminance_delta) >= gradient_threshold;
+  }
+
+  if (!p_at_end) {
+    puv = puv + edge_step * EDGE_GUESS;
+  }
+
+  var nuv = uv_edge - edge_step * EDGE_STEPS[0];
+  var n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;
+  var n_at_end = abs(n_luminance_delta) >= gradient_threshold;
+
+  for (var i = 1; i < EDGE_STEP_COUNT && !n_at_end; i = i + 1) {
+    nuv = nuv - edge_step * EDGE_STEPS[i];
+    n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;
+    n_at_end = abs(n_luminance_delta) >= gradient_threshold;
+  }
+
+  if (!n_at_end) {
+    nuv = nuv - edge_step * EDGE_GUESS;
+  }
+
+  var p_distance: f32;
+  var n_distance: f32;
+  if (e.is_horizontal) {
+    p_distance = puv.x - uv.x;
+    n_distance = uv.x - nuv.x;
+  } else {
+    p_distance = puv.y - uv.y;
+    n_distance = uv.y - nuv.y;
+  }
+
+  var shortest_distance: f32;
+  var delta_sign: bool;
+  if (p_distance <= n_distance) {
+    shortest_distance = p_distance;
+    delta_sign = p_luminance_delta >= 0.0;
+  } else {
+    shortest_distance = n_distance;
+    delta_sign = n_luminance_delta >= 0.0;
+  }
+
+  if (delta_sign == (l.m - edge_luminance >= 0.0)) {
+    return 0.0;
+  }
+
+  return 0.5 - shortest_distance / (p_distance + n_distance);
+}
+
+fn apply_fxaa(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv_in: vec2<f32>) -> vec4<f32> {
+  let luminance = sample_luminance_neighborhood(tex, smp, tex_size, uv_in);
+  if (should_skip_pixel(luminance)) {
+    return fxaa_sample_color(tex, smp, uv_in);
+  }
+
+  let pixel_blend = determine_pixel_blend_factor(luminance);
+  let edge = determine_edge(tex_size, luminance);
+  let edge_blend = determine_edge_blend_factor(tex, smp, tex_size, luminance, edge, uv_in);
+  let final_blend = max(pixel_blend, edge_blend);
+
+  var uv = uv_in;
+  if (edge.is_horizontal) {
+    uv.y = uv.y + edge.pixel_step * final_blend;
+  } else {
+    uv.x = uv.x + edge.pixel_step * final_blend;
+  }
+
+  return fxaa_sample_color(tex, smp, uv);
+}
+`;
+export const FXAA_185_FRAGMENT_WGSL = /* wgsl */ `// FXAA_NO_DITHER — pipeline-overridable: the v2 unfused tail compiles with
+// true so S12 finalize's single triangular dither isn't doubled.
+override FXAA_NO_DITHER: bool = false;
+override FXAA_LUMA_ALPHA: i32 = 0;
+
+struct FxaaParams {
+  texel_size: vec2<f32>,   // 1 / source dims (the FXAA tap step)
+  output_texel: vec2<f32>, // 1 / output dims (base uv)
+};
+
+@group(0) @binding(0) var<uniform> u_params: FxaaParams;
+@group(0) @binding(1) var u_source_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_source_smp: sampler;
+
+// AURA_FXAA_SAMPLE for the standalone pass: a plain LOD-0 filtered fetch.
+fn fxaa_sample(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {
+  return textureSampleLevel(tex, smp, uv, 0.0);
+}
+
+${FXAA_185_FNS_WGSL}
+
+fn pcg2d(v_in: vec2<u32>) -> vec2<u32> {
+  var v = v_in * vec2<u32>(1664525u) + vec2<u32>(1013904223u);
+  v.x = v.x + v.y * 1664525u;
+  v.y = v.y + v.x * 1664525u;
+  v = v ^ (v >> vec2<u32>(16u));
+  v.x = v.x + v.y * 1664525u;
+  v.y = v.y + v.x * 1664525u;
+  v = v ^ (v >> vec2<u32>(16u));
+  return v;
+}
+
+fn triangular_dither(frag_coord: vec2<f32>, frame: f32) -> f32 {
+  let seed = vec2<u32>(frag_coord) + vec2<u32>(u32(frame) * 747796405u);
+  let rand = vec2<f32>(pcg2d(seed)) / 4294967296.0;
+  return (rand.x + rand.y - 1.0) / 255.0;
+}
+
+@fragment
+fn fs_fxaa(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let uv = frag_coord.xy * u_params.output_texel;
+  let color = apply_fxaa(u_source_tex, u_source_smp, u_params.texel_size, uv);
+  // S12: the triangular-PDF dither belongs to the last write to the 8-bit
+  // output — on the legacy present this program IS the last write; on the v2
+  // unfused tail S12-finalize follows, so it compiles with FXAA_NO_DITHER.
+  var rgb = color.rgb;
+  if (!FXAA_NO_DITHER) {
+    rgb = rgb + vec3<f32>(triangular_dither(frag_coord.xy, 0.0));
+  }
+  return vec4<f32>(rgb, color.a);
+}
+`;
+//# sourceMappingURL=fxaa.wgsl.js.map

package/dist/post/shaders/fxaa.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fxaa.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/fxaa.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwM3C,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;EAmB/C,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgClB,CAAC"}

package/dist/post/shaders/godrays.glsl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * PRD-03 §8.5 — S4 god rays for the v2 post chain (WebGL2, half-res RGBA16F).
+ *
+ * Radial light-shaft march replacing the CPU `volumetricLightPixels` path
+ * (which cost ~0.5 fps in Deep Recovery):
+ *   occlusion src  = (linZ ≥ far·0.999 || luma(hdr) > 4.0) ? hdr.rgb : 0
+ *                    + (sky ? light-disk mask smoothstep(r1, r0, |uv − lightUv|) : 0)
+ *   march          = samples taps from uv toward lightUv, weight decay^i·weight
+ *   output         = accum · color · intensity · offScreenFade
+ *   offScreenFade  = saturate(1 − (max(|lightUv−0.5|) − 0.5)·4) · step(0, lightClip.w)
+ *
+ * The half-res output is added into HDR by the S10 composite. On the v2 path
+ * this supersedes `VolumetricFog.ts:105-144` (lane 07, deletion = Q-07-1).
+ */
+export declare const GODRAYS_GLSL = "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_hdr;             // half-res HDR input\nuniform highp sampler2D u_depthHalf; // half-res linear depth (.r)\nuniform float u_far;\nuniform vec2 u_lightUv;              // projected light position, uv space\nuniform float u_lightClipW;          // clip-space w of the projected light\nuniform vec3 u_color;                // light shaft tint\nuniform float u_intensity;\nuniform float u_decay;\nuniform float u_weight;\nuniform float u_diskOuter;           // r1: disk feather outer radius (uv)\nuniform float u_diskInner;           // r0: disk core radius (uv)\nout vec4 o_color;\n\n#ifndef AURA_GODRAY_SAMPLES\n#define AURA_GODRAY_SAMPLES 32\n#endif\n\nvoid main() {\n  vec2 uv = gl_FragCoord.xy / vec2(textureSize(u_hdr, 0));\n  vec2 dir = u_lightUv - uv;\n  float dist = length(dir);\n  vec2 stepUv = dist > 0.0 ? dir / float(AURA_GODRAY_SAMPLES) : vec2(0.0);\n\n  // Off-screen / behind-camera fade: step(0, w) zeroes lights behind the eye,\n  // the linear ramp fades across 25% uv past the frame edge.\n  float offScreen = clamp(1.0 - (max(abs(u_lightUv.x - 0.5), abs(u_lightUv.y - 0.5)) - 0.5) * 4.0, 0.0, 1.0)\n                  * step(0.0, u_lightClipW);\n\n  float marchWeight = u_weight;\n  vec3 accum = vec3(0.0);\n  vec2 sampleUv = uv;\n  for (int i = 0; i < AURA_GODRAY_SAMPLES; ++i) {\n    sampleUv += stepUv;\n    vec4 hdr = textureLod(u_hdr, sampleUv, 0.0);\n    float linZ = textureLod(u_depthHalf, sampleUv, 0.0).r;\n    bool sky = linZ >= u_far * 0.999;\n    float luma = dot(hdr.rgb, vec3(0.2126, 0.7152, 0.0722));\n    // Emitters: sky pixels (the \"gap\" through occluders) or HDR highlights.\n    vec3 src = (sky || luma > 4.0) ? hdr.rgb : vec3(0.0);\n    // The sun disk emits only where the sky is unoccluded. #1185 multiplied\n    // the whole source by the disk mask: with a dim sky that leaves nothing\n    // to emit, and the S4-isolated A/B measured S4 on == S4 off (GPU run\n    // 38163537496). The original additive disk emitted through occluders.\n    if (sky) src += vec3(smoothstep(u_diskOuter, u_diskInner, length(sampleUv - u_lightUv)));\n    accum += marchWeight * src;\n    marchWeight *= u_decay;\n  }\n\n  o_color = vec4(accum * u_color * u_intensity * offScreen, 1.0);\n}\n";
+//# sourceMappingURL=godrays.glsl.d.ts.map

package/dist/post/shaders/godrays.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"godrays.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/godrays.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,eAAO,MAAM,YAAY,4uEAmDxB,CAAC"}