@woosh/meep-engine 3.47.0 → 3.49.0

package/src/shade/device/pipeline/RenderPipelineManager.js

@@ -6,6 +6,7 @@ import { rp_validate_and_rewrite_for_color_attachments } from "./rp_validate_and
 /**
  * @typedef {import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler} ShaderModuleCompiler
  * @typedef {import("./PipelineLayoutManager.js").PipelineLayoutManager} PipelineLayoutManager
+ * @typedef {import("./PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  */
 
 
@@ -39,6 +40,22 @@ export class RenderPipelineManager {
      */
     #cache = new HashMap();
 
+    /**
+     * Compilations {@link prepare} started that have not finished.
+     *
+     * @type {HashMap<RenderPipelineDescriptor, Promise<void>>}
+     */
+    #pending = new HashMap();
+
+    /**
+     * How many pipelines {@link prepare} is still compiling.
+     *
+     * @returns {number}
+     */
+    get pending_count() {
+        return this.#pending.size;
+    }
+
     /**
      *
      * @param {GPUDevice} device
@@ -63,15 +80,13 @@ export class RenderPipelineManager {
     /**
      *
      * @param {RenderPipelineDescriptor} descriptor
-     * @returns {GPURenderPipeline}
+     * @returns {GPURenderPipelineDescriptor}
      */
-    #create(descriptor) {
+    #gpu_descriptor(descriptor) {
 
         const shaders = this.#shaders;
 
         const layouts = this.#layouts;
-        const device = this.#device;
-
 
         const gpu_descriptor = {
             label: descriptor.label,
@@ -97,6 +112,20 @@ export class RenderPipelineManager {
             };
         }
 
+        return gpu_descriptor;
+    }
+
+    /**
+     *
+     * @param {RenderPipelineDescriptor} descriptor
+     * @returns {GPURenderPipeline}
+     */
+    #create(descriptor) {
+
+        const device = this.#device;
+
+        const gpu_descriptor = this.#gpu_descriptor(descriptor);
+
         device.pushErrorScope("validation");
         device.pushErrorScope("internal");
 
@@ -138,4 +167,55 @@ export class RenderPipelineManager {
         return this.#cache.getOrCompute(_descriptor, this.#create, this);
     }
 
+    /**
+     * Compile the pipeline for `descriptor` off the thread that presents frames, into the cache
+     * {@link obtain} reads — see {@link PipelineEnquiry} for why.
+     *
+     * Nothing new starts for a descriptor that is cached or already compiling. A pipeline that fails
+     * is reported and left out of the cache, so `obtain` makes it again the old way and reports it
+     * again. If `obtain` makes it while it is still compiling here, the one `obtain` made is kept.
+     *
+     * @param {RenderPipelineDescriptor} descriptor exactly as {@link obtain} will be asked for it:
+     * after any rewrite for the attachments it is drawn into
+     * @returns {Promise<void>} settles once the pipeline is cached or has failed; never rejects
+     */
+    prepare(descriptor) {
+        assert.isInstanceOf(descriptor, RenderPipelineDescriptor, "descriptor", "RenderPipelineDescriptor");
+
+        const cache = this.#cache;
+
+        if (cache.has(descriptor)) {
+            return Promise.resolve();
+        }
+
+        const pending = this.#pending;
+
+        const existing = pending.get(descriptor);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        const gpu_descriptor = this.#gpu_descriptor(descriptor);
+
+        const compilation = this.#device.createRenderPipelineAsync(gpu_descriptor).then(
+            (pipeline) => {
+                pending.delete(descriptor);
+
+                if (!cache.has(descriptor)) {
+                    cache.set(descriptor, pipeline);
+                }
+            },
+            (error) => {
+                pending.delete(descriptor);
+
+                console.error(`Failed to create "${descriptor.label}" pipeline: `, error.message, gpu_descriptor);
+            }
+        );
+
+        pending.set(descriptor, compilation);
+
+        return compilation;
+    }
+
 }

package/src/shade/playground/contact_shadows/ContactShadowLab.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Which contact term the sun's shadow reads.
+ */
+export type ContactMethod = number;
+export namespace ContactMethod {
+    let Off: number;
+    let Wavefront: number;
+    let March: number;
+    let Linear: number;
+}
+/**
+ * The contact shadow playground's frame work, as two render extensions sharing this state:
+ *
+ * - at {@link FramePhase.AfterLighting}: the contact term ({@link method}), the ray-traced sun
+ *   visibility when asked for ({@link reference}), the composite that puts the contact term into the
+ *   sun's shadow, and, while {@link measuring}, the counters;
+ * - at {@link FramePhase.BeforePresent}: the debug {@link view}, drawn after the upscale and before the
+ *   tonemap.
+ *
+ * Nothing here changes the renderer's own passes; see {@link shader_contact_lab_composite} for how the
+ * mask reaches the lit image without them.
+ */
+export class ContactShadowLab {
+    /**
+     * @param {import("../../renderer/Renderer.js").Renderer} renderer
+     */
+    constructor(renderer: import("../../renderer/Renderer.js").Renderer);
+    /** @type {number} a {@link ContactMethod} */
+    method: number;
+    /** @type {number} a {@link ContactCombine} */
+    combine: number;
+    /** @type {number} a {@link ContactLabView} */
+    view: number;
+    /**
+     * Trace the sun's visibility from every pixel through the scene's BVH, for the reference and error
+     * views. Always on while {@link measuring}.
+     * @type {boolean}
+     */
+    reference: boolean;
+    /**
+     * Run the counters this frame; {@link read_stats} collects them.
+     * @type {boolean}
+     */
+    measuring: boolean;
+    /**
+     * Tuning shared by both methods: Bend's starting values (`bend_sss_gpu.h`, `SetDefaults`).
+     */
+    settings: {
+        surface_thickness: number;
+        bilinear_threshold: number;
+        shadow_contrast: number;
+        flags: number;
+        debug_mode: number;
+    };
+    /**
+     * Unit vector from the scene toward the sun, world space. The playground's scenes keep it.
+     * @type {Float32Array}
+     */
+    to_light: Float32Array;
+    /**
+     * How far the reference's rays start off their surface, along its geometric normal, as a fraction of
+     * the pixel's distance from the camera: a position rebuilt from the depth buffer is off by an amount
+     * that grows with distance, and a ray starting under its own surface shadows itself.
+     *
+     * Measured on the 4090 (still camera, 1578×802), pixels the reference shadows: with `offset_ray`
+     * alone 180,140 in `combine` and 96,352 in `grazing` (the far ground shadowing itself); 43,101 and
+     * 45,579 at 1e-6; 25,166 and 9,709 at 1e-5, where both settle (3e-5 … 3e-4 within 0.2% of it); at
+     * 1e-3 real contacts start to go (`grazing` 9,393). 3e-5 is three times the onset.
+     * @type {number}
+     */
+    reference_normal_offset: number;
+    /**
+     * Samples per pixel the march arm takes, matched to the wavefront pass's 60.
+     * @type {number}
+     */
+    march_steps: number;
+    /**
+     * The linear trace's settings, read when its pass executes (`CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT`).
+     * `to_light` is kept equal to {@link to_light}; `jitter_frame` is the view's frame index while
+     * {@link linear_jitter} is on. The page sets the rest.
+     */
+    linear_settings: {
+        to_light: Float32Array;
+        length: number;
+        steps: number;
+        thickness: number;
+        jitter_frame: number;
+    };
+    /**
+     * Shift each pixel's first step by noise every frame, for TAA to integrate.
+     * @type {boolean}
+     */
+    linear_jitter: boolean;
+    /**
+     * Copy the lit colour of the next frames aside, for {@link read_capture}.
+     * @type {boolean}
+     */
+    capture: boolean;
+    /**
+     * Records at {@link FramePhase.AfterLighting}.
+     * @type {RenderExtension}
+     */
+    lighting: RenderExtension;
+    /**
+     * Records at {@link FramePhase.BeforePresent}.
+     * @type {RenderExtension}
+     */
+    overlay: RenderExtension;
+    /**
+     * Forget the last measured frame, so the next one counts no flips against a frame from elsewhere.
+     */
+    reset_history(): void;
+    /**
+     * Zero the counters ahead of a measured frame; queued, so it lands before the frame's commands.
+     */
+    clear_stats(): void;
+    /**
+     * The counters of the last measured frame, after its commands.
+     *
+     * @returns {Promise<Uint32Array>} indexed by {@link ContactStat}
+     */
+    read_stats(): Promise<Uint32Array>;
+    /**
+     * The colour the last captured frame was lit with, as RGB floats.
+     *
+     * @returns {Promise<{rgb: Float32Array, width: number, height: number}>}
+     */
+    read_capture(): Promise<{
+        rgb: Float32Array;
+        width: number;
+        height: number;
+    }>;
+    destroy(): void;
+    #private;
+}
+import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
+//# sourceMappingURL=ContactShadowLab.d.ts.map

package/src/shade/playground/contact_shadows/ContactShadowLab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactShadowLab.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/ContactShadowLab.js"],"names":[],"mappings":";;;4BAwBU,MAAM;;;;;;;AAehB;;;;;;;;;;;GAWG;AACH;IAuII;;OAEG;IACH,sBAFW,OAAO,4BAA4B,EAAE,QAAQ,EAiEvD;IAxMD,6CAA6C;IAC7C,QADW,MAAM,CACgB;IAEjC,8CAA8C;IAC9C,SADW,MAAM,CACiB;IAElC,8CAA8C;IAC9C,MADW,MAAM,CACW;IAE5B;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,WAFU,OAAO,CAEC;IAElB;;OAEG;IACH;;;;;;MAME;IAEF;;;OAGG;IACH,UAFU,YAAY,CAEiB;IAEvC;;;;;;;;;;OAUG;IACH,yBAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,aAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH;;;;;;MAME;IAEF;;;OAGG;IACH,eAFU,OAAO,CAEK;IAoCtB;;;OAGG;IACH,SAFU,OAAO,CAED;IAOhB;;;OAGG;IACH,UAFU,eAAe,CAEhB;IAET;;;OAGG;IACH,SAFU,eAAe,CAEjB;IAsER;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,cAFa,QAAQ,WAAW,CAAC,CAgBhC;IA0QD;;;;OAIG;IACH,gBAFa,QAAQ;QAAC,GAAG,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CA0CvE;IA8BD,gBAIC;;CACJ;gCApnB+B,6CAA6C"}