@woosh/meep-engine 3.27.0 → 3.29.0

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js

@@ -3,7 +3,6 @@ import { noop } from "../../../../core/function/noop.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { shader_hzb_mesh_filter_2way } from "../cull/hzb/shader_hzb_mesh_filter_2way.js";
-import { U32_CONTAINER_STRUCT } from "../../shader/type/U32_CONTAINER_STRUCT.js";
 import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 import { TransparencyMode } from "../../material/TransparencyMode.js";
@@ -15,13 +14,13 @@ import {
     graph_build_indirect_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
 import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
 import { graph_expand_meshes_to_meshlets } from "../expand/mesh/graph_expand_meshes_to_meshlets.js";
 import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js";
 import { MeshletFilter2WayPassData, pass_filter_meshlets_2way } from "../expand/pass1/pass_filter_meshlets_2way.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
 import { construct_primitive_state, CullPolicy } from "../bucket/construct_primitive_state.js";
+import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 
 /**
  *
@@ -96,16 +95,11 @@ export function graph_rasterize_partial_opaque({
             0
         );
 
-        // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-        const u_bucket_index = encoder.allocateTransientValueBuffer(U32_CONTAINER_STRUCT, {
-            value: bucket_index,
-        });
-
         // split 2 ways
         shader_hzb_mesh_filter_2way.dispatchIndirect({
             encoder,
             bindings: {
-                bucket_index: u_bucket_index,
+                bucket_index: { value: bucket_index },
                 camera_previous,
                 bucket_data: buckets,
                 scene_database: scene_ctx.scene_database_buffer,
@@ -144,93 +138,85 @@ export function graph_rasterize_partial_opaque({
 
     let is_first_draw = true;
 
-    for (const draw_mode of Object.values(ShadeDrawMode)) {
-        for (const side of Object.values(ShadeDrawSide)) {
-
-            const bucket_id = rasterization_material_bucket(TransparencyMode.Opaque, draw_mode, side);
-
-            if (!active_buckets.has(bucket_id)) {
-                // no matching materials, skip
-                continue;
-            }
-
-            const pass_data_instances_0 = {};
-
-            const pass_instances_0 = graph.add("HZB mesh filter", pass_data_instances_0, execute);
-
-            pass_data_instances_0.bucket_index = bucket_id;
-
-            pass_data_instances_0.buckets = pass_instances_0.read(buckets);
-            pass_data_instances_0.command = pass_instances_0.create("indirect dispatch command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR)
-            pass_data_instances_0.camera_previous = pass_instances_0.read(camera_previous);
-            pass_data_instances_0.hzb = pass_instances_0.read(hzb);
-
-            pass_data_instances_0.instances_positive = pass_instances_0.create("positive meshes", BufferResourceDescriptor.from(
-                collection_size_meshes,
-                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-                0, 16
-            ));
-
-            gr_instances_maybe = pass_data_instances_0.instances_maybe = pass_instances_0.write(gr_instances_maybe);
-
-            let meshlet_expansion_0 = graph_expand_meshes_to_meshlets({
-                graph,
-                input_meshes: pass_data_instances_0.instances_positive,
-                scene: scene_ctx,
-                expected_output_size: collection_size_meshlets,
-                limits,
-            });
-
-            // the seam. The instance sets of the two HZB passes are disjoint, so cutting each of
-            // them costs one cut per view in total and no instance is ever cut twice
-            meshlet_expansion_0 = graph_vgeo_expand_if_enabled({
-                graph,
-                input_meshes: pass_data_instances_0.instances_positive,
-                output_meshlets: meshlet_expansion_0,
-                view,
-                limits,
-            });
-
-
-            graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, meshlet_expansion_0);
-
-            // ----------
-
-            const gr_command_iterate_meshlets_0 = graph_build_indirect_dispatch_command(graph, meshlet_expansion_0, COMPUTE_SHADER_DEFAULT_GROUP_SIZE);
-
-            const pass_data_meshlets_1 = new MeshletFilter2WayPassData();
-
-            const pass_meshlets_1 = graph.add("filter meshlets 2 way", pass_data_meshlets_1, pass_filter_meshlets_2way);
-
-            pass_data_meshlets_1.view = view;
-            pass_data_meshlets_1.hzb = pass_meshlets_1.read(hzb);
-            pass_data_meshlets_1.command = pass_meshlets_1.read(gr_command_iterate_meshlets_0);
-            pass_data_meshlets_1.input_meshlets = pass_meshlets_1.read(meshlet_expansion_0);
-            pass_data_meshlets_1.out_meshlets_positive = pass_meshlets_1.create("meshlets positive", BufferResourceDescriptor.from(
-                collection_size_meshlets,
-                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-                0, 16 // clear count
-            ));
-            gr_meshlets_maybe = pass_data_meshlets_1.out_meshlets_maybe = pass_meshlets_1.write(gr_meshlets_maybe);
-
-            const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
-
-            // ----------
-            [viz_depth, raster_color_targets] = graph_meshlets_rasterize({
-                graph,
-                view,
-                input_meshlets: pass_data_meshlets_1.out_meshlets_positive,
-                depth: viz_depth,
-                color_targets: raster_color_targets,
-                pass_descriptor: render_pass_descriptor,
-                clear_targets: is_first_draw,
-                primitive_state,
-                viewport,
-            });
-
-            //
-            is_first_draw = false;
-        }
+    for (const { draw_mode, side, bucket_id } of rasterization_opaque_buckets(active_buckets)) {
+        const pass_data_instances_0 = {};
+
+        const pass_instances_0 = graph.add("HZB mesh filter", pass_data_instances_0, execute);
+
+        pass_data_instances_0.bucket_index = bucket_id;
+
+        pass_data_instances_0.buckets = pass_instances_0.read(buckets);
+        pass_data_instances_0.command = pass_instances_0.create("indirect dispatch command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR)
+        pass_data_instances_0.camera_previous = pass_instances_0.read(camera_previous);
+        pass_data_instances_0.hzb = pass_instances_0.read(hzb);
+
+        pass_data_instances_0.instances_positive = pass_instances_0.create("positive meshes", BufferResourceDescriptor.from(
+            collection_size_meshes,
+            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            0, 16
+        ));
+
+        gr_instances_maybe = pass_data_instances_0.instances_maybe = pass_instances_0.write(gr_instances_maybe);
+
+        let meshlet_expansion_0 = graph_expand_meshes_to_meshlets({
+            graph,
+            input_meshes: pass_data_instances_0.instances_positive,
+            scene: scene_ctx,
+            expected_output_size: collection_size_meshlets,
+            limits,
+        });
+
+        // the seam. The instance sets of the two HZB passes are disjoint, so cutting each of
+        // them costs one cut per view in total and no instance is ever cut twice
+        meshlet_expansion_0 = graph_vgeo_expand_if_enabled({
+            graph,
+            input_meshes: pass_data_instances_0.instances_positive,
+            output_meshlets: meshlet_expansion_0,
+            view,
+            limits,
+        });
+
+
+        graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, meshlet_expansion_0);
+
+        // ----------
+
+        // folded: a meshlet collection is past what one dispatch dimension reaches — see
+        // IndirectComputeCommandBuildPass
+        const gr_command_iterate_meshlets_0 = graph_build_indirect_dispatch_command(graph, meshlet_expansion_0, COMPUTE_SHADER_DEFAULT_GROUP_SIZE, true);
+
+        const pass_data_meshlets_1 = new MeshletFilter2WayPassData();
+
+        const pass_meshlets_1 = graph.add("filter meshlets 2 way", pass_data_meshlets_1, pass_filter_meshlets_2way);
+
+        pass_data_meshlets_1.view = view;
+        pass_data_meshlets_1.hzb = pass_meshlets_1.read(hzb);
+        pass_data_meshlets_1.command = pass_meshlets_1.read(gr_command_iterate_meshlets_0);
+        pass_data_meshlets_1.input_meshlets = pass_meshlets_1.read(meshlet_expansion_0);
+        pass_data_meshlets_1.out_meshlets_positive = pass_meshlets_1.create("meshlets positive", BufferResourceDescriptor.from(
+            collection_size_meshlets,
+            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            0, 16 // clear count
+        ));
+        gr_meshlets_maybe = pass_data_meshlets_1.out_meshlets_maybe = pass_meshlets_1.write(gr_meshlets_maybe);
+
+        const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
+
+        // ----------
+        [viz_depth, raster_color_targets] = graph_meshlets_rasterize({
+            graph,
+            view,
+            input_meshlets: pass_data_meshlets_1.out_meshlets_positive,
+            depth: viz_depth,
+            color_targets: raster_color_targets,
+            pass_descriptor: render_pass_descriptor,
+            clear_targets: is_first_draw,
+            primitive_state,
+            viewport,
+        });
+
+        //
+        is_first_draw = false;
     }
 
     // at this point we have rendered all occluders, and the uncertain cases are all stored in the "maybe" set

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AAgGA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CA4GlD"}
+{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAkGlD"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js

@@ -7,10 +7,8 @@ import { TransparencyMode } from "../../material/TransparencyMode.js";
 import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { graph_record_stat } from "../../util/graph_record_stat.js";
 import { build_indirect_compute_dispatch_command } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
 import { graph_sort_meshlets_by_bucket_id } from "../expand/bucket/meshlet/graph_sort_meshlets_by_bucket_id.js";
 import { shader_meshlets_extract_bucket } from "../expand/bucket/meshlet/shader_meshlets_extract_bucket.js";
-import { U32_CONTAINER_STRUCT } from "../../shader/type/U32_CONTAINER_STRUCT.js";
 import { graph_mesh_filter_one_way } from "../expand/graph_mesh_filter_one_way.js";
 import { graph_meshlets_filter_one_way } from "../expand/graph_meshlets_filter_one_way.js";
 import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
@@ -18,6 +16,7 @@ import { graph_expand_meshes_to_meshlets } from "../expand/mesh/graph_expand_mes
 import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
 import { construct_primitive_state, CullPolicy } from "../bucket/construct_primitive_state.js";
+import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 
 /**
  *
@@ -49,6 +48,8 @@ function graph_extract_meshlets_from_bucket({
 
         const bucket_id = data.bucket_id;
 
+        // folded: a meshlet collection is past what one dispatch dimension reaches — see
+        // IndirectComputeCommandBuildPass
         build_indirect_compute_dispatch_command(
             COMPUTE_SHADER_DEFAULT_GROUP_SIZE,
             encoder,
@@ -56,19 +57,15 @@ function graph_extract_meshlets_from_bucket({
             // the bucketed buffer header consists of pairs of u32 values (count,offset)
             bucket_id * (u32.size * 2),
             command,
-            0
+            0,
+            true,
         );
 
-        // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-        const u_bucket_index = encoder.allocateTransientValueBuffer(U32_CONTAINER_STRUCT, {
-            value: bucket_id,
-        });
-
         shader_meshlets_extract_bucket.dispatchIndirect({
             encoder,
             command,
             bindings: {
-                bucket_index: u_bucket_index,
+                bucket_index: { value: bucket_id },
                 bucket_data: buckets,
                 output: output,
             }
@@ -180,38 +177,28 @@ export function graph_rasterize_remaining_opaque({
         limits,
     });
 
-    for (const draw_mode of Object.values(ShadeDrawMode)) {
-        for (const side of Object.values(ShadeDrawSide)) {
-
-            const bucket_id = rasterization_material_bucket(TransparencyMode.Opaque, draw_mode, side);
+    for (const { draw_mode, side, bucket_id } of rasterization_opaque_buckets(active_buckets)) {
+        const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
 
-            if (!active_buckets.has(bucket_id)) {
-                // no matching materials, skip
-                continue;
-            }
+        // copy out a meshlet set
+        const meshlets = graph_extract_meshlets_from_bucket({
+            graph,
+            buckets: meshlet_buckets,
+            bucket_id,
+            limits,
+        });
 
-            const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
-
-            // copy out a meshlet set
-            const meshlets = graph_extract_meshlets_from_bucket({
-                graph,
-                buckets: meshlet_buckets,
-                bucket_id,
-                limits,
-            });
-
-            [gr_depth_texture, raster_color_targets] = graph_meshlets_rasterize({
-                graph,
-                view,
-                input_meshlets: meshlets,
-                depth: gr_depth_texture,
-                color_targets: raster_color_targets,
-                pass_descriptor: render_pass_descriptor,
-                clear_targets: false,
-                primitive_state,
-                viewport,
-            });
-        }
+        [gr_depth_texture, raster_color_targets] = graph_meshlets_rasterize({
+            graph,
+            view,
+            input_meshlets: meshlets,
+            depth: gr_depth_texture,
+            color_targets: raster_color_targets,
+            pass_descriptor: render_pass_descriptor,
+            clear_targets: false,
+            primitive_state,
+            viewport,
+        });
     }
 
     return {

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAmEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAoHD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAmCrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;OAIG;IACH,cAqEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD,gBAYC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA1pBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAoHD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAmCrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;OAIG;IACH,cAqEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD,gBAYC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA5pBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -51,6 +51,8 @@ const ROOT_RECORD = {
     global: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
     prev_global: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
     parent: NODE3D_SCENE_ID,
+    // identity does not reflect
+    global_flags: 0,
 };
 
 /**

package/src/shade/renderer/scene/NODE3D_STRUCT.d.ts

@@ -18,6 +18,25 @@
  * shaders that need it pull in `chunk_mat4_inverse`.
  */
 export const NODE3D_STRUCT: WebGPUStruct;
+/**
+ * `global` reflects: the determinant of its linear part is negative,
+ * because an odd number of negative scale axes appears somewhere in the
+ * chain that composed it.
+ *
+ * Two consequences, and the renderer has to act on both. Every triangle
+ * drawn under the node comes out of the vertex shader wound backwards,
+ * so fixed-function front-face determination culls exactly the faces
+ * pointing at the camera unless the draw reverses them. And the node's
+ * tangent frame changes handedness, so a bitangent reconstructed as
+ * `cross(N, T) * w` needs the other `w`.
+ *
+ * A node is not necessarily a mesh — bones, empties and particle
+ * emitters have rows in the same table — so this says nothing about
+ * geometry, only about the transform.
+ *
+ * @type {number}
+ */
+export const NODE3D_GLOBAL_FLAG_MIRRORED: number;
 /**
  * Reserved row id for the scene root in the GPU `transforms` table.
  *

package/src/shade/renderer/scene/NODE3D_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NODE3D_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/NODE3D_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCA4CU;AAEV;;;;;;;;;;;;;;;GAeG;AACH,8BAFU,MAAM,CAEiB;6BAnFJ,gCAAgC"}
+{"version":3,"file":"NODE3D_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/NODE3D_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCA0DU;AAEV;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,8BAFU,MAAM,CAEiB;6BArHJ,gCAAgC"}

package/src/shade/renderer/scene/NODE3D_STRUCT.js

@@ -64,8 +64,42 @@ export const NODE3D_STRUCT = WebGPUStruct.from({
      * terminates when it sees this value.
      */
     parent: u32,
+
+    /**
+     * Properties of `global` that are cheaper to carry than to re-derive
+     * per vertex and per pixel — see {@link NODE3D_GLOBAL_FLAG_MIRRORED}.
+     *
+     * Not an independent field: it is part of how `global` is
+     * represented, and whoever writes one writes the other.
+     * `scene_write_node_global` is the only publisher and writes both, so
+     * the two cannot drift.
+     *
+     * Free, as it happens — the packed record was 176 bytes with the
+     * padding this word now occupies, and is 176 bytes with it.
+     */
+    global_flags: u32,
 }).pack();
 
