@woosh/meep-engine 3.60.7 → 3.60.9

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

@@ -20,7 +20,7 @@ import {
     chunk_read_meshlet_triangle_vertices
 } from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_vertices.js";
 import {
-    chunk_anti_alias_roughness_kaplanyan
+    chunk_anti_alias_roughness_kaplanyan_footprint
 } from "../../shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js";
 import {
     chunk_build_orthonormal_matrix_nt
@@ -69,15 +69,26 @@ export const g_buffer_viz_resources = new ShaderResourceGroupDescriptor();
 
 g_buffer_viz_resources.label = "viz buffer";
 
-g_buffer_viz_resources
-    .addTexture("viz_buffer_triangle", "uint")
-    .addTexture("viz_buffer_mesh", "uint")
-    .addUniform("view", VIEW_UNIFORM_STRUCT)
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-;
+add_g_buffer_viz_resources(g_buffer_viz_resources);
 
 g_buffer_viz_resources.addVisibility(GPUShaderStage.FRAGMENT);
 
+/**
+ * Declare in `group` what {@link build_gbuffer_laydown} reads of the visibility buffer and the
+ * view that drew it: the first four bindings of group 1, under the names the body reads them by.
+ *
+ * @param {ShaderResourceGroupDescriptor} group
+ * @returns {ShaderResourceGroupDescriptor} `group`
+ */
+export function add_g_buffer_viz_resources(group) {
+    return group
+        .addTexture("viz_buffer_triangle", "uint")
+        .addTexture("viz_buffer_mesh", "uint")
+        .addUniform("view", VIEW_UNIFORM_STRUCT)
+        .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+        ;
+}
+
 /**
  * Group 2 of every material's G-buffer pipeline: what the body pulls vertices from.
  *
@@ -123,18 +134,30 @@ export function build_gbuffer_shader_resources(material_group) {
 export const g_buffer_shader_resources = build_gbuffer_shader_resources(SHADING_MATERIAL_RESOURCE_GROUP);
 
 /**
- * Assemble the viz-buffer → G-buffer fragment shader body around a template's surface function.
- * Everything else — vertex pulling, perspective-correct barycentric derivatives, normal frame
- * construction, roughness AA, G-buffer encoding — is shared verbatim between templates, so it can
- * only evolve in one place.
+ * The viz-buffer → G-buffer laydown of one pixel, around a template's surface function. Everything
+ * else — vertex pulling, perspective-correct barycentric derivatives, normal frame construction,
+ * roughness AA, G-buffer encoding — is shared verbatim between templates and between every entry
+ * point that runs it, so it can only evolve in one place.
+ *
+ * Reconstructs the {@link chunk_material_surface_contract} input from the visibility buffer and
+ * calls `material_surface` once; what comes back is anti-aliased, dithered and encoded here.
+ *
+ * ```wgsl
+ * fn gbuffer_laydown(coord: vec2<f32>) -> GBufferOutput
+ * ```
  *
- * The body reconstructs the {@link chunk_material_surface_contract} input from the visibility buffer
- * and calls `material_surface` once; what comes back is anti-aliased, dithered and encoded here.
+ * `coord` is the pixel's centre in framebuffer coordinates — what a fragment's `position` holds.
+ *
+ * Every derivative it takes is analytic, from the barycentrics, except one: the specular
+ * anti-aliasing footprint, `fwidth` of the normal-mapped normal. That one the entry point supplies,
+ * by `derivatives`.
  *
  * @param {CodeChunk} surface defines `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`
+ * @param {CodeChunk} derivatives defines `fn gbuffer_fwidth(v: vec2<f32>) -> vec2<f32>`, `fwidth` as
+ *   the stage can take it — {@link chunk_gbuffer_fwidth_fragment} in a fragment shader
  * @returns {CodeChunk}
  */
-export function build_gbuffer_fragment_body(surface) {
+export function build_gbuffer_laydown(surface, derivatives) {
     return CodeChunk.from(
 // language=WGSL
         `
@@ -145,18 +168,14 @@ struct GBufferOutput {
   @location(3) emissive : u32,
 }
 
-// this is a multiplies applies to gradients before invoking texture sampling
-
-
-@fragment
-fn main(
-  @builtin(position) coord : vec4<f32>,
+fn gbuffer_laydown(
+  coord : vec2<f32>,
 ) -> GBufferOutput {
     var output : GBufferOutput;
 
     let encoded_meshlet_triangle = textureLoad(
         viz_buffer_triangle,
-        vec2<i32>(coord.xy),
+        vec2<i32>(coord),
         0
     ).r;
 
@@ -166,7 +185,7 @@ fn main(
 
     let mesh_index = textureLoad(
         viz_buffer_mesh,
-        vec2<i32>(coord.xy),
+        vec2<i32>(coord),
         0
     ).r;
 
@@ -211,7 +230,7 @@ fn main(
         projected_vertex_position_0,
         projected_vertex_position_1,
         projected_vertex_position_2,
-        coord.xy
+        coord
     );
 
     let position_ws = interpolate_attribute_3f32(
@@ -317,18 +336,21 @@ fn main(
     surface_input.face_normal_ws = world_face_normal;
     surface_input.view_direction_ws = view_direction;
     surface_input.vertex_color = geometry_color;
-    surface_input.pixel = coord.xy;
+    surface_input.pixel = coord;
 
     let surface = material_surface(surface_input);
 
     // transform_global normal
     let world_shading_normal:vec3<f32> = normalize( world_tangent_frame * surface.normal );
 
-    // let's filter rougness based on local normals
-    let filtered_roughness = anti_alias_roughness_kaplanyan(surface.roughness, world_shading_normal, world_tangent_frame[0], world_tangent_frame[1]);
+    // let's filter rougness based on local normals, over the footprint the stage measures
+    let filtered_roughness = anti_alias_roughness_kaplanyan_footprint(
+        surface.roughness,
+        gbuffer_fwidth(kaplanyan_plane_half_vector(world_shading_normal, world_tangent_frame[0], world_tangent_frame[1]))
+    );
 
     // apply dither
-    let output_roughness = filtered_roughness + dither_color_8bit_triangle_noise(coord.xy);
+    let output_roughness = filtered_roughness + dither_color_8bit_triangle_noise(coord);
 
     output.albedo = vec4<f32>(
         surface.albedo,
@@ -347,6 +369,7 @@ fn main(
     return output;
 }`, [
         surface,
+        derivatives,
         chunk_material_surface_contract,
 
         chunk_mat4_extract_position,
@@ -359,7 +382,7 @@ fn main(
 
         chunk_barycentric_interpolate_uv,
         chunk_compute_normal_matrix_from_m4,
-        chunk_anti_alias_roughness_kaplanyan,
+        chunk_anti_alias_roughness_kaplanyan_footprint,
         chunk_build_orthonormal_matrix_nt,
         chunk_read_meshlet_triangle_vertices,
         chunk_decode_meshlet_element,
@@ -367,12 +390,48 @@ fn main(
         chunk_rgbe9995_encode,
         chunk_dither_color_8bit_triangle_noise,
         chunk_scene_database_access,
-        chunk_node3d_flags,
+        chunk_node3d_flags,
         chunk_view_mip_bias,
     ]
     );
 }
 
+/**
+ * `fn gbuffer_fwidth(v: vec2<f32>) -> vec2<f32>` for {@link build_gbuffer_laydown} in a fragment
+ * shader: the fragment's own `fwidth`, across its quad.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_gbuffer_fwidth_fragment = CodeChunk.from(
+// language=WGSL
+    `
+fn gbuffer_fwidth(v: vec2<f32>) -> vec2<f32> {
+    return fwidth(v);
+}
+`);
+
+/**
+ * The fragment entry of a template's G-buffer pipeline: {@link build_gbuffer_laydown} at the
+ * fragment's own pixel, which the material-depth mask has already narrowed to the material's.
+ *
+ * @param {CodeChunk} surface defines `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`
+ * @returns {CodeChunk}
+ */
+export function build_gbuffer_fragment_body(surface) {
+    return CodeChunk.from(
+// language=WGSL
+        `
+@fragment
+fn main(
+  @builtin(position) coord : vec4<f32>,
+) -> GBufferOutput {
+    return gbuffer_laydown(coord.xy);
+}`, [
+        build_gbuffer_laydown(surface, chunk_gbuffer_fwidth_fragment),
+    ]
+    );
+}
+
 /**
  * The G-buffer pipeline of a template: its group 0 and surface function around the shared body,
  * after the shared binding-free vertex stage.

package/src/shade/renderer/material/template/ShadeMaterialTemplate.d.ts

@@ -11,7 +11,10 @@
  * material built on it serves the G-buffer pass and both alpha-tested passes. Groups 1 and 2 belong
  * to the passes, so a template must not reuse their names (`viz_buffer_triangle`, `viz_buffer_mesh`,
  * `view`, `camera`, `scene_database`, `geometries`, `meshlets`, `meshlet_metadata`, `meshlet_data`,
- * `materials`, `t_noise`).
+ * `materials`, `t_noise`) — nor those of the experimental compute material dispatch, which
+ * assembles a laydown of its own around {@link gbuffer_surface} (`material_quads`, `g_buffer_pbr`,
+ * `g_buffer_normal`, `g_buffer_albedo`, `g_buffer_emissive`, `material_dispatch`,
+ * `material_dispatch_places`).
  *
  * **The surface function** — `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`,
  * see {@link chunk_material_surface_contract} — is all a template contributes to the G-buffer pass.
@@ -101,6 +104,15 @@ export class ShadeMaterialTemplate {
      * @returns {RenderPipelineDescriptor}
      */
     gbuffer_pipeline_descriptor(services: GPUMaterialServices): RenderPipelineDescriptor;
+    /**
+     * The surface function the template's G-buffer laydown runs, for a pass that assembles a
+     * laydown of its own around it — {@link surface}, unless the template builds one from what the
+     * services carry.
+     *
+     * @param {GPUMaterialServices} services
+     * @returns {CodeChunk} defines `material_surface`
+     */
+    gbuffer_surface(services: GPUMaterialServices): CodeChunk;
     /**
      * Once, when the material's context is created and before its uniform is written: obtain what
      * the bind group will name, and upload anything the template owns, so the first bind group

package/src/shade/renderer/material/template/ShadeMaterialTemplate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeMaterialTemplate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/template/ShadeMaterialTemplate.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAqEI;;;;;;;;;OASG;IACH;QAR2B,IAAI,EAApB,MAAM;QACiC,SAAS,EAAhD,6BAA6B;QACL,OAAO,EAA/B,SAAS,GAAC,IAAI;QACY,YAAY,GAAtC,UAAU,GAAC,IAAI;QACU,OAAO,GAAhC,SAAS,GAAC,IAAI;QACI,OAAO,GAAzB,OAAO;QACW,OAAO,GAAzB,OAAO;OAwBjB;IApGD;;;;;;OAMG;IACH,kBAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,MAFU,MAAM,CAEX;IAEL;;;;OAIG;IACH,WAFU,6BAA6B,CAE7B;IAEV;;;;;;;OAOG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;;;OAKG;IACH,SAFU,SAAS,GAAC,IAAI,CAEhB;IAER;;;;OAIG;IACH,SAFU,SAAS,GAAC,IAAI,CAET;IAEf;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAyChB;;;;;OAKG;IACH,sCAHW,mBAAmB,GACjB,wBAAwB,CAcpC;IAED;;;;;;;OAOG;IACH,WAHW,kBAAkB,YAClB,mBAAmB,QAG7B;IAED;;;;;;;;OAQG;IACH,wBANW,aAAa,uBAQvB;IAED;;;;;;;OAOG;IACH,yBAHW,aAAa,OAKvB;IAED;;;;;;OAMG;IACH,uBANW,kBAAkB,wCAGlB,mBAAmB,gBAK7B;IAED;;;;;;;OAOG;IACH,YALW,kBAAkB,YAClB,mBAAmB,GACjB,OAAO,CAKnB;IAED;;;;;OAKG;IACH,aAHW,kBAAkB,YAClB,mBAAmB,QAG7B;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;uCA9NY,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;4CACtD,OAAO,wDAAwD,EAAE,6BAA6B;yBAC9F,OAAO,iCAAiC,EAAE,UAAU;iCACpD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;kCAC3C,OAAO,0BAA0B,EAAE,mBAAmB"}
+{"version":3,"file":"ShadeMaterialTemplate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/template/ShadeMaterialTemplate.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAqEI;;;;;;;;;OASG;IACH;QAR2B,IAAI,EAApB,MAAM;QACiC,SAAS,EAAhD,6BAA6B;QACL,OAAO,EAA/B,SAAS,GAAC,IAAI;QACY,YAAY,GAAtC,UAAU,GAAC,IAAI;QACU,OAAO,GAAhC,SAAS,GAAC,IAAI;QACI,OAAO,GAAzB,OAAO;QACW,OAAO,GAAzB,OAAO;OAwBjB;IApGD;;;;;;OAMG;IACH,kBAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,MAFU,MAAM,CAEX;IAEL;;;;OAIG;IACH,WAFU,6BAA6B,CAE7B;IAEV;;;;;;;OAOG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;;;OAKG;IACH,SAFU,SAAS,GAAC,IAAI,CAEhB;IAER;;;;OAIG;IACH,SAFU,SAAS,GAAC,IAAI,CAET;IAEf;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAyChB;;;;;OAKG;IACH,sCAHW,mBAAmB,GACjB,wBAAwB,CAcpC;IAED;;;;;;;OAOG;IACH,0BAHW,mBAAmB,GACjB,SAAS,CAMrB;IAED;;;;;;;OAOG;IACH,WAHW,kBAAkB,YAClB,mBAAmB,QAG7B;IAED;;;;;;;;OAQG;IACH,wBANW,aAAa,uBAQvB;IAED;;;;;;;OAOG;IACH,yBAHW,aAAa,OAKvB;IAED;;;;;;OAMG;IACH,uBANW,kBAAkB,wCAGlB,mBAAmB,gBAK7B;IAED;;;;;;;OAOG;IACH,YALW,kBAAkB,YAClB,mBAAmB,GACjB,OAAO,CAKnB;IAED;;;;;OAKG;IACH,aAHW,kBAAkB,YAClB,mBAAmB,QAG7B;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;uCA/OY,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;4CACtD,OAAO,wDAAwD,EAAE,6BAA6B;yBAC9F,OAAO,iCAAiC,EAAE,UAAU;iCACpD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;kCAC3C,OAAO,0BAA0B,EAAE,mBAAmB"}

package/src/shade/renderer/material/template/ShadeMaterialTemplate.js

@@ -27,7 +27,10 @@ let ordinal_counter = 0;
  * material built on it serves the G-buffer pass and both alpha-tested passes. Groups 1 and 2 belong
  * to the passes, so a template must not reuse their names (`viz_buffer_triangle`, `viz_buffer_mesh`,
  * `view`, `camera`, `scene_database`, `geometries`, `meshlets`, `meshlet_metadata`, `meshlet_data`,
- * `materials`, `t_noise`).
+ * `materials`, `t_noise`) — nor those of the experimental compute material dispatch, which
+ * assembles a laydown of its own around {@link gbuffer_surface} (`material_quads`, `g_buffer_pbr`,
+ * `g_buffer_normal`, `g_buffer_albedo`, `g_buffer_emissive`, `material_dispatch`,
+ * `material_dispatch_places`).
  *
  * **The surface function** — `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`,
  * see {@link chunk_material_surface_contract} — is all a template contributes to the G-buffer pass.
@@ -158,6 +161,20 @@ export class ShadeMaterialTemplate {
         return this.#gbuffer_pipeline_descriptor;
     }
 
+    /**
+     * The surface function the template's G-buffer laydown runs, for a pass that assembles a
+     * laydown of its own around it — {@link surface}, unless the template builds one from what the
+     * services carry.
+     *
+     * @param {GPUMaterialServices} services
+     * @returns {CodeChunk} defines `material_surface`
+     */
+    gbuffer_surface(services) {
+        assert.notNull(this.surface, `template '${this.name}' has no surface function`);
+
+        return this.surface;
+    }
+
     /**
      * Once, when the material's context is created and before its uniform is written: obtain what
      * the bind group will name, and upload anything the template owns, so the first bind group

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

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

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

@@ -155,6 +155,12 @@ export class GPUSceneContext {
      * dataset ({@link Scene.dataset}) before this is first asked for, because the rows are written
      * from that dataset's components.
      *
+     * The rows are the entities of the dataset the scene names when they are asked for. Once it
+     * names another, the next ask moves them there — the same rows, taking the next dataset's
+     * entities — and every holder must have let go of the last dataset's by then: their ids are
+     * the next one's too. While the scene names none, the rows stay the last dataset's, which is
+     * what its holders let go of.
+     *
      * @returns {GPUSceneRows}
      */
     get rows(): GPUSceneRows;

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":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA2KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IArND;;;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;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA0ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;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;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA91BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,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;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;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;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAx2BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,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;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}

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

@@ -235,7 +235,8 @@ export class GPUSceneContext {
 
     /**
      * Entities as rows of {@link scene_database} — see {@link rows}. Built the first time it is
-     * asked for, which needs the scene to name its dataset by then.
+     * asked for, which needs the scene to name its dataset by then, and moved to whichever dataset
+     * the scene names after.
      *
      * @type {GPUSceneRows|null}
      */
@@ -547,6 +548,12 @@ export class GPUSceneContext {
      * dataset ({@link Scene.dataset}) before this is first asked for, because the rows are written
      * from that dataset's components.
      *
+     * The rows are the entities of the dataset the scene names when they are asked for. Once it
+     * names another, the next ask moves them there — the same rows, taking the next dataset's
+     * entities — and every holder must have let go of the last dataset's by then: their ids are
+     * the next one's too. While the scene names none, the rows stay the last dataset's, which is
+     * what its holders let go of.
+     *
      * @returns {GPUSceneRows}
      */
     get rows() {
@@ -588,9 +595,10 @@ export class GPUSceneContext {
      * @returns {GPUSceneRows}
      */
     #obtain_rows() {
-        if (this.#rows === null) {
-            const dataset = this.#scene.dataset;
+        const dataset = this.#scene.dataset;
+        const rows = this.#rows;
 
+        if (rows === null) {
             assert.notNull(dataset, 'the scene names no dataset — set Scene.dataset before asking for its rows');
             assert.defined(dataset, 'the scene names no dataset — set Scene.dataset before asking for its rows');
 
@@ -603,6 +611,8 @@ export class GPUSceneContext {
                 tlas: this.#tlas,
                 skinning: () => this.skinning,
             });
+        } else if (dataset !== rows.dataset && dataset !== null && dataset !== undefined) {
+            rows.bind(dataset);
         }
 
         return this.#rows;
@@ -621,10 +631,10 @@ export class GPUSceneContext {
             this.#root_written = true;
         }
 
-        // Entities are rows — marked by the systems that place them, written here. Built on demand
-        // because the scene may name its dataset after this context was made.
-        if (this.#rows === null && this.#scene.dataset !== null && this.#scene.dataset !== undefined) {
-            this.rows;
+        // Entities are rows — marked by the systems that place them, written here. Obtained on demand
+        // because the scene may name its dataset, or another one, after this context was made.
+        if (this.#scene.dataset !== null && this.#scene.dataset !== undefined) {
+            this.#obtain_rows();
         }
 
         if (this.#rows !== null) {

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

@@ -12,9 +12,10 @@
  */
 export class Scene {
     /**
-     * The dataset whose entities are this scene's rows. A scene is bound to one dataset; whoever
-     * owns both names it here, before anything asks the scene's GPU context for its rows. Null
-     * for a scene that draws nothing.
+     * The dataset whose entities are this scene's rows, one at a time. Whoever owns both names it
+     * here, before anything asks the scene's GPU context for its rows. Naming another moves the
+     * rows to it at the context's next ask, once everything placed from the last one has been let
+     * go: entity ids repeat across datasets. Null for a scene that draws nothing, and between two.
      *
      * @type {EntityComponentDataset|null}
      */

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

@@ -1 +1 @@
-{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Scene.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;OAMG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IAEf;;;;;OAKG;IACH,QAFU,eAAe,CAEM;IAE/B;;;OAGG;IACH,oBAFU,gBAAgB,CAEkB;IAE5C;;;OAGG;IACH,aAFU,gBAAgB,CAEW;IAGzC;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;qCAzCY,OAAO,+CAA+C,EAAE,sBAAsB;gCAJ3D,6BAA6B;iCAD5B,gDAAgD;iCAEhD,oCAAoC"}
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/Scene.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IACI;;;;;;;OAOG;IACH,SAFU,sBAAsB,GAAC,IAAI,CAEtB;IAEf;;;;;OAKG;IACH,QAFU,eAAe,CAEM;IAE/B;;;OAGG;IACH,oBAFU,gBAAgB,CAEkB;IAE5C;;;OAGG;IACH,aAFU,gBAAgB,CAEW;IAGzC;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;qCA1CY,OAAO,+CAA+C,EAAE,sBAAsB;gCAJ3D,6BAA6B;iCAD5B,gDAAgD;iCAEhD,oCAAoC"}

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

@@ -1,53 +1,54 @@
-import { LightProbeVolume } from "../global_illumination/lpv/LightProbeVolume.js";
-import { LightCollection } from "../light/LightCollection.js";
-import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
-
-/**
- * @typedef {import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
- */
-
-/**
- * A scene: the dataset whose entities are what it draws and poses, and the three things that are
- * not entities — its lights' collection, a light probe volume, volumetrics.
- *
- * Everything drawn is an entity of {@link dataset} holding a row of the scene's GPU database
- * (`GPUSceneContext.rows`), at `entity + 1`. A game's systems take rows as components appear; a
- * scene with no systems places a model with `prefab_place`, a primitive with `place_primitive`
- * and a light with `place_light`. Nothing is added to the scene itself.
- */
-export class Scene {
-    /**
-     * The dataset whose entities are this scene's rows. A scene is bound to one dataset; whoever
-     * owns both names it here, before anything asks the scene's GPU context for its rows. Null
-     * for a scene that draws nothing.
-     *
-     * @type {EntityComponentDataset|null}
-     */
-    dataset = null;
-
-    /**
-     * Each light at an entity of {@link dataset} — `lights.add(light, entity)`, or `place_light`
-     * for a caller with no entity of its own.
-     *
-     * @type {LightCollection}
-     */
-    lights = new LightCollection();
-
-    /**
-     *
-     * @type {LightProbeVolume}
-     */
-    light_probe_volume = new LightProbeVolume();
-
-    /**
-     *
-     * @type {SceneVolumetrics}
-     */
-    volumetrics = new SceneVolumetrics();
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-Scene.prototype.isScene = true;
+import { LightProbeVolume } from "../global_illumination/lpv/LightProbeVolume.js";
+import { LightCollection } from "../light/LightCollection.js";
+import { SceneVolumetrics } from "../volumetrics/SceneVolumetrics.js";
+
+/**
+ * @typedef {import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ */
+
+/**
+ * A scene: the dataset whose entities are what it draws and poses, and the three things that are
+ * not entities — its lights' collection, a light probe volume, volumetrics.
+ *
+ * Everything drawn is an entity of {@link dataset} holding a row of the scene's GPU database
+ * (`GPUSceneContext.rows`), at `entity + 1`. A game's systems take rows as components appear; a
+ * scene with no systems places a model with `prefab_place`, a primitive with `place_primitive`
+ * and a light with `place_light`. Nothing is added to the scene itself.
+ */
+export class Scene {
+    /**
+     * The dataset whose entities are this scene's rows, one at a time. Whoever owns both names it
+     * here, before anything asks the scene's GPU context for its rows. Naming another moves the
+     * rows to it at the context's next ask, once everything placed from the last one has been let
+     * go: entity ids repeat across datasets. Null for a scene that draws nothing, and between two.
+     *
+     * @type {EntityComponentDataset|null}
+     */
+    dataset = null;
+
+    /**
+     * Each light at an entity of {@link dataset} — `lights.add(light, entity)`, or `place_light`
+     * for a caller with no entity of its own.
+     *
+     * @type {LightCollection}
+     */
+    lights = new LightCollection();
+
+    /**
+     *
+     * @type {LightProbeVolume}
+     */
+    light_probe_volume = new LightProbeVolume();
+
+    /**
+     *
+     * @type {SceneVolumetrics}
+     */
+    volumetrics = new SceneVolumetrics();
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Scene.prototype.isScene = true;

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

@@ -39,6 +39,9 @@ export function entity_of_row(row: number): number;
  * root, which is exact because the ECS composes every chain on the CPU regardless. A primitive
  * {@link attach_mesh}es and takes the `meshes` row of the same index.
  *
+ * **The entities are one dataset's at a time.** {@link bind} moves the rows to another once nothing
+ * of the last is held; the same object carries on, so whatever listens to it keeps listening.
+ *
  * **Change flow is mark, then flush.** The systems that place entities listen to the dataset's
  * change events and {@link mark_local} or {@link mark_world}; nothing is read at mark time. The
  * flush, in `GPUSceneContext.build`, reads each marked entity's components once, consults
@@ -81,9 +84,22 @@ export class GPUSceneRows {
         skinning: () => GPUMeshSkinningContext;
     });
     /**
+     * The dataset whose entities the rows are — see {@link bind}.
+     *
      * @returns {EntityComponentDataset}
      */
     get dataset(): import("../../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset;
+    /**
+     * Write the rows from another dataset's entities from now on.
+     *
+     * Only while nothing is held. Entity ids come out of each dataset's own pool, so a hold carried
+     * across would be the next dataset's entity of the same id — merged with its holds, and taking
+     * its row when released. Every holder lets go of the last dataset first, and the rows they gave
+     * back are already off the tables.
+     *
+     * @param {EntityComponentDataset} dataset
+     */
+    bind(dataset: EntityComponentDataset): void;
     /**
      * Bumped every time the `meshes` table gains or loses an entity's row. A row read and kept is
      * only as valid as this number.

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":"AAmBA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAqMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;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;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;;;;;;;OAWG;IACH,mBAA6B;IAE7B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,QAAE,MAAM,KAAG,IAAI,QASjF;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFW,MAAM,QA0ChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA4BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;OAaG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IA4BD;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oBANW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,cACP,OAAO,QAkDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAgOD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;;;;;OASG;IACH,gBAgBC;;CACJ;qCAjzCY,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":"AAmBA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAqMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;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;;;;OAIG;IACH,iGAEC;IAED;;;;;;;;;OASG;IACH,cAFW,sBAAsB,QAmBhC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;;;;;;;OAWG;IACH,mBAA6B;IAE7B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,QAAE,MAAM,KAAG,IAAI,QASjF;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFW,MAAM,QA0ChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA4BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;OAaG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IA4BD;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oBANW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,cACP,OAAO,QAkDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAgOD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;;;;;OASG;IACH,gBAgBC;;CACJ;qCAn1CY,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

@@ -260,6 +260,9 @@ function mesh_entry_flags(entry) {
  * root, which is exact because the ECS composes every chain on the CPU regardless. A primitive
  * {@link attach_mesh}es and takes the `meshes` row of the same index.
  *
+ * **The entities are one dataset's at a time.** {@link bind} moves the rows to another once nothing
+ * of the last is held; the same object carries on, so whatever listens to it keeps listening.
+ *
  * **Change flow is mark, then flush.** The systems that place entities listen to the dataset's
  * change events and {@link mark_local} or {@link mark_world}; nothing is read at mark time. The
  * flush, in `GPUSceneContext.build`, reads each marked entity's components once, consults
@@ -450,12 +453,43 @@ export class GPUSceneRows {
     }
 
     /**
+     * The dataset whose entities the rows are — see {@link bind}.
+     *
      * @returns {EntityComponentDataset}
      */
     get dataset() {
         return this.#dataset;
     }
 
+    /**
+     * Write the rows from another dataset's entities from now on.
+     *
+     * Only while nothing is held. Entity ids come out of each dataset's own pool, so a hold carried
+     * across would be the next dataset's entity of the same id — merged with its holds, and taking
+     * its row when released. Every holder lets go of the last dataset first, and the rows they gave
+     * back are already off the tables.
+     *
+     * @param {EntityComponentDataset} dataset
+     */
+    bind(dataset) {
+        assert.defined(dataset, 'dataset');
+        assert.equal(dataset.isEntityComponentDataset, true, 'dataset.isEntityComponentDataset !== true');
+
+        if (dataset === this.#dataset) {
+            return;
+        }
+
+        assert.equal(
+            this.#acquired.nextSetBit(0), -1,
+            'rows of the last dataset are still held — every holder lets go of it before the rows take the next'
+        );
+
+        // what is left are entities released since they were marked, which the flush would skip
+        this.#marked.length = 0;
+
+        this.#dataset = dataset;
+    }
+
     /**
      * Bumped every time the `meshes` table gains or loses an entity's row. A row read and kept is
      * only as valid as this number.

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

@@ -1,10 +1,29 @@
 /**
+ * Kaplanyan's roughness filtering, given the screen-space footprint of the plane-plane half vector
+ * rather than taking it — so a stage without implicit derivatives can hand in its own.
+ *
+ * ```wgsl
+ * fn kaplanyan_plane_half_vector(normal: vec3<f32>, tangent: vec3<f32>, bitangent: vec3<f32>) -> vec2<f32>
+ * fn anti_alias_roughness_kaplanyan_footprint(roughness: f32, footprint_bounding_box: vec2<f32>) -> f32
+ * ```
+ *
+ * `footprint_bounding_box` is `fwidth` of the half vector, as {@link chunk_anti_alias_roughness_kaplanyan}
+ * takes it.
+ *
  * @param sigma  screen space variance
  * @param Kappa  clamping treshold
  * @see "Filtering Distributions of Normals for Shading Antialiasing" by A.S. Kaplanyan et al (NVIDIA) 2016, Eurographics Proceedings
  * @see https://github.com/tksuoran/erhe/blob/57734a5ae170aa2a50c3068fe19ffc3a667c52d0/src/editor/res/shaders/circular_brushed_metal.frag#L53
  * @type {CodeChunk}
  */
+export const chunk_anti_alias_roughness_kaplanyan_footprint: CodeChunk;
+/**
+ * Kaplanyan's roughness filtering with the footprint from the fragment's own `fwidth` — fragment
+ * stage only.
+ *
+ * @see chunk_anti_alias_roughness_kaplanyan_footprint
+ * @type {CodeChunk}
+ */
 export const chunk_anti_alias_roughness_kaplanyan: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_anti_alias_roughness_kaplanyan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_anti_alias_roughness_kaplanyan.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,mDAFU,SAAS,CAoCf;0BA3CsB,gCAAgC"}
+{"version":3,"file":"chunk_anti_alias_roughness_kaplanyan.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,6DAFU,SAAS,CAoCf;AAEJ;;;;;;GAMG;AACH,mDAFU,SAAS,CAkBhB;0BA/EuB,gCAAgC"}