@woosh/meep-engine 3.27.0 → 3.28.0

package/src/shade/renderer/rasterize/bucket/rasterization_opaque_buckets.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The opaque rasterization buckets a scene has anything in, once each.
+ *
+ * Every opaque path records one pass per bucket, and the pass is expensive — extract, expand to
+ * meshlets, select a virtual-geometry cut, one render pass. So what is iterated has to be the
+ * *buckets*, and iterating `ShadeDrawSide` is not that: `Front` and `Back` are one bucket, and a
+ * loop over the enum visits it twice and draws the scene's single-sided geometry twice.
+ *
+ * Which is why this exists rather than the three callers each writing the loop: the enum is the
+ * obvious thing to reach for and it is wrong, and it is wrong in a way that costs a whole pass and
+ * shows up in nothing but a frame time.
+ *
+ * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
+ * @yields {{draw_mode: ShadeDrawMode, side: ShadeDrawSide, bucket_id: number}} `side` is the
+ *   bucket's representative, which is what {@link construct_primitive_state} wants
+ */
+export function rasterization_opaque_buckets(active_buckets: Set<number>): Generator<{
+    draw_mode: number;
+    side: number;
+    bucket_id: number;
+}, void, unknown>;
+//# sourceMappingURL=rasterization_opaque_buckets.d.ts.map

package/src/shade/renderer/rasterize/bucket/rasterization_opaque_buckets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterization_opaque_buckets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/rasterization_opaque_buckets.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,6DAJW,IAAI,MAAM,CAAC;;;;kBAkBrB"}

package/src/shade/renderer/rasterize/bucket/rasterization_opaque_buckets.js

@@ -0,0 +1,36 @@
+import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
+import { TransparencyMode } from "../../material/TransparencyMode.js";
+import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
+import { RASTERIZATION_BUCKET_SIDES } from "./construct_primitive_state.js";
+
+/**
+ * The opaque rasterization buckets a scene has anything in, once each.
+ *
+ * Every opaque path records one pass per bucket, and the pass is expensive — extract, expand to
+ * meshlets, select a virtual-geometry cut, one render pass. So what is iterated has to be the
+ * *buckets*, and iterating `ShadeDrawSide` is not that: `Front` and `Back` are one bucket, and a
+ * loop over the enum visits it twice and draws the scene's single-sided geometry twice.
+ *
+ * Which is why this exists rather than the three callers each writing the loop: the enum is the
+ * obvious thing to reach for and it is wrong, and it is wrong in a way that costs a whole pass and
+ * shows up in nothing but a frame time.
+ *
+ * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
+ * @yields {{draw_mode: ShadeDrawMode, side: ShadeDrawSide, bucket_id: number}} `side` is the
+ *   bucket's representative, which is what {@link construct_primitive_state} wants
+ */
+export function* rasterization_opaque_buckets(active_buckets) {
+    for (const draw_mode of Object.values(ShadeDrawMode)) {
+        for (const side of RASTERIZATION_BUCKET_SIDES) {
+
+            const bucket_id = rasterization_material_bucket(TransparencyMode.Opaque, draw_mode, side);
+
+            if (!active_buckets.has(bucket_id)) {
+                // no matching materials, skip
+                continue;
+            }
+
+            yield { draw_mode, side, bucket_id };
+        }
+    }
+}

package/src/shade/renderer/rasterize/chunk_triangle_winding_is_reversed.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The whole of what a vertex shader needs to know to emit a triangle the right way round, in one
+ * place — because there is more than one reason to reverse and they are not independent of each
+ * other.
+ *
+ * Feed the answer to `triangle_list_reverse_winding`. Nanite's `ReverseWindingOrder` is the same
+ * function for the same reason: a GPU-driven draw mixes instances that disagree about this, so it
+ * cannot be pipeline state, and every reason has to be combined before the corner is chosen.
+ *
+ * @see chunk_triangle_list_reverse_winding
+ * @type {CodeChunk}
+ */
+export const chunk_triangle_winding_is_reversed: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_triangle_winding_is_reversed.d.ts.map