+/**
+ * `global` reflects: the determinant of its linear part is negative,
+ * because an odd number of negative scale axes appears somewhere in the
+ * chain that composed it.
+ *
+ * Two consequences, and the renderer has to act on both. Every triangle
+ * drawn under the node comes out of the vertex shader wound backwards,
+ * so fixed-function front-face determination culls exactly the faces
+ * pointing at the camera unless the draw reverses them. And the node's
+ * tangent frame changes handedness, so a bitangent reconstructed as
+ * `cross(N, T) * w` needs the other `w`.
+ *
+ * A node is not necessarily a mesh — bones, empties and particle
+ * emitters have rows in the same table — so this says nothing about
+ * geometry, only about the transform.
+ *
+ * @type {number}
+ */
+export const NODE3D_GLOBAL_FLAG_MIRRORED = 1;
+
 /**
  * Reserved row id for the scene root in the GPU `transforms` table.
  *

package/src/shade/renderer/scene/chunk_node3d_flags.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Readers for {@link NODE3D_STRUCT}'s `global_flags`. Every consumer of the encoding goes through
+ * here rather than masking the word itself.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_node3d_flags: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_node3d_flags.d.ts.map

package/src/shade/renderer/scene/chunk_node3d_flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_node3d_flags.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/chunk_node3d_flags.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,iCAFU,SAAS,CAeb;0BAtBoB,iCAAiC"}

package/src/shade/renderer/scene/chunk_node3d_flags.js

@@ -0,0 +1,23 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { NODE3D_GLOBAL_FLAG_MIRRORED, NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
+
+/**
+ * Readers for {@link NODE3D_STRUCT}'s `global_flags`. Every consumer of the encoding goes through
+ * here rather than masking the word itself.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_node3d_flags = CodeChunk.from(
+    //language=WGSL
+    `
+/**
+ * Whether the node's world transform reflects — an odd number of negative scale axes anywhere in
+ * its ancestry. Triangles drawn under it come out wound backwards unless the draw reverses them,
+ * and its tangent frame changes handedness.
+ */
+fn node3d_global_is_mirrored( node: ${NODE3D_STRUCT.wgsl_ref} ) -> bool{
+    return ( node.global_flags & ${NODE3D_GLOBAL_FLAG_MIRRORED}u ) != 0u;
+}
+`, [
+        NODE3D_STRUCT.declaration_chunk,
+    ])

package/src/shade/renderer/scene/chunk_scene_database_access.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_scene_database_access.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/chunk_scene_database_access.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wGAA8D;AAC9D,4GAAsE;AAEtE;;;;;;;GAOG;AACH,0CAFU,SAAS,CAqBZ;AAEP;;;;;;;;;;;;;;GAcG;AACH,6CAFU,SAAS,CAsGZ;0BA9JmB,iCAAiC"}
+{"version":3,"file":"chunk_scene_database_access.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/chunk_scene_database_access.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wGAA8D;AAC9D,4GAAsE;AAEtE;;;;;;;GAOG;AACH,0CAFU,SAAS,CAqBZ;AAEP;;;;;;;;;;;;;;GAcG;AACH,6CAFU,SAAS,CAiHZ;0BAzKmB,iCAAiC"}

package/src/shade/renderer/scene/chunk_scene_database_access.js

@@ -1,6 +1,9 @@
+import {
+    chunk_mat4_linear_determinant
+} from "../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
-import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
+import { NODE3D_GLOBAL_FLAG_MIRRORED, NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 import { SCENE_DATABASE_SPEC } from "./SCENE_DATABASE_SPEC.js";
 
 /**
@@ -113,12 +116,21 @@ fn scene_write_node_local_scale(
     ${TRANSFORMS_TABLE.marshalling_method_write_field('local_scale')}(database, node_id, value);
 }
 
+/**
+ * Publishes a node's world transform. Writes \`global_flags\` from the same matrix — the flags are
+ * part of how \`global\` is represented, not a field of their own, and deriving them here is what
+ * stops a caller from publishing one without the other.
+ */
 fn scene_write_node_global(
     database: ptr<storage, array<u32>, read_write>,
     node_id: u32,
     value: mat4x4<f32>,
 ) {
     ${TRANSFORMS_TABLE.marshalling_method_write_field('global')}(database, node_id, value);
+
+    let flags = select(0u, ${NODE3D_GLOBAL_FLAG_MIRRORED}u, mat4_linear_determinant(value) < 0.0);
+
+    ${TRANSFORMS_TABLE.marshalling_method_write_field('global_flags')}(database, node_id, flags);
 }
 
 fn scene_write_node_prev_global(
@@ -153,7 +165,9 @@ fn scene_write_mesh_bounding_sphere(
         TRANSFORMS_TABLE.wgsl_gen_write_field_code('local_rotation'),
         TRANSFORMS_TABLE.wgsl_gen_write_field_code('local_scale'),
         TRANSFORMS_TABLE.wgsl_gen_write_field_code('global'),
+        TRANSFORMS_TABLE.wgsl_gen_write_field_code('global_flags'),
         TRANSFORMS_TABLE.wgsl_gen_write_field_code('prev_global'),
+        chunk_mat4_linear_determinant,
         MESHES_TABLE.wgsl_gen_write_field_code('bounding_box'),
         MESHES_TABLE.wgsl_gen_write_field_code('bounding_sphere'),
     ]);

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAYA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAmID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAsCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAmMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;OAEG;IACH,gBA+BC;;CACJ;qCAxnCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}
+{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAaA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAoID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAsCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAyMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;OAEG;IACH,gBA+BC;;CACJ;qCA/nCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}

package/src/shade/renderer/scene/rows/GPUSceneRows.js

@@ -4,10 +4,11 @@ import { GPUStateAuthority } from "../../../../engine/ecs/gpu/GPUStateAuthority.
 import { GPUStateAuthorityFlags } from "../../../../engine/ecs/gpu/GPUStateAuthorityFlags.js";
 import { TransformAttachment } from "../../../../engine/ecs/transform-attachment/TransformAttachment.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { m4_linear_determinant } from "../../../../core/geom/3d/mat4/m4_linear_determinant.js";
 import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
 import { generate_record_writer } from "../../buffer/table/serde/generate_record_writer.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "../MESH_INSTANCE_METADATA_STRUCT.js";
-import { NODE3D_SCENE_ID, NODE3D_STRUCT } from "../NODE3D_STRUCT.js";
+import { NODE3D_GLOBAL_FLAG_MIRRORED, NODE3D_SCENE_ID, NODE3D_STRUCT } from "../NODE3D_STRUCT.js";
 import { TransparencyMode } from "../../material/TransparencyMode.js";
 
 /**
@@ -66,6 +67,7 @@ const TRANSFORM_RECORD = {
     global: new Float32Array(16),
     prev_global: new Float32Array(16),
     parent: NODE3D_SCENE_ID,
+    global_flags: 0,
 };
 
 /**
@@ -962,6 +964,12 @@ export class GPUSceneRows {
             TRANSFORM_RECORD.prev_global[i] = world[i];
         }
 
+        // seeded alongside `global`, exactly as the hierarchy pass derives it when it recomposes
+        // the row next tick — a row that reflects has to read as reflecting on its first frame too
+        TRANSFORM_RECORD.global_flags = m4_linear_determinant(world) < 0
+            ? NODE3D_GLOBAL_FLAG_MIRRORED
+            : 0;
+
         return TRANSFORM_RECORD;
     }
 

package/src/shade/renderer/shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.d.ts

@@ -1,6 +1,13 @@
 /**
  * This is the transpose adjugate method of computing the normal matrix from a 4x4 matrix
  * Note that the matrix will produce scaled vectors, so you need to normalize them afterward.
+ *
+ * The adjugate transpose is `det(M) * M^-T`, so under a reflection it points every normal *into*
+ * the surface rather than out of it — the one case where the determinant's magnitude being
+ * irrelevant does not make its sign irrelevant too. Re-orienting by that sign is what keeps a
+ * mirrored instance's shading normal, tangent and geometric normal agreeing with each other and
+ * with the winding the rasterizer sees.
+ *
  * @source Eric Lengyel, "Transforming Normals", 2024:  https://terathon.com/blog/transforming-normals.html
  * @source Ken Turkowski, "Properties of Surface Normal Transformations" (Graphics Gems, 1990)
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_normal_matrix_from_m4.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,kDAFU,SAAS,CAiBjB;0BAxBwB,gCAAgC"}
+{"version":3,"file":"chunk_compute_normal_matrix_from_m4.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,kDAFU,SAAS,CAsBjB;0BApCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js

@@ -3,6 +3,13 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
 /**
  * This is the transpose adjugate method of computing the normal matrix from a 4x4 matrix
  * Note that the matrix will produce scaled vectors, so you need to normalize them afterward.
+ *
+ * The adjugate transpose is `det(M) * M^-T`, so under a reflection it points every normal *into*
+ * the surface rather than out of it — the one case where the determinant's magnitude being
+ * irrelevant does not make its sign irrelevant too. Re-orienting by that sign is what keeps a
+ * mirrored instance's shading normal, tangent and geometric normal agreeing with each other and
+ * with the winding the rasterizer sees.
+ *
  * @source Eric Lengyel, "Transforming Normals", 2024:  https://terathon.com/blog/transforming-normals.html
  * @source Ken Turkowski, "Properties of Surface Normal Transformations" (Graphics Gems, 1990)
  * @type {CodeChunk}
@@ -14,11 +21,16 @@ fn compute_normal_matrix_from_m4( m: mat4x4<f32> ) -> mat3x3<f32>{
     let c0 = m[0].xyz;
     let c1 = m[1].xyz;
     let c2 = m[2].xyz;
-    
+
+    let cofactor_0 = cross(c1, c2);
+
+    // dot(c0, cross(c1, c2)) is the determinant, and the cross is already in hand
+    let orientation = select(1.0, -1.0, dot(c0, cofactor_0) < 0.0);
+
     return mat3x3<f32>(
-        cross(c1, c2),
-        cross(c2, c0),
-        cross(c0, c1)
+        cofactor_0 * orientation,
+        cross(c2, c0) * orientation,
+        cross(c0, c1) * orientation
     );
 }
 `, [

package/src/shade/renderer/shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Determinant of the linear (upper-left 3x3) part of a 4x4 transform. WGSL twin of
+ * {@link m4_linear_determinant} — keep the two in step.
+ *
+ * Negative exactly when the transform reflects, which is what reverses triangle winding and
+ * tangent-frame handedness under it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mat4_linear_determinant: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mat4_linear_determinant.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mat4_linear_determinant.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,4CAFU,SAAS,CAQb;0BAjBoB,gCAAgC"}