@woosh/meep-engine 3.14.1 → 3.14.2

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAuDA,sDAAuD;AAEvD,wDAAyD;AAEzD,+DAAiJ;AAEjJ,+DAA+I;AAE/I;IA8GI;;;;OAIG;IACH,0DAoCC;IA3HD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IA0GD;;;;OAIG;IACH,0CAFa,YAAY,CAIxB;IAgBD;;;;OAIG;IACH,uCAFa,WAAW,CAIvB;IAGD,uBAqHC;IAED,wBA2EC;IAED;;;OAGG;IACH,2CAgBC;IAoCD,eASC;IAGD,gBAGC;;CACJ;kCAnhBiC,oCAAoC;AAOtE;IACI,WAAM;IAEN;;OAEG;IACH,8BAAO;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;OAEG;IACH,gBAFU,WAAW,CAEP;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;CACnB;AAED;IACI,WAAO;IAEP;;OAEG;IACH,qBAAO;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAuDA,sDAAuD;AAEvD,wDAAyD;AAEzD,+DAAiJ;AAEjJ,+DAA+I;AAE/I;IA8GI;;;;OAIG;IACH,0DAoCC;IA3HD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IA0GD;;;;OAIG;IACH,0CAFa,YAAY,CAIxB;IAgBD;;;;OAIG;IACH,uCAFa,WAAW,CAIvB;IAGD,uBA+HC;IAED,wBA2EC;IAED;;;OAGG;IACH,2CAgBC;IAoCD,eASC;IAGD,gBAGC;;CACJ;kCA7hBiC,oCAAoC;AAOtE;IACI,WAAM;IAEN;;OAEG;IACH,8BAAO;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;OAEG;IACH,gBAFU,WAAW,CAEP;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;CACnB;AAED;IACI,WAAO;IAEP;;OAEG;IACH,qBAAO;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -322,7 +322,17 @@ export class GPUResidentMaterialContext {
 
             const is_square = source_ctx.width === source_ctx.height;
 
-            const is_srgb = source.image.color_space === ColorSpace.SRGB;
+            /*
+             The fast path is a copyTextureToTexture, which requires the two formats to be
+             copy-compatible. `!is_srgb` used to stand in for that and was true only by accident: every
+             material texture was rgba8unorm, so the only way to differ was the srgb suffix. A BC7
+             source would have reached the copy and failed validation.
+
+             Asking the question directly costs nothing and covers every format at once — a source
+             that does not match takes the render path below, which samples it into the atlas and is
+             what that path exists for.
+            */
+            const format_matches = source_ctx.gpu_texture.format === target_texture.gpu_texture.format;
 
             const is_pot_w = isPowerOfTwo(source_ctx.width) && isPowerOfTwo(source_ctx.height);
 
@@ -335,7 +345,7 @@ export class GPUResidentMaterialContext {
             const texture_slot_y = Math.floor(id_in_slice / RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION);
             const texture_slot_x = id_in_slice % RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION;
 
-            if (is_square && is_pot_w && source_mip_w >= 0 && source_ctx.gpu_texture.mipLevelCount >= source_mip_w && !is_srgb) {
+            if (is_square && is_pot_w && source_mip_w >= 0 && source_ctx.gpu_texture.mipLevelCount >= source_mip_w && format_matches) {
 
                 encoder.copyTextureToTexture(
                     {

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAiOrB;AAhRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AAwQH,8CAIE;0BAzSwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAkOrB;AAjRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AAyQH,8CAIE;0BA1SwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}

package/src/shade/renderer/material/standard/fragment_gbuffer.js

@@ -1,4 +1,5 @@
 import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
@@ -308,6 +309,7 @@ fn main(
         chunk_compute_normal_matrix_from_m4,
         chunk_anti_alias_roughness_kaplanyan,
         chunk_build_orthonormal_matrix_nt,
+        chunk_decode_tangent_normal,
         chunk_read_meshlet_triangle_vertices,
         chunk_decode_meshlet_element,
         chunk_compute_triangle_face_normal,
@@ -322,7 +324,7 @@ fn main(
 
 const body = build_gbuffer_fragment_body({
     orm: `textureSampleBarycentric(texture_orm, texture_orm_sampler, uv_info)`,
-    normal: `textureSampleBarycentric(texture_normal, texture_normal_sampler, uv_info).rgb * 2.0 - 1.0`,
+    normal: `decode_tangent_normal(textureSampleBarycentric(texture_normal, texture_normal_sampler, uv_info))`,
     diffuse: `textureSampleBarycentric(texture_diffuse, texture_diffuse_sampler, uv_info)`,
     emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
 });

package/src/shade/renderer/material/standard/fragment_gbuffer_vt.js

@@ -1,169 +1,169 @@
-import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
-import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { VT_STACK_INFO_STRUCT } from "../../texture/virtual/VT_STACK_INFO_STRUCT.js";
-import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
-import {
-    build_gbuffer_fragment_body,
-    g_buffer_scene_resources,
-    g_buffer_viz_resources,
-} from "./fragment_gbuffer.js";
-import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
-
-/**
- * Group 0 of the virtual-texture material variant. Replaces the four
- * per-material texture bindings of the standard group with the VT globals:
- * the shared page table, the stack info buffer and the physical cache
- * layers — identical for every VT material, which is what lets hundreds of
- * them share one pipeline and the same feedback/table infrastructure.
- * Emissive stays a regular per-material texture (emissive maps are rarely
- * the memory problem VT solves).
- *
- * `material_info` must stay at binding 0 — the shared vertex stage
- * ({@link material_gbuffer_vertex_shader_code}) addresses it there.
- */
-export const SHADING_MATERIAL_VT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
-
-SHADING_MATERIAL_VT_RESOURCE_GROUP.label = "Material VT";
-
-SHADING_MATERIAL_VT_RESOURCE_GROUP
-    .addUniform("material_info", MATERIAL_METADATA_STRUCT)
-    .addTexture("texture_emissive", "float")
-    .addSampler("texture_emissive_sampler")
-    .addTexture("vt_page_table", "uint")
-    .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
-    .addTexture("vt_cache_albedo", "float")
-    .addTexture("vt_cache_normal", "float")
-    .addTexture("vt_cache_orm", "float")
-    .addSampler("vt_cache_sampler");
-
-export const vt_gbuffer_shader_resources = new ShaderResourceSetDescriptor();
-
-// group order mirrors the standard material set — groups 1 and 2 are the
-// *same descriptor objects*, so the two pipelines are bind-group compatible
-// and the material pass can set viz/scene groups once for both
-vt_gbuffer_shader_resources.addGroup(SHADING_MATERIAL_VT_RESOURCE_GROUP);
-vt_gbuffer_shader_resources.addGroup(g_buffer_viz_resources);
-vt_gbuffer_shader_resources.addGroup(g_buffer_scene_resources);
-
-vt_gbuffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
-vt_gbuffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
-
-const chunk_vt_sample_layer = new WeakMap();
-
-/**
- * Build the VT variant of the G-buffer material pipeline for a concrete
- * cache geometry. Called (and memoized) by the VirtualTextureManager once
- * its configuration is frozen.
- *
- * Sampling model (v1): one page-table fetch per pixel serves all three
- * layers — the stack's UV set, wrap mode and residency resolve once, then
- * albedo/normal/ORM are three bilinear fetches at the same physical
- * coordinate in their respective atlases. Missing layers and not-yet-
- * resident cells fall back to per-layer neutral values (albedo falls back
- * to the stack's average colour).
- *
- * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
- * @returns {RenderPipelineDescriptor}
- */
-export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
-
-    let sample_chunk = chunk_vt_sample_layer.get(chunk_vt_lookup);
-
-    if (sample_chunk === undefined) {
-        sample_chunk = CodeChunk.from(
-            //language=WGSL
-            `
-fn vt_sample_layer(
-    cache: texture_2d<f32>,
-    cache_sampler: sampler,
-    phys: VTPhysical,
-    available: bool,
-    fallback: vec4<f32>,
-) -> vec4<f32> {
-    if (!available) {
-        return fallback;
-    }
-
-    // physical atlases are single-mip; virtual mip selection already
-    // happened through the page table
-    return textureSampleLevel(cache, cache_sampler, phys.uv, 0.0);
-}
-`,
-            [chunk_vt_lookup]
-        );
-
-        chunk_vt_sample_layer.set(chunk_vt_lookup, sample_chunk);
-    }
-
-    const body = build_gbuffer_fragment_body(
-        {
-            prelude: `
-    // ── virtual texture resolve, once per pixel for all layers ──────
-    let vt_info = vt_stacks[material_info.vt_stack];
-    let vt_layer_mask = vt_info.flags >> 8u;
-
-    if ((vt_info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
-        // stack binds the second UV set — re-interpolate and re-bias
-        uv_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
-        uv_info.ddx *= uv_derivative_bias.x;
-        uv_info.ddy *= uv_derivative_bias.y;
-    }
-
-    let vt_uv = vt_stack_wrap_uv(uv_info.uv, vt_info.flags);
-    let vt_mip = vt_mip_select(vt_info, uv_info.ddx, uv_info.ddy, 0.0);
-    let vt_entry = vt_page_table_load(vt_page_table, vt_info, vt_uv, vt_mip);
-
-    var vt_phys = VTPhysical(vec2<f32>(0.0), 0.0);
-
-    if (vt_entry.valid) {
-        vt_phys = vt_physical_uv(vt_entry, vt_info, vt_uv);
-    }
-`,
-            orm: `vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0))`,
-            normal: `vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)).rgb * 2.0 - 1.0`,
-            diffuse: `vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color)`,
-            emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
-        },
-        [
-            sample_chunk,
-        ]
-    );
-
-    const shader = ShaderDescriptor.from({
-        label: "Material / GBuffer laydown (virtual texture)",
-        resources: vt_gbuffer_shader_resources,
-        body,
-    });
-
-    return RenderPipelineDescriptor.from({
-        label: "VT material / Viz-Buffer to G-Buffer laydown",
-        layout: vt_gbuffer_shader_resources.generatePipelineLayoutDescriptor(),
-        vertex: {
-            module: {
-                code: material_gbuffer_vertex_shader_code
-            }
-        },
-        fragment: {
-            module: {
-                code: shader.source,
-            },
-            targets: G_BUFFER_COLOR_TARGETS
-        },
-        depthStencil: {
-            // depth is a material mask — see the standard material pipeline
-            depthCompare: 'equal',
-            format: 'depth32float',
-            depthWriteEnabled: false
-        },
-        primitive: {
-            topology: 'triangle-list',
-            cullMode: 'none',
-        }
-    });
-}
+import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { VT_STACK_INFO_STRUCT } from "../../texture/virtual/VT_STACK_INFO_STRUCT.js";
+import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
+import {
+    build_gbuffer_fragment_body,
+    g_buffer_scene_resources,
+    g_buffer_viz_resources,
+} from "./fragment_gbuffer.js";
+import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
+
+/**
+ * Group 0 of the virtual-texture material variant. Replaces the four
+ * per-material texture bindings of the standard group with the VT globals:
+ * the shared page table, the stack info buffer and the physical cache
+ * layers — identical for every VT material, which is what lets hundreds of
+ * them share one pipeline and the same feedback/table infrastructure.
+ * Emissive stays a regular per-material texture (emissive maps are rarely
+ * the memory problem VT solves).
+ *
+ * `material_info` must stay at binding 0 — the shared vertex stage
+ * ({@link material_gbuffer_vertex_shader_code}) addresses it there.
+ */
+export const SHADING_MATERIAL_VT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
+
+SHADING_MATERIAL_VT_RESOURCE_GROUP.label = "Material VT";
+
+SHADING_MATERIAL_VT_RESOURCE_GROUP
+    .addUniform("material_info", MATERIAL_METADATA_STRUCT)
+    .addTexture("texture_emissive", "float")
+    .addSampler("texture_emissive_sampler")
+    .addTexture("vt_page_table", "uint")
+    .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
+    .addTexture("vt_cache_albedo", "float")
+    .addTexture("vt_cache_normal", "float")
+    .addTexture("vt_cache_orm", "float")
+    .addSampler("vt_cache_sampler");
+
+export const vt_gbuffer_shader_resources = new ShaderResourceSetDescriptor();
+
+// group order mirrors the standard material set — groups 1 and 2 are the
+// *same descriptor objects*, so the two pipelines are bind-group compatible
+// and the material pass can set viz/scene groups once for both
+vt_gbuffer_shader_resources.addGroup(SHADING_MATERIAL_VT_RESOURCE_GROUP);
+vt_gbuffer_shader_resources.addGroup(g_buffer_viz_resources);
+vt_gbuffer_shader_resources.addGroup(g_buffer_scene_resources);
+
+vt_gbuffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
+vt_gbuffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
+
+const chunk_vt_sample_layer = new WeakMap();
+
+/**
+ * Build the VT variant of the G-buffer material pipeline for a concrete
+ * cache geometry. Called (and memoized) by the VirtualTextureManager once
+ * its configuration is frozen.
+ *
+ * Sampling model (v1): one page-table fetch per pixel serves all three
+ * layers — the stack's UV set, wrap mode and residency resolve once, then
+ * albedo/normal/ORM are three bilinear fetches at the same physical
+ * coordinate in their respective atlases. Missing layers and not-yet-
+ * resident cells fall back to per-layer neutral values (albedo falls back
+ * to the stack's average colour).
+ *
+ * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
+ * @returns {RenderPipelineDescriptor}
+ */
+export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
+
+    let sample_chunk = chunk_vt_sample_layer.get(chunk_vt_lookup);
+
+    if (sample_chunk === undefined) {
+        sample_chunk = CodeChunk.from(
+            //language=WGSL
+            `
+fn vt_sample_layer(
+    cache: texture_2d<f32>,
+    cache_sampler: sampler,
+    phys: VTPhysical,
+    available: bool,
+    fallback: vec4<f32>,
+) -> vec4<f32> {
+    if (!available) {
+        return fallback;
+    }
+
+    // physical atlases are single-mip; virtual mip selection already
+    // happened through the page table
+    return textureSampleLevel(cache, cache_sampler, phys.uv, 0.0);
+}
+`,
+            [chunk_vt_lookup]
+        );
+
+        chunk_vt_sample_layer.set(chunk_vt_lookup, sample_chunk);
+    }
+
+    const body = build_gbuffer_fragment_body(
+        {
+            prelude: `
+    // ── virtual texture resolve, once per pixel for all layers ──────
+    let vt_info = vt_stacks[material_info.vt_stack];
+    let vt_layer_mask = vt_info.flags >> 8u;
+
+    if ((vt_info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
+        // stack binds the second UV set — re-interpolate and re-bias
+        uv_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
+        uv_info.ddx *= uv_derivative_bias.x;
+        uv_info.ddy *= uv_derivative_bias.y;
+    }
+
+    let vt_uv = vt_stack_wrap_uv(uv_info.uv, vt_info.flags);
+    let vt_mip = vt_mip_select(vt_info, uv_info.ddx, uv_info.ddy, 0.0);
+    let vt_entry = vt_page_table_load(vt_page_table, vt_info, vt_uv, vt_mip);
+
+    var vt_phys = VTPhysical(vec2<f32>(0.0), 0.0);
+
+    if (vt_entry.valid) {
+        vt_phys = vt_physical_uv(vt_entry, vt_info, vt_uv);
+    }
+`,
+            orm: `vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0))`,
+            normal: `decode_tangent_normal(vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)))`,
+            diffuse: `vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color)`,
+            emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
+        },
+        [
+            sample_chunk,
+        ]
+    );
+
+    const shader = ShaderDescriptor.from({
+        label: "Material / GBuffer laydown (virtual texture)",
+        resources: vt_gbuffer_shader_resources,
+        body,
+    });
+
+    return RenderPipelineDescriptor.from({
+        label: "VT material / Viz-Buffer to G-Buffer laydown",
+        layout: vt_gbuffer_shader_resources.generatePipelineLayoutDescriptor(),
+        vertex: {
+            module: {
+                code: material_gbuffer_vertex_shader_code
+            }
+        },
+        fragment: {
+            module: {
+                code: shader.source,
+            },
+            targets: G_BUFFER_COLOR_TARGETS
+        },
+        depthStencil: {
+            // depth is a material mask — see the standard material pipeline
+            depthCompare: 'equal',
+            format: 'depth32float',
+            depthWriteEnabled: false
+        },
+        primitive: {
+            topology: 'triangle-list',
+            cullMode: 'none',
+        }
+    });
+}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AA6BA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDAqHC;0BA9NyB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDAsHC;0BA/NyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -1,4 +1,5 @@
 import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
 import {
     chunk_build_orthonormal_matrix_nt
@@ -202,7 +203,7 @@ fn sample_material_data(
 
     let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, geometry_tangent.w));
 
-    var normal_sample = indirect_sample_texture(material.texture_normal, material.sampler_normal, uv).rgb * 2.0 - 1.0;
+    var normal_sample = decode_tangent_normal(indirect_sample_texture(material.texture_normal, material.sampler_normal, uv));
     
     var output: ${STANDARD_MATERIAL_DATA_STRUCT.wgsl_ref};
     
@@ -238,6 +239,7 @@ fn sample_material_data(
         chunk_interpolate_attribute_4f32,
         chunk_compute_normal_matrix_from_m4,
         chunk_build_orthonormal_matrix_nt,
+        chunk_decode_tangent_normal,
         chunk_compute_triangle_face_normal,
         chunk_indirect_sample_texture,
         chunk_random_vec3,

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -49,7 +49,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#136@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#140@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_brick4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_forward_shade_standard_fragment_brick4.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_brick4.js"],"names":[],"mappings":"AA2BA,qEAuJC;0BA1JyB,uCAAuC"}
+{"version":3,"file":"chunk_forward_shade_standard_fragment_brick4.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_brick4.js"],"names":[],"mappings":"AA4BA,qEAwJC;0BA3JyB,uCAAuC"}

package/src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_brick4.js

@@ -1,4 +1,5 @@
 import { chunk_shade_standard_material_direct } from "../../../deferred/chunk_shade_standard_material_direct.js";
+import { chunk_decode_tangent_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { INDIRECT_LIGHT_INTENSITY } from "../../../deferred/INDIRECT_LIGHT_INTENSITY.js";
 import {
     chunk_brick4_sample_forward_indirect
@@ -34,7 +35,7 @@ fn forward_shade_standard_fragment(
 ) -> vec4f {
     let world_tangent_frame = build_orthonormal_matrix_nt(vert.normal, vert.tangent);
     
-    let t_normal = textureSample(texture_normal, texture_normal_sampler, vert.uv).rgb * 2.0 - 1.0;
+    let t_normal = decode_tangent_normal(textureSample(texture_normal, texture_normal_sampler, vert.uv));
     var world_shading_normal:vec3<f32> = normalize( world_tangent_frame * t_normal );
     
     // flip normal if fragment is back-facing, 
@@ -169,6 +170,7 @@ fn forward_shade_standard_fragment(
         chunk_dielectric_specular_color,
         chunk_F_Hauber,
         chunk_build_orthonormal_matrix_nt,
+        chunk_decode_tangent_normal,
         chunk_anti_alias_roughness_kaplanyan,
         chunk_shade_standard_material_direct,
         chunk_get_view_space_depth,

package/src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_ibl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_forward_shade_standard_fragment_ibl.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_ibl.js"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,kEA4IC;0BAnJyB,uCAAuC"}
+{"version":3,"file":"chunk_forward_shade_standard_fragment_ibl.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_ibl.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,kEA6IC;0BApJyB,uCAAuC"}

package/src/shade/renderer/rasterize/native/oit/chunk_forward_shade_standard_fragment_ibl.js

@@ -1,4 +1,5 @@
 import { chunk_shade_standard_material_direct } from "../../../deferred/chunk_shade_standard_material_direct.js";
+import { chunk_decode_tangent_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { chunk_get_ibl_irradiance } from "../../../deferred/indirect/chunk_get_ibl_irradiance.js";
 import { chunk_get_ibl_radiance } from "../../../deferred/indirect/chunk_get_ibl_radiance.js";
 import { INDIRECT_LIGHT_INTENSITY } from "../../../deferred/INDIRECT_LIGHT_INTENSITY.js";
@@ -37,7 +38,7 @@ fn forward_shade_standard_fragment(
 ) -> vec4f {
     let world_tangent_frame = build_orthonormal_matrix_nt(vert.normal, vert.tangent);
     
-    let t_normal = textureSample(texture_normal, texture_normal_sampler, vert.uv).rgb * 2.0 - 1.0;
+    let t_normal = decode_tangent_normal(textureSample(texture_normal, texture_normal_sampler, vert.uv));
     var world_shading_normal:vec3<f32> = normalize( world_tangent_frame * t_normal );
     
     // flip normal if fragment is back-facing, 
@@ -160,6 +161,7 @@ fn forward_shade_standard_fragment(
         chunk_dielectric_specular_color,
         chunk_F_Hauber,
         chunk_build_orthonormal_matrix_nt,
+        chunk_decode_tangent_normal,
         chunk_anti_alias_roughness_kaplanyan,
         chunk_shade_standard_material_direct,
         chunk_get_view_space_depth,

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

@@ -0,0 +1,28 @@
+/**
+ * Decode a tangent-space normal from a normal map sample.
+ *
+ * **Z is reconstructed, never read.** A tangent-space normal points away from the surface, so its Z
+ * is positive by construction and `sqrt(1 - x² - y²)` recovers it exactly for a unit normal. The blue
+ * channel of an RGB normal map is therefore redundant, and reconstructing rather than reading it
+ * makes this decode correct for two-channel formats as well — `bc5-rg-unorm` and `eac-rg11unorm`
+ * spend the same bits on two channels that BC7 spends on three, and are what a normal map should be
+ * shipped as.
+ *
+ * That is the whole reason this exists. A two-channel sample reads `(x, y, 0, 1)`, so the
+ * `.rgb * 2.0 - 1.0` this replaces produced `z = -1` — every normal pointing directly into the
+ * surface, and no lighting at all. One decode serves both, so nothing downstream branches on the
+ * format and no pipeline is compiled twice.
+ *
+ * {@link chunk_safe_sqrt} guards the root: filtering and lossy compression both produce samples
+ * slightly off the unit circle, and `x² + y²` a hair over 1 would otherwise be `NaN` rather than a
+ * normal lying in the tangent plane.
+ *
+ * Object-space normal maps are not this, and would need the sign they do not carry. glTF's
+ * `normalTexture` is tangent-space by specification, which is where every normal map in the engine
+ * comes from.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decode_tangent_normal: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_decode_tangent_normal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_decode_tangent_normal.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_decode_tangent_normal.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0CAFU,SAAS,CAYZ;0BAtCmB,gCAAgC"}

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

@@ -0,0 +1,39 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_safe_sqrt } from "../../math/chunk_safe_sqrt.js";
+
+/**
+ * Decode a tangent-space normal from a normal map sample.
+ *
+ * **Z is reconstructed, never read.** A tangent-space normal points away from the surface, so its Z
+ * is positive by construction and `sqrt(1 - x² - y²)` recovers it exactly for a unit normal. The blue
+ * channel of an RGB normal map is therefore redundant, and reconstructing rather than reading it
+ * makes this decode correct for two-channel formats as well — `bc5-rg-unorm` and `eac-rg11unorm`
+ * spend the same bits on two channels that BC7 spends on three, and are what a normal map should be
+ * shipped as.
+ *
+ * That is the whole reason this exists. A two-channel sample reads `(x, y, 0, 1)`, so the
+ * `.rgb * 2.0 - 1.0` this replaces produced `z = -1` — every normal pointing directly into the
+ * surface, and no lighting at all. One decode serves both, so nothing downstream branches on the
+ * format and no pipeline is compiled twice.
+ *
+ * {@link chunk_safe_sqrt} guards the root: filtering and lossy compression both produce samples
+ * slightly off the unit circle, and `x² + y²` a hair over 1 would otherwise be `NaN` rather than a
+ * normal lying in the tangent plane.
+ *
+ * Object-space normal maps are not this, and would need the sign they do not carry. glTF's
+ * `normalTexture` is tangent-space by specification, which is where every normal map in the engine
+ * comes from.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decode_tangent_normal = CodeChunk.from(
+    //language=WGSL
+    `
+fn decode_tangent_normal(texel: vec4<f32>) -> vec3<f32> {
+    let xy = fma(texel.rg, vec2<f32>(2.0), vec2<f32>(-1.0));
+
+    return vec3<f32>(xy, safe_sqrt(1.0 - dot(xy, xy)));
+}
+`, [
+        chunk_safe_sqrt,
+    ]);

package/src/shade/renderer/shader/chunk/geometry/triangle/chunk_barycentric_full.d.ts

@@ -1,3 +1,48 @@
+/**
+ * Perspective-correct barycentric coordinates for a pixel inside a triangle, with the per-pixel
+ * derivatives the texture gradients are built from.
+ *
+ * ## What it solves
+ *
+ * A point of the triangle with barycentric `l` sits at clip position `sum(l_i * P_i)` and therefore
+ * at screen position `sum(l_i * P_i.xy) / sum(l_i * P_i.w)`. Asking for the `l` whose screen
+ * position is this pixel gives two linear equations, and `sum(l) == 1` gives the third:
+ *
+ * ```
+ *   sum_i  l_i * (x_i - pixel.x * w_i) = 0
+ *   sum_i  l_i * (y_i - pixel.y * w_i) = 0
+ *   sum_i  l_i                         = 1
+ * ```
+ *
+ * This function forms the two pixel-relative coordinate vectors that system is written in;
+ * {@link chunk_barycentric_solve} solves it.
+ *
+ * ## Why it is written this way
+ *
+ * **It never divides by w.** A vertex on the eye plane has `w == 0` and one behind it has `w < 0`;
+ * projecting either to NDC first yields an infinity or a sign-flipped coordinate hundreds of
+ * thousands of pixels outside the viewport, and every later term then has to cancel that magnitude
+ * back down. Here `w` only ever multiplies, so a triangle straddling the eye plane is an ordinary
+ * case rather than a near-singular one.
+ *
+ * **It has no anchor, and that is the point.** The previous formulation measured every pixel from
+ * `pixel - ndc0` and scaled by a determinant taken about vertex 1, so vertex 0 was the origin of
+ * the whole reconstruction and the three corners were not interchangeable. In exact arithmetic that
+ * is irrelevant. In f32, on a triangle whose corners project far outside the viewport, it is not:
+ * the rounding depended on which corner was first, so two coplanar triangles meeting along an edge
+ * reconstructed measurably different UVs on either side of it — and the difference moved with the
+ * TAA jitter, which turned it into a temporally unstable seam along the shared edge. Invisible in a
+ * still frame, plainly visible in a multi-frame difference. `src/shade/playground/ground_seam`
+ * measures it, and measured this rewrite: the seam goes from a 2.1x step in per-pixel temporal
+ * spread to none, and a two-triangle quad now behaves like the same quad subdivided 8x8.
+ *
+ * **The derivatives are evaluations, not a differentiation.** `ddx` is defined as
+ * `lambda(pixel + (1,0)) - lambda(pixel)`, a whole-pixel forward difference, which is what mip
+ * selection wants; it is computed by solving the same system one pixel over. Stepping the pixel by
+ * one in x subtracts `w` from `u`, so the second and third solves share every input with the first.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_barycentric_full: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_barycentric_full.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/triangle/chunk_barycentric_full.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_barycentric_full.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/triangle/chunk_barycentric_full.js"],"names":[],"mappings":"AAWA,+CAiDE;0BA3DwB,gCAAgC"}
+{"version":3,"file":"chunk_barycentric_full.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/triangle/chunk_barycentric_full.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qCAFU,SAAS,CAuCjB;0BA5FwB,gCAAgC"}