package/src/shade/renderer/rasterize/chunk_triangle_winding_is_reversed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_triangle_winding_is_reversed.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/chunk_triangle_winding_is_reversed.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,iDAFU,SAAS,CAmBb;0BA/BoB,iCAAiC"}

package/src/shade/renderer/rasterize/chunk_triangle_winding_is_reversed.js

@@ -0,0 +1,35 @@
+import { chunk_material_draw_side } from "../material/chunk_material_draw_side.js";
+import { chunk_node3d_flags } from "../scene/chunk_node3d_flags.js";
+import { NODE3D_STRUCT } from "../scene/NODE3D_STRUCT.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+
+/**
+ * The whole of what a vertex shader needs to know to emit a triangle the right way round, in one
+ * place — because there is more than one reason to reverse and they are not independent of each
+ * other.
+ *
+ * Feed the answer to `triangle_list_reverse_winding`. Nanite's `ReverseWindingOrder` is the same
+ * function for the same reason: a GPU-driven draw mixes instances that disagree about this, so it
+ * cannot be pipeline state, and every reason has to be combined before the corner is chosen.
+ *
+ * @see chunk_triangle_list_reverse_winding
+ * @type {CodeChunk}
+ */
+export const chunk_triangle_winding_is_reversed = CodeChunk.from(
+    //language=WGSL
+    `
+/**
+ * Whether this instance's triangles must be emitted back to front.
+ *
+ * Two reasons, and they cancel: the instance's transform reflects, or the material asks for the
+ * back face. A back-sided material on a mirrored instance is wound like a front-sided one on an
+ * ordinary instance, and draws with the same pipeline state as both.
+ */
+fn triangle_winding_is_reversed( node: ${NODE3D_STRUCT.wgsl_ref}, draw_side: u32 ) -> bool{
+    return node3d_global_is_mirrored(node) != material_draws_back_side(draw_side);
+}
+`, [
+        NODE3D_STRUCT.declaration_chunk,
+        chunk_node3d_flags,
+        chunk_material_draw_side,
+    ])

package/src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.d.ts

@@ -1,6 +1,15 @@
 export const RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE: number;
 export const RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE: number;
