@aura3d/engine 3.0.0 → 4.0.0

package/dist/rendering/post/shaders/smaa.glsl.js

@@ -0,0 +1,354 @@
+/**
+ * PRD-03 §8.14 — SMAA 1x ("medium"): three passes ported verbatim from three
+ * r185 `examples/jsm/shaders/SMAAShader.js` (MIT; WebGL port of SMAA v2.8 by
+ * the three.js authors, algorithm by Jorge Jimenez et al.).
+ *
+ * Conventions matching the rest of `post/shaders/`: `#version 300 es`,
+ * `in vec2 v_uv`, `out vec4 outColor`. three's vertex shaders only computed
+ * the `vOffset`/`vPixcoord` varyings — they are pure functions of `v_uv` and
+ * the texel-size uniform, so this port computes them in the fragment
+ * preamble (`SMAAEdgeDetectionVS` → `smaaOffsets*` below), byte-identical
+ * math. `texture2D(x, uv, 0.0)` → `texture(x, uv)` (LOD 0 = lod-0 chain
+ * rules do not apply to full-screen post targets; the v2 targets carry a
+ * single mip).
+ *
+ * `u_resolution` is the texel size `vec2(1/w, 1/h)` (three names it
+ * `resolution` and feeds `Vector2(1/w, 1/h)` — same value, pipeline name).
+ * AreaTex/SearchTex arrive from the `post/smaa/` lazy chunk.
+ */
+/** Pass 1 — `SMAAColorEdgeDetectionPS` (colour edges, threshold 0.1). */
+export const SMAA_EDGES_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+#define SMAA_THRESHOLD 0.1
+uniform sampler2D u_color;
+uniform vec2 u_resolution;
+in vec2 v_uv;
+out vec4 outColor;
+
+vec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {
+	vec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );
+
+	// Calculate color deltas:
+	vec4 delta;
+	vec3 C = texture( colorTex, texcoord ).rgb;
+
+	vec3 Cleft = texture( colorTex, offset[0].xy ).rgb;
+	vec3 t = abs( C - Cleft );
+	delta.x = max( max( t.r, t.g ), t.b );
+
+	vec3 Ctop = texture( colorTex, offset[0].zw ).rgb;
+	t = abs( C - Ctop );
+	delta.y = max( max( t.r, t.g ), t.b );
+
+	// We do the usual threshold:
+	vec2 edges = step( threshold, delta.xy );
+
+	// Then discard if there is no edge:
+	if ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )
+		discard;
+
+	// Calculate right and bottom deltas:
+	vec3 Cright = texture( colorTex, offset[1].xy ).rgb;
+	t = abs( C - Cright );
+	delta.z = max( max( t.r, t.g ), t.b );
+
+	vec3 Cbottom  = texture( colorTex, offset[1].zw ).rgb;
+	t = abs( C - Cbottom );
+	delta.w = max( max( t.r, t.g ), t.b );
+
+	// Calculate the maximum delta in the direct neighborhood:
+	float maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );
+
+	// Calculate left-left and top-top deltas:
+	vec3 Cleftleft  = texture( colorTex, offset[2].xy ).rgb;
+	t = abs( C - Cleftleft );
+	delta.z = max( max( t.r, t.g ), t.b );
+
+	vec3 Ctoptop = texture( colorTex, offset[2].zw ).rgb;
+	t = abs( C - Ctoptop );
+	delta.w = max( max( t.r, t.g ), t.b );
+
+	// Calculate the final maximum delta:
+	maxDelta = max( max( maxDelta, delta.z ), delta.w );
+
+	// Local contrast adaptation in action:
+	edges.xy *= step( 0.5 * maxDelta, delta.xy );
+
+	return vec4( edges, 0.0, 0.0 );
+}
+
+void main() {
+	// three's SMAAEdgeDetectionVS offsets, computed fragment-side (identical
+	// values — the offsets are a pure function of texcoord + resolution).
+	vec4 vOffset0 = v_uv.xyxy + u_resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 );
+	vec4 vOffset1 = v_uv.xyxy + u_resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 );
+	vec4 vOffset2 = v_uv.xyxy + u_resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 );
+	vec4 vOffset[3] = vec4[3]( vOffset0, vOffset1, vOffset2 );
+	outColor = SMAAColorEdgeDetectionPS( v_uv, vOffset, u_color );
+}
+`;
+/**
+ * Pass 2 — `SMAABlendingWeightCalculationPS` (SMAA_MAX_SEARCH_STEPS 8,
+ * AreaTex 160×560 RG, SearchTex 66×33 R, no diagonal search).
+ */
+export const SMAA_WEIGHTS_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+#define SMAA_MAX_SEARCH_STEPS 8
+#define SMAA_AREATEX_MAX_DISTANCE 16
+#define SMAA_AREATEX_PIXEL_SIZE ( 1.0 / vec2( 160.0, 560.0 ) )
+#define SMAA_AREATEX_SUBTEX_SIZE ( 1.0 / 7.0 )
+#define SMAASampleLevelZeroOffset( tex, coord, offset ) texture( tex, coord + vec2( offset ) * u_resolution )
+
+uniform sampler2D u_edges;   // the pass-1 edges surface (three tDiffuse)
+uniform sampler2D u_area;
+uniform sampler2D u_search;
+uniform vec2 u_resolution;
+in vec2 v_uv;
+out vec4 outColor;
+
+float SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {
+	// Not required if searchTex accesses are set to point:
+	// float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);
+	// e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +
+	//     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;
+	e.r = bias + e.r * scale;
+	return 255.0 * texture( searchTex, e ).r;
+}
+
+float SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+	/**
+		* @PSEUDO_GATHER4
+		* This texcoord has been offset by (-0.25, -0.125) in the vertex shader to
+		* sample between edge, thus fetching four edges in a row.
+		* Sampling with different offsets in each direction allows to disambiguate
+		* which edges are active from the four fetched ones.
+		*/
+	vec2 e = vec2( 0.0, 1.0 );
+
+	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for
+		e = texture( edgesTex, texcoord ).rg;
+		texcoord -= vec2( 2.0, 0.0 ) * u_resolution;
+		if ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;
+	}
+
+	// We correct the previous (-0.25, -0.125) offset we applied:
+	texcoord.x += 0.25 * u_resolution.x;
+
+	// The searches are bias by 1, so adjust the coords accordingly:
+	texcoord.x += u_resolution.x;
+
+	// Disambiguate the length added by the last step:
+	texcoord.x += 2.0 * u_resolution.x; // Undo last step
+	texcoord.x -= u_resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);
+
+	return texcoord.x;
+}
+
+float SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+	vec2 e = vec2( 0.0, 1.0 );
+
+	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {
+		e = texture( edgesTex, texcoord ).rg;
+		texcoord += vec2( 2.0, 0.0 ) * u_resolution;
+		if ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;
+	}
+
+	texcoord.x -= 0.25 * u_resolution.x;
+	texcoord.x -= u_resolution.x;
+	texcoord.x -= 2.0 * u_resolution.x;
+	texcoord.x += u_resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );
+
+	return texcoord.x;
+}
+
+float SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+	vec2 e = vec2( 1.0, 0.0 );
+
+	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {
+		e = texture( edgesTex, texcoord ).rg;
+		texcoord += vec2( 0.0, 2.0 ) * u_resolution; // WebGL port note: Changed sign
+		if ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;
+	}
+
+	texcoord.y -= 0.25 * u_resolution.y; // WebGL port note: Changed sign
+	texcoord.y -= u_resolution.y; // WebGL port note: Changed sign
+	texcoord.y -= 2.0 * u_resolution.y; // WebGL port note: Changed sign
+	texcoord.y += u_resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 ); // WebGL port note: Changed sign
+
+	return texcoord.y;
+}
+
+float SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {
+	vec2 e = vec2( 1.0, 0.0 );
+
+	for ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {
+		e = texture( edgesTex, texcoord ).rg;
+		texcoord -= vec2( 0.0, 2.0 ) * u_resolution; // WebGL port note: Changed sign
+		if ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;
+	}
+
+	texcoord.y += 0.25 * u_resolution.y; // WebGL port note: Changed sign
+	texcoord.y += u_resolution.y; // WebGL port note: Changed sign
+	texcoord.y += 2.0 * u_resolution.y; // WebGL port note: Changed sign
+	texcoord.y -= u_resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 ); // WebGL port note: Changed sign
+
+	return texcoord.y;
+}
+
+vec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {
+	// Rounding prevents precision errors of bilinear filtering:
+	vec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;
+
+	// We do a scale and bias for mapping to texel space:
+	texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );
+
+	// Move to proper place, according to the subpixel offset:
+	texcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;
+
+	return texture( areaTex, texcoord ).rg;
+}
+
+vec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {
+	vec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );
+
+	vec2 e = texture( edgesTex, texcoord ).rg;
+
+	if ( e.g > 0.0 ) { // Edge at north
+		vec2 d;
+
+		// Find the distance to the left:
+		vec2 coords;
+		coords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );
+		coords.y = offset[ 1 ].y; // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
+		d.x = coords.x;
+
+		// Now fetch the left crossing edges, two at a time using bilinear
+		// filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to
+		// discern what value each edge has:
+		float e1 = texture( edgesTex, coords ).r;
+
+		// Find the distance to the right:
+		coords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );
+		d.y = coords.x;
+
+		// We want the distances to be in pixel units (doing this here allow to
+		// better interleave arithmetic and memory accesses):
+		d = d / u_resolution.x - pixcoord.x;
+
+		// SMAAArea below needs a sqrt, as the areas texture is compressed
+		// quadratically:
+		vec2 sqrt_d = sqrt( abs( d ) );
+
+		// Fetch the right crossing edges:
+		coords.y -= 1.0 * u_resolution.y; // WebGL port note: Added
+		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;
+
+		// Ok, we know how this pattern looks like, now it is time for getting
+		// the actual area:
+		weights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );
+	}
+
+	if ( e.r > 0.0 ) { // Edge at west
+		vec2 d;
+
+		// Find the distance to the top:
+		vec2 coords;
+
+		coords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );
+		coords.x = offset[ 0 ].x; // offset[1].x = texcoord.x - 0.25 * resolution.x;
+		d.x = coords.y;
+
+		// Fetch the top crossing edges:
+		float e1 = texture( edgesTex, coords ).g;
+
+		// Find the distance to the bottom:
+		coords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );
+		d.y = coords.y;
+
+		// We want the distances to be in pixel units:
+		d = d / u_resolution.y - pixcoord.y;
+
+		// SMAAArea below needs a sqrt, as the areas texture is compressed
+		// quadratically:
+		vec2 sqrt_d = sqrt( abs( d ) );
+
+		// Fetch the bottom crossing edges:
+		coords.y -= 1.0 * u_resolution.y; // WebGL port note: Added
+		float e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;
+
+		// Get the area for this direction:
+		weights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );
+	}
+
+	return weights;
+}
+
+void main() {
+	// three's SMAABlendingWeightCalculationVS varyings, computed fragment-side.
+	vec2 vPixcoord = v_uv / u_resolution;
+	vec4 vOffset0 = v_uv.xyxy + u_resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 );
+	vec4 vOffset1 = v_uv.xyxy + u_resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 );
+	vec4 vOffset2 = vec4( vOffset0.xz, vOffset1.yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * u_resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );
+	vec4 vOffset[3] = vec4[3]( vOffset0, vOffset1, vOffset2 );
+	outColor = SMAABlendingWeightCalculationPS( v_uv, vPixcoord, vOffset, u_edges, u_area, u_search, ivec4( 0 ) );
+}
+`;
+/** Pass 3 — `SMAANeighborhoodBlendingPS` (`u_weights` = three `tDiffuse`, `u_color` = three `tColor`). */
+export const SMAA_BLEND_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_weights;  // three tDiffuse — the blend-weights surface
+uniform sampler2D u_color;    // three tColor — the colour surface
+uniform vec2 u_resolution;
+in vec2 v_uv;
+out vec4 outColor;
+
+vec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {
+	// Fetch the blending weights for current pixel:
+	vec4 a;
+	a.xz = texture( blendTex, texcoord ).xz;
+	a.y = texture( blendTex, offset[ 1 ].zw ).g;
+	a.w = texture( blendTex, offset[ 1 ].xy ).a;
+
+	// Is there any blending weight with a value greater than 0.0?
+	if ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {
+		return texture( colorTex, texcoord );
+	} else {
+		// Up to 4 lines can be crossing a pixel (one through each edge). We
+		// favor blending by choosing the line with the maximum weight for each
+		// direction:
+		vec2 offset;
+		offset.x = a.a > a.b ? a.a : -a.b; // left vs. right
+		offset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs
+
+		// Then we go in the direction that has the maximum weight:
+		if ( abs( offset.x ) > abs( offset.y )) { // horizontal vs. vertical
+			offset.y = 0.0;
+		} else {
+			offset.x = 0.0;
+		}
+
+		// Fetch the opposite color and lerp by hand:
+		vec4 C = texture( colorTex, texcoord );
+		texcoord += sign( offset ) * u_resolution;
+		vec4 Cop = texture( colorTex, texcoord );
+		float s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );
+
+		// WebGL port note: Added gamma correction
+		C.xyz = pow(C.xyz, vec3(2.2));
+		Cop.xyz = pow(Cop.xyz, vec3(2.2));
+		vec4 mixed = mix(C, Cop, s);
+		mixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));
+
+		return mixed;
+	}
+}
+
+void main() {
+	// three's SMAANeighborhoodBlendingVS varyings, computed fragment-side.
+	vec4 vOffset0 = v_uv.xyxy + u_resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 );
+	vec4 vOffset1 = v_uv.xyxy + u_resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 );
+	vec4 vOffset[2] = vec4[2]( vOffset0, vOffset1 );
+	outColor = SMAANeighborhoodBlendingPS( v_uv, vOffset, u_color, u_weights );
+}
+`;
+//# sourceMappingURL=smaa.glsl.js.map

package/dist/rendering/post/shaders/smaa.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smaa.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/smaa.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,yEAAyE;AACzE,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqEzC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyM3C,CAAC;AAEF,0GAA0G;AAC1G,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDzC,CAAC"}

package/dist/rendering/post/shaders/smaa.wgsl.d.ts

@@ -0,0 +1,20 @@
+/**
+ * PRD-03 §8.14 Phase 7 — SMAA 1x WGSL twins (three passes, verbatim port of
+ * the GLSL twins, themselves three r185 `SMAAShader.js` — MIT; WebGL port of
+ * SMAA v2.8 by the three.js authors, algorithm by Jorge Jimenez et al.).
+ *
+ * three's vertex-computed `vOffset`/`vPixcoord` varyings are pure functions
+ * of uv + texel size — computed fragment-side, identical math.
+ * `SMAASampleLevelZeroOffset` = `textureLevel(tex, uv + offset·texel, 0)`.
+ * `u_resolution` is the texel size `vec2(1/w, 1/h)` (same value as the GL
+ * twin's `u_resolution`; three names it `resolution`).
+ * AreaTex/SearchTex arrive from the `post/smaa/` lazy chunk — areaTex needs
+ * a linear sampler, searchTex point (declared as separate samplers).
+ */
+/** Pass 1 — `SMAAColorEdgeDetectionPS` (colour edges, threshold 0.1). */
+export declare const SMAA_EDGES_WGSL = "const SMAA_THRESHOLD: f32 = 0.1;\n\nstruct SmaaEdgesParams {\n  resolution: vec2<f32>,   // texel size 1/w, 1/h\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: SmaaEdgesParams;\n@group(0) @binding(1) var u_color_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_color_smp: sampler;\n\nfn smaa_color_edge_detection(texcoord: vec2<f32>, offset: array<vec4<f32>, 3>, color_tex: texture_2d<f32>, color_smp: sampler) -> vec4<f32> {\n  let threshold = vec2<f32>(SMAA_THRESHOLD, SMAA_THRESHOLD);\n\n  // Calculate color deltas:\n  var delta: vec4<f32>;\n  let c = textureSampleLevel(color_tex, color_smp, texcoord, 0.0).rgb;\n\n  let c_left = textureSampleLevel(color_tex, color_smp, offset[0].xy, 0.0).rgb;\n  var t = abs(c - c_left);\n  delta.x = max(max(t.r, t.g), t.b);\n\n  let c_top = textureSampleLevel(color_tex, color_smp, offset[0].zw, 0.0).rgb;\n  t = abs(c - c_top);\n  delta.y = max(max(t.r, t.g), t.b);\n\n  // We do the usual threshold:\n  var edges = step(threshold, delta.xy);\n\n  // Then discard if there is no edge:\n  if (dot(edges, vec2<f32>(1.0, 1.0)) == 0.0) {\n    discard;\n  }\n\n  // Calculate right and bottom deltas:\n  let c_right = textureSampleLevel(color_tex, color_smp, offset[1].xy, 0.0).rgb;\n  t = abs(c - c_right);\n  delta.z = max(max(t.r, t.g), t.b);\n\n  let c_bottom = textureSampleLevel(color_tex, color_smp, offset[1].zw, 0.0).rgb;\n  t = abs(c - c_bottom);\n  delta.w = max(max(t.r, t.g), t.b);\n\n  // Calculate the maximum delta in the direct neighborhood:\n  var max_delta = max(max(max(delta.x, delta.y), delta.z), delta.w);\n\n  // Calculate left-left and top-top deltas:\n  let c_left_left = textureSampleLevel(color_tex, color_smp, offset[2].xy, 0.0).rgb;\n  t = abs(c - c_left_left);\n  delta.z = max(max(t.r, t.g), t.b);\n\n  let c_top_top = textureSampleLevel(color_tex, color_smp, offset[2].zw, 0.0).rgb;\n  t = abs(c - c_top_top);\n  delta.w = max(max(t.r, t.g), t.b);\n\n  // Calculate the final maximum delta:\n  max_delta = max(max(max_delta, delta.z), delta.w);\n\n  // Local contrast adaptation in action:\n  edges = edges * step(vec2<f32>(0.5 * max_delta), delta.xy);\n\n  return vec4<f32>(edges, 0.0, 0.0);\n}\n\n@fragment\nfn fs_smaa_edges(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  // three's SMAAEdgeDetectionVS offsets, computed fragment-side (identical\n  // values \u2014 the offsets are a pure function of texcoord + resolution).\n  let v_offset0 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-1.0, 0.0, 0.0, 1.0);\n  let v_offset1 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(1.0, 0.0, 0.0, -1.0);\n  let v_offset2 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-2.0, 0.0, 0.0, 2.0);\n  let v_offset = array<vec4<f32>, 3>(v_offset0, v_offset1, v_offset2);\n  return smaa_color_edge_detection(uv, v_offset, u_color_tex, u_color_smp);\n}\n";
+/** Pass 2 — `SMAABlendingWeightCalculationPS` (max search 8, no diagonal). */
+export declare const SMAA_WEIGHTS_WGSL = "const SMAA_MAX_SEARCH_STEPS: i32 = 8;\nconst SMAA_AREATEX_MAX_DISTANCE: f32 = 16.0;\nconst SMAA_AREATEX_PIXEL_SIZE: vec2<f32> = vec2<f32>(1.0 / 160.0, 1.0 / 560.0);\nconst SMAA_AREATEX_SUBTEX_SIZE: f32 = 1.0 / 7.0;\n\nstruct SmaaWeightsParams {\n  resolution: vec2<f32>,   // texel size 1/w, 1/h\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: SmaaWeightsParams;\n@group(0) @binding(1) var u_edges_tex: texture_2d<f32>;   // the pass-1 edges surface (three tDiffuse)\n@group(0) @binding(2) var u_edges_smp: sampler;\n@group(0) @binding(3) var u_area_tex: texture_2d<f32>;\n@group(0) @binding(4) var u_area_smp: sampler;            // linear\n@group(0) @binding(5) var u_search_tex: texture_2d<f32>;\n@group(0) @binding(6) var u_search_smp: sampler;          // point/nearest\n\nfn smaa_sample_level_zero_offset(tex: texture_2d<f32>, smp: sampler, coord: vec2<f32>, offset: vec2<i32>) -> vec4<f32> {\n  return textureSampleLevel(tex, smp, coord + vec2<f32>(offset) * u_params.resolution, 0.0);\n}\n\nfn smaa_search_length(search_tex: texture_2d<f32>, search_smp: sampler, e: vec2<f32>, bias: f32, scale: f32) -> f32 {\n  // Not required if searchTex accesses are set to point:\n  // float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);\n  // e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +\n  //     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;\n  var e2 = e;\n  e2.r = bias + e.r * scale;\n  return 255.0 * textureSampleLevel(search_tex, search_smp, e2, 0.0).r;\n}\n\nfn smaa_search_x_left(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {\n  /**\n   * @PSEUDO_GATHER4\n   * This texcoord has been offset by (-0.25, -0.125) in the vertex shader to\n   * sample between edge, thus fetching four edges in a row.\n   * Sampling with different offsets in each direction allows to disambiguate\n   * which edges are active from the four fetched ones.\n   */\n  var e = vec2<f32>(0.0, 1.0);\n  var texcoord = texcoord_in;\n\n  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) { // WebGL port note: Changed while to for\n    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;\n    texcoord = texcoord - vec2<f32>(2.0, 0.0) * u_params.resolution;\n    if (!(texcoord.x > end_coord && e.g > 0.8281 && e.r == 0.0)) { break; }\n  }\n\n  // We correct the previous (-0.25, -0.125) offset we applied:\n  texcoord.x = texcoord.x + 0.25 * u_params.resolution.x;\n\n  // The searches are bias by 1, so adjust the coords accordingly:\n  texcoord.x = texcoord.x + u_params.resolution.x;\n\n  // Disambiguate the length added by the last step:\n  texcoord.x = texcoord.x + 2.0 * u_params.resolution.x; // Undo last step\n  texcoord.x = texcoord.x - u_params.resolution.x * smaa_search_length(search_tex, search_smp, e, 0.0, 0.5);\n\n  return texcoord.x;\n}\n\nfn smaa_search_x_right(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {\n  var e = vec2<f32>(0.0, 1.0);\n  var texcoord = texcoord_in;\n\n  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) {\n    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;\n    texcoord = texcoord + vec2<f32>(2.0, 0.0) * u_params.resolution;\n    if (!(texcoord.x < end_coord && e.g > 0.8281 && e.r == 0.0)) { break; }\n  }\n\n  texcoord.x = texcoord.x - 0.25 * u_params.resolution.x;\n  texcoord.x = texcoord.x - u_params.resolution.x;\n  texcoord.x = texcoord.x - 2.0 * u_params.resolution.x;\n  texcoord.x = texcoord.x + u_params.resolution.x * smaa_search_length(search_tex, search_smp, e, 0.5, 0.5);\n\n  return texcoord.x;\n}\n\nfn smaa_search_y_up(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {\n  var e = vec2<f32>(1.0, 0.0);\n  var texcoord = texcoord_in;\n\n  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) {\n    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;\n    texcoord = texcoord + vec2<f32>(0.0, 2.0) * u_params.resolution; // WebGL port note: Changed sign\n    if (!(texcoord.y > end_coord && e.r > 0.8281 && e.g == 0.0)) { break; }\n  }\n\n  texcoord.y = texcoord.y - 0.25 * u_params.resolution.y; // WebGL port note: Changed sign\n  texcoord.y = texcoord.y - u_params.resolution.y; // WebGL port note: Changed sign\n  texcoord.y = texcoord.y - 2.0 * u_params.resolution.y; // WebGL port note: Changed sign\n  texcoord.y = texcoord.y + u_params.resolution.y * smaa_search_length(search_tex, search_smp, vec2<f32>(e.g, e.r), 0.0, 0.5); // WebGL port note: Changed sign\n\n  return texcoord.y;\n}\n\nfn smaa_search_y_down(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {\n  var e = vec2<f32>(1.0, 0.0);\n  var texcoord = texcoord_in;\n\n  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) {\n    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;\n    texcoord = texcoord - vec2<f32>(0.0, 2.0) * u_params.resolution; // WebGL port note: Changed sign\n    if (!(texcoord.y < end_coord && e.r > 0.8281 && e.g == 0.0)) { break; }\n  }\n\n  texcoord.y = texcoord.y + 0.25 * u_params.resolution.y; // WebGL port note: Changed sign\n  texcoord.y = texcoord.y + u_params.resolution.y; // WebGL port note: Changed sign\n  texcoord.y = texcoord.y + 2.0 * u_params.resolution.y; // WebGL port note: Changed sign\n  texcoord.y = texcoord.y - u_params.resolution.y * smaa_search_length(search_tex, search_smp, vec2<f32>(e.g, e.r), 0.5, 0.5); // WebGL port note: Changed sign\n\n  return texcoord.y;\n}\n\nfn smaa_area(area_tex: texture_2d<f32>, area_smp: sampler, dist: vec2<f32>, e1: f32, e2: f32, offset: f32) -> vec2<f32> {\n  // Rounding prevents precision errors of bilinear filtering:\n  var texcoord = SMAA_AREATEX_MAX_DISTANCE * round(4.0 * vec2<f32>(e1, e2)) + dist;\n\n  // We do a scale and bias for mapping to texel space:\n  texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + (0.5 * SMAA_AREATEX_PIXEL_SIZE);\n\n  // Move to proper place, according to the subpixel offset:\n  texcoord.y = texcoord.y + SMAA_AREATEX_SUBTEX_SIZE * offset;\n\n  return textureSampleLevel(area_tex, area_smp, texcoord, 0.0).rg;\n}\n\nfn smaa_blending_weight_calculation(texcoord: vec2<f32>, pixcoord: vec2<f32>, offset: array<vec4<f32>, 3>, edges_tex: texture_2d<f32>, edges_smp: sampler, area_tex: texture_2d<f32>, area_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, subsample_indices: vec4<i32>) -> vec4<f32> {\n  var weights = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n\n  let e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;\n\n  if (e.g > 0.0) { // Edge at north\n    var d: vec2<f32>;\n\n    // Find the distance to the left:\n    var coords: vec2<f32>;\n    coords.x = smaa_search_x_left(edges_tex, edges_smp, search_tex, search_smp, offset[0].xy, offset[2].x);\n    coords.y = offset[1].y; // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)\n    d.x = coords.x;\n\n    // Now fetch the left crossing edges, two at a time using bilinear\n    // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to\n    // discern what value each edge has:\n    let e1 = textureSampleLevel(edges_tex, edges_smp, coords, 0.0).r;\n\n    // Find the distance to the right:\n    coords.x = smaa_search_x_right(edges_tex, edges_smp, search_tex, search_smp, offset[0].zw, offset[2].y);\n    d.y = coords.x;\n\n    // We want the distances to be in pixel units (doing this here allow to\n    // better interleave arithmetic and memory accesses):\n    d = d / u_params.resolution.x - vec2<f32>(pixcoord.x);\n\n    // smaa_area below needs a sqrt, as the areas texture is compressed\n    // quadratically:\n    let sqrt_d = sqrt(abs(d));\n\n    // Fetch the right crossing edges:\n    coords.y = coords.y - 1.0 * u_params.resolution.y; // WebGL port note: Added\n    let e2 = smaa_sample_level_zero_offset(edges_tex, edges_smp, coords, vec2<i32>(1, 0)).r;\n\n    // Ok, we know how this pattern looks like, now it is time for getting\n    // the actual area:\n    let area = smaa_area(area_tex, area_smp, sqrt_d, e1, e2, f32(subsample_indices.y));\n    weights.x = area.x;\n    weights.y = area.y;\n  }\n\n  if (e.r > 0.0) { // Edge at west\n    var d: vec2<f32>;\n\n    // Find the distance to the top:\n    var coords: vec2<f32>;\n\n    coords.y = smaa_search_y_up(edges_tex, edges_smp, search_tex, search_smp, offset[1].xy, offset[2].z);\n    coords.x = offset[0].x; // offset[1].x = texcoord.x - 0.25 * resolution.x;\n    d.x = coords.y;\n\n    // Fetch the top crossing edges:\n    let e1 = textureSampleLevel(edges_tex, edges_smp, coords, 0.0).g;\n\n    // Find the distance to the bottom:\n    coords.y = smaa_search_y_down(edges_tex, edges_smp, search_tex, search_smp, offset[1].zw, offset[2].w);\n    d.y = coords.y;\n\n    // We want the distances to be in pixel units:\n    d = d / u_params.resolution.y - vec2<f32>(pixcoord.y);\n\n    // smaa_area below needs a sqrt, as the areas texture is compressed\n    // quadratically:\n    let sqrt_d = sqrt(abs(d));\n\n    // Fetch the bottom crossing edges:\n    coords.y = coords.y - 1.0 * u_params.resolution.y; // WebGL port note: Added\n    let e2 = smaa_sample_level_zero_offset(edges_tex, edges_smp, coords, vec2<i32>(0, 1)).g;\n\n    // Get the area for this direction:\n    let area = smaa_area(area_tex, area_smp, sqrt_d, e1, e2, f32(subsample_indices.x));\n    weights.z = area.x;\n    weights.w = area.y;\n  }\n\n  return weights;\n}\n\n@fragment\nfn fs_smaa_weights(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  // three's SMAABlendingWeightCalculationVS varyings, computed fragment-side.\n  let v_pixcoord = uv / u_params.resolution;\n  let v_offset0 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-0.25, 0.125, 1.25, 0.125);\n  let v_offset1 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-0.125, 0.25, -0.125, -1.25);\n  let v_offset2 = vec4<f32>(v_offset0.xz, v_offset1.yw) + vec4<f32>(-2.0, 2.0, -2.0, 2.0) * u_params.resolution.xxyy * f32(SMAA_MAX_SEARCH_STEPS);\n  let v_offset = array<vec4<f32>, 3>(v_offset0, v_offset1, v_offset2);\n  return smaa_blending_weight_calculation(uv, v_pixcoord, v_offset, u_edges_tex, u_edges_smp, u_area_tex, u_area_smp, u_search_tex, u_search_smp, vec4<i32>(0));\n}\n";
+/** Pass 3 — `SMAANeighborhoodBlendingPS` (`u_weights` = three `tDiffuse`, `u_color` = three `tColor`). */
+export declare const SMAA_BLEND_WGSL = "struct SmaaBlendParams {\n  resolution: vec2<f32>,   // texel size 1/w, 1/h\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: SmaaBlendParams;\n@group(0) @binding(1) var u_weights_tex: texture_2d<f32>;  // three tDiffuse \u2014 the blend-weights surface\n@group(0) @binding(2) var u_weights_smp: sampler;\n@group(0) @binding(3) var u_color_tex: texture_2d<f32>;    // three tColor \u2014 the colour surface\n@group(0) @binding(4) var u_color_smp: sampler;\n\nfn smaa_neighborhood_blending(texcoord_in: vec2<f32>, offset: array<vec4<f32>, 2>, color_tex: texture_2d<f32>, color_smp: sampler, blend_tex: texture_2d<f32>, blend_smp: sampler) -> vec4<f32> {\n  // Fetch the blending weights for current pixel:\n  var a: vec4<f32>;\n  let axz = textureSampleLevel(blend_tex, blend_smp, texcoord_in, 0.0).xz;\n  a.x = axz.x;\n  a.z = axz.y;\n  a.y = textureSampleLevel(blend_tex, blend_smp, offset[1].zw, 0.0).g;\n  a.w = textureSampleLevel(blend_tex, blend_smp, offset[1].xy, 0.0).a;\n\n  // Is there any blending weight with a value greater than 0.0?\n  if (dot(a, vec4<f32>(1.0, 1.0, 1.0, 1.0)) < 1e-5) {\n    return textureSampleLevel(color_tex, color_smp, texcoord_in, 0.0);\n  } else {\n    // Up to 4 lines can be crossing a pixel (one through each edge). We\n    // favor blending by choosing the line with the maximum weight for each\n    // direction:\n    var offset: vec2<f32>;\n    offset.x = select(-a.b, a.a, a.a > a.b); // left vs. right\n    offset.y = select(a.r, -a.g, a.g > a.r); // top vs. bottom // WebGL port note: Changed signs\n\n    // Then we go in the direction that has the maximum weight:\n    if (abs(offset.x) > abs(offset.y)) { // horizontal vs. vertical\n      offset.y = 0.0;\n    } else {\n      offset.x = 0.0;\n    }\n\n    // Fetch the opposite color and lerp by hand:\n    var texcoord = texcoord_in;\n    var c = textureSampleLevel(color_tex, color_smp, texcoord, 0.0);\n    texcoord = texcoord + sign(offset) * u_params.resolution;\n    let c_op = textureSampleLevel(color_tex, color_smp, texcoord, 0.0);\n    let s = select(abs(offset.y), abs(offset.x), abs(offset.x) > abs(offset.y));\n\n    // WebGL port note: Added gamma correction\n    c = vec4<f32>(pow(c.xyz, vec3<f32>(2.2)), c.w);\n    let c_op_gamma = pow(c_op.xyz, vec3<f32>(2.2));\n    var mixed = mix(c, vec4<f32>(c_op_gamma, c_op.w), s);\n    mixed = vec4<f32>(pow(mixed.xyz, vec3<f32>(1.0 / 2.2)), mixed.w);\n\n    return mixed;\n  }\n}\n\n@fragment\nfn fs_smaa_blend(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  // three's SMAANeighborhoodBlendingVS varyings, computed fragment-side.\n  let v_offset0 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-1.0, 0.0, 0.0, 1.0);\n  let v_offset1 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(1.0, 0.0, 0.0, -1.0);\n  let v_offset = array<vec4<f32>, 2>(v_offset0, v_offset1);\n  return smaa_neighborhood_blending(uv, v_offset, u_color_tex, u_color_smp, u_weights_tex, u_weights_smp);\n}\n";
+//# sourceMappingURL=smaa.wgsl.d.ts.map

package/dist/rendering/post/shaders/smaa.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smaa.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/smaa.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,yEAAyE;AACzE,eAAO,MAAM,eAAe,0yFA0E3B,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,iuUA0N7B,CAAC;AAEF,0GAA0G;AAC1G,eAAO,MAAM,eAAe,+5FA+D3B,CAAC"}