@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_encode_g_buffer_normal.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,2CAFU,SAAS,CAajB;0BAlBwB,gCAAgC"}
+{"version":3,"file":"chunk_encode_g_buffer_normal.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,2CAFU,SAAS,CAWjB;0BA1BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js

@@ -2,18 +2,26 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_uv_octahedral_unit_encode } from "../octahedron/chunk_uv_octahedral_unit_encode.js";
 
 /**
- * Input must be normalized
+ * A unit normal as one `u32`: octahedral UV through `pack2x16unorm`, each component the nearest 16-bit
+ * code, u in the low half and v in the high half — the format of a mesh's vertex normals
+ * (`encode_vertex_normal`). What the G-buffer's `r32uint` normal target holds, and every other texture
+ * that stores a normal the same way (GTAO's bent normal).
+ *
+ * ```wgsl
+ * fn encode_g_buffer_normal(normal: vec3<f32>) -> u32
+ * ```
+ *
+ * Input must be normalized.
+ *
  * @type {CodeChunk}
  */
 export const chunk_encode_g_buffer_normal = CodeChunk.from(
     //language=WGSL
     `
-fn encode_g_buffer_normal(normal: vec3<f32>) -> vec2<u32>{
-    let octahedral = uv_octahedral_unit_encode(normal);
-
-    return vec2<u32>(octahedral * 65535.0);
+fn encode_g_buffer_normal(normal: vec3<f32>) -> u32 {
+    return pack2x16unorm(uv_octahedral_unit_encode(normal));
 }
     `, [
         chunk_uv_octahedral_unit_encode
     ]
-);
+);

package/src/shade/renderer/shader/chunk/material/albedo_compress.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The code `albedo_compress` (`chunk_albedo_compress.js`) gives an albedo, on the host: each channel
+ * clamped to [0, 1], its square root rounded to f32 and then to unorm8, as `pack4x8unorm` rounds, the
+ * top byte 255.
+ *
+ * @param {number} r linear
+ * @param {number} g linear
+ * @param {number} b linear
+ * @returns {number} u32
+ */
+export function albedo_compress(r: number, g: number, b: number): number;
+//# sourceMappingURL=albedo_compress.d.ts.map

package/src/shade/renderer/shader/chunk/material/albedo_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"albedo_compress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/albedo_compress.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,mCALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/shade/renderer/shader/chunk/material/albedo_compress.js

@@ -0,0 +1,26 @@
+import { clamp01 } from "../../../../../core/math/clamp01.js";
+
+/**
+ * The code `albedo_compress` (`chunk_albedo_compress.js`) gives an albedo, on the host: each channel
+ * clamped to [0, 1], its square root rounded to f32 and then to unorm8, as `pack4x8unorm` rounds, the
+ * top byte 255.
+ *
+ * @param {number} r linear
+ * @param {number} g linear
+ * @param {number} b linear
+ * @returns {number} u32
+ */
+export function albedo_compress(r, g, b) {
+    return (unorm8_root(r) | (unorm8_root(g) << 8) | (unorm8_root(b) << 16) | (255 << 24)) >>> 0;
+}
+
+/**
+ * @param {number} v
+ * @returns {number}
+ */
+function unorm8_root(v) {
+    const root = Math.fround(Math.sqrt(Math.fround(clamp01(Math.fround(v)))));
+
+    // ⌊0.5 + 255·e⌋ of the f32 e, which a double holds exactly
+    return Math.floor(0.5 + 255 * root);
+}

package/src/shade/renderer/shader/chunk/material/chunk_albedo_compress.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A diffuse albedo, RGB on [0, 1], in a 32-bit code, as `albedo_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn albedo_compress(albedo: vec3<f32>) -> u32
+ * ```
+ *
+ * Each channel is clamped to [0, 1] and stored as its square root, unorm8, which puts more codes in the
+ * dark. The top byte is 255, so a code is never 0, black
+ * included: a reader may take 0 for no albedo at all.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_compress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_albedo_compress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_albedo_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_albedo_compress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_albedo_compress.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,oCAFU,SAAS,CAQhB;0BArBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_albedo_compress.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * A diffuse albedo, RGB on [0, 1], in a 32-bit code, as `albedo_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn albedo_compress(albedo: vec3<f32>) -> u32
+ * ```
+ *
+ * Each channel is clamped to [0, 1] and stored as its square root, unorm8, which puts more codes in the
+ * dark. The top byte is 255, so a code is never 0, black
+ * included: a reader may take 0 for no albedo at all.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_compress = CodeChunk.from(
+    //language=WGSL
+    `
+fn albedo_compress(albedo: vec3<f32>) -> u32 {
+    return pack4x8unorm(vec4<f32>(sqrt(saturate(albedo)), 1.0));
+}
+`);