-export const RASTERIZATION_BUCKET_BIT_COUNT_DRAW_SIDE: number;
+/**
+ * One bit, not the two {@link ShadeDrawSide} would need. Only double-sided geometry needs a
+ * pipeline of its own — `cullMode: 'none'` has no winding equivalent. `Front` and `Back` share
+ * one: a back-sided material is a front-sided one drawn with its winding reversed, and the
+ * vertex shader does the reversing.
+ *
+ * @see rasterization_material_bucket
+ * @type {number}
+ */
+export const RASTERIZATION_BUCKET_BIT_COUNT_DOUBLE_SIDED: number;
 /**
  * Maximum number of rasterization buckets. This is a number of permutations of different alpha and draw modes.
  * See Northlight talk on "Alan Wake 2" meshlet shading.

package/src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RASTERIZATION_BUCKET_LIMIT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.js"],"names":[],"mappings":"AAmBA,+DAA0F;AAC1F,8DAAsF;AACtF,8DAAsF;AAEtF;;;;GAIG;AACH,yCAFU,MAAM,CAEmK"}
+{"version":3,"file":"RASTERIZATION_BUCKET_LIMIT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.js"],"names":[],"mappings":"AAkBA,+DAA0F;AAC1F,8DAAsF;AAEtF;;;;;;;;GAQG;AACH,0DAFU,MAAM,CAE6C;AAE7D;;;;GAIG;AACH,yCAFU,MAAM,CAEsK"}

package/src/shade/renderer/rasterize/expand/bucket/RASTERIZATION_BUCKET_LIMIT.js

@@ -1,29 +1,38 @@
-import { assert } from "../../../../../core/assert.js";
-import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
-import { ShadeDrawSide } from "../../../material/ShadeDrawSide.js";
-import { TransparencyMode } from "../../../material/TransparencyMode.js";
-
-/**
- *
- * @param {Object} e enum
- * @return {number} number of bits required to represent it
- */
-function enum_bit_count(e) {
-    const max = Math.max.apply(null, Object.values(e));
-
-    assert.isNonNegativeInteger(max, 'max');
-    assert.lessThanOrEqual(max, 5, "the bucket count is going to be absurd");
-
-    return 32 - Math.clz32(max);
-}
-
-export const RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE = enum_bit_count(TransparencyMode);
-export const RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE = enum_bit_count(ShadeDrawMode);
-export const RASTERIZATION_BUCKET_BIT_COUNT_DRAW_SIDE = enum_bit_count(ShadeDrawSide);
-
-/**
- * Maximum number of rasterization buckets. This is a number of permutations of different alpha and draw modes.
- * See Northlight talk on "Alan Wake 2" meshlet shading.
- * @type {number}
- */
-export const RASTERIZATION_BUCKET_LIMIT = (1 << (RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DRAW_SIDE));
+import { assert } from "../../../../../core/assert.js";
+import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
+import { TransparencyMode } from "../../../material/TransparencyMode.js";
+
+/**
+ *
+ * @param {Object} e enum
+ * @return {number} number of bits required to represent it
+ */
+function enum_bit_count(e) {
+    const max = Math.max.apply(null, Object.values(e));
+
+    assert.isNonNegativeInteger(max, 'max');
+    assert.lessThanOrEqual(max, 5, "the bucket count is going to be absurd");
+
+    return 32 - Math.clz32(max);
+}
+
+export const RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE = enum_bit_count(TransparencyMode);
+export const RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE = enum_bit_count(ShadeDrawMode);
+
+/**
+ * One bit, not the two {@link ShadeDrawSide} would need. Only double-sided geometry needs a
+ * pipeline of its own — `cullMode: 'none'` has no winding equivalent. `Front` and `Back` share
+ * one: a back-sided material is a front-sided one drawn with its winding reversed, and the
+ * vertex shader does the reversing.
+ *
+ * @see rasterization_material_bucket
+ * @type {number}
+ */
+export const RASTERIZATION_BUCKET_BIT_COUNT_DOUBLE_SIDED = 1;
+
+/**
+ * Maximum number of rasterization buckets. This is a number of permutations of different alpha and draw modes.
+ * See Northlight talk on "Alan Wake 2" meshlet shading.
+ * @type {number}
+ */
+export const RASTERIZATION_BUCKET_LIMIT = (1 << (RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE + RASTERIZATION_BUCKET_BIT_COUNT_DOUBLE_SIDED));

package/src/shade/renderer/rasterize/expand/bucket/chunk_rasterization_material_bucket.d.ts

