@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/shader/pass/RenderPassDescriptor.js

@@ -1,190 +1,190 @@
-import { assert } from "../../../../core/assert.js";
-import { rp_rewrite_for_primitive_state } from "../../../device/pipeline/rp_rewrite_for_primitive_state.js";
-import { RenderPassDepthStencilAttachmentDescriptor } from "./RenderPassDepthStencilAttachmentDescriptor.js";
-
-/**
- * {@link GPURenderPassDescriptor}
- */
-export class RenderPassDescriptor {
-    /**
-     * @type {RenderPipelineDescriptor}
-     */
-    pipeline
-
-    /**
-     * @type {ShaderResourceSetDescriptor}
-     */
-    resources
-
-    /**
-     *
-     * @type {RenderPassColorAttachmentDescriptor[]}
-     */
-    colorAttachments = [];
-
-    /**
-     *
-     * @type {RenderPassDepthStencilAttachmentDescriptor}
-     */
-    depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
-
-
-    /**
-     * @param {GPUTextureContext[]} [colorTargets]
-     * @param {GPUTextureContext} [depthTarget]
-     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
-     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
-     * @param {GPULoadOp} [colorLoadOp] defaults to `loadOp`
-     * @param {GPUStoreOp} [colorStoreOp] defaults to `storeOp`
-     * @param {GPULoadOp} [depthLoadOp] defaults to `loadOp`
-     * @param {GPUStoreOp} [depthStoreOp] defaults to `storeOp`
-     * @returns {GPURenderPassDescriptor}
-     */
-    toGPU({
-              colorTargets = [],
-              depthTarget,
-              loadOp = "clear",
-              storeOp = "store",
-              colorLoadOp = loadOp,
-              colorStoreOp = storeOp,
-              depthLoadOp = loadOp,
-              depthStoreOp = storeOp,
-          }) {
-
-        assert.defined(colorTargets, 'colorAttachments');
-        assert.isArray(colorTargets, 'colorAttachments');
-
-        assert.isOneOf(loadOp, ['clear', 'load'], 'loadOp');
-        assert.isOneOf(storeOp, ['store', 'discard'], 'storeOp');
-
-
-        assert.isOneOf(colorLoadOp, ['clear', 'load'], 'colorLoadOp');
-        assert.isOneOf(colorStoreOp, ['store', 'discard'], 'colorStoreOp');
-
-        assert.isOneOf(depthLoadOp, ['clear', 'load'], 'depthLoadOp');
-        assert.isOneOf(depthStoreOp, ['store', 'discard'], 'depthStoreOp');
-
-        const _colorAttachments = [];
-
-        const color_target_count = colorTargets.length;
-        for (let i = 0; i < color_target_count; i++) {
-            const texture = colorTargets[i];
-
-            assert.defined(texture, 'texture');
-            assert.isObject(texture, 'texture');
-            assert.equal(texture.isGPUTextureContext, true, 'texture.isGPUTextureContext !== true');
-
-            const descriptor = this.colorAttachments[i];
-            _colorAttachments[i] = {
-                view: texture.obtainView(descriptor.view),
-                clearValue: descriptor.clearValue,
-                loadOp: colorLoadOp,
-                storeOp: colorStoreOp,
-            };
-        }
-
-        const depthDescriptor = this.depthStencilAttachment;
-
-
-        let _depthStencilAttachment;
-
-        if (depthTarget !== undefined) {
-            assert.equal(depthTarget.isGPUTextureContext, true, 'depthTarget.isGPUTextureContext !== true')
-
-            _depthStencilAttachment = {
-                view: depthTarget.obtainView(depthDescriptor.view),
-                depthClearValue: depthDescriptor.depthClearValue,
-                depthLoadOp: depthLoadOp,
-                depthStoreOp: depthStoreOp,
-            };
-
-        } else {
-
-            // no depth
-
-        }
-
-        return {
-            label: this.pipeline.label,
-            colorAttachments: _colorAttachments,
-            depthStencilAttachment: _depthStencilAttachment,
-        };
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {GPUTextureContext[]} [colorTargets]
-     * @param {GPUTextureContext} [depthTarget]
-     * @param {Object} [bindings]
-     * @param {PrimitiveState} [primitive_state]
-     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
-     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
-     * @returns {GPURenderPassEncoder}
-     */
-    begin({
-              encoder,
-              colorTargets = [],
-              depthTarget,
-              bindings = {},
-        primitive_state,
-              loadOp = "clear",
-              storeOp = "store",
-          }) {
-        assert.defined(encoder, 'encoder');
-
-        assert.defined(bindings, 'bindings');
-        assert.isObject(bindings, 'bindings');
-
-        const gpu_descriptor = this.toGPU({
-            colorTargets,
-            depthTarget,
-            loadOp,
-            storeOp,
-        });
-
-        let pipeline = this.pipeline;
-
-        if(primitive_state !== undefined){
-            pipeline = rp_rewrite_for_primitive_state(pipeline,primitive_state);
-        }
-
-        return encoder.constructRenderPass({
-            pipeline,
-            bindings: this.resources.generateBindings(bindings),
-            immediate: encoder.writeImmediate(this.resources, bindings),
-            colorAttachments: gpu_descriptor.colorAttachments,
-            depthStencilAttachment: gpu_descriptor.depthStencilAttachment,
-        });
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {GPUBuffer} command See {@link STRUCT_UNINDEXED_DRAW_COMMAND}
-     * @param {number} [command_offset]
-     * @param {Object} [bindings]
-     * @param {RenderTarget} render_target
-     */
-    drawIndirect({
-                     encoder,
-                     command,
-                     command_offset = 0,
-                     bindings = {},
-                     render_target
-                 }) {
-
-        const pass = this.begin({ encoder: encoder, render_target: render_target, bindings: bindings });
-
-        pass.drawIndirect(command, command_offset);
-
-        pass.end();
-
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
+import { assert } from "../../../../core/assert.js";
+import { rp_rewrite_for_primitive_state } from "../../../device/pipeline/rp_rewrite_for_primitive_state.js";
+import { RenderPassDepthStencilAttachmentDescriptor } from "./RenderPassDepthStencilAttachmentDescriptor.js";
+
+/**
+ * {@link GPURenderPassDescriptor}
+ */
+export class RenderPassDescriptor {
+    /**
+     * @type {RenderPipelineDescriptor}
+     */
+    pipeline
+
+    /**
+     * @type {ShaderResourceSetDescriptor}
+     */
+    resources
+
+    /**
+     *
+     * @type {RenderPassColorAttachmentDescriptor[]}
+     */
+    colorAttachments = [];
+
+    /**
+     *
+     * @type {RenderPassDepthStencilAttachmentDescriptor}
+     */
+    depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
+
+
+    /**
+     * @param {GPUTextureContext[]} [colorTargets]
+     * @param {GPUTextureContext} [depthTarget]
+     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
+     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
+     * @param {GPULoadOp} [colorLoadOp] defaults to `loadOp`
+     * @param {GPUStoreOp} [colorStoreOp] defaults to `storeOp`
+     * @param {GPULoadOp} [depthLoadOp] defaults to `loadOp`
+     * @param {GPUStoreOp} [depthStoreOp] defaults to `storeOp`
+     * @returns {GPURenderPassDescriptor}
+     */
+    toGPU({
+              colorTargets = [],
+              depthTarget,
+              loadOp = "clear",
+              storeOp = "store",
+              colorLoadOp = loadOp,
+              colorStoreOp = storeOp,
+              depthLoadOp = loadOp,
+              depthStoreOp = storeOp,
+          }) {
+
+        assert.defined(colorTargets, 'colorAttachments');
+        assert.isArray(colorTargets, 'colorAttachments');
+
+        assert.isOneOf(loadOp, ['clear', 'load'], 'loadOp');
+        assert.isOneOf(storeOp, ['store', 'discard'], 'storeOp');
+
+
+        assert.isOneOf(colorLoadOp, ['clear', 'load'], 'colorLoadOp');
+        assert.isOneOf(colorStoreOp, ['store', 'discard'], 'colorStoreOp');
+
+        assert.isOneOf(depthLoadOp, ['clear', 'load'], 'depthLoadOp');
+        assert.isOneOf(depthStoreOp, ['store', 'discard'], 'depthStoreOp');
+
+        const _colorAttachments = [];
+
+        const color_target_count = colorTargets.length;
+        for (let i = 0; i < color_target_count; i++) {
+            const texture = colorTargets[i];
+
+            assert.defined(texture, 'texture');
+            assert.isObject(texture, 'texture');
+            assert.equal(texture.isGPUTextureContext, true, 'texture.isGPUTextureContext !== true');
+
+            const descriptor = this.colorAttachments[i];
+            _colorAttachments[i] = {
+                view: texture.obtainView(descriptor.view),
+                clearValue: descriptor.clearValue,
+                loadOp: colorLoadOp,
+                storeOp: colorStoreOp,
+            };
+        }
+
+        const depthDescriptor = this.depthStencilAttachment;
+
+
+        let _depthStencilAttachment;
+
+        if (depthTarget !== undefined) {
+            assert.equal(depthTarget.isGPUTextureContext, true, 'depthTarget.isGPUTextureContext !== true')
+
+            _depthStencilAttachment = {
+                view: depthTarget.obtainView(depthDescriptor.view),
+                depthClearValue: depthDescriptor.depthClearValue,
+                depthLoadOp: depthLoadOp,
+                depthStoreOp: depthStoreOp,
+            };
+
+        } else {
+
+            // no depth
+
+        }
+
+        return {
+            label: this.pipeline.label,
+            colorAttachments: _colorAttachments,
+            depthStencilAttachment: _depthStencilAttachment,
+        };
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {GPUTextureContext[]} [colorTargets]
+     * @param {GPUTextureContext} [depthTarget]
+     * @param {Object} [bindings]
+     * @param {PrimitiveState} [primitive_state]
+     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
+     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
+     * @returns {ShadeGPURenderPassEncoder}
+     */
+    begin({
+              encoder,
+              colorTargets = [],
+              depthTarget,
+              bindings = {},
+        primitive_state,
+              loadOp = "clear",
+              storeOp = "store",
+          }) {
+        assert.defined(encoder, 'encoder');
+
+        assert.defined(bindings, 'bindings');
+        assert.isObject(bindings, 'bindings');
+
+        const gpu_descriptor = this.toGPU({
+            colorTargets,
+            depthTarget,
+            loadOp,
+            storeOp,
+        });
+
+        let pipeline = this.pipeline;
+
+        if(primitive_state !== undefined){
+            pipeline = rp_rewrite_for_primitive_state(pipeline,primitive_state);
+        }
+
+        return encoder.constructRenderPass({
+            pipeline,
+            bindings: this.resources.generateBindings(bindings),
+            immediate: encoder.writeImmediate(this.resources, bindings),
+            colorAttachments: gpu_descriptor.colorAttachments,
+            depthStencilAttachment: gpu_descriptor.depthStencilAttachment,
+        });
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {GPUBuffer} command See {@link STRUCT_UNINDEXED_DRAW_COMMAND}
+     * @param {number} [command_offset]
+     * @param {Object} [bindings]
+     * @param {RenderTarget} render_target
+     */
+    drawIndirect({
+                     encoder,
+                     command,
+                     command_offset = 0,
+                     bindings = {},
+                     render_target
+                 }) {
+
+        const pass = this.begin({ encoder: encoder, render_target: render_target, bindings: bindings });
+
+        pass.drawIndirect(command, command_offset);
+
+        pass.end();
+
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
 RenderPassDescriptor.prototype.isRenderPassDescriptor = true;

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AA8HA;IAoBI;;OAEG;IACH;cAFoB,MAAM;;MAIzB;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,aAAW,MAAM,GAEf,IAAI,CA6ChB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAEJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,8DAFa,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,gDAFa,OAAO,CA0CnB;;CACJ;;eAKS,SAAS,2BAA2B,CAAC;;8CAzjBD,oCAAoC;yCAXzC,0DAA0D;0BAIzE,0BAA0B"}
+{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAgIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;;MAIzB;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,aAAW,MAAM,GAEf,IAAI,CA6ChB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAEJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,8DAFa,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,gDAFa,OAAO,CA0CnB;;CACJ;;eAKS,SAAS,2BAA2B,CAAC;;8CA3jBD,oCAAoC;yCAXzC,0DAA0D;0BAIzE,0BAA0B"}

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js

@@ -114,7 +114,9 @@ function gen_type_storage_texture(member) {
 function gen_type_sampler(member) {
     // see https://www.w3.org/TR/WGSL/#sampler-type
 
-    if (member.type === "filtering") {
+    // WGSL has no "non-filtering" sampler type; filtering is a bind-group-layout property, so
+    // both "filtering" and "non-filtering" declare a plain `sampler`
+    if (member.type === "filtering" || member.type === "non-filtering") {
         return "sampler";
     } else if (member.type === "comparison") {
         return "sampler_comparison";

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAuFA;;GAEG;AACH;IA8JI;;;;;;;;OAQG;IACH,8FA0DC;IAhOD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsBpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAqCtC;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAgGD;;;;OAIG;IACH,uBAFa,YAAU,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,0EAJW,MAAM,mBACN,UAAU,MAAM,CAAC,QA6G3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gDAiFC;IAgbD;;;;;;;;;;;;;;OAcG;IACH,kBALa,OAAO,CAkMnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAWC;;CACJ;oCA3yCmC,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAsFA;;GAEG;AACH;IA8JI;;;;;;;;OAQG;IACH,8FA0DC;IAhOD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsBpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAqCtC;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAgGD;;;;OAIG;IACH,uBAFa,YAAU,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,0EAJW,MAAM,mBACN,UAAU,MAAM,CAAC,QA6G3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gDAiFC;IA6aD;;;;;;;;;;;;;;OAcG;IACH,kBALa,OAAO,CAkMnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAWC;;CACJ;oCAvyCmC,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js

@@ -33,7 +33,6 @@ import {
 } from "./POINT_SHADOW_TETRAHEDRON_LAYOUT.js";
 import { PointLightShadowmap } from "./PointLightShadowmap.js";
 import {
-    POINT_SHADOW_REMAP_SETTINGS,
     shader_shadowmap_remap_cube_to_octahedral
 } from "./shader/shader_shadowmap_remap_cube_to_octahedral.js";
 import {
@@ -834,23 +833,20 @@ export class GPUSceneShadowmapContext {
             const atlas = resources.get(data.atlas);
             const cube_texture = resources.get(data.cube_texture);
 
-            const settings = context.encoder.allocateTransientValueBuffer(
-                POINT_SHADOW_REMAP_SETTINGS,
-                {
-                    atlas_offset: [
-                        atlas_rect.x0 + SHADOWMAP_ATLAS_BORDER,
-                        atlas_rect.y0 + SHADOWMAP_ATLAS_BORDER,
-                        atlas_rect.width - 2 * SHADOWMAP_ATLAS_BORDER,
-                        atlas_rect.height - 2 * SHADOWMAP_ATLAS_BORDER,
-                    ],
-                    light_params: [
-                        map.light.distance,
-                        map.cube_near,
-                        0,
-                        0,
-                    ]
-                }
-            );
+            const settings = {
+                atlas_offset: [
+                    atlas_rect.x0 + SHADOWMAP_ATLAS_BORDER,
+                    atlas_rect.y0 + SHADOWMAP_ATLAS_BORDER,
+                    atlas_rect.width - 2 * SHADOWMAP_ATLAS_BORDER,
+                    atlas_rect.height - 2 * SHADOWMAP_ATLAS_BORDER,
+                ],
+                light_params: [
+                    map.light.distance,
+                    map.cube_near,
+                    0,
+                    0,
+                ]
+            };
 
             shader_shadowmap_remap_cube_to_octahedral.draw({
                 encoder: context.encoder,

package/src/shade/renderer/shadow/map/shader/shader_shadowmap_remap_cube_to_octahedral.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_shadowmap_remap_cube_to_octahedral.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/shader_shadowmap_remap_cube_to_octahedral.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,0CAFU,YAAY,CAKS;AA+K/B,oEAcG;6BA1N0B,sCAAsC;4BAQvC,gCAAgC"}
+{"version":3,"file":"shader_shadowmap_remap_cube_to_octahedral.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/shader_shadowmap_remap_cube_to_octahedral.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,0CAFU,YAAY,CAKS;AAmL/B,oEAcG;6BA9N0B,sCAAsC;4BAQvC,gCAAgC"}

package/src/shade/renderer/shadow/map/shader/shader_shadowmap_remap_cube_to_octahedral.js

@@ -33,8 +33,12 @@ export const POINT_SHADOW_REMAP_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
+// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer. The tetrahedron
+// variant of this shader cannot follow: its settings carry a face_view_proj array, and the immediate
+// address space excludes arrays.
+resources.setImmediate("settings", POINT_SHADOW_REMAP_SETTINGS);
+
 resources.createGroup()
-    .addUniform('settings', POINT_SHADOW_REMAP_SETTINGS)
     .addTexture('cube_faces', 'unfilterable-float');
 
 /**

package/src/shade/renderer/shadow/ray/shader_shadow_upscale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_shadow_upscale.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/shader_shadow_upscale.js"],"names":[],"mappings":"AAmJA,gDASG;4BA1IyB,6BAA6B"}
+{"version":3,"file":"shader_shadow_upscale.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/shader_shadow_upscale.js"],"names":[],"mappings":"AAqJA,gDASG;4BA5IyB,6BAA6B"}

package/src/shade/renderer/shadow/ray/shader_shadow_upscale.js

@@ -25,8 +25,10 @@ const PUSH_CONSTANTS = WebGPUStruct.from({
 });
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", PUSH_CONSTANTS);
 resources.createGroup()
-    .addUniform("settings", PUSH_CONSTANTS)
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addTexture("tInput", "unfilterable-float")
     .addTexture("tNormals", "uint")

package/src/shade/renderer/shadow/ray/staged/gen/graph_gen_rays.js

@@ -1,74 +1,74 @@
-import { BufferResourceDescriptor } from "../../../../../device/graph/BufferResourceDescriptor.js";
-import { HILBERT_R2_INDEX_TEXTURE } from "../../../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
-import { PACKED_RAY_WORD_COUNT, PUSH_CONSTANTS, shader_generate_rays } from "./shader_generate_rays.js";
-
-/**
- *
- * @param {FrameGraph} graph
- * @param {number[]} resolution
- * @param {number} input_normals
- * @param {number} input_depth
- * @param {GPUViewContext} view
- * @returns {number} buffer of rays
- */
-export function graph_gen_rays({
-                                   graph,
-                                   resolution,
-                                   input_normals = -1,
-                                   input_depth = -1,
-                                   view,
-                               }) {
-
-    const data = {};
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-
-        const output = resources.get(data.output);
-        const depth = resources.get(data.depth);
-        const normals = resources.get(data.normals);
-
-        const noise_texture = context.graphics.textures.obtain(HILBERT_R2_INDEX_TEXTURE);
-
-        const settings = context.encoder.allocateTransientValueBuffer(PUSH_CONSTANTS, {
-            frame_index: view.frame_index,
-        });
-
-        const scene_ctx = view.scene;
-
-        shader_generate_rays.dispatchThreads({
-            encoder: context.encoder,
-            thread_count_x: resolution[0],
-            thread_count_y: resolution[1],
-            bindings: {
-                settings,
-                camera: view.camera.buffer.buffer,
-                texture_noise: noise_texture.obtainView(),
-                output,
-                texture_depth: depth,
-                texture_normal: normals,
-                light_data: scene_ctx.lights.buffer_data,
-            }
-        })
-    }
-
-    const pass = graph.add("generate rays", data, execute);
-
-    const pixel_count = resolution[0] * resolution[1];
-
-    data.depth = pass.read(input_depth);
-    data.normals = pass.read(input_normals);
-
-    data.output = pass.create("output", BufferResourceDescriptor.from(
-        16 + PACKED_RAY_WORD_COUNT * 4 * pixel_count,
-        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-        0, 16
-    ));
-
-    return data.output;
+import { BufferResourceDescriptor } from "../../../../../device/graph/BufferResourceDescriptor.js";
+import { HILBERT_R2_INDEX_TEXTURE } from "../../../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
+import { PACKED_RAY_WORD_COUNT, PUSH_CONSTANTS, shader_generate_rays } from "./shader_generate_rays.js";
+
+/**
+ *
+ * @param {FrameGraph} graph
+ * @param {number[]} resolution
+ * @param {number} input_normals
+ * @param {number} input_depth
+ * @param {GPUViewContext} view
+ * @returns {number} buffer of rays
+ */
+export function graph_gen_rays({
+                                   graph,
+                                   resolution,
+                                   input_normals = -1,
+                                   input_depth = -1,
+                                   view,
+                               }) {
+
+    const data = {};
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+
+        const output = resources.get(data.output);
+        const depth = resources.get(data.depth);
+        const normals = resources.get(data.normals);
+
+        const noise_texture = context.graphics.textures.obtain(HILBERT_R2_INDEX_TEXTURE);
+
+        const settings = {
+            frame_index: view.frame_index,
+        };
+
+        const scene_ctx = view.scene;
+
+        shader_generate_rays.dispatchThreads({
+            encoder: context.encoder,
+            thread_count_x: resolution[0],
+            thread_count_y: resolution[1],
+            bindings: {
+                settings,
+                camera: view.camera.buffer.buffer,
+                texture_noise: noise_texture.obtainView(),
+                output,
+                texture_depth: depth,
+                texture_normal: normals,
+                light_data: scene_ctx.lights.buffer_data,
+            }
+        })
+    }
+
+    const pass = graph.add("generate rays", data, execute);
+
+    const pixel_count = resolution[0] * resolution[1];
+
+    data.depth = pass.read(input_depth);
+    data.normals = pass.read(input_normals);
+
+    data.output = pass.create("output", BufferResourceDescriptor.from(
+        16 + PACKED_RAY_WORD_COUNT * 4 * pixel_count,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        0, 16
+    ));
+
+    return data.output;
 }

package/src/shade/renderer/shadow/ray/staged/gen/shader_generate_rays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_generate_rays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/ray/staged/gen/shader_generate_rays.js"],"names":[],"mappings":"AA0BA,0CAEG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AA8GvC,iDAIE;6BAlJ2B,yCAAyC;8BAmBxC,qCAAqC"}
+{"version":3,"file":"shader_generate_rays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/ray/staged/gen/shader_generate_rays.js"],"names":[],"mappings":"AA0BA,0CAEG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAiHvC,iDAIE;6BArJ2B,yCAAyC;8BAmBxC,qCAAqC"}