package/src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A diffuse albedo from the code `albedo_compress` wrote:
+ *
+ * ```wgsl
+ * fn albedo_uncompress(code: u32) -> vec3<f32> // RGB on [0, 1]
+ * ```
+ *
+ * The code's low three bytes are the square roots of R, G and B, unorm8; its top byte is 255 for every
+ * albedo.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_uncompress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_albedo_uncompress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_albedo_uncompress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,sCAFU,SAAS,CAUhB;0BAtBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.js

@@ -0,0 +1,23 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * A diffuse albedo from the code `albedo_compress` wrote:
+ *
+ * ```wgsl
+ * fn albedo_uncompress(code: u32) -> vec3<f32> // RGB on [0, 1]
+ * ```
+ *
+ * The code's low three bytes are the square roots of R, G and B, unorm8; its top byte is 255 for every
+ * albedo.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_uncompress = CodeChunk.from(
+    //language=WGSL
+    `
+fn albedo_uncompress(code: u32) -> vec3<f32> {
+    let root = unpack4x8unorm(code).rgb;
+
+    return root * root;
+}
+`);

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_albedo.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The linear albedo from the G-buffer albedo texel's `rgb`, the inverse of
+ * {@link chunk_encode_g_buffer_albedo}. Every reader of the albedo goes through this; the texel's
+ * alpha, the ambient occlusion, is linear and is read as it is.
+ *
+ * ```wgsl
+ * fn decode_g_buffer_albedo(encoded: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decode_g_buffer_albedo: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_decode_g_buffer_albedo.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_albedo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_decode_g_buffer_albedo.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_albedo.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,2CAFU,SAAS,CAWjB;0BAvBwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_decode_g_buffer_albedo.js

@@ -0,0 +1,24 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_sRGBTransferEOTF } from "../color/sRGB/chunk_sRGBTransferEOTF.js";
+
+/**
+ * The linear albedo from the G-buffer albedo texel's `rgb`, the inverse of
+ * {@link chunk_encode_g_buffer_albedo}. Every reader of the albedo goes through this; the texel's
+ * alpha, the ambient occlusion, is linear and is read as it is.
+ *
+ * ```wgsl
+ * fn decode_g_buffer_albedo(encoded: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decode_g_buffer_albedo = CodeChunk.from(
+    //language=WGSL
+    `
+fn decode_g_buffer_albedo(encoded: vec3<f32>) -> vec3<f32> {
+    return sRGBTransferEOTF(encoded);
+}
+`, [
+        chunk_sRGBTransferEOTF
+    ]
+);

package/src/shade/renderer/shader/chunk/material/chunk_encode_g_buffer_albedo.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The albedo as the G-buffer's 8-bit target stores it: sRGB-encoded, so that each level of an 8-bit
+ * sRGB texture is kept as its own code. The texel's alpha, the ambient occlusion, is stored linear and
+ * is not part of this. {@link chunk_decode_g_buffer_albedo} reads it back.
+ *
+ * The encoding is done here rather than by an `-srgb` target format because the compute material
+ * dispatch writes the albedo as a storage texture, which no sRGB format can be.
+ *
+ * ```wgsl
+ * fn encode_g_buffer_albedo(albedo: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_encode_g_buffer_albedo: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_encode_g_buffer_albedo.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_encode_g_buffer_albedo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_encode_g_buffer_albedo.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_encode_g_buffer_albedo.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,2CAFU,SAAS,CAWjB;0BA1BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_encode_g_buffer_albedo.js

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_sRGBTransferOETF } from "../color/sRGB/chunk_sRGBTransferOETF.js";
+
+/**
+ * The albedo as the G-buffer's 8-bit target stores it: sRGB-encoded, so that each level of an 8-bit
+ * sRGB texture is kept as its own code. The texel's alpha, the ambient occlusion, is stored linear and
+ * is not part of this. {@link chunk_decode_g_buffer_albedo} reads it back.
+ *
+ * The encoding is done here rather than by an `-srgb` target format because the compute material
+ * dispatch writes the albedo as a storage texture, which no sRGB format can be.
+ *
+ * ```wgsl
+ * fn encode_g_buffer_albedo(albedo: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_encode_g_buffer_albedo = CodeChunk.from(
+    //language=WGSL
+    `
+fn encode_g_buffer_albedo(albedo: vec3<f32>) -> vec3<f32> {
+    return sRGBTransferOETF(albedo);
+}
+`, [
+        chunk_sRGBTransferOETF
+    ]
+);

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Metalness and roughness, each on [0, 1], in a code of `METAL_ROUGH_CODE_BITS` bits, as
+ * `metal_rough_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn metal_rough_compress(metal_rough: vec2<f32>) -> u32 // (metalness, roughness)
+ * ```
+ *
+ * Each is clamped to [0, 1] and rounded to the nearest of 2^{@link METAL_ROUGH_CHANNEL_BITS} even
+ * steps, metalness in the low bits.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_compress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_metal_rough_compress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_metal_rough_compress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAUhB;0BAxBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { METAL_ROUGH_CHANNEL_BITS } from "./chunk_metal_rough_uncompress.js";
+
+/**
+ * Metalness and roughness, each on [0, 1], in a code of `METAL_ROUGH_CODE_BITS` bits, as
+ * `metal_rough_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn metal_rough_compress(metal_rough: vec2<f32>) -> u32 // (metalness, roughness)
+ * ```
+ *
+ * Each is clamped to [0, 1] and rounded to the nearest of 2^{@link METAL_ROUGH_CHANNEL_BITS} even
+ * steps, metalness in the low bits.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_compress = CodeChunk.from(
+    //language=WGSL
+    `
+fn metal_rough_compress(metal_rough: vec2<f32>) -> u32 {
+    let q = vec2<u32>(round(saturate(metal_rough) * ${2 ** METAL_ROUGH_CHANNEL_BITS - 1}.0));
+
+    return q.x | (q.y << ${METAL_ROUGH_CHANNEL_BITS}u);
+}
+`);

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bits of each of metalness and roughness in a `metal_rough_compress` code.
+ * @type {number}
+ */
+export const METAL_ROUGH_CHANNEL_BITS: number;
+/**
+ * Bits of a `metal_rough_compress` code: metalness, then roughness.
+ * @type {number}
+ */
+export const METAL_ROUGH_CODE_BITS: number;
+/**
+ * Metalness and roughness from the code `metal_rough_compress` wrote:
+ *
+ * ```wgsl
+ * fn metal_rough_uncompress(code: u32) -> vec2<f32> // (metalness, roughness), on [0, 1]
+ * ```
+ *
+ * The code's low {@link METAL_ROUGH_CHANNEL_BITS} bits are the metalness and the next as many the
+ * roughness, each unorm. Bits past {@link METAL_ROUGH_CODE_BITS} are ignored.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_uncompress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_metal_rough_uncompress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_metal_rough_uncompress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,oCAFU,MAAM,CAEkD;AAElE;;;;;;;;;;;GAWG;AACH,2CAFU,SAAS,CAWhB;0BAnCuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.js

@@ -0,0 +1,36 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Bits of each of metalness and roughness in a `metal_rough_compress` code.
+ * @type {number}
+ */
+export const METAL_ROUGH_CHANNEL_BITS = 4;
+
+/**
+ * Bits of a `metal_rough_compress` code: metalness, then roughness.
+ * @type {number}
+ */
+export const METAL_ROUGH_CODE_BITS = 2 * METAL_ROUGH_CHANNEL_BITS;
+
+/**
+ * Metalness and roughness from the code `metal_rough_compress` wrote:
+ *
+ * ```wgsl
+ * fn metal_rough_uncompress(code: u32) -> vec2<f32> // (metalness, roughness), on [0, 1]
+ * ```
+ *
+ * The code's low {@link METAL_ROUGH_CHANNEL_BITS} bits are the metalness and the next as many the
+ * roughness, each unorm. Bits past {@link METAL_ROUGH_CODE_BITS} are ignored.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_uncompress = CodeChunk.from(
+    //language=WGSL
+    `
+fn metal_rough_uncompress(code: u32) -> vec2<f32> {
+    return vec2<f32>(
+        f32(extractBits(code, 0u, ${METAL_ROUGH_CHANNEL_BITS}u)),
+        f32(extractBits(code, ${METAL_ROUGH_CHANNEL_BITS}u, ${METAL_ROUGH_CHANNEL_BITS}u))
+    ) / ${2 ** METAL_ROUGH_CHANNEL_BITS - 1}.0;
+}
+`);

package/src/shade/renderer/shader/chunk/material/metal_rough_compress.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The code `metal_rough_compress` (`chunk_metal_rough_compress.js`) gives a metalness and roughness, on
+ * the host: each clamped to [0, 1], scaled to its steps in f32 and rounded half to even, as WGSL's
+ * `round` does.
+ *
+ * @param {number} metalness
+ * @param {number} roughness
+ * @returns {number} the code, {@link METAL_ROUGH_CHANNEL_BITS} bits each, metalness low
+ */
+export function metal_rough_compress(metalness: number, roughness: number): number;
+//# sourceMappingURL=metal_rough_compress.d.ts.map

package/src/shade/renderer/shader/chunk/material/metal_rough_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metal_rough_compress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/metal_rough_compress.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,gDAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/shade/renderer/shader/chunk/material/metal_rough_compress.js

@@ -0,0 +1,38 @@
+import { clamp01 } from "../../../../../core/math/clamp01.js";
+import { METAL_ROUGH_CHANNEL_BITS } from "./chunk_metal_rough_uncompress.js";
+
+const STEPS = 2 ** METAL_ROUGH_CHANNEL_BITS - 1;
+
+/**
+ * The code `metal_rough_compress` (`chunk_metal_rough_compress.js`) gives a metalness and roughness, on
+ * the host: each clamped to [0, 1], scaled to its steps in f32 and rounded half to even, as WGSL's
+ * `round` does.
+ *
+ * @param {number} metalness
+ * @param {number} roughness
+ * @returns {number} the code, {@link METAL_ROUGH_CHANNEL_BITS} bits each, metalness low
+ */
+export function metal_rough_compress(metalness, roughness) {
+    return step(metalness) | (step(roughness) << METAL_ROUGH_CHANNEL_BITS);
+}
+
+/**
+ * @param {number} v
+ * @returns {number}
+ */
+function step(v) {
+    const scaled = Math.fround(Math.fround(clamp01(Math.fround(v))) * STEPS);
+    const floor = Math.floor(scaled);
+    const fraction = scaled - floor;
+
+    if (fraction > 0.5) {
+        return floor + 1;
+    }
+
+    if (fraction < 0.5) {
+        return floor;
+    }
+
+    // halfway: to the even one
+    return floor % 2 === 0 ? floor : floor + 1;
+}

package/src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.d.ts

@@ -9,9 +9,15 @@ export const SCREEN_DEPTH_RESOURCE: ShaderResourceDescriptor;
  */
 export const SCREEN_HZB_RESOURCE: ShaderResourceDescriptor;
 /**
- * The scene's normals, encoded.
+ * The scene's shading normal, encoded (`decode_g_buffer_normal`).
  * @type {ShaderResourceDescriptor}
  */
 export const SCREEN_NORMAL_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The G-buffer's PBR target, for the face normal it holds (`decode_g_buffer_face_normal`): the plane of the
+ * triangle a pixel shows.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_PBR_RESOURCE: ShaderResourceDescriptor;
 import { ShaderResourceDescriptor } from "../../resource/ShaderResourceDescriptor.js";
 //# sourceMappingURL=SCREEN_SPACE_RESOURCES.d.ts.map

package/src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SCREEN_SPACE_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oCAFU,wBAAwB,CAE8C;AAEhF;;;GAGG;AACH,kCAFU,wBAAwB,CAE0C;AAE5E;;;GAGG;AACH,qCAFU,wBAAwB,CAEwD;yCAlBjD,4CAA4C"}
+{"version":3,"file":"SCREEN_SPACE_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oCAFU,wBAAwB,CAE8C;AAEhF;;;GAGG;AACH,kCAFU,wBAAwB,CAE0C;AAE5E;;;GAGG;AACH,qCAFU,wBAAwB,CAEwD;AAE1F;;;;GAIG;AACH,kCAFU,wBAAwB,CAE0C;yCAzBnC,4CAA4C"}

package/src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js

@@ -13,7 +13,14 @@ export const SCREEN_DEPTH_RESOURCE = ShaderResourceDescriptor.texture("tDepth");
 export const SCREEN_HZB_RESOURCE = ShaderResourceDescriptor.texture("tHZB");
 
 /**
- * The scene's normals, encoded.
+ * The scene's shading normal, encoded (`decode_g_buffer_normal`).
  * @type {ShaderResourceDescriptor}
  */
 export const SCREEN_NORMAL_RESOURCE = ShaderResourceDescriptor.texture("tNormal", "uint");
+
+/**
+ * The G-buffer's PBR target, for the face normal it holds (`decode_g_buffer_face_normal`): the plane of the
+ * triangle a pixel shows.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_PBR_RESOURCE = ShaderResourceDescriptor.texture("tPBR");

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_world_space_normal.js

@@ -7,7 +7,7 @@ export const chunk_ffx_sssr_load_world_space_normal = CodeChunk.from(
     `
 fn ffx_sssr_load_world_space_normal(texel_coord: vec2<i32>)-> vec3<f32>{
     // Using shading normal
-    return decode_g_buffer_normal( textureLoad(tNormal, texel_coord, 0).xy );
+    return decode_g_buffer_normal( textureLoad(tNormal, texel_coord, 0).x );
 }    
     `, [
         chunk_decode_g_buffer_normal

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.js

@@ -1,6 +1,6 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_is_background } from "../depth/chunk_is_background.js";
-import { chunk_decode_g_buffer_normal } from "../geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_decode_g_buffer_face_normal } from "../geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_plane_from_normal_and_point } from "../geometry/plane/chunk_plane_from_normal_and_point.js";
 import { chunk_plane_ray_raycast } from "../geometry/plane/chunk_plane_ray_raycast.js";
 import { RAY_STRUCT } from "../geometry/ray/RAY_STRUCT.js";
@@ -35,10 +35,10 @@ struct ScreenSpaceRayReceiver {
     plane: vec4<f32>,
 }
 
-// One G-buffer fetch. Depth is stored at the texel center; .zw is the geometric
-// face normal, while .xy includes material normal mapping.
+// One G-buffer texel: its depth, stored at the texel center, and its face normal, read from the PBR
+// target. The shading normal includes material normal mapping and is not the surface's plane.
 fn screen_space_ray_load_receiver(
-    uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    uv: vec2<f32>, depth: texture_2d<f32>, pbr: texture_2d<f32>,
     inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
 ) -> ScreenSpaceRayReceiver {
     let size = textureDimensions(depth, 0);
@@ -46,7 +46,7 @@ fn screen_space_ray_load_receiver(
     let d = textureLoad(depth, coord, 0).r;
     let center = (vec2<f32>(coord) + 0.5) / vec2<f32>(size);
     let position = inv_project_position(vec3<f32>(center, d), inverse_projection);
-    let normal = (world_to_view * vec4<f32>(decode_g_buffer_normal(textureLoad(normals, coord, 0).zw), 0.0)).xyz;
+    let normal = (world_to_view * vec4<f32>(decode_g_buffer_face_normal(textureLoad(pbr, coord, 0)), 0.0)).xyz;
     return ScreenSpaceRayReceiver(d, plane_from_normal_and_point(normal, position));
 }
 
@@ -86,12 +86,12 @@ fn screen_space_ray_accept(
 }
 
 fn screen_space_ray_validate(
-    ray: Ray, uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    ray: Ray, uv: vec2<f32>, depth: texture_2d<f32>, pbr: texture_2d<f32>,
     projection: mat4x4<f32>, inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
     distance_tolerance: f32,
 ) -> ScreenSpaceRayHit {
     if (!screen_space_ray_in_bounds(uv)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, 0u, 1u); }
-    let receiver = screen_space_ray_load_receiver(uv, depth, normals, inverse_projection, world_to_view);
+    let receiver = screen_space_ray_load_receiver(uv, depth, pbr, inverse_projection, world_to_view);
     if (is_background(receiver.depth)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, 0u, 2u); }
     return screen_space_ray_accept(ray, uv, receiver, vec2<f32>(textureDimensions(depth, 0)),
         projection, inverse_projection, distance_tolerance);
@@ -100,7 +100,7 @@ fn screen_space_ray_validate(
 // One G-buffer fetch per lookup, as in the paper: the plane that rejects lookup n
 // is also the tangent plane of update n+1. max_updates updates read max_updates+1 texels.
 fn screen_space_newton_ray(
-    ray: Ray, seed_uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    ray: Ray, seed_uv: vec2<f32>, depth: texture_2d<f32>, pbr: texture_2d<f32>,
     projection: mat4x4<f32>, inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
     max_updates: u32, distance_tolerance: f32,
 ) -> ScreenSpaceRayHit {
@@ -112,7 +112,7 @@ fn screen_space_newton_ray(
     for (var i = 0u; i <= updates; i++) {
         let iterations = max(i, 1u);
         if (!screen_space_ray_in_bounds(uv)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, iterations, 1u); }
-        let receiver = screen_space_ray_load_receiver(uv, depth, normals, inverse_projection, world_to_view);
+        let receiver = screen_space_ray_load_receiver(uv, depth, pbr, inverse_projection, world_to_view);
         if (is_background(receiver.depth)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, iterations, 2u); }
         // The seed is the undisplaced background, not an update; only updated lookups are accepted.
         if (i > 0u) {
@@ -130,6 +130,6 @@ fn screen_space_newton_ray(
     }
     return hit;
 }
-`, [RAY_STRUCT.declaration_chunk, chunk_is_background, chunk_decode_g_buffer_normal,
+`, [RAY_STRUCT.declaration_chunk, chunk_is_background, chunk_decode_g_buffer_face_normal,
     chunk_plane_from_normal_and_point, chunk_plane_ray_raycast, chunk_ray_at,
     chunk_ray_nearest_point, chunk_inv_project_position, chunk_project_position]);

package/src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot.d.ts

@@ -0,0 +1,20 @@
+/**
+ * An RGB SH2 (L1) function of a unit normal written about a pivot normal, and its evaluation:
+ *
+ * ```wgsl
+ * struct Sh2ColorPivot { value: vec3<f32>, gradient: mat3x3<f32>, pivot: vec3<f32> }
+ * fn sh2_color_pivot_evaluate(f: Sh2ColorPivot, n: vec3<f32>) -> vec3<f32> // value + gradient · (n − pivot)
+ * ```
+ *
+ * Any L1 function on the sphere is affine in the normal, c₀ + c·n, so this is the same function space as
+ * band 0 and band 1 of SH. Writing it about a pivot near the normals it was fitted on puts a real value
+ * in `value`, the function at the pivot, where band 0 is the function's mean over the whole sphere. A
+ * one-sided fit's mean can lie far outside the range its values take on the fitted side.
+ *
+ * `gradient`'s column `a` is the RGB derivative along normal axis `a`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh2_color_pivot.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh2_color_pivot.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,oCAFU,SAAS,CAiBhB;0BAlCuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot.js

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * An RGB SH2 (L1) function of a unit normal written about a pivot normal, and its evaluation:
+ *
+ * ```wgsl
+ * struct Sh2ColorPivot { value: vec3<f32>, gradient: mat3x3<f32>, pivot: vec3<f32> }
+ * fn sh2_color_pivot_evaluate(f: Sh2ColorPivot, n: vec3<f32>) -> vec3<f32> // value + gradient · (n − pivot)
+ * ```
+ *
+ * Any L1 function on the sphere is affine in the normal, c₀ + c·n, so this is the same function space as
+ * band 0 and band 1 of SH. Writing it about a pivot near the normals it was fitted on puts a real value
+ * in `value`, the function at the pivot, where band 0 is the function's mean over the whole sphere. A
+ * one-sided fit's mean can lie far outside the range its values take on the fitted side.
+ *
+ * `gradient`'s column `a` is the RGB derivative along normal axis `a`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot = CodeChunk.from(
+    //language=WGSL
+    `
+struct Sh2ColorPivot {
+    /** the function at the pivot */
+    value: vec3<f32>,
+    /** a column an axis of the normal: the RGB change per unit of that axis */
+    gradient: mat3x3<f32>,
+    /** unit length */
+    pivot: vec3<f32>,
+}
+
+fn sh2_color_pivot_evaluate(f: Sh2ColorPivot, n: vec3<f32>) -> vec3<f32> {
+    return f.value + f.gradient * (n - f.pivot);
+}
+`);