@@ -7,6 +7,11 @@
  */
 export function rasterization_material_bucket(alpha_mode: number | TransparencyMode, draw_mode: number | ShadeDrawMode, side: number | ShadeDrawSide): number;
 /**
+ * A bucket is a pipeline state, and the third field is the only thing a {@link ShadeDrawSide}
+ * still says about one: whether it culls at all. `Front` and `Back` land in the same bucket —
+ * a back-sided material is a front-sided one whose winding the vertex shader reverses — so a
+ * scene that mixes them draws in one pass, through one expansion chain.
+ *
  * @see TransparencyMode
  * @see ShadeDrawMode
  * @see rasterization_material_bucket

package/src/shade/renderer/rasterize/expand/bucket/chunk_rasterization_material_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_rasterization_material_bucket.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/bucket/chunk_rasterization_material_bucket.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,0DALW,MAAM,GAAC,gBAAgB,aACvB,MAAM,GAAC,aAAa,QACpB,MAAM,GAAC,aAAa,GACnB,MAAM,CAUjB;AAhCD;;;;;GAKG;AACH,kDAFU,SAAS,CAWjB;iCAlC+B,uCAAuC;8BAF1C,oCAAoC;8BACpC,oCAAoC;0BAExC,uCAAuC"}
+{"version":3,"file":"chunk_rasterization_material_bucket.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/expand/bucket/chunk_rasterization_material_bucket.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,0DALW,MAAM,GAAC,gBAAgB,aACvB,MAAM,GAAC,aAAa,QACpB,MAAM,GAAC,aAAa,GACnB,MAAM,CAYjB;AAzCD;;;;;;;;;;GAUG;AACH,kDAFU,SAAS,CAajB;iCAxC+B,uCAAuC;8BAF1C,oCAAoC;8BACpC,oCAAoC;0BAExC,uCAAuC"}

package/src/shade/renderer/rasterize/expand/bucket/chunk_rasterization_material_bucket.js

@@ -1,55 +1,63 @@
-import { assert } from "../../../../../core/assert.js";
-import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
-import { ShadeDrawSide } from "../../../material/ShadeDrawSide.js";
-import { TransparencyMode } from "../../../material/TransparencyMode.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import {
-    RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE,
-    RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE,
-    RASTERIZATION_BUCKET_BIT_COUNT_DRAW_SIDE
-} from "./RASTERIZATION_BUCKET_LIMIT.js";
-
-// A field of N bits is masked with (1 << N) - 1, not N + 1 (the two coincide only at N == 2,
-// which is the value all three enums happen to have today).
-const mask_alpha = (1 << RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE) - 1;
-const shift_alpha = 0;
-
-const mask_primitive = (1 << RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE) - 1;
-const shift_primitive = shift_alpha + RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE;
-
-const mask_side = (1 << RASTERIZATION_BUCKET_BIT_COUNT_DRAW_SIDE) - 1;
-const shift_side = shift_primitive + RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE;
-
-/**
- * @see TransparencyMode
- * @see ShadeDrawMode
- * @see rasterization_material_bucket
- * @type {CodeChunk}
- */
-export const chunk_rasterization_material_bucket = CodeChunk.from(
-    //language=WGSL
-    `
-fn rasterization_material_bucket( alpha_mode: u32, draw_mode: u32, side: u32 ) -> u32{
-    return ( ( alpha_mode & ${mask_alpha} ) << ${shift_alpha} ) 
-         | ( ( draw_mode & ${mask_primitive} ) << ${shift_primitive} ) 
-         | ( ( side & ${mask_side} ) << ${shift_side} );
-}
-    `
-);
-
-/**
- * @see chunk_rasterization_material_bucket
- * @param {number|TransparencyMode} alpha_mode
- * @param {number|ShadeDrawMode} draw_mode
- * @param {number|ShadeDrawSide} side
- * @return {number}
- */
-export function rasterization_material_bucket(alpha_mode, draw_mode, side) {
-    assert.enum(alpha_mode, TransparencyMode);
-    assert.enum(draw_mode, ShadeDrawMode);
-    assert.enum(side, ShadeDrawSide);
-
-    return ((alpha_mode & mask_alpha) << shift_alpha)
-        | ((draw_mode & mask_primitive) << shift_primitive)
-        | ((side & mask_side) << shift_side);
-}
+import { assert } from "../../../../../core/assert.js";
+import { ShadeDrawMode } from "../../../material/ShadeDrawMode.js";
+import { ShadeDrawSide } from "../../../material/ShadeDrawSide.js";
+import { TransparencyMode } from "../../../material/TransparencyMode.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE,
+    RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE
+} from "./RASTERIZATION_BUCKET_LIMIT.js";
+
+// A field of N bits is masked with (1 << N) - 1, not N + 1 (the two coincide only at N == 2,
+// which is the value both of these enums happen to have today).
+const mask_alpha = (1 << RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE) - 1;
+const shift_alpha = 0;
+
+const mask_primitive = (1 << RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE) - 1;
+const shift_primitive = shift_alpha + RASTERIZATION_BUCKET_BIT_COUNT_ALPHA_MODE;
+
+// the last field carries no mask: it is a boolean by construction, not an enum being narrowed
+const shift_double_sided = shift_primitive + RASTERIZATION_BUCKET_BIT_COUNT_DRAW_MODE;
+
+/**
+ * A bucket is a pipeline state, and the third field is the only thing a {@link ShadeDrawSide}
+ * still says about one: whether it culls at all. `Front` and `Back` land in the same bucket —
+ * a back-sided material is a front-sided one whose winding the vertex shader reverses — so a
+ * scene that mixes them draws in one pass, through one expansion chain.
+ *
+ * @see TransparencyMode
+ * @see ShadeDrawMode
+ * @see rasterization_material_bucket
+ * @type {CodeChunk}
+ */
+export const chunk_rasterization_material_bucket = CodeChunk.from(
+    //language=WGSL
+    `
+fn rasterization_material_bucket( alpha_mode: u32, draw_mode: u32, side: u32 ) -> u32{
+    let double_sided = u32( side == ${ShadeDrawSide.Double}u );
+
+    return ( ( alpha_mode & ${mask_alpha} ) << ${shift_alpha} )
+         | ( ( draw_mode & ${mask_primitive} ) << ${shift_primitive} )
+         | ( double_sided << ${shift_double_sided} );
+}
+    `
+);
+
+/**
+ * @see chunk_rasterization_material_bucket
+ * @param {number|TransparencyMode} alpha_mode
+ * @param {number|ShadeDrawMode} draw_mode
+ * @param {number|ShadeDrawSide} side
+ * @return {number}
+ */
+export function rasterization_material_bucket(alpha_mode, draw_mode, side) {
+    assert.enum(alpha_mode, TransparencyMode);
+    assert.enum(draw_mode, ShadeDrawMode);
+    assert.enum(side, ShadeDrawSide);
+
+    const double_sided = side === ShadeDrawSide.Double ? 1 : 0;
+
+    return ((alpha_mode & mask_alpha) << shift_alpha)
+        | ((draw_mode & mask_primitive) << shift_primitive)
+        | (double_sided << shift_double_sided);
+}

