@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -11,11 +11,16 @@ import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescr
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
 import { BindGroupDescriptor } from "../binding/BindGroupDescriptor.js";
 import { GPUSingleTypeTable } from "../buffer/table/single/GPUSingleTypeTable.js";
-import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
 import { G_BUFFER_ALBEDO_FORMAT } from "../gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
+import { G_BUFFER_COLOR_TARGETS } from "../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { chunk_hash_table_get } from "../gpu_primitive/hash_table/chunk_hash_table_get.js";
 import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+    cpu_hash_table_create,
+    cpu_hash_table_word_count
+} from "../gpu_primitive/hash_table/cpu_build_hash_table.js";
+import { graph_import_raw_buffer } from "../shader/graph/graph_import_raw_buffer.js";
+import { MESHLET_COLLECTION_STRUCT } from "../rasterize/MESHLET_COLLECTION_STRUCT.js";
+import { chunk_visibility_decode } from "../rasterize/visibility/chunk_visibility_decode.js";
 import { chunk_scene_database_access } from "../scene/chunk_scene_database_access.js";
 import {
     chunk_subgroup_bitset_or,
@@ -32,6 +37,7 @@ import {
     MATERIAL_BIND_GROUP_SCENE_DATA,
     MATERIAL_BIND_GROUP_VIZ_BUFFER
 } from "./GPUMaterialContext.js";
+import { MATERIAL_MASK_FORMAT, MATERIAL_MASK_NONE } from "./MATERIAL_MASK.js";
 import { MATERIAL_METADATA_STRUCT } from "./MATERIAL_METADATA_STRUCT.js";
 import { PIXEL_TEXTURE_ORM } from "./PIXEL_TEXTURE_ORM.js";
 import { GPUMaterialServices, MaterialGPUDefaults } from "./template/GPUMaterialServices.js";
@@ -94,11 +100,34 @@ class DrawnMaterialLists {
     gbuffer_version = -1;
 
     /**
-     * One past the highest material id in {@link gbuffer}, 0 when it is empty.
+     * Each context of {@link gbuffer} at its place in it, keyed by material id: a
+     * {@link cpu_hash_table_create} table, for shaders that start from the material id of a mesh.
      *
-     * @type {number}
+     * @type {Uint32Array}
      */
-    gbuffer_id_bound = 0;
+    gbuffer_slots = new Uint32Array(0);
+}
+
+/**
+ * @param {GPUMaterialContext[]} contexts
+ * @returns {Uint32Array} a {@link cpu_hash_table_create} table from each context's material id to its
+ *   index in `contexts`
+ */
+function build_slot_table(contexts) {
+    const count = contexts.length;
+    const ids = new Array(count);
+
+    for (let i = 0; i < count; i++) {
+        ids[i] = contexts[i].material_id;
+    }
+
+    let table = new Uint32Array(cpu_hash_table_word_count(count));
+
+    while (!cpu_hash_table_create(table, ids, count)) {
+        table = new Uint32Array(table.length * 2);
+    }
+
+    return table;
 }
 
 /**
@@ -152,7 +181,11 @@ const MATERIAL_BUFFER_BIND_GROUP_0_LAYOUT_DESCRIPTOR = BindGroupLayoutDescriptor
                 sampleType: "uint"
             }
         },
-
+        {
+            binding: 1,
+            visibility: GPUShaderStage.FRAGMENT,
+            buffer: BufferBindingLayout.readOnlyStorage
+        },
     ]
 });
 
@@ -167,22 +200,31 @@ const MATERIAL_BUFFER_BIND_GROUP_1_LAYOUT_DESCRIPTOR = BindGroupLayoutDescriptor
             binding: 1,
             visibility: GPUShaderStage.FRAGMENT,
             buffer: BufferBindingLayout.storage
+        },
+        {
+            binding: 2,
+            visibility: GPUShaderStage.FRAGMENT,
+            buffer: BufferBindingLayout.readOnlyStorage
         }
     ]
 });
 
 /**
- * The material-depth pass's fragment stage: writes the material id of each pixel as its depth, for
- * the G-buffer pass to test against, and marks in `material_seen` every material that holds a pixel.
+ * The material-depth pass's fragment stage: writes, as its depth, the place in the G-buffer pass's
+ * list of the material that holds each pixel, for the G-buffer pass to test against, and marks that
+ * place in `material_seen`. A pixel of no mesh, or of a material the list leaves out, gets the
+ * cleared value and marks nothing.
  *
  * @type {CodeChunk}
  */
 const material_depth_fragment = CodeChunk.from(
     // language=WGSL
     `
-        @group(0) @binding(0) var mesh_texture: texture_2d<u32>;
+        @group(0) @binding(0) var visibility: texture_2d<u32>;
+        @group(0) @binding(1) var<storage, read> visible_meshlets: ${MESHLET_COLLECTION_STRUCT.wgsl_ref};
         @group(1) @binding(0) var<storage, read> scene_database: array<u32>;
         @group(1) @binding(1) var<storage, read_write> material_seen: array<atomic<u32>>;
+        @group(1) @binding(2) var<storage, read> material_slots: array<u32>;
 
         struct Outputs{
             @builtin(frag_depth) depth:f32,
@@ -195,34 +237,43 @@ const material_depth_fragment = CodeChunk.from(
 
             let pixel = vec2<u32>(coord.xy);
 
-            var material = ${SUBGROUP_BITSET_OR_NONE}u;
+            // a miss in the table is the bitset's "none" as well
+            var slot = ${SUBGROUP_BITSET_OR_NONE}u;
 
             // a helper invocation past the edge of the target holds no material, so it marks nothing
-            if(all(pixel < textureDimensions(mesh_texture))){
-                let mesh_id = textureLoad(
-                    mesh_texture,
+            if(all(pixel < textureDimensions(visibility))){
+                let encoded = textureLoad(
+                    visibility,
                     pixel,
                     0
                 ).r;
 
-                if(mesh_id != ${VIZ_BUFFER_INVALID_MESH_VALUE}){
-                    material = scene_read_mesh(&scene_database, mesh_id).material;
+                if(encoded != VISIBILITY_NONE){
+                    let material = scene_read_mesh(&scene_database, visibility_decode(encoded).mesh).material;
+
+                    slot = hash_table_get(&material_slots, 0u, material);
                 }
             }
 
-            // the G-buffer pass draws only the materials marked here
-            subgroup_bitset_or(&material_seen, material);
+            // the G-buffer pass draws only the places marked here
+            subgroup_bitset_or(&material_seen, slot);
 
-            if(material == ${SUBGROUP_BITSET_OR_NONE}u){
+            if(slot == ${SUBGROUP_BITSET_OR_NONE}u){
                 return Outputs(1.0);
             }
 
             return Outputs(
-                f32(material)/16777216
+                f32(slot) / ${MATERIAL_MASK_NONE}.0
             );
         }
     `,
-    [chunk_scene_database_access, chunk_subgroup_bitset_or]
+    [
+        chunk_scene_database_access,
+        chunk_subgroup_bitset_or,
+        chunk_hash_table_get,
+        MESHLET_COLLECTION_STRUCT.declaration_chunk,
+        chunk_visibility_decode
+    ]
 );
 
 /**
@@ -255,7 +306,7 @@ const material_buffer_pipeline_descriptor = RenderPipelineDescriptor.from({
         },
     },
     depthStencil: {
-        format: 'depth32float',
+        format: MATERIAL_MASK_FORMAT,
         depthWriteEnabled: true,
         depthCompare: "always",
         // disable stencil
@@ -456,22 +507,25 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} view
      * @param {GPUTextureContext} mesh_texture
      * @param {GPUTextureContext} material_depth_texture
-     * @param {GPUBufferBinding} material_seen zeroed, a bit per material id, set for each material
-     *   that holds a pixel
+     * @param {GPUBufferBinding} material_seen zeroed, a bit per place in the G-buffer pass's list, set
+     *   for each place whose material holds a pixel
+     * @param {GPUBuffer} material_slots the list's {@link gbuffer_slot_table}
      */
     #prepare_material_depth_buffer(
         encoder,
         view,
-        mesh_texture,
+        visibility,
+        visible_meshlets,
         material_depth_texture,
         material_seen,
+        material_slots,
     ) {
 
         const pass = encoder.beginRenderPass({
             label: "GPUMaterialManager/material-depth",
             colorAttachments: [],
             depthStencilAttachment: {
-                // we use very high value to indicate invalid material slot
+                // MATERIAL_MASK_NONE: no listed material
                 depthClearValue: 1,
                 view: material_depth_texture.obtainView(),
                 depthLoadOp: 'clear',
@@ -494,7 +548,8 @@ export class GPUMaterialManager {
         const bind_0 = bindings.obtain(BindGroupDescriptor.from(
             MATERIAL_BUFFER_BIND_GROUP_0_LAYOUT_DESCRIPTOR,
             [
-                mesh_texture.obtainView(),
+                visibility.obtainView(),
+                { buffer: visible_meshlets },
             ]
         ));
 
@@ -503,6 +558,7 @@ export class GPUMaterialManager {
             [
                 { buffer: view.scene.scene_database_buffer },
                 material_seen,
+                { buffer: material_slots },
             ]
         ));
 
@@ -519,22 +575,25 @@ export class GPUMaterialManager {
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {GPUViewContext} options.view
-     * @param {number} options.texture_viz_mesh
-     * @param {number} options.texture_viz_triangle
-     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
-     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
+     * @param {number} options.texture_visibility the visibility buffer
+     * @param {number} options.visible_meshlets the frame's visible-meshlet table, which resolves it
+     * @param {number} options.texture_pbr the PBR target to write, `G_BUFFER_COLOR_TARGETS[0].format` at
+     *   the view's resolution. The caller owns it so that it outlives the frame: reprojection reads last
+     *   frame's face normal from it.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
     graph_viz_render({
                          graph,
                          view,
-                         texture_viz_mesh,
-                         texture_viz_triangle,
-                         texture_normal,
+                         texture_visibility,
+                         visible_meshlets,
+                         texture_pbr,
                      }) {
 
         assert.defined(graph, 'graph');
-        assert.isNonNegativeInteger(texture_normal, 'texture_normal');
+        assert.isNonNegativeInteger(texture_visibility, 'texture_visibility');
+        assert.isNonNegativeInteger(visible_meshlets, 'visible_meshlets');
+        assert.isNonNegativeInteger(texture_pbr, 'texture_pbr');
         assert.defined(view, 'view');
 
         /**
@@ -545,8 +604,8 @@ export class GPUMaterialManager {
          */
         const execute = (data, resources, context) => {
 
-            const viz_mesh = resources.get(data.viz_mesh);
-            const viz_triangle = resources.get(data.viz_triangle);
+            const visibility = resources.get(data.visibility);
+            const visible_meshlets = resources.get(data.visible_meshlets);
 
             const g_pbr = resources.get(data.g_pbr);
             const g_normal = resources.get(data.g_normal);
@@ -572,9 +631,11 @@ export class GPUMaterialManager {
             this.#prepare_material_depth_buffer(
                 encoder,
                 view,
-                viz_mesh,
+                visibility,
+                visible_meshlets,
                 material_depth,
                 material_seen,
+                resources.get(data.material_slots),
             );
 
             const pass = encoder.beginRenderPass({
@@ -603,7 +664,7 @@ export class GPUMaterialManager {
                 ],
                 depthStencilAttachment: {
                     // this is our mask
-                    view: material_depth.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
+                    view: material_depth.obtainView(),
                     depthReadOnly: true,
                 },
                 primitive: {
@@ -617,8 +678,8 @@ export class GPUMaterialManager {
                 BindGroupDescriptor.from(
                     MATERIAL_BIND_GROUP_VIZ_BUFFER,
                     [
-                        viz_triangle.obtainView(),
-                        viz_mesh.obtainView(),
+                        visibility.obtainView(),
+                        { buffer: visible_meshlets },
                         { buffer: view.uniform_buffer.buffer },
                         { buffer: view.camera.buffer.buffer },
                         material_seen,
@@ -641,7 +702,8 @@ export class GPUMaterialManager {
             pass.setBindGroup(1, bind_1)
             pass.setBindGroup(2, bind_2)
 
-            const materials = this.#gbuffer_contexts(view.scene.drawn_materials);
+            // the list the mask was written from, not whatever the manager holds by now
+            const materials = data.contexts;
             const material_count = materials.length;
 
             let cached_last_pipeline = null;
@@ -663,9 +725,9 @@ export class GPUMaterialManager {
 
                 pass.setBindGroup(0, material_ctx.material_binding);
 
-                // the id rides in the instance index; a material with no pixel in the view draws a
-                // triangle of no area, see material_gbuffer_vertex_shader_code
-                pass.draw(3, 1, 0, material_ctx.material_id);
+                // the material's place rides in the instance index; a material with no pixel in the
+                // view draws a triangle of no area, see material_gbuffer_vertex_shader_code
+                pass.draw(3, 1, 0, i);
             }
 
             pass.end();
@@ -673,22 +735,41 @@ export class GPUMaterialManager {
             encoder.popDebugGroup();
         }
 
+        // The list and its slot table as they are now. Both are replaced rather than rewritten when
+        // the list changes, so the mask and the draws agree on every material's place even if a
+        // context joins before the pass runs.
+        const drawn = view.scene.drawn_materials;
+        const contexts = this.#gbuffer_contexts(drawn);
+        const slot_table = this.#lists_of(drawn).gbuffer_slots;
+
+        assert.lessThan(contexts.length, MATERIAL_MASK_NONE, 'G-buffer materials of one view');
+
+        // added ahead of the pass that reads it, as the graph runs passes in the order they are added
+        const gr_material_slots = graph_import_raw_buffer({
+            graph,
+            value: slot_table.buffer,
+            offset: slot_table.byteOffset,
+            size: slot_table.byteLength,
+            label: "material slots",
+            usage: GPUBufferUsage.STORAGE,
+        });
+
         const pass_data = {};
 
         const pass = graph.add('Material Draw', pass_data, execute);
 
-        pass_data.viz_mesh = pass.read(texture_viz_mesh);
-        pass_data.viz_triangle = pass.read(texture_viz_triangle);
+        pass_data.visibility = pass.read(texture_visibility);
+        pass_data.visible_meshlets = pass.read(visible_meshlets);
 
-        pass_data.g_pbr = pass.create(
-            "g-buffer / PBR",
+        pass_data.g_pbr = pass.write(texture_pbr);
+        pass_data.g_normal = pass.create(
+            "g-buffer / Normal",
             TextureResourceDescriptor.from({
-                format:"rg8unorm",
+                format: G_BUFFER_COLOR_TARGETS[1].format,
                 resolution: view.resolution,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
             })
         );
-        pass_data.g_normal = pass.write(texture_normal);
         pass_data.g_albedo = pass.create(
             "g-buffer / Albedo",
             TextureResourceDescriptor.from({
@@ -709,18 +790,17 @@ export class GPUMaterialManager {
         pass_data.material_depth = pass.create(
             'material depth texture',
             TextureResourceDescriptor.from({
-                format: 'depth32float',
+                format: MATERIAL_MASK_FORMAT,
                 resolution: view.resolution,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
             })
         );
 
-        // a bit for every id the list holds now; one that joins before the pass runs is past the end
-        // and drawn as though seen
-        this.#gbuffer_contexts(view.scene.drawn_materials);
+        pass_data.contexts = contexts;
+        pass_data.material_slots = pass.read(gr_material_slots);
 
-        const id_bound = this.#lists_of(view.scene.drawn_materials).gbuffer_id_bound;
-        const material_seen_words = Math.max(1, Math.ceil(id_bound / 32));
+        // a bit for every place in the list
+        const material_seen_words = Math.max(1, Math.ceil(contexts.length / 32));
 
         pass_data.material_seen_size = material_seen_words * 4;
         pass_data.material_seen = pass.create(
@@ -904,7 +984,9 @@ export class GPUMaterialManager {
     /**
      * The contexts the G-buffer pass draws for a scene's drawn materials: every one that is not
      * transparent and has a context, grouped by template, in the order {@link graph_viz_render} draws
-     * them. The array is kept and rebuilt in place — {@link gbuffer_contexts_version} says when.
+     * them. A material's index here is its place in the pass. The array is replaced, never
+     * rewritten, when the list changes — {@link gbuffer_contexts_version} says when — so one held
+     * across a change still names the places it was read with.
      *
      * @param {ShadeMaterial[]} drawn a scene's {@link GPUSceneContext#drawn_materials}
      * @returns {GPUMaterialContext[]}
@@ -913,6 +995,21 @@ export class GPUMaterialManager {
         return this.#gbuffer_contexts(drawn);
     }
 
+    /**
+     * Each of {@link gbuffer_contexts} at its place there, keyed by material id: a
+     * {@link cpu_hash_table_create} table, for a shader that starts from the material id of a mesh
+     * (read with `hash_table_get`, a miss for a material the pass does not draw). Replaced along with
+     * the list, so it always matches the array {@link gbuffer_contexts} returns at the same version.
+     *
+     * @param {ShadeMaterial[]} drawn a scene's {@link GPUSceneContext#drawn_materials}
+     * @returns {Uint32Array}
+     */
+    gbuffer_slot_table(drawn) {
+        this.#gbuffer_contexts(drawn);
+
+        return this.#lists_of(drawn).gbuffer_slots;
+    }
+
     /**
      * Moves whenever {@link gbuffer_contexts} may answer differently for the same drawn set.
      *
@@ -940,11 +1037,9 @@ export class GPUMaterialManager {
 
         if (lists.gbuffer_version !== this.#list_version) {
             const sorted = lists.sorted;
-            const contexts = lists.gbuffer;
 
-            contexts.length = 0;
-
-            let id_bound = 0;
+            // a new array, so a pass that captured the old one keeps the places it was recorded with
+            const contexts = [];
 
             for (let i = 0; i < sorted.length; i++) {
                 const material = sorted[i];
@@ -961,11 +1056,10 @@ export class GPUMaterialManager {
                 }
 
                 contexts.push(material_ctx);
-
-                id_bound = Math.max(id_bound, material_ctx.material_id + 1);
             }
 
-            lists.gbuffer_id_bound = id_bound;
+            lists.gbuffer = contexts;
+            lists.gbuffer_slots = build_slot_table(contexts);
             lists.gbuffer_version = this.#list_version;
         }
 

package/src/shade/renderer/material/MATERIAL_MASK.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Format of the G-buffer pass's material mask: a depth target holding, at each pixel, the place in
+ * the pass's list of the material the visibility buffer names there, as `place / MATERIAL_MASK_NONE`.
+ * A material's draw is a full-screen triangle at its own place's depth, tested `equal` against it.
+ *
+ * A place, not a material id: ids come from one counter for the life of the process and are never
+ * reused, so only a material's place in the list is bounded by what one pass can draw.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const MATERIAL_MASK_FORMAT: GPUTextureFormat;
+/**
+ * The mask's value where no listed material holds the pixel: the cleared depth, 1.0. Every place in
+ * the G-buffer pass's list is below it, so the list holds fewer materials than this.
+ *
+ * @type {number}
+ */
+export const MATERIAL_MASK_NONE: number;
+//# sourceMappingURL=MATERIAL_MASK.d.ts.map

package/src/shade/renderer/material/MATERIAL_MASK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MATERIAL_MASK.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/MATERIAL_MASK.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,oDAAmD;AAEnD;;;;;GAKG;AACH,iCAFU,MAAM,CAEwB"}

package/src/shade/renderer/material/MATERIAL_MASK.js

@@ -0,0 +1,19 @@
+/**
+ * Format of the G-buffer pass's material mask: a depth target holding, at each pixel, the place in
+ * the pass's list of the material the visibility buffer names there, as `place / MATERIAL_MASK_NONE`.
+ * A material's draw is a full-screen triangle at its own place's depth, tested `equal` against it.
+ *
+ * A place, not a material id: ids come from one counter for the life of the process and are never
+ * reused, so only a material's place in the list is bounded by what one pass can draw.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const MATERIAL_MASK_FORMAT = 'depth16unorm';
+
+/**
+ * The mask's value where no listed material holds the pixel: the cleared depth, 1.0. Every place in
+ * the G-buffer pass's list is below it, so the list holds fewer materials than this.
+ *
+ * @type {number}
+ */
+export const MATERIAL_MASK_NONE = 65535;

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.d.ts

@@ -33,18 +33,18 @@ export class GPUMaterialComputeDispatch {
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {GPUViewContext} options.view
-     * @param {number} options.texture_viz_mesh
-     * @param {number} options.texture_viz_triangle
-     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
-     *   resolution, with `STORAGE_BINDING`
+     * @param {number} options.texture_visibility the visibility buffer
+     * @param {number} options.visible_meshlets the frame's visible-meshlet table, which resolves it
+     * @param {number} options.texture_pbr the PBR target to write, `G_BUFFER_COLOR_TARGETS[0].format` at
+     *   the view's resolution, with `STORAGE_BINDING`
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}}
      */
-    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, texture_normal, }: {
+    graph_viz_render({ graph, view, texture_visibility, visible_meshlets, texture_pbr, }: {
         graph: FrameGraph;
         view: GPUViewContext;
-        texture_viz_mesh: number;
-        texture_viz_triangle: number;
-        texture_normal: number;
+        texture_visibility: number;
+        visible_meshlets: number;
+        texture_pbr: number;
     }): {
         g_pbr: number;
         g_normal: number;

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialComputeDispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;GAaG;AACH;IA8DI;;;;;;OAMG;IACH;QAL8B,MAAM;QACG,SAAS,EAArC,kBAAkB;QACc,iBAAiB,EAAjD,sBAAsB;QACI,QAAQ,EAAlC,gBAAgB;OAa1B;IAED;;;;;;;;;;;;OAYG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA0BnF;IAED;;;;;;OAMG;IACH,0BAFW,eAAe,QAazB;IAED,gBAOC;;CAqHJ;yBAlUY,OAAO,8DAA8D,EAAE,UAAU;wCACjF,OAAO,mEAAmE,EAAE,yBAAyB;qCACrG,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,6CAA6C,EAAE,eAAe;+BACrE,OAAO,mCAAmC,EAAE,gBAAgB;6BAC5D,OAAO,8BAA8B,EAAE,cAAc;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,sCAAsC,EAAE,qBAAqB"}
+{"version":3,"file":"GPUMaterialComputeDispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;GAaG;AACH;IAgDI;;;;;;OAMG;IACH;QAL8B,MAAM;QACG,SAAS,EAArC,kBAAkB;QACc,iBAAiB,EAAjD,sBAAsB;QACI,QAAQ,EAAlC,gBAAgB;OAa1B;IAED;;;;;;;;;;;;OAYG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,kBAAkB,EAAlC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACU,WAAW,EAA3B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA0BnF;IAED;;;;;;OAMG;IACH,0BAFW,eAAe,QAazB;IAED,gBAMC;;CAsEJ;yBArPY,OAAO,8DAA8D,EAAE,UAAU;wCACjF,OAAO,mEAAmE,EAAE,yBAAyB;qCACrG,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,6CAA6C,EAAE,eAAe;+BACrE,OAAO,mCAAmC,EAAE,gBAAgB;6BAC5D,OAAO,8BAA8B,EAAE,cAAc;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,sCAAsC,EAAE,qBAAqB"}