@woosh/meep-engine 3.65.0 → 3.68.0

package/src/shade/renderer/light/GPULightCollection.js

@@ -1,7 +1,10 @@
 import { assert } from "../../../core/assert.js";
 import { gpu_texture_format_info } from "../../descriptor/texture/format/gpu_texture_format_info.js";
+import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
 import { isImageBitmap } from "../../../core/dom/isImageBitmap.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { create_atmosphere_sun_state, resolve_atmosphere_sun } from "../atmosphere/resolve_atmosphere_sun.js";
+import { SKY_IRRADIANCE_LUT_RESOLUTION, shader_sky_irradiance_lut } from "../atmosphere/shader_sky_irradiance_lut.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { GPUSceneShadowmapContext } from "../shadow/map/GPUSceneShadowmapContext.js";
 import { GPUTextureContext } from "../texture/GPUTextureContext.js";
@@ -50,15 +53,23 @@ import {
  */
 const MAX_DIRECTIONAL_LIGHTS = 32;
 
+const MIP_0_VIEW_DESCRIPTOR = TextureViewDescriptor.from({
+    baseMipLevel: 0,
+    mipLevelCount: 1,
+});
+
+const ZERO_ENVIRONMENT_SH = new Float32Array(ENVIRONMENT_SH_TYPE.size / 4);
+
 export class GPULightCollection {
 
     /**
      * Offer the pipelines a scene's lights are updated with — the environment map's filtering and
-     * projection, and the pose refresh — see {@link PipelineEnquiry}.
+     * projection, procedural sky mip-0 synthesis, and the pose refresh — see {@link PipelineEnquiry}.
      *
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry) {
+        enquiry.render.push(shader_sky_irradiance_lut.pipeline);
         enquire_filter_environment_map_pipelines(enquiry);
         enquiry.compute.push(shader_project_environment_sh.pipeline);
         enquiry.compute.push(shader_project_far_field_irradiance_sh.pipeline);
@@ -66,6 +77,11 @@ export class GPULightCollection {
     }
 
 
+    /**
+     * @type {GPUSceneContext}
+     */
+    #scene_ctx;
+
     /**
      * @type {LightCollection}
      */
@@ -178,10 +194,39 @@ export class GPULightCollection {
     #environment;
 
     /**
-     * @type {ShadeTexture}
+     * @type {ShadeTexture|undefined}
      */
     #environment_source;
 
+    /**
+     * Active backing mode for {@link #environment}: `"black"` (`1×1` zeroed fallback),
+     * `"texture"` (authored `ShadeTexture` from `lights.environment`), or `"atmosphere"`
+     * (procedural Hillaire octahedral sky driven by `scene.atmosphere`).
+     *
+     * @type {"black" | "texture" | "atmosphere"}
+     */
+    #environment_mode = "black";
+
+    /**
+     * Reusable per-update sun descriptor for procedural sky synthesis.
+     */
+    #atmosphere_sun_state = create_atmosphere_sun_state();
+
+    /**
+     * Reusable immediate settings payload for {@link shader_sky_irradiance_lut}.
+     */
+    #sky_irradiance_settings = {
+        sun_direction: this.#atmosphere_sun_state.sun_direction,
+        reference_altitude: 0,
+        sun_irradiance: this.#atmosphere_sun_state.sun_irradiance,
+        resolution: SKY_IRRADIANCE_LUT_RESOLUTION,
+    };
+
+    #committed_atmosphere_version = -1;
+    #committed_reference_altitude = NaN;
+    #committed_sun_direction = new Float32Array([NaN, NaN, NaN]);
+    #committed_sun_irradiance = new Float32Array([NaN, NaN, NaN]);
+
     /**
      * The environment's radiance as RGB SH2, projected from {@link #environment} whenever it changes;
      * see {@link shader_project_environment_sh}.
@@ -258,6 +303,7 @@ export class GPULightCollection {
         const device = graphics.device;
 
         this.#device = device;
+        this.#scene_ctx = scene_ctx;
         this.#source = scene.lights;
 
         this.#source.onRemoved.add(this.#removed, this);
@@ -268,6 +314,7 @@ export class GPULightCollection {
         this.#environment.descriptor.usage |=
             GPUTextureUsage.COPY_DST // so we can write to it
             | GPUTextureUsage.STORAGE_BINDING // so we can convolve it in compute shader
+            | GPUTextureUsage.RENDER_ATTACHMENT // for procedural sky mip-0 synthesis and ImageBitmap uploads
         ;
 
         // zeroed on creation, which is what an absent environment projects to
@@ -298,115 +345,201 @@ export class GPULightCollection {
      */
     #update_environment(ctx) {
         const source_env = this.#source.environment;
+        const gpu_ctx = this.#environment;
+
+        if (source_env !== undefined) {
+            if (this.#environment_mode === "texture" && this.#environment_source === source_env) {
+                return;
+            }
+
+            const source_image = source_env.image;
+
+            /*
+             An environment map comes with a one-texel octahedral skirt: the octahedral square in the
+             interior, each texel of the outer ring a copy of the one the fold puts beside it. The renderer
+             filters it in hardware through that skirt and skirts the levels it filters itself; an
+             unskirted map is the caller's error, and it would read as seams along the octahedron's
+             edges. Every level the roughness mapping reaches needs an interior, so 3 texels at the last.
+             `resample_equirectangular_to_octahedral` and the offline converter write the skirt by default.
+
+             Checked where the pixels are on hand; an ImageBitmap's are not.
+            */
+            assert.greaterThanOrEqual(
+                source_image.width >> (SPHERE_PROBE_MIPMAP_LEVELS - 1),
+                3,
+                'environment map too small for its last filtered level'
+            );
+
+            assert.equal(source_image.width, source_image.height, 'an octahedral environment map is square');
+
+            const source_texels = source_image.source;
+
+            if (source_texels?.isSampler2D === true) {
+                assert.ok(
+                    octahedral_skirt_matches(source_texels.data, source_texels.itemSize, source_texels.width),
+                    'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
+                );
+            } else if (
+                source_texels?.isShadeTexelData === true
+                && source_texels.levels[0] !== undefined
+                && gpu_texture_format_info(source_texels.format).block_width === 1
+            ) {
+                assert.ok(
+                    octahedral_skirt_matches(
+                        source_texels.levels[0],
+                        gpu_texture_format_info(source_texels.format).bytes_per_block,
+                        source_texels.width
+                    ),
+                    'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
+                );
+            }
+
+            this.#environment_mode = "texture";
+            this.#environment_source = source_env;
+
+            /*
+             Assign descriptor.size directly rather than calling gpu_ctx.resize(): resize() immediately
+             re-allocates when the context is already in TEXTURE_STATE_ALLOCATED, which would call
+             createTexture with the new size and the previous map's mipLevelCount (failing WebGPU
+             validation whenever the new map is smaller) before allocate() below replaces it again.
+            */
+            gpu_ctx.descriptor.size = [source_image.width, source_image.height, 1];
+            /*
+             The environment map is octahedral 2D and this context keeps the default dimension while
+             `size` above sets two spatial axes. Asked of the descriptor rather than assumed, so the
+             count follows if that ever stops being true.
+            */
+            const gpu_size = gpu_ctx.descriptor.size;
+
+            gpu_ctx.descriptor.mipLevelCount = texture_mip_level_count(
+                gpu_size.width, gpu_size.height, gpu_size.depthOrArrayLayers, gpu_ctx.descriptor.dimension
+            );
+
+            if (isImageBitmap(source_image.source)) {
+                // need RENDER_ATTACHMENT to use GPUQueue.copyExternalImageToTexture API
+                gpu_ctx.descriptor.usage |= GPUTextureUsage.RENDER_ATTACHMENT;
+            }
+
+            gpu_ctx.allocate();
+            gpu_ctx.incrementVersion();
+
+            texture_write_to_gpu(source_image, gpu_ctx.gpu_texture, this.#device.queue, source_image.level_count);
+
+            // convolve
+            const cmd = ShadeGPUCommandContext.create(ctx);
+
+            encode_filter_environment_map(gpu_ctx, cmd);
 
-        if (this.#environment_source === source_env) {
-            // assume up-to-date
+            // after the prefilter, whose roughest levels are what it reads
+            shader_project_environment_sh.dispatch({
+                encoder: cmd,
+                group_count_x: 1,
+                bindings: {
+                    tEnvironment: gpu_ctx.obtainView(),
+                    output: this.#environment_sh,
+                },
+            });
+
+            this.#far_field_sh_dirty = true;
+
+            cmd.finish();
             return;
         }
 
-        this.#environment_source = source_env;
-
-        const gpu_ctx = this.#environment;
+        const scene = this.#scene_ctx.scene;
+        const atmosphere = scene.atmosphere;
 
         /*
-         No environment is a supported state, not a mistake: LightCollection's setter takes
-         undefined — its assert is conditional on the value being defined — and serialize_scene
-         writes the absence of one. Clearing a map that had been set used to walk straight into
-         source_env.image and take the frame down from inside the renderer's per-frame update.
-
-         Every consumer binds this texture unconditionally — the path tracer, the probe atlas, the
-         lightmap baker, the transparent passes all call obtainView() on it without asking whether
-         there is an environment — so it has to keep existing. A freshly allocated 1x1 at one mip
-         is zeroed, which is the same black IBL they read before an environment is ever assigned.
+         No authored environment and procedural atmosphere disabled: keep a valid 1x1 zeroed texture
+         and zeroed SH buffer because downstream consumers (path tracer, probe atlas, lightmap baker,
+         transparent passes) bind `environment` unconditionally via `obtainView()`.
         */
-        if (source_env === undefined) {
+        if (!atmosphere.enabled) {
+            if (this.#environment_mode === "black") {
+                return;
+            }
+
+            this.#environment_mode = "black";
+            this.#environment_source = undefined;
+
             gpu_ctx.descriptor.mipLevelCount = 1;
             gpu_ctx.descriptor.size = [1, 1, 1];
 
             gpu_ctx.allocate();
+            gpu_ctx.incrementVersion();
 
             // what a black environment projects to; nothing to run the projection over
-            this.#device.queue.writeBuffer(this.#environment_sh, 0, new Float32Array(this.#environment_sh.size / 4));
+            this.#device.queue.writeBuffer(this.#environment_sh, 0, ZERO_ENVIRONMENT_SH);
             this.#far_field_sh_dirty = true;
 
             return;
         }
 
-        const source_image = source_env.image;
-
-        /*
-         An environment map comes with a one-texel octahedral skirt: the octahedral square in the
-         interior, each texel of the outer ring a copy of the one the fold puts beside it. The renderer
-         filters it in hardware through that skirt and skirts the levels it filters itself; an
-         unskirted map is the caller's error, and it would read as seams along the octahedron's
-         edges. Every level the roughness mapping reaches needs an interior, so 3 texels at the last.
-         `resample_equirectangular_to_octahedral` and the offline converter write the skirt by default.
-
-         Checked where the pixels are on hand; an ImageBitmap's are not.
-        */
-        assert.greaterThanOrEqual(
-            source_image.width >> (SPHERE_PROBE_MIPMAP_LEVELS - 1),
-            3,
-            'environment map too small for its last filtered level'
-        );
-
-        assert.equal(source_image.width, source_image.height, 'an octahedral environment map is square');
+        const sun = resolve_atmosphere_sun(scene, this.#atmosphere_sun_state);
+
+        if (
+            this.#environment_mode === "atmosphere"
+            && this.#committed_atmosphere_version === atmosphere.version
+            && this.#committed_reference_altitude === atmosphere.reference_altitude
+            && this.#committed_sun_direction[0] === sun.sun_direction[0]
+            && this.#committed_sun_direction[1] === sun.sun_direction[1]
+            && this.#committed_sun_direction[2] === sun.sun_direction[2]
+            && this.#committed_sun_irradiance[0] === sun.sun_irradiance[0]
+            && this.#committed_sun_irradiance[1] === sun.sun_irradiance[1]
+            && this.#committed_sun_irradiance[2] === sun.sun_irradiance[2]
+        ) {
+            return;
+        }
 
-        const source_texels = source_image.source;
+        const sky = this.#scene_ctx.sky;
+        sky.update();
 
-        if (source_texels?.isSampler2D === true) {
-            assert.ok(
-                octahedral_skirt_matches(source_texels.data, source_texels.itemSize, source_texels.width),
-                'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
-            );
-        } else if (
-            source_texels?.isShadeTexelData === true
-            && source_texels.levels[0] !== undefined
-            && gpu_texture_format_info(source_texels.format).block_width === 1
+        if (
+            this.#environment_mode !== "atmosphere"
+            || gpu_ctx.width !== SKY_IRRADIANCE_LUT_RESOLUTION
+            || gpu_ctx.height !== SKY_IRRADIANCE_LUT_RESOLUTION
         ) {
-            assert.ok(
-                octahedral_skirt_matches(
-                    source_texels.levels[0],
-                    gpu_texture_format_info(source_texels.format).bytes_per_block,
-                    source_texels.width
-                ),
-                'environment map has no octahedral skirt (see sampler2d_octahedral_skirt_fill)'
+            gpu_ctx.descriptor.size = [SKY_IRRADIANCE_LUT_RESOLUTION, SKY_IRRADIANCE_LUT_RESOLUTION, 1];
+            const gpu_size = gpu_ctx.descriptor.size;
+            gpu_ctx.descriptor.mipLevelCount = texture_mip_level_count(
+                gpu_size.width, gpu_size.height, gpu_size.depthOrArrayLayers, gpu_ctx.descriptor.dimension
             );
+            gpu_ctx.allocate();
         }
 
-        /*
-         Assign descriptor.size directly rather than calling gpu_ctx.resize(): resize() immediately
-         re-allocates when the context is already in TEXTURE_STATE_ALLOCATED, which would call
-         createTexture with the new size and the previous map's mipLevelCount (failing WebGPU
-         validation whenever the new map is smaller) before allocate() below replaces it again.
-        */
-        gpu_ctx.descriptor.size = [source_image.width, source_image.height, 1];
-        /*
-         The environment map is equirectangular and this context is built 2D a few lines up — the
-         descriptor keeps the default dimension and `size` above only sets two spatial axes. Asked of
-         the descriptor rather than assumed, so the count follows if that ever stops being true.
-        */
-        const gpu_size = gpu_ctx.descriptor.size;
+        gpu_ctx.incrementVersion();
 
-        gpu_ctx.descriptor.mipLevelCount = texture_mip_level_count(
-            gpu_size.width, gpu_size.height, gpu_size.depthOrArrayLayers, gpu_ctx.descriptor.dimension
-        );
+        this.#environment_mode = "atmosphere";
+        this.#environment_source = undefined;
+        this.#committed_atmosphere_version = atmosphere.version;
+        this.#committed_reference_altitude = atmosphere.reference_altitude;
+        this.#committed_sun_direction.set(sun.sun_direction);
+        this.#committed_sun_irradiance.set(sun.sun_irradiance);
 
-        if (isImageBitmap(source_image.source)) {
-            // need RENDER_ATTACHMENT to use GPUQueue.copyExternalImageToTexture API
-            gpu_ctx.descriptor.usage |= GPUTextureUsage.RENDER_ATTACHMENT;
-        }
-
-        gpu_ctx.allocate();
+        this.#sky_irradiance_settings.reference_altitude = atmosphere.reference_altitude;
 
-        texture_write_to_gpu(source_image, gpu_ctx.gpu_texture, this.#device.queue, source_image.level_count);
+        const cmd = ShadeGPUCommandContext.create(ctx, "GPULightCollection/sky_environment");
 
-        // convolve
-        const cmd = ShadeGPUCommandContext.create(ctx);
+        shader_sky_irradiance_lut.draw({
+            encoder: cmd,
+            bindings: {
+                settings: this.#sky_irradiance_settings,
+                atmosphere: sky.parameters_buffer.buffer,
+                tSkyLutTransmittance: sky.lut_transmittance.obtainView(),
+                tSkyLutMultiscatter: sky.lut_multiple_scattering.obtainView(),
+            },
+            colorAttachments: [
+                {
+                    view: gpu_ctx.obtainView(MIP_0_VIEW_DESCRIPTOR),
+                    loadOp: "clear",
+                    storeOp: "store",
+                    clearValue: [0, 0, 0, 1],
+                }
+            ],
+        });
 
         encode_filter_environment_map(gpu_ctx, cmd);
 
-        // after the prefilter, whose roughest levels are what it reads
         shader_project_environment_sh.dispatch({
             encoder: cmd,
             group_count_x: 1,

package/src/shade/renderer/{atmosphere → light/environment}/chunk_sample_environment_color.d.ts

@@ -2,9 +2,8 @@
  * The environment map's level 0 in a direction: one hardware bilinear tap through the octahedral
  * skirt (see `texture_octahedral_skirt_uv`).
  *
- * see {@link shader_sky_irradiance_lut}
  * @type {CodeChunk}
  */
 export const chunk_sample_environment_color: CodeChunk;
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_sample_environment_color.d.ts.map

package/src/shade/renderer/light/environment/chunk_sample_environment_color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sample_environment_color.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/chunk_sample_environment_color.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,6CAFU,SAAS,CAcjB;0BApBwB,oCAAoC"}

package/src/shade/renderer/{atmosphere → light/environment}/chunk_sample_environment_color.js

@@ -1,12 +1,11 @@
-import { chunk_uv_octahedral_unit_encode } from "../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
-import { chunk_texture_octahedral_skirt_uv } from "../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_uv_octahedral_unit_encode } from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_texture_octahedral_skirt_uv } from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 
 /**
  * The environment map's level 0 in a direction: one hardware bilinear tap through the octahedral
  * skirt (see `texture_octahedral_skirt_uv`).
  *
- * see {@link shader_sky_irradiance_lut}
  * @type {CodeChunk}
  */
 export const chunk_sample_environment_color = CodeChunk.from(

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#312@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#315@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js

@@ -1,6 +1,6 @@
 import { f32, u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { chunk_sample_environment_color } from "../../atmosphere/chunk_sample_environment_color.js";
+import { chunk_sample_environment_color } from "../../light/environment/chunk_sample_environment_color.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
 import { chunk_BRDF_GGX } from "../../shader/chunk/brdf/chunk_BRDF_GGX.js";
 import { chunk_compute_ggx_vndf_pdf } from "../../shader/chunk/brdf/chunk_compute_ggx_pdf.js";

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js

@@ -41,7 +41,7 @@ fn main(
 
     let depth = textureLoad( DepthBuffer, current_coord, 0 ).r;
 
-    let velocity = textureLoad( VelocityBuffer, current_coord, 0 ).rgb;
+    let velocity = textureLoad( VelocityBuffer, current_coord, 0 ).rg;
     let current_coord_f = vec2<f32>(current_coord.xy);
     
     let previous_coord = current_coord_f - velocity.xy;

package/src/shade/renderer/postprocess/eye/GPUCameraExposureManager.d.ts

@@ -5,6 +5,10 @@
  * The factor lives in one buffer for the manager's life, {@link multiplier}, which a frame's {@link update} or
  * {@link unadapted} writes over. A pass recorded ahead of that write in the frame reads the factor the last frame was
  * shown with: the exposure of the image on screen, Unreal Engine's `View.PreExposure`.
+ *
+ * Beside it, {@link adaptation}: the luminance the view is adapted to, cd/m², written by the same pass. Adapted, it is
+ * the luminance the eye has adapted to, without {@link exposure_compensation}; unadapted, it is the luminance the
+ * exposure shows at middle grey.
  */
 export class GPUCameraExposureManager {
     /**
@@ -44,9 +48,17 @@ export class GPUCameraExposureManager {
      * imports it into its graph once, and hands the handle both to the passes that read it ahead of the exposure,
      * which take the last frame's factor, and to {@link update} or {@link unadapted}, which write this frame's.
      *
-     * @returns {GPUBuffer} usable as a uniform or read-only storage
+     * @returns {GPUBuffer} usable as a uniform or read-only storage, and as a copy source, to read it back
      */
     get multiplier(): GPUBuffer;
+    /**
+     * The luminance the view is adapted to, cd/m², {@link F32_CONTAINER_STRUCT}, as the last {@link update} or
+     * {@link unadapted} wrote it. Imported into a frame's graph once and handed to {@link update} or {@link unadapted},
+     * like {@link multiplier}.
+     *
+     * @returns {GPUBuffer} usable as a uniform or read-only storage
+     */
+    get adaptation(): GPUBuffer;
     /**
      * Offer the pipelines {@link update} meters and adapts with — see {@link PipelineEnquiry}.
      * {@link unadapted} dispatches none.
@@ -55,34 +67,48 @@ export class GPUCameraExposureManager {
      */
     enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
-     * This frame's factor from {@link exposure_compensation} alone: 2^compensation.
+     * This frame's factor from {@link exposure_compensation} alone: 2^compensation. Its adaptation is the luminance
+     * that factor shows at middle grey, 0.18 / 2^compensation cd/m².
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
-     * @return {number} the handle of {@link multiplier} with this frame's factor written
+     * @param {number} options.adaptation the graph handle of {@link adaptation}, imported into `graph`
+     * @return {{multiplier: number, adaptation: number}} the handles of {@link multiplier} and {@link adaptation}
+     *         with this frame's written; the object is reused by the next call
      */
-    unadapted({ graph, multiplier, }: {
+    unadapted({ graph, multiplier, adaptation, }: {
         graph: FrameGraph;
         multiplier: number;
-    }): number;
+        adaptation: number;
+    }): {
+        multiplier: number;
+        adaptation: number;
+    };
     /**
      * This frame's factor metered from `input_color`: the luminance adapted toward the frame's, from the last
-     * frame's, by the adaptation speeds; its factor is middle grey over it, times 2^{@link exposure_compensation}.
+     * frame's, by the adaptation speeds; its factor is middle grey over it, times 2^{@link exposure_compensation}. Its
+     * adaptation is that adapted luminance, without the compensation.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {number} options.input_color
      * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
+     * @param {number} options.adaptation the graph handle of {@link adaptation}, imported into `graph`
      * @param {number} [options.time_delta_seconds]
-     * @return {number} the handle of {@link multiplier} with this frame's factor written
+     * @return {{multiplier: number, adaptation: number}} the handles of {@link multiplier} and {@link adaptation}
+     *         with this frame's written; the object is reused by the next call
      */
-    update({ input_color, graph, multiplier, time_delta_seconds, }: {
+    update({ input_color, graph, multiplier, adaptation, time_delta_seconds, }: {
         graph: FrameGraph;
         input_color: number;
         multiplier: number;
+        adaptation: number;
         time_delta_seconds?: number;
-    }): number;
+    }): {
+        multiplier: number;
+        adaptation: number;
+    };
     #private;
 }
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;

package/src/shade/renderer/postprocess/eye/GPUCameraExposureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUCameraExposureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/GPUCameraExposureManager.js"],"names":[],"mappings":"AAwBA;;;;;;;GAOG;AACH;IA0DI;;;OAGG;IACH,+BAyBC;IAtED;;;;OAIG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,yBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,uBAFU,MAAM,CAEY;IA4C5B,gBAMC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAMzB;IAED;;;;;;;OAOG;IACH;QAJ+B,KAAK;QACT,UAAU,EAA1B,MAAM;QACL,MAAM,CAejB;IAoBD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACU,UAAU,EAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACL,MAAM,CAmDjB;;CA2EJ;8BA7TY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"GPUCameraExposureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/GPUCameraExposureManager.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;GAWG;AACH;IAuEI;;;OAGG;IACH,+BAoCC;IAlFD;;;;OAIG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,yBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,uBAFU,MAAM,CAEY;IAwD5B,gBAOC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAMzB;IAED;;;;;;;;;;OAUG;IACH;QAN+B,KAAK;QACT,UAAU,EAA1B,MAAM;QACU,UAAU,EAA1B,MAAM;QACL;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAwBnD;IAsBD;;;;;;;;;;;;;OAaG;IACH;QAR+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,UAAU,EAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACL;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA4DnD;;CA4EJ;8BAnYY,OAAO,6CAA6C,EAAE,eAAe"}