package/src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_meshlets_rasterize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH;IAX+B,KAAK;IACD,IAAI;IACZ,cAAc,EAA9B,MAAM;IACU,KAAK,EAArB,MAAM;IACwB,eAAe;IAC1B,aAAa,GAAhC,MAAM,EAAE;IACW,QAAQ,GAA3B,MAAM,EAAE;IACiB,eAAe;IACtB,aAAa,GAA/B,OAAO;IACN,CAAC,KAAK,EAAC,MAAM,EAAE,KAAK,EAAC,MAAM,EAAE,CAAC,CA0IzC"}
+{"version":3,"file":"graph_meshlets_rasterize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH;IAX+B,KAAK;IACD,IAAI;IACZ,cAAc,EAA9B,MAAM;IACU,KAAK,EAArB,MAAM;IACwB,eAAe;IAC1B,aAAa,GAAhC,MAAM,EAAE;IACW,QAAQ,GAA3B,MAAM,EAAE;IACiB,eAAe;IACtB,aAAa,GAA/B,OAAO;IACN,CAAC,KAAK,EAAC,MAAM,EAAE,KAAK,EAAC,MAAM,EAAE,CAAC,CA2IzC"}

package/src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.js

@@ -117,6 +117,7 @@ export function graph_meshlets_rasterize({
                 meshlet_data: scene.geometries.meshlets.buffer_data,
                 meshlet_metadata: scene.geometries.meshlets.buffer_metadata,
                 geometries: geometry_context.buffer_metadata,
+                materials: scene.materials.metadata_table.buffer,
                 meshlets: input_meshlets,
             }
         });

package/src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_scene_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;GAUG;AACH;;;;;;;IAFa;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CAoJ3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAJ+B,KAAK;IACC,GAAG;IACA,MAAM;SA8C7C"}
+{"version":3,"file":"graph_rasterize_scene_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH;;;;;;;IAFa;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CA0I3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAJ+B,KAAK;IACC,GAAG;IACA,MAAM;SA8C7C"}

package/src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js

@@ -12,6 +12,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 } from "../bucket/construct_primitive_state.js";
+import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 import { graph_mesh_frustum_cull } from "../compute/graph_mesh_frustum_cull.js";
 import { graph_rasterize_meshes_alpha_tested } from "../native/graph_rasterize_meshes_alpha_tested.js";
 import { graph_extract_meshes_from_bucket } from "./graph_extract_meshes_from_bucket.js";
@@ -75,59 +76,49 @@ export function graph_rasterize_scene_fast_raw({
     // rasterize each active opaque bucket in a single pass, with no occlusion filtering
     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 gr_bucket_meshes = graph_extract_meshes_from_bucket({
-                graph,
-                buckets: gr_render_buckets,
-                bucket_id,
-                limits,
-            });
-
-            let gr_bucket_meshlets = graph_expand_meshes_to_meshlets({
-                graph,
-                input_meshes: gr_bucket_meshes,
-                scene: scene_ctx,
-                expected_output_size: limits.compute_buffer_size(RasterizationCollectionType.Meshlets),
-                limits,
-            });
-
-            // the seam: this bucket's virtual-geometry instances select their cut and append it to
-            // the same collection, which is the whole of what the rest of this function is told
-            gr_bucket_meshlets = graph_vgeo_expand_if_enabled({
-                graph,
-                input_meshes: gr_bucket_meshes,
-                output_meshlets: gr_bucket_meshlets,
-                view: view_ctx,
-                limits,
-            });
-
-            graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, gr_bucket_meshlets);
-
-            const primitive_state = construct_primitive_state(draw_mode, side, job.cull_policy);
-
-            [target_depth, targets_color] = graph_meshlets_rasterize({
-                graph,
-                view: view_ctx,
-                input_meshlets: gr_bucket_meshlets,
-                depth: target_depth,
-                color_targets: targets_color,
-                pass_descriptor: job.opaque_pass,
-                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 gr_bucket_meshes = graph_extract_meshes_from_bucket({
+            graph,
+            buckets: gr_render_buckets,
+            bucket_id,
+            limits,
+        });
+
+        let gr_bucket_meshlets = graph_expand_meshes_to_meshlets({
+            graph,
+            input_meshes: gr_bucket_meshes,
+            scene: scene_ctx,
+            expected_output_size: limits.compute_buffer_size(RasterizationCollectionType.Meshlets),
+            limits,
+        });
+
+        // the seam: this bucket's virtual-geometry instances select their cut and append it to
+        // the same collection, which is the whole of what the rest of this function is told
+        gr_bucket_meshlets = graph_vgeo_expand_if_enabled({
+            graph,
+            input_meshes: gr_bucket_meshes,
+            output_meshlets: gr_bucket_meshlets,
+            view: view_ctx,
+            limits,
+        });
+
+        graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, gr_bucket_meshlets);
+
+        const primitive_state = construct_primitive_state(draw_mode, side, job.cull_policy);
+
+        [target_depth, targets_color] = graph_meshlets_rasterize({
+            graph,
+            view: view_ctx,
+            input_meshlets: gr_bucket_meshlets,
+            depth: target_depth,
+            color_targets: targets_color,
+            pass_descriptor: job.opaque_pass,
+            clear_targets: is_first_draw,
+            primitive_state,
+            viewport,
+        });
+
+        is_first_draw = false;
     }
 
     // alpha-tested: reuse the existing native pass but skip HZB filtering by passing hzb=-1

package/src/shade/renderer/rasterize/forward/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/forward/chunk_forward_shade_standard_fragment_brick4.js"],"names":[],"mappings":"AA4BA,qEAwJC;0BA3JyB,oCAAoC"}
+{"version":3,"file":"chunk_forward_shade_standard_fragment_brick4.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment_brick4.js"],"names":[],"mappings":"AA6BA,qEA2JC;0BA9JyB,oCAAoC"}

package/src/shade/renderer/rasterize/forward/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_material_draw_side } from "../../material/chunk_material_draw_side.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 {
@@ -38,8 +39,10 @@ fn forward_shade_standard_fragment(
     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, 
-    if(!front_facing) {
+    // flip the normal when looking at the surface's back. The raw front_facing cannot say:
+    // a back-sided material emits its winding reversed on purpose, so its "front" faces
+    // are the surface's back.
+    if(!material_fragment_faces_front(front_facing, material_info.draw_side)) {
         world_shading_normal = -world_shading_normal;
     }
     
@@ -177,5 +180,6 @@ fn forward_shade_standard_fragment(
         chunk_compute_indirect_specular,
         chunk_brick4_sample_forward_indirect,
         chunk_compute_specular_occlusion,
+        chunk_material_draw_side,
     ]
 )

package/src/shade/renderer/rasterize/forward/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/forward/chunk_forward_shade_standard_fragment_ibl.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,kEA6IC;0BApJyB,oCAAoC"}
+{"version":3,"file":"chunk_forward_shade_standard_fragment_ibl.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment_ibl.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,kEAgJC;0BAvJyB,oCAAoC"}

package/src/shade/renderer/rasterize/forward/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_material_draw_side } from "../../material/chunk_material_draw_side.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";
@@ -41,8 +42,10 @@ fn forward_shade_standard_fragment(
     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, 
-    if(!front_facing) {
+    // flip the normal when looking at the surface's back. The raw front_facing cannot say:
+    // a back-sided material emits its winding reversed on purpose, so its "front" faces
+    // are the surface's back.
+    if(!material_fragment_faces_front(front_facing, material_info.draw_side)) {
         world_shading_normal = -world_shading_normal;
     }
     
@@ -169,5 +172,6 @@ fn forward_shade_standard_fragment(
         chunk_get_ibl_radiance,
         chunk_get_ibl_irradiance,
         chunk_compute_specular_occlusion,
+        chunk_material_draw_side,
     ]
 )

package/src/shade/renderer/rasterize/forward/vertex_shader_chunk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertex_shader_chunk.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/vertex_shader_chunk.js"],"names":[],"mappings":"AAUA,4CAoDE;0BAvDwB,oCAAoC"}
+{"version":3,"file":"vertex_shader_chunk.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/vertex_shader_chunk.js"],"names":[],"mappings":"AAeA,4CAgEE;0BAnEwB,oCAAoC"}

package/src/shade/renderer/rasterize/forward/vertex_shader_chunk.js

@@ -1,7 +1,12 @@
+import { chunk_triangle_winding_is_reversed } from "../chunk_triangle_winding_is_reversed.js";
+import { chunk_node3d_flags } from "../../scene/chunk_node3d_flags.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
 import {
     chunk_compute_normal_matrix_from_m4
 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import {
+    chunk_triangle_list_reverse_winding
+} from "../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
 import {
     chunk_read_meshlet_vertex_by_draw_index
 } from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
@@ -26,9 +31,16 @@ fn main(
     let mesh = scene_read_mesh(&scene_database, meshlet_def.mesh);
     let node = scene_read_node(&scene_database, mesh.node);
 
+    // the tangent frame's handedness turns on the reflection alone: looking at a surface's back
+    // does not change which way its +V runs, and a back-sided material is only a way of looking
+    let is_mirrored = node3d_global_is_mirrored(node);
+
     let geo_vertex = read_meshlet_vertex_by_draw_index(
         meshlet_header,
-        meshlet_vertex_id,
+        triangle_list_reverse_winding(
+            meshlet_vertex_id,
+            triangle_winding_is_reversed(node, material_info.draw_side)
+        ),
     );
 
     let instance_matrix = node.global;
@@ -47,7 +59,9 @@ fn main(
     output.normal = normalize(normal_model_matrix * geo_vertex.normal);
 
     let geometry_tangent = geo_vertex.tangent;
-    let world_tangent = vec4( normalize( normal_model_matrix * geometry_tangent.xyz ), geometry_tangent.w );
+    // a reflection changes the tangent frame's handedness — see NODE3D_GLOBAL_FLAG_MIRRORED
+    let tangent_handedness = select(geometry_tangent.w, -geometry_tangent.w, is_mirrored);
+    let world_tangent = vec4( normalize( normal_model_matrix * geometry_tangent.xyz ), tangent_handedness );
     output.tangent = world_tangent;
 
     output.color = geo_vertex.color * material_info.albedo_color.rgb;
@@ -59,5 +73,8 @@ fn main(
         chunk_compute_normal_matrix_from_m4,
         chunk_read_meshlet_vertex_by_draw_index,
         chunk_scene_database_access,
+        chunk_node3d_flags,
+        chunk_triangle_winding_is_reversed,
+        chunk_triangle_list_reverse_winding,
     ]
 );