@woosh/meep-engine 3.60.4 → 3.60.5

package/src/engine/graphics3/decal/DecalTileShader.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A fragment program drawn over the screen tiles that hold a decal, rather than over the whole
+ * screen — what an `ImageShader` is to a full-screen pass, for the decal passes that only need to
+ * touch the surfaces a decal could be on.
+ *
+ * The tiles come from `graph_gather_decal_tiles`, and so does the draw: the instance count is the
+ * live tile count, read on the device through an indirect command, so the work follows how much of
+ * the screen the decals cover and never the size of the screen.
+ *
+ * The fragment program is `descriptor`, an ordinary one — it is what the emulator runs and what
+ * specs read. The vertex program is {@link chunk_decal_tile_vertex}, compiled against the same
+ * resources, so both stages share one layout and the descriptor must declare `decal_tiles` and an
+ * immediate `settings` with a `screen_resolution`.
+ */
+export class DecalTileShader {
+    /**
+     * @param {object} options
+     * @param {ShaderDescriptor} options.descriptor the fragment program
+     * @param {GPUColorTargetState[]} options.targets
+     */
+    constructor({ descriptor, targets }: {
+        descriptor: ShaderDescriptor;
+        targets: GPUColorTargetState[];
+    });
+    /**
+     * @returns {ShaderDescriptor}
+     */
+    get descriptor(): ShaderDescriptor;
+    /**
+     * @returns {RenderPipelineDescriptor}
+     */
+    get pipeline(): RenderPipelineDescriptor;
+    /**
+     * See `ImageShader#pipeline_for`.
+     *
+     * @param {GPUTextureFormat[]} color_formats
+     * @returns {RenderPipelineDescriptor}
+     */
+    pipeline_for(color_formats: GPUTextureFormat[]): RenderPipelineDescriptor;
+    /**
+     * Draw over every listed tile.
+     *
+     * @param {object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {GPURenderPassColorAttachment[]} options.colorAttachments
+     * @param {GPUTextureFormat[]} options.color_formats
+     * @param {GPUBuffer} options.command the tiles' draw command: 6 vertices, one instance per tile
+     */
+    draw({ encoder, bindings, colorAttachments, color_formats, command }: {
+        encoder: ShadeGPUCommandContext;
+        bindings: any;
+        colorAttachments: GPURenderPassColorAttachment[];
+        color_formats: GPUTextureFormat[];
+        command: GPUBuffer;
+    }): void;
+    #private;
+}
+import { ShaderDescriptor } from "../../../shade/renderer/shader/ShaderDescriptor.js";
+import { RenderPipelineDescriptor } from "../../../shade/descriptor/pipeline/render/RenderPipelineDescriptor.js";
+//# sourceMappingURL=DecalTileShader.d.ts.map

package/src/engine/graphics3/decal/DecalTileShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecalTileShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/DecalTileShader.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH;IAkBI;;;;OAIG;IACH;QAHqC,UAAU,EAApC,gBAAgB;QACe,OAAO,EAAtC,qBAAqB;OA8B/B;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,yCAEC;IAED;;;;;OAKG;IACH,4BAHW,kBAAkB,GAChB,wBAAwB,CAIpC;IAED;;;;;;;;;OASG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACgB,gBAAgB,EAAxD,8BAA8B;QACF,aAAa,EAAzC,kBAAkB;QACC,OAAO;aA6BpC;;CACJ;iCApIgC,oDAAoD;yCAJ5C,uEAAuE"}

package/src/engine/graphics3/decal/DecalTileShader.js

@@ -0,0 +1,138 @@
+import { assert } from "../../../core/assert.js";
+import { RenderPipelineDescriptor } from "../../../shade/descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import {
+    rp_validate_and_rewrite_for_color_attachments
+} from "../../../shade/device/pipeline/rp_validate_and_rewrite_for_color_attachments.js";
+import { ShaderDescriptor } from "../../../shade/renderer/shader/ShaderDescriptor.js";
+import { chunk_decal_tile_vertex } from "./chunk_decal_tile_vertex.js";
+
+/**
+ * A fragment program drawn over the screen tiles that hold a decal, rather than over the whole
+ * screen — what an `ImageShader` is to a full-screen pass, for the decal passes that only need to
+ * touch the surfaces a decal could be on.
+ *
+ * The tiles come from `graph_gather_decal_tiles`, and so does the draw: the instance count is the
+ * live tile count, read on the device through an indirect command, so the work follows how much of
+ * the screen the decals cover and never the size of the screen.
+ *
+ * The fragment program is `descriptor`, an ordinary one — it is what the emulator runs and what
+ * specs read. The vertex program is {@link chunk_decal_tile_vertex}, compiled against the same
+ * resources, so both stages share one layout and the descriptor must declare `decal_tiles` and an
+ * immediate `settings` with a `screen_resolution`.
+ */
+export class DecalTileShader {
+    /**
+     * @type {ShaderDescriptor}
+     */
+    #descriptor;
+
+    /**
+     * @type {RenderPipelineDescriptor}
+     */
+    #pipeline;
+
+    /**
+     * See `ImageShader`'s field of the same name: one device check per device, not one per draw.
+     *
+     * @type {GPUDevice|null}
+     */
+    #validated_device = null;
+
+    /**
+     * @param {object} options
+     * @param {ShaderDescriptor} options.descriptor the fragment program
+     * @param {GPUColorTargetState[]} options.targets
+     */
+    constructor({ descriptor, targets }) {
+        assert.defined(descriptor, 'descriptor');
+        assert.isArray(targets, 'targets');
+
+        this.#descriptor = descriptor;
+
+        const vertex = ShaderDescriptor.from({
+            label: `${descriptor.label} / tiles`,
+            resources: descriptor.resources,
+            body: chunk_decal_tile_vertex
+        });
+
+        this.#pipeline = RenderPipelineDescriptor.from({
+            label: descriptor.label,
+            layout: descriptor.resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+            vertex: {
+                module: { code: vertex.source },
+                entryPoint: 'main',
+            },
+            fragment: {
+                module: { code: descriptor.source },
+                targets,
+            },
+            primitive: {
+                topology: 'triangle-list',
+                cullMode: 'none',
+            },
+        });
+    }
+
+    /**
+     * @returns {ShaderDescriptor}
+     */
+    get descriptor() {
+        return this.#descriptor;
+    }
+
+    /**
+     * @returns {RenderPipelineDescriptor}
+     */
+    get pipeline() {
+        return this.#pipeline;
+    }
+
+    /**
+     * See `ImageShader#pipeline_for`.
+     *
+     * @param {GPUTextureFormat[]} color_formats
+     * @returns {RenderPipelineDescriptor}
+     */
+    pipeline_for(color_formats) {
+        return rp_validate_and_rewrite_for_color_attachments(this.#pipeline, color_formats);
+    }
+
+    /**
+     * Draw over every listed tile.
+     *
+     * @param {object} options
+     * @param {ShadeGPUCommandContext} options.encoder
+     * @param {Object} options.bindings
+     * @param {GPURenderPassColorAttachment[]} options.colorAttachments
+     * @param {GPUTextureFormat[]} options.color_formats
+     * @param {GPUBuffer} options.command the tiles' draw command: 6 vertices, one instance per tile
+     */
+    draw({ encoder, bindings, colorAttachments, color_formats, command }) {
+        assert.defined(encoder, 'encoder');
+        assert.defined(command, 'command');
+
+        const descriptor = this.#descriptor;
+        const resources = descriptor.resources;
+
+        if (encoder.device !== this.#validated_device) {
+            descriptor.validate_against_device(encoder.device);
+
+            this.#validated_device = encoder.device;
+        }
+
+        encoder.pushDebugGroup(descriptor.label);
+
+        const pass = encoder.constructRenderPass({
+            pipeline: this.pipeline_for(color_formats),
+            bindings: resources.generateBindings(bindings, encoder),
+            colorAttachments,
+            immediate: encoder.writeImmediate(resources, bindings),
+        });
+
+        pass.drawIndirect(command, 0);
+
+        pass.end();
+
+        encoder.popDebugGroup();
+    }
+}

package/src/engine/graphics3/decal/GPUDecalRenderer.d.ts

@@ -1,10 +1,16 @@
 /**
  * Draws decals into the G-buffer.
  *
- * Four passes, in order: the atlases and this frame's records are uploaded, the decals are culled
- * against the camera, they are binned into their own froxels, and the composite reads the G-buffer
- * and writes a new one. The last of those is what {@link GBufferTextures} being publishable at
- * {@link FramePhase.AfterGBuffer} is for — see D23.
+ * Six passes, in order: the atlases and this frame's records are uploaded, the decals are culled
+ * against the camera, they are binned into their own froxels, the screen tiles whose froxels hold a
+ * decal are listed, the G-buffer under those tiles is copied, and the composite paints the decals
+ * into the G-buffer in place over the same tiles, reading the copy. The last of those is what
+ * {@link GBufferTextures} being publishable at {@link FramePhase.AfterGBuffer} is for — see D23.
+ *
+ * **Only the covered part of the screen costs anything.** The composite used to read the whole
+ * G-buffer and write a whole new one whenever any decal was on screen; on a 2-CU iGPU at 720p that
+ * copy alone was ~385 µs of a 544 µs pass for two small markers (2026-10-31). Now both tile passes
+ * are drawn indirectly over the gathered tiles, so their cost follows the area the decals cover.
  */
 export class GPUDecalRenderer {
     /**

package/src/engine/graphics3/decal/GPUDecalRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA4CA;;;;;;;GAOG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aAuBnC;IAkPD,gBAoBC;;CACJ"}
+{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;GAaG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aA+BnC;IA4SD,gBAoBC;;CACJ"}

package/src/engine/graphics3/decal/GPUDecalRenderer.js

@@ -11,6 +11,8 @@ import { SAMPLER_ANISOTROPIC_CLAMP } from "../../../shade/renderer/texture/SAMPL
 import { graph_build_decal_clusters } from "./graph_build_decal_clusters.js";
 import { DECAL_RECORD_WORD_COUNT } from "./DECAL_GPU_RECORD.js";
 import { shader_decal_composite } from "./shader_decal_composite.js";
+import { shader_decal_tile_copy } from "./shader_decal_tile_copy.js";
+import { graph_gather_decal_tiles } from "./graph_gather_decal_tiles.js";
 import { build_light_cluster_parameters } from "../../../shade/renderer/light/cluster/build_light_cluster_parameters.js";
 import { DECAL_CLUSTER_RESOLUTION_Z } from "./DECAL_CLUSTER.js";
 
@@ -22,6 +24,37 @@ import { DECAL_CLUSTER_RESOLUTION_Z } from "./DECAL_CLUSTER.js";
  */
 const GROWTH_FACTOR = 1.5;
 
+/**
+ * The G-buffer's four targets, in the order both tile passes write them.
+ *
+ * @type {GPUTextureFormat[]}
+ */
+const G_BUFFER_FORMATS = ["rg8unorm", "rgba16uint", G_BUFFER_ALBEDO_FORMAT, "r32uint"];
+
+/**
+ * @type {TextureViewDescriptor}
+ */
+const MIP_0 = TextureViewDescriptor.from({
+    mipLevelCount: 1,
+    baseMipLevel: 0
+});
+
+/**
+ * Mip 0 of a target, kept — a tile pass draws over part of the screen, so whatever lies outside the
+ * tiles has to survive it.
+ *
+ * @param {FramePassResources} resources
+ * @param {number} handle
+ * @returns {GPURenderPassColorAttachment}
+ */
+function attachment(resources, handle) {
+    return {
+        loadOp: "load",
+        storeOp: "store",
+        view: resources.get(handle).obtainView(MIP_0)
+    };
+}
+
 /**
  * One atlas as the GPU holds it, with the mip chain its borders exist to make usable.
  */
@@ -45,10 +78,16 @@ class AtlasResidency {
 /**
  * Draws decals into the G-buffer.
  *
- * Four passes, in order: the atlases and this frame's records are uploaded, the decals are culled
- * against the camera, they are binned into their own froxels, and the composite reads the G-buffer
- * and writes a new one. The last of those is what {@link GBufferTextures} being publishable at
- * {@link FramePhase.AfterGBuffer} is for — see D23.
+ * Six passes, in order: the atlases and this frame's records are uploaded, the decals are culled
+ * against the camera, they are binned into their own froxels, the screen tiles whose froxels hold a
+ * decal are listed, the G-buffer under those tiles is copied, and the composite paints the decals
+ * into the G-buffer in place over the same tiles, reading the copy. The last of those is what
+ * {@link GBufferTextures} being publishable at {@link FramePhase.AfterGBuffer} is for — see D23.
+ *
+ * **Only the covered part of the screen costs anything.** The composite used to read the whole
+ * G-buffer and write a whole new one whenever any decal was on screen; on a 2-CU iGPU at 720p that
+ * copy alone was ~385 µs of a 544 µs pass for two small markers (2026-10-31). Now both tile passes
+ * are drawn indirectly over the gathered tiles, so their cost follows the area the decals cover.
  */
 export class GPUDecalRenderer {
     /**
@@ -111,15 +150,94 @@ export class GPUDecalRenderer {
             resolution: frame.resolution
         });
 
-        this.#graph_composite({ frame, clusters });
+        const tiles = graph_gather_decal_tiles({
+            graph,
+            cluster_lookup: clusters.lookup,
+            resolution: frame.resolution
+        });
+
+        const copy = this.#graph_copy({ frame, tiles });
+
+        this.#graph_composite({ frame, clusters, tiles, copy });
+    }
+
+    /**
+     * Copy the G-buffer under the listed tiles, for the composite to read while it writes them.
+     *
+     * The copy's textures are screen-sized, so a tile's texels sit where they are on screen and need
+     * no address of their own — only the listed tiles are ever written or read, and the rest of each
+     * texture is whatever it last held.
+     *
+     * @param {object} args
+     * @param {FrameContext} args.frame
+     * @param {{tiles: number, command: number}} args.tiles
+     * @returns {{pbr: number, normal: number, albedo: number, emissive: number}}
+     */
+    #graph_copy({ frame, tiles }) {
+        const graph = frame.graph;
+        const resolution = frame.resolution;
+
+        const gbuffer = frame.get(GBufferTextures);
+
+        const data = {};
+
+        const pass = graph.add('decals / copy covered tiles', data, (data, resources, context) => {
+            shader_decal_tile_copy.draw({
+                encoder: context.encoder,
+                bindings: {
+                    settings: { screen_resolution: resolution },
+                    decal_tiles: resources.get(data.tiles),
+                    gBufferPBR: resources.get(data.in_pbr).obtainView(),
+                    gBufferNormal: resources.get(data.in_normal).obtainView(),
+                    gBufferAlbedo: resources.get(data.in_albedo).obtainView(),
+                    gBufferEmissive: resources.get(data.in_emissive).obtainView(),
+                },
+                colorAttachments: [
+                    attachment(resources, data.pbr),
+                    attachment(resources, data.normal),
+                    attachment(resources, data.albedo),
+                    attachment(resources, data.emissive),
+                ],
+                color_formats: G_BUFFER_FORMATS,
+                command: resources.get(data.command),
+            });
+        });
+
+        data.tiles = pass.read(tiles.tiles);
+        data.command = pass.read(tiles.command);
+
+        data.in_pbr = pass.read(gbuffer.pbr);
+        data.in_normal = pass.read(gbuffer.normal);
+        data.in_albedo = pass.read(gbuffer.albedo);
+        data.in_emissive = pass.read(gbuffer.emissive);
+
+        /**
+         * @param {string} name
+         * @param {GPUTextureFormat} format
+         * @returns {number}
+         */
+        const target = (name, format) => pass.create(name, TextureResourceDescriptor.from({
+            format,
+            resolution,
+            usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+        }));
+
+        data.pbr = target("decals / covered PBR", G_BUFFER_FORMATS[0]);
+        data.normal = target("decals / covered normal", G_BUFFER_FORMATS[1]);
+        data.albedo = target("decals / covered albedo", G_BUFFER_FORMATS[2]);
+        data.emissive = target("decals / covered emissive", G_BUFFER_FORMATS[3]);
+
+        return { pbr: data.pbr, normal: data.normal, albedo: data.albedo, emissive: data.emissive };
     }
 
     /**
      * @param {object} args
      * @param {FrameContext} args.frame
      * @param {{lookup: number, data: number}} args.clusters
+     * @param {{tiles: number, command: number}} args.tiles
+     * @param {{pbr: number, normal: number, albedo: number, emissive: number}} args.copy
      */
-    #graph_composite({ frame, clusters }) {
+    #graph_composite({ frame, clusters, tiles, copy }) {
         const graph = frame.graph;
         const resolution = frame.resolution;
 
@@ -143,35 +261,29 @@ export class GPUDecalRenderer {
 
         data.depth = pass.read(frame.get(ViewTextures).depth);
 
-        data.in_pbr = pass.read(gbuffer.pbr);
-        data.in_normal = pass.read(gbuffer.normal);
-        data.in_albedo = pass.read(gbuffer.albedo);
-        data.in_emissive = pass.read(gbuffer.emissive);
+        data.in_pbr = pass.read(copy.pbr);
+        data.in_normal = pass.read(copy.normal);
+        data.in_albedo = pass.read(copy.albedo);
+        data.in_emissive = pass.read(copy.emissive);
 
         data.cluster_lookup = pass.read(clusters.lookup);
         data.cluster_data = pass.read(clusters.data);
 
-        /**
-         * @param {string} name
-         * @param {GPUTextureFormat} format
-         * @returns {number}
-         */
-        const target = (name, format) => pass.create(name, TextureResourceDescriptor.from({
-            format,
-            resolution,
-            usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
-        }));
-
-        data.out_pbr = target("g-buffer / PBR + decals", "rg8unorm");
-        data.out_normal = target("g-buffer / Normal + decals", "rgba16uint");
-        data.out_albedo = target("g-buffer / Albedo + decals", G_BUFFER_ALBEDO_FORMAT);
-        data.out_emissive = target("g-buffer / Emissive + decals", "r32uint");
+        data.tiles = pass.read(tiles.tiles);
+        data.command = pass.read(tiles.command);
 
         /*
-         The whole reason this pass can composite exactly. Everything downstream — ambient occlusion,
-         reflections, shading — now reads what the decals wrote, and the graph knows it does, so the
-         ordering is a real edge rather than an accident of declaration order.
+         In place, and still a real edge: a written handle is a new version of the same texture, its
+         producer this pass, and it is what the record hands on. Everything downstream — ambient
+         occlusion, reflections, shading — reads the version the decals wrote and the graph knows it
+         does. Pixels outside the listed tiles are never drawn, so they keep what the G-buffer pass
+         left there, which is exactly what they should hold.
         */
+        data.out_pbr = pass.write(gbuffer.pbr);
+        data.out_normal = pass.write(gbuffer.normal);
+        data.out_albedo = pass.write(gbuffer.albedo);
+        data.out_emissive = pass.write(gbuffer.emissive);
+
         gbuffer.pbr = data.out_pbr;
         gbuffer.normal = data.out_normal;
         gbuffer.albedo = data.out_albedo;
@@ -186,7 +298,7 @@ export class GPUDecalRenderer {
      * @param {number[]} cluster_params
      * @param {number[]} resolution
      */
-    #execute(data, resources, context, view_context, cluster_params, resolution) {
+    #execute(data, resources, context, view_context, cluster_params, resolution) {
         const camera = view_context.camera;
         const encoder = context.encoder;
         const graphics = context.graphics;
@@ -206,19 +318,10 @@ export class GPUDecalRenderer {
          */
         const view = handle => resources.get(handle).obtainView();
 
-        const attachment = handle => ({
-            loadOp: "clear",
-            storeOp: "store",
-            view: resources.get(handle).obtainView(TextureViewDescriptor.from({
-                mipLevelCount: 1,
-                baseMipLevel: 0
-            }))
-        });
-
         shader_decal_composite.draw({
             encoder,
             bindings: {
-                camera: camera.buffer,
+                camera: camera.buffer,
                 view: view_context.uniform_buffer.buffer,
                 settings,
                 gBufferPBR: view(data.in_pbr),
@@ -235,14 +338,16 @@ export class GPUDecalRenderer {
                 atlas_normal_sampler: sampler,
                 atlas_orm: this.#orm.texture.obtainView(),
                 atlas_orm_sampler: sampler,
+                decal_tiles: resources.get(data.tiles),
             },
             colorAttachments: [
-                attachment(data.out_pbr),
-                attachment(data.out_normal),
-                attachment(data.out_albedo),
-                attachment(data.out_emissive),
+                attachment(resources, data.out_pbr),
+                attachment(resources, data.out_normal),
+                attachment(resources, data.out_albedo),
+                attachment(resources, data.out_emissive),
             ],
-            color_formats: ["rg8unorm", "rgba16uint", G_BUFFER_ALBEDO_FORMAT, "r32uint"]
+            color_formats: G_BUFFER_FORMATS,
+            command: resources.get(data.command),
         });
     }
 

package/src/engine/graphics3/decal/chunk_decal_tile_vertex.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Where corner `vertex_index` of a listed screen tile lands in clip space.
+ *
+ * A tile is one column of the decal froxel grid, packed `x | y << 16`. Six vertices make two
+ * triangles covering it exactly, so a pixel is shaded by a tile draw if and only if its froxel column
+ * is that tile — the same column the composite then looks its decals up in.
+ *
+ * The froxel grid is built over a flipped y, counting rows up from the bottom edge
+ * (`cluster_from_fragment_coord`), which is the direction NDC y already runs. So no flip appears here:
+ * it is the grid's convention and clip space's agreeing, not an omission.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decal_tile_corner: CodeChunk;
+/**
+ * The vertex stage of a pass drawn over the screen tiles that hold a decal: instance `i` is the tile
+ * at `decal_tiles[1 + i]`, the word before them being their count.
+ *
+ * Reads `decal_tiles` and `settings.screen_resolution`, which every pass using it declares.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decal_tile_vertex: CodeChunk;
+import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_decal_tile_vertex.d.ts.map

package/src/engine/graphics3/decal/chunk_decal_tile_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_decal_tile_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/chunk_decal_tile_vertex.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,sCAFU,SAAS,CAgBjB;AAEF;;;;;;;GAOG;AACH,sCAFU,SAAS,CAgBjB;0BAtDwB,sDAAsD"}

package/src/engine/graphics3/decal/chunk_decal_tile_vertex.js

@@ -0,0 +1,55 @@
+import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
+import { DECAL_CLUSTER_TILE_RESOLUTION } from "./DECAL_CLUSTER.js";
+
+/**
+ * Where corner `vertex_index` of a listed screen tile lands in clip space.
+ *
+ * A tile is one column of the decal froxel grid, packed `x | y << 16`. Six vertices make two
+ * triangles covering it exactly, so a pixel is shaded by a tile draw if and only if its froxel column
+ * is that tile — the same column the composite then looks its decals up in.
+ *
+ * The froxel grid is built over a flipped y, counting rows up from the bottom edge
+ * (`cluster_from_fragment_coord`), which is the direction NDC y already runs. So no flip appears here:
+ * it is the grid's convention and clip space's agreeing, not an omission.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decal_tile_corner = CodeChunk.from(
+    //language=WGSL
+    `
+fn decal_tile_corner(tile: u32, vertex_index: u32, screen_resolution: vec2<u32>) -> vec2<f32> {
+    let cell = vec2<u32>(tile & 0xFFFFu, tile >> 16u);
+
+    // corners (0,0) (1,0) (0,1) (0,1) (1,0) (1,1), one bit per vertex
+    let corner = vec2<u32>((0x32u >> vertex_index) & 1u, (0x2Cu >> vertex_index) & 1u);
+
+    let pixel = (cell + corner) * ${DECAL_CLUSTER_TILE_RESOLUTION}u;
+
+    return vec2<f32>(pixel) / vec2<f32>(screen_resolution) * 2.0 - 1.0;
+}
+`
+);
+
+/**
+ * The vertex stage of a pass drawn over the screen tiles that hold a decal: instance `i` is the tile
+ * at `decal_tiles[1 + i]`, the word before them being their count.
+ *
+ * Reads `decal_tiles` and `settings.screen_resolution`, which every pass using it declares.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decal_tile_vertex = CodeChunk.from(
+    //language=WGSL
+    `
+@vertex
+fn main(
+    @builtin(vertex_index) vertex_index : u32,
+    @builtin(instance_index) instance_index : u32,
+) -> @builtin(position) vec4<f32> {
+    let ndc = decal_tile_corner(decal_tiles[1u + instance_index], vertex_index, settings.screen_resolution);
+
+    return vec4<f32>(ndc, 0.0, 1.0);
+}
+`,
+    [chunk_decal_tile_corner]
+);

package/src/engine/graphics3/decal/graph_gather_decal_tiles.d.ts

@@ -0,0 +1,22 @@
+/**
+ * List the screen tiles that hold a decal, and the draw command a `DecalTileShader` draws them with.
+ *
+ * The list holds every tile of the screen at worst, so it never drops one; what it costs to draw
+ * follows the count the gather wrote, through the command. The command has a buffer of its own, as
+ * an indirect argument may not be bound writable in the scope it is used in.
+ *
+ * @param {object} args
+ * @param {FrameGraph} args.graph
+ * @param {number} args.cluster_lookup handle of the decal froxels' lookup
+ * @param {number[]} args.resolution
+ * @returns {{tiles: number, command: number}}
+ */
+export function graph_gather_decal_tiles({ graph, cluster_lookup, resolution }: {
+    graph: FrameGraph;
+    cluster_lookup: number;
+    resolution: number[];
+}): {
+    tiles: number;
+    command: number;
+};
+//# sourceMappingURL=graph_gather_decal_tiles.d.ts.map

package/src/engine/graphics3/decal/graph_gather_decal_tiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_gather_decal_tiles.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/graph_gather_decal_tiles.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH;IAL4B,KAAK;IACT,cAAc,EAA3B,MAAM;IACS,UAAU,EAAzB,MAAM,EAAE;IACN;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CA2C5C"}