@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/render/gi/scene_gi.js

@@ -0,0 +1,282 @@
+import { GlobalSDF } from '../sdf/global_sdf.js';
+import { VoxelScene } from './voxel_scene.js';
+import { ProbeVolume } from './probe_volume.js';
+import { PROBE_MAX_LEVELS } from '../../shaders/probes.js';
+import { RenderGraphExecutor } from '../rendergraph/executor.js';
+
+/**
+ * Probe-based global illumination of a scene, at `scene.gi`. Off by default.
+ *
+ * Built on the scene's signed distance field (enabling it turns the field on) plus
+ * a {@link VoxelScene} giving the field's surfaces albedo and emissive. WebGPU only.
+ *
+ * @public
+ */ class SceneGI {
+    _scene;
+    _enabled;
+    _voxels;
+    _atlasSize;
+    _voxelizeBudget;
+    _lighting;
+    _probeOptions;
+    _probes;
+    _updateMode;
+    _warned;
+    constructor(scene){
+        this._scene = scene;
+        this._enabled = false;
+        this._voxels = null;
+        this._atlasSize = 256;
+        this._voxelizeBudget = 8;
+        this._lighting = {
+            sunShadowConeAngle: 0.5357,
+            slicesPerFrame: 8,
+            localLightShadows: true
+        };
+        this._probeOptions = {
+            grid: [
+                32,
+                16,
+                32
+            ],
+            spacing: 1,
+            levels: 4,
+            levelScale: 2,
+            raysPerProbe: 128,
+            budget: 4096,
+            hysteresis: 0.97,
+            // Lumen's irradiance field gather: (0.2 N + 0.8 V) * 0.75 * cell * 0.8
+            normalBias: 0.12,
+            viewBias: 0.48,
+            intensity: 1,
+            maxRayDistance: 48
+        };
+        this._probes = null;
+        this._updateMode = 'continuous';
+        this._warned = false;
+    }
+    /** True on a device that can build it. */ static isSupported() {
+        return GlobalSDF.isSupported();
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(val) {
+        val = !!val;
+        if (val === this._enabled) {
+            return;
+        }
+        this._enabled = val;
+        if (val) {
+            // The voxel scene extends the field; turning the field off afterwards idles this
+            this._scene.sdf.enabled = true;
+        } else {
+            this._voxels?.detach(this._scene.sdf);
+            this._voxels?.dispose();
+            this._voxels = null;
+            this._probes?.dispose();
+            this._probes = null;
+        }
+    }
+    /** The probe volume, once built. */ get probes() {
+        return this._probes;
+    }
+    /** Distance between probes in world units; applied when the volume is next built. */ get probeSpacing() {
+        return this._probeOptions.spacing;
+    }
+    set probeSpacing(val) {
+        val = Math.max(0.1, val);
+        if (val !== this._probeOptions.spacing) {
+            this._probeOptions.spacing = val;
+            this.rebuildProbes();
+        }
+    }
+    /** Probes along x, y and z; applied when the volume is next built. */ get probeGrid() {
+        return [
+            ...this._probeOptions.grid
+        ];
+    }
+    set probeGrid(val) {
+        const grid = val.map((v)=>Math.max(2, Math.floor(v)));
+        const cur = this._probeOptions.grid;
+        if (grid[0] !== cur[0] || grid[1] !== cur[1] || grid[2] !== cur[2]) {
+            this._probeOptions.grid = grid;
+            this.rebuildProbes();
+        }
+    }
+    /** Clipmap levels of the probe volume, each twice the spacing of the one inside it; applied when the volume is next built. */ get probeLevels() {
+        return this._probeOptions.levels;
+    }
+    set probeLevels(val) {
+        val = Math.max(1, Math.min(PROBE_MAX_LEVELS, Math.floor(val)));
+        if (val !== this._probeOptions.levels) {
+            this._probeOptions.levels = val;
+            this.rebuildProbes();
+        }
+    }
+    /**
+   * Whether the indirect lighting keeps updating. `frozen` stops voxel lighting and
+   * probe updates (including the probe windows following the camera).
+   */ get updateMode() {
+        return this._updateMode;
+    }
+    set updateMode(val) {
+        this._updateMode = val === 'frozen' ? 'frozen' : 'continuous';
+    }
+    /** Saves the probe volume's state, see {@link ProbeVolume.exportState}. */ exportProbeState() {
+        if (!this._probes?.ready) {
+            throw new Error('SceneGI.exportProbeState(): the probes are not built yet');
+        }
+        return this._probes.exportState();
+    }
+    /**
+   * Restores a probe state saved by {@link SceneGI.exportProbeState} into a
+   * volume built with the current settings, and freezes the lighting.
+   */ importProbeState(buffer) {
+        if (!this._probes) {
+            this._probes = new ProbeVolume(this._scene, this._probeOptions);
+        }
+        this._probes.importState(buffer);
+        this._updateMode = 'frozen';
+    }
+    /** Rays traced per probe per update; applied when the volume is next built. */ get probeRays() {
+        return this._probeOptions.raysPerProbe;
+    }
+    set probeRays(val) {
+        val = Math.max(16, Math.min(1024, Math.floor(val)));
+        if (val !== this._probeOptions.raysPerProbe) {
+            this._probeOptions.raysPerProbe = val;
+            this.rebuildProbes();
+        }
+    }
+    /** Probes updated per frame; applied when the volume is next built. */ get probeBudget() {
+        return this._probeOptions.budget;
+    }
+    set probeBudget(val) {
+        val = Math.max(1, Math.floor(val));
+        if (val !== this._probeOptions.budget) {
+            this._probeOptions.budget = val;
+            this.rebuildProbes();
+        }
+    }
+    /** Share of a probe's previous value kept per update, 0 to 1. */ get probeHysteresis() {
+        return this._probeOptions.hysteresis;
+    }
+    set probeHysteresis(val) {
+        this._probeOptions.hysteresis = Math.max(0, Math.min(0.999, val));
+    }
+    /** Multiplier on the indirect light the probes give. */ get intensity() {
+        return this._probeOptions.intensity;
+    }
+    set intensity(val) {
+        this._probeOptions.intensity = Math.max(0, val);
+    }
+    /** Surface offset along the normal when sampling the probes, in probe spacings of the level read. */ get probeNormalBias() {
+        return this._probeOptions.normalBias;
+    }
+    set probeNormalBias(val) {
+        this._probeOptions.normalBias = Math.max(0, val);
+    }
+    /** Surface offset towards the viewer when sampling the probes, in probe spacings of the level read. */ get probeViewBias() {
+        return this._probeOptions.viewBias;
+    }
+    set probeViewBias(val) {
+        this._probeOptions.viewBias = Math.max(0, val);
+    }
+    /** @internal */ rebuildProbes() {
+        this._probes?.dispose();
+        this._probes = null;
+    }
+    /** Meshes voxelized per frame. */ get voxelizeBudget() {
+        return this._voxelizeBudget;
+    }
+    set voxelizeBudget(val) {
+        this._voxelizeBudget = Math.max(1, Math.floor(val));
+    }
+    /** Voxels per axis of the material atlas; applied when the voxel scene is next built. */ get atlasSize() {
+        return this._atlasSize;
+    }
+    set atlasSize(val) {
+        val = Math.max(16, Math.floor(val));
+        if (val !== this._atlasSize) {
+            this._atlasSize = val;
+            this._voxels?.detach(this._scene.sdf);
+            this._voxels?.dispose();
+            this._voxels = null;
+        }
+    }
+    /** Half angle of the sun shadow cone in the voxel lighting, in degrees; wider is softer. */ get sunShadowConeAngle() {
+        return this._lighting.sunShadowConeAngle;
+    }
+    set sunShadowConeAngle(val) {
+        this._lighting.sunShadowConeAngle = Math.max(0.1, Math.min(45, val));
+    }
+    /**
+   * Whether point, spot and rect lights that cast shadows also cast them in the bounced light,
+   * traced through the global distance field for the nearest eight such lights. Default true.
+   */ get localLightShadows() {
+        return this._lighting.localLightShadows;
+    }
+    set localLightShadows(val) {
+        this._lighting.localLightShadows = !!val;
+    }
+    /** Z slices of every clipmap level lit per frame; the voxel lighting is refreshed every `64 / slices` frames. */ get lightingSlicesPerFrame() {
+        return this._lighting.slicesPerFrame;
+    }
+    set lightingSlicesPerFrame(val) {
+        this._lighting.slicesPerFrame = Math.max(1, Math.floor(val));
+    }
+    /** The voxel scene, once built. */ get voxels() {
+        return this._voxels;
+    }
+    getStats() {
+        return {
+            enabled: this._enabled,
+            supported: SceneGI.isSupported(),
+            voxels: this._voxels?.getStats() ?? null,
+            probes: this._probes?.getStats() ?? null
+        };
+    }
+    /** Called by the scene once a frame, before the scene field's update. */ update(cameraPos, deltaSeconds) {
+        if (!this._enabled || !this._scene.sdf.enabled) {
+            return;
+        }
+        if (!SceneGI.isSupported()) {
+            if (!this._warned) {
+                this._warned = true;
+                console.warn('SceneGI: global illumination needs WebGPU; nothing is built on this device');
+            }
+            return;
+        }
+        if (!this._voxels) {
+            this._voxels = new VoxelScene(this._scene, this._atlasSize);
+        }
+        this._voxels.voxelizeBudget = this._voxelizeBudget;
+        this._voxels.update(this._scene.sdf, cameraPos, deltaSeconds);
+    }
+    /** Called by the scene once a frame, after the scene field's update. */ updateLighting(camera) {
+        if (!this._enabled || !this._voxels || !this._scene.sdf.enabled) {
+            return;
+        }
+        // The probes are read at the camera's exposure even while frozen
+        this._probes?.setReadExposure(camera);
+        if (this._updateMode === 'frozen') {
+            return;
+        }
+        RenderGraphExecutor.profileScope('VoxelLighting', ()=>this._voxels.updateLighting(this._scene.sdf, camera, this._lighting));
+        if (!this._voxels.lit) {
+            return;
+        }
+        if (!this._probes) {
+            this._probes = new ProbeVolume(this._scene, this._probeOptions);
+        }
+        this._probes.setReadExposure(camera);
+        RenderGraphExecutor.profileScope('ProbeUpdate', ()=>this._probes.update(this._scene.sdf, this._voxels, camera));
+    }
+    dispose() {
+        this.enabled = false;
+    }
+}
+
+export { SceneGI };
+//# sourceMappingURL=scene_gi.js.map

package/dist/render/gi/scene_gi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene_gi.js","sources":["../../../src/render/gi/scene_gi.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport type { Vector3 } from '@zephyr3d/base';\r\nimport type { Scene } from '../../scene/scene';\r\nimport type { Camera } from '../../camera/camera';\r\nimport { GlobalSDF } from '../sdf/global_sdf';\r\nimport { VoxelScene } from './voxel_scene';\r\nimport type { VoxelSceneStats } from './voxel_scene';\r\nimport type { VoxelLightingOptions } from './voxel_lighting';\r\nimport { ProbeVolume } from './probe_volume';\r\nimport { PROBE_MAX_LEVELS } from '../../shaders/probes';\r\nimport type { ProbeVolumeOptions, ProbeVolumeStats } from './probe_volume';\r\nimport { RenderGraphExecutor } from '../rendergraph/executor';\r\n\r\n/**\r\n * Whether the indirect lighting keeps updating, see {@link SceneGI.updateMode}.\r\n * @public\r\n */\r\nexport type GIUpdateMode = 'continuous' | 'frozen';\r\n\r\n/**\r\n * Counters of a {@link SceneGI}.\r\n * @public\r\n */\r\nexport interface SceneGIStats {\r\n  enabled: boolean;\r\n  /** False on a device that cannot build it (WebGL2). */\r\n  supported: boolean;\r\n  voxels: Nullable<VoxelSceneStats>;\r\n  probes: Nullable<ProbeVolumeStats>;\r\n}\r\n\r\n/**\r\n * Probe-based global illumination of a scene, at `scene.gi`. Off by default.\r\n *\r\n * Built on the scene's signed distance field (enabling it turns the field on) plus\r\n * a {@link VoxelScene} giving the field's surfaces albedo and emissive. WebGPU only.\r\n *\r\n * @public\r\n */\r\nexport class SceneGI {\r\n  private readonly _scene: Scene;\r\n  private _enabled: boolean;\r\n  private _voxels: Nullable<VoxelScene>;\r\n  private _atlasSize: number;\r\n  private _voxelizeBudget: number;\r\n  private readonly _lighting: VoxelLightingOptions;\r\n  private readonly _probeOptions: ProbeVolumeOptions;\r\n  private _probes: Nullable<ProbeVolume>;\r\n  private _updateMode: GIUpdateMode;\r\n  private _warned: boolean;\r\n  constructor(scene: Scene) {\r\n    this._scene = scene;\r\n    this._enabled = false;\r\n    this._voxels = null;\r\n    this._atlasSize = 256;\r\n    this._voxelizeBudget = 8;\r\n    this._lighting = { sunShadowConeAngle: 0.5357, slicesPerFrame: 8, localLightShadows: true };\r\n    this._probeOptions = {\r\n      grid: [32, 16, 32],\r\n      spacing: 1,\r\n      levels: 4,\r\n      levelScale: 2,\r\n      raysPerProbe: 128,\r\n      budget: 4096,\r\n      hysteresis: 0.97,\r\n      // Lumen's irradiance field gather: (0.2 N + 0.8 V) * 0.75 * cell * 0.8\r\n      normalBias: 0.12,\r\n      viewBias: 0.48,\r\n      intensity: 1,\r\n      maxRayDistance: 48\r\n    };\r\n    this._probes = null;\r\n    this._updateMode = 'continuous';\r\n    this._warned = false;\r\n  }\r\n  /** True on a device that can build it. */\r\n  static isSupported() {\r\n    return GlobalSDF.isSupported();\r\n  }\r\n  get enabled() {\r\n    return this._enabled;\r\n  }\r\n  set enabled(val: boolean) {\r\n    val = !!val;\r\n    if (val === this._enabled) {\r\n      return;\r\n    }\r\n    this._enabled = val;\r\n    if (val) {\r\n      // The voxel scene extends the field; turning the field off afterwards idles this\r\n      this._scene.sdf.enabled = true;\r\n    } else {\r\n      this._voxels?.detach(this._scene.sdf);\r\n      this._voxels?.dispose();\r\n      this._voxels = null;\r\n      this._probes?.dispose();\r\n      this._probes = null;\r\n    }\r\n  }\r\n  /** The probe volume, once built. */\r\n  get probes() {\r\n    return this._probes;\r\n  }\r\n  /** Distance between probes in world units; applied when the volume is next built. */\r\n  get probeSpacing() {\r\n    return this._probeOptions.spacing;\r\n  }\r\n  set probeSpacing(val: number) {\r\n    val = Math.max(0.1, val);\r\n    if (val !== this._probeOptions.spacing) {\r\n      this._probeOptions.spacing = val;\r\n      this.rebuildProbes();\r\n    }\r\n  }\r\n  /** Probes along x, y and z; applied when the volume is next built. */\r\n  get probeGrid(): [number, number, number] {\r\n    return [...this._probeOptions.grid];\r\n  }\r\n  set probeGrid(val: [number, number, number]) {\r\n    const grid = val.map((v) => Math.max(2, Math.floor(v))) as [number, number, number];\r\n    const cur = this._probeOptions.grid;\r\n    if (grid[0] !== cur[0] || grid[1] !== cur[1] || grid[2] !== cur[2]) {\r\n      this._probeOptions.grid = grid;\r\n      this.rebuildProbes();\r\n    }\r\n  }\r\n  /** Clipmap levels of the probe volume, each twice the spacing of the one inside it; applied when the volume is next built. */\r\n  get probeLevels() {\r\n    return this._probeOptions.levels;\r\n  }\r\n  set probeLevels(val: number) {\r\n    val = Math.max(1, Math.min(PROBE_MAX_LEVELS, Math.floor(val)));\r\n    if (val !== this._probeOptions.levels) {\r\n      this._probeOptions.levels = val;\r\n      this.rebuildProbes();\r\n    }\r\n  }\r\n  /**\r\n   * Whether the indirect lighting keeps updating. `frozen` stops voxel lighting and\r\n   * probe updates (including the probe windows following the camera).\r\n   */\r\n  get updateMode() {\r\n    return this._updateMode;\r\n  }\r\n  set updateMode(val: GIUpdateMode) {\r\n    this._updateMode = val === 'frozen' ? 'frozen' : 'continuous';\r\n  }\r\n  /** Saves the probe volume's state, see {@link ProbeVolume.exportState}. */\r\n  exportProbeState() {\r\n    if (!this._probes?.ready) {\r\n      throw new Error('SceneGI.exportProbeState(): the probes are not built yet');\r\n    }\r\n    return this._probes.exportState();\r\n  }\r\n  /**\r\n   * Restores a probe state saved by {@link SceneGI.exportProbeState} into a\r\n   * volume built with the current settings, and freezes the lighting.\r\n   */\r\n  importProbeState(buffer: ArrayBuffer) {\r\n    if (!this._probes) {\r\n      this._probes = new ProbeVolume(this._scene, this._probeOptions);\r\n    }\r\n    this._probes.importState(buffer);\r\n    this._updateMode = 'frozen';\r\n  }\r\n  /** Rays traced per probe per update; applied when the volume is next built. */\r\n  get probeRays() {\r\n    return this._probeOptions.raysPerProbe;\r\n  }\r\n  set probeRays(val: number) {\r\n    val = Math.max(16, Math.min(1024, Math.floor(val)));\r\n    if (val !== this._probeOptions.raysPerProbe) {\r\n      this._probeOptions.raysPerProbe = val;\r\n      this.rebuildProbes();\r\n    }\r\n  }\r\n  /** Probes updated per frame; applied when the volume is next built. */\r\n  get probeBudget() {\r\n    return this._probeOptions.budget;\r\n  }\r\n  set probeBudget(val: number) {\r\n    val = Math.max(1, Math.floor(val));\r\n    if (val !== this._probeOptions.budget) {\r\n      this._probeOptions.budget = val;\r\n      this.rebuildProbes();\r\n    }\r\n  }\r\n  /** Share of a probe's previous value kept per update, 0 to 1. */\r\n  get probeHysteresis() {\r\n    return this._probeOptions.hysteresis;\r\n  }\r\n  set probeHysteresis(val: number) {\r\n    this._probeOptions.hysteresis = Math.max(0, Math.min(0.999, val));\r\n  }\r\n  /** Multiplier on the indirect light the probes give. */\r\n  get intensity() {\r\n    return this._probeOptions.intensity;\r\n  }\r\n  set intensity(val: number) {\r\n    this._probeOptions.intensity = Math.max(0, val);\r\n  }\r\n  /** Surface offset along the normal when sampling the probes, in probe spacings of the level read. */\r\n  get probeNormalBias() {\r\n    return this._probeOptions.normalBias;\r\n  }\r\n  set probeNormalBias(val: number) {\r\n    this._probeOptions.normalBias = Math.max(0, val);\r\n  }\r\n  /** Surface offset towards the viewer when sampling the probes, in probe spacings of the level read. */\r\n  get probeViewBias() {\r\n    return this._probeOptions.viewBias;\r\n  }\r\n  set probeViewBias(val: number) {\r\n    this._probeOptions.viewBias = Math.max(0, val);\r\n  }\r\n  /** @internal */\r\n  private rebuildProbes() {\r\n    this._probes?.dispose();\r\n    this._probes = null;\r\n  }\r\n  /** Meshes voxelized per frame. */\r\n  get voxelizeBudget() {\r\n    return this._voxelizeBudget;\r\n  }\r\n  set voxelizeBudget(val: number) {\r\n    this._voxelizeBudget = Math.max(1, Math.floor(val));\r\n  }\r\n  /** Voxels per axis of the material atlas; applied when the voxel scene is next built. */\r\n  get atlasSize() {\r\n    return this._atlasSize;\r\n  }\r\n  set atlasSize(val: number) {\r\n    val = Math.max(16, Math.floor(val));\r\n    if (val !== this._atlasSize) {\r\n      this._atlasSize = val;\r\n      this._voxels?.detach(this._scene.sdf);\r\n      this._voxels?.dispose();\r\n      this._voxels = null;\r\n    }\r\n  }\r\n  /** Half angle of the sun shadow cone in the voxel lighting, in degrees; wider is softer. */\r\n  get sunShadowConeAngle() {\r\n    return this._lighting.sunShadowConeAngle;\r\n  }\r\n  set sunShadowConeAngle(val: number) {\r\n    this._lighting.sunShadowConeAngle = Math.max(0.1, Math.min(45, val));\r\n  }\r\n  /**\r\n   * Whether point, spot and rect lights that cast shadows also cast them in the bounced light,\r\n   * traced through the global distance field for the nearest eight such lights. Default true.\r\n   */\r\n  get localLightShadows() {\r\n    return this._lighting.localLightShadows;\r\n  }\r\n  set localLightShadows(val: boolean) {\r\n    this._lighting.localLightShadows = !!val;\r\n  }\r\n  /** Z slices of every clipmap level lit per frame; the voxel lighting is refreshed every `64 / slices` frames. */\r\n  get lightingSlicesPerFrame() {\r\n    return this._lighting.slicesPerFrame;\r\n  }\r\n  set lightingSlicesPerFrame(val: number) {\r\n    this._lighting.slicesPerFrame = Math.max(1, Math.floor(val));\r\n  }\r\n  /** The voxel scene, once built. */\r\n  get voxels() {\r\n    return this._voxels;\r\n  }\r\n  getStats(): SceneGIStats {\r\n    return {\r\n      enabled: this._enabled,\r\n      supported: SceneGI.isSupported(),\r\n      voxels: this._voxels?.getStats() ?? null,\r\n      probes: this._probes?.getStats() ?? null\r\n    };\r\n  }\r\n  /** Called by the scene once a frame, before the scene field's update. */\r\n  update(cameraPos: Vector3, deltaSeconds: number) {\r\n    if (!this._enabled || !this._scene.sdf.enabled) {\r\n      return;\r\n    }\r\n    if (!SceneGI.isSupported()) {\r\n      if (!this._warned) {\r\n        this._warned = true;\r\n        console.warn('SceneGI: global illumination needs WebGPU; nothing is built on this device');\r\n      }\r\n      return;\r\n    }\r\n    if (!this._voxels) {\r\n      this._voxels = new VoxelScene(this._scene, this._atlasSize);\r\n    }\r\n    this._voxels.voxelizeBudget = this._voxelizeBudget;\r\n    this._voxels.update(this._scene.sdf, cameraPos, deltaSeconds);\r\n  }\r\n  /** Called by the scene once a frame, after the scene field's update. */\r\n  updateLighting(camera: Camera) {\r\n    if (!this._enabled || !this._voxels || !this._scene.sdf.enabled) {\r\n      return;\r\n    }\r\n    // The probes are read at the camera's exposure even while frozen\r\n    this._probes?.setReadExposure(camera);\r\n    if (this._updateMode === 'frozen') {\r\n      return;\r\n    }\r\n    RenderGraphExecutor.profileScope('VoxelLighting', () =>\r\n      this._voxels!.updateLighting(this._scene.sdf, camera, this._lighting)\r\n    );\r\n    if (!this._voxels.lit) {\r\n      return;\r\n    }\r\n    if (!this._probes) {\r\n      this._probes = new ProbeVolume(this._scene, this._probeOptions);\r\n    }\r\n    this._probes.setReadExposure(camera);\r\n    RenderGraphExecutor.profileScope('ProbeUpdate', () =>\r\n      this._probes!.update(this._scene.sdf, this._voxels!, camera)\r\n    );\r\n  }\r\n  dispose() {\r\n    this.enabled = false;\r\n  }\r\n}\r\n"],"names":["SceneGI","_scene","_enabled","_voxels","_atlasSize","_voxelizeBudget","_lighting","_probeOptions","_probes","_updateMode","_warned","scene","sunShadowConeAngle","slicesPerFrame","localLightShadows","grid","spacing","levels","levelScale","raysPerProbe","budget","hysteresis","normalBias","viewBias","intensity","maxRayDistance","isSupported","GlobalSDF","enabled","val","sdf","detach","dispose","probes","probeSpacing","Math","max","rebuildProbes","probeGrid","map","v","floor","cur","probeLevels","min","PROBE_MAX_LEVELS","updateMode","exportProbeState","ready","Error","exportState","importProbeState","buffer","ProbeVolume","importState","probeRays","probeBudget","probeHysteresis","probeNormalBias","probeViewBias","voxelizeBudget","atlasSize","lightingSlicesPerFrame","voxels","getStats","supported","update","cameraPos","deltaSeconds","console","warn","VoxelScene","updateLighting","camera","setReadExposure","RenderGraphExecutor","profileScope","lit"],"mappings":"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"}

package/dist/render/gi/voxel_atlas.js

@@ -0,0 +1,198 @@
+import { getDevice } from '../../app/api.js';
+import { VolumeBoxAllocator } from '../sdf/box_allocator.js';
+
+/** Allocation granularity of the atlas in voxels, per axis. */ const VOXEL_ATLAS_BLOCK = 4;
+/**
+ * Material atlases of the voxel scene: two same-layout 3D textures, albedo
+ * (rgba8unorm, a = 1 where a surface was rasterized) and emissive (rgba8unorm as RGBE),
+ * one block-aligned region per voxelized mesh. GPU-written only, so evicted regions are
+ * re-rasterized and a fragmented atlas is cleared and refilled rather than repacked.
+ * WebGPU only.
+ *
+ * @public
+ */ class VoxelMaterialAtlas {
+    size;
+    _albedo;
+    _emissive;
+    _allocator;
+    _entries;
+    _usedVoxels;
+    _version;
+    constructor(size = [
+        256,
+        256,
+        256
+    ]){
+        this.size = size.map((v)=>Math.max(VOXEL_ATLAS_BLOCK, Math.ceil(v / VOXEL_ATLAS_BLOCK) * VOXEL_ATLAS_BLOCK));
+        this._albedo = null;
+        this._emissive = null;
+        this._allocator = new VolumeBoxAllocator(this.size);
+        this._entries = new Map();
+        this._usedVoxels = 0;
+        this._version = 0;
+    }
+    /** The albedo atlas, created on first use. */ get albedo() {
+        if (!this._albedo) {
+            this._albedo = this.createTexture('@VoxelAlbedoAtlas');
+        }
+        return this._albedo;
+    }
+    /** The emissive atlas (RGBE), created on first use. */ get emissive() {
+        if (!this._emissive) {
+            this._emissive = this.createTexture('@VoxelEmissiveAtlas');
+        }
+        return this._emissive;
+    }
+    /** Meshes resident in the atlas. */ get count() {
+        return this._entries.size;
+    }
+    /** Share of the atlas allocated, 0 to 1. */ get occupancy() {
+        return this._usedVoxels / (this.size[0] * this.size[1] * this.size[2]);
+    }
+    /** Bumped whenever a slot is removed, so users of slot offsets can refresh them. */ get version() {
+        return this._version;
+    }
+    /** The slot of a resident mesh, or null. */ getSlot(key) {
+        return this._entries.get(key)?.slot ?? null;
+    }
+    /**
+   * Allocates a region for a mesh.
+   * @param key - Identity of the mesh, used to look it up and free it.
+   * @param resolution - Voxels per axis.
+   * @returns The slot, or null when nothing fits.
+   */ add(key, resolution) {
+        const existing = this._entries.get(key);
+        if (existing) {
+            return existing.slot;
+        }
+        const need = this.blockAligned(resolution);
+        if (need[0] > this.size[0] || need[1] > this.size[1] || need[2] > this.size[2]) {
+            return null;
+        }
+        const box = this._allocator.allocate(need);
+        if (!box) {
+            return null;
+        }
+        const entry = {
+            slot: {
+                offset: [
+                    box.x,
+                    box.y,
+                    box.z
+                ],
+                resolution: [
+                    ...resolution
+                ]
+            },
+            box
+        };
+        this._entries.set(key, entry);
+        this._usedVoxels += box.w * box.h * box.d;
+        return entry.slot;
+    }
+    /**
+   * True when meshes of the given resolutions would fit an empty atlas, packed
+   * in {@link VoxelMaterialAtlas.packOrder}. Changes nothing.
+   */ fits(resolutions) {
+        const allocator = new VolumeBoxAllocator(this.size);
+        return VoxelMaterialAtlas.packOrder(resolutions).every((r)=>!!allocator.allocate(this.blockAligned(r)));
+    }
+    /**
+   * The order an atlas cleared for a set of meshes adds them in, largest
+   * first, for which {@link VoxelMaterialAtlas.fits} answers.
+   */ static packOrder(items) {
+        const volume = (item)=>{
+            const r = Array.isArray(item) ? item : item.resolution;
+            return r[0] * r[1] * r[2];
+        };
+        return [
+            ...items
+        ].sort((a, b)=>volume(b) - volume(a));
+    }
+    /**
+   * Packs the given meshes from an empty atlas in
+   * {@link VoxelMaterialAtlas.packOrder}, freeing every other region. Fails,
+   * changing nothing, when they do not all fit (see {@link VoxelMaterialAtlas.fits}).
+   * @returns The keys whose region moved, whose content is lost, or null.
+   */ repack(items) {
+        const allocator = new VolumeBoxAllocator(this.size);
+        const placed = [];
+        for (const item of VoxelMaterialAtlas.packOrder(items)){
+            const box = allocator.allocate(this.blockAligned(item.resolution));
+            if (!box) {
+                return null;
+            }
+            placed.push({
+                ...item,
+                box
+            });
+        }
+        const moved = new Set();
+        const entries = new Map();
+        this._usedVoxels = 0;
+        for (const { key, resolution, box } of placed){
+            const old = this._entries.get(key)?.box;
+            if (!old || old.x !== box.x || old.y !== box.y || old.z !== box.z) {
+                moved.add(key);
+            }
+            entries.set(key, {
+                slot: {
+                    offset: [
+                        box.x,
+                        box.y,
+                        box.z
+                    ],
+                    resolution: [
+                        ...resolution
+                    ]
+                },
+                box
+            });
+            this._usedVoxels += box.w * box.h * box.d;
+        }
+        this._entries.clear();
+        for (const [key, entry] of entries){
+            this._entries.set(key, entry);
+        }
+        this._allocator = allocator;
+        this._version++;
+        return moved;
+    }
+    /** Frees the region of a mesh. */ remove(key) {
+        const entry = this._entries.get(key);
+        if (entry) {
+            this._entries.delete(key);
+            this._allocator.free(entry.box);
+            this._usedVoxels -= entry.box.w * entry.box.h * entry.box.d;
+            this._version++;
+        }
+    }
+    /** Frees every region; the textures keep their content until written again. */ clear() {
+        this._entries.clear();
+        this._allocator.reset();
+        this._usedVoxels = 0;
+        this._version++;
+    }
+    dispose() {
+        this._albedo?.dispose();
+        this._emissive?.dispose();
+        this._albedo = null;
+        this._emissive = null;
+        this.clear();
+    }
+    /** @internal */ blockAligned(resolution) {
+        return resolution.map((v)=>Math.ceil(v / VOXEL_ATLAS_BLOCK) * VOXEL_ATLAS_BLOCK);
+    }
+    /** @internal */ createTexture(name) {
+        const [w, h, d] = this.size;
+        const tex = getDevice().createTexture3D('rgba8unorm', w, h, d, {
+            mipmapping: false,
+            writable: true
+        });
+        tex.name = name;
+        return tex;
+    }
+}
+
+export { VOXEL_ATLAS_BLOCK, VoxelMaterialAtlas };
+//# sourceMappingURL=voxel_atlas.js.map

package/dist/render/gi/voxel_atlas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"voxel_atlas.js","sources":["../../../src/render/gi/voxel_atlas.ts"],"sourcesContent":["import type { Texture3D } from '@zephyr3d/device';\r\nimport type { Nullable } from '@zephyr3d/base';\r\nimport { getDevice } from '../../app/api';\r\nimport { VolumeBoxAllocator } from '../sdf/box_allocator';\r\nimport type { VolumeBox } from '../sdf/box_allocator';\r\n\r\n/** Allocation granularity of the atlas in voxels, per axis. */\r\nexport const VOXEL_ATLAS_BLOCK = 4;\r\n\r\n/**\r\n * A region of the material atlas holding one voxelized mesh.\r\n * @public\r\n */\r\nexport interface VoxelAtlasSlot {\r\n  /** Voxel offset of the region in the atlas. */\r\n  offset: [number, number, number];\r\n  /** Voxels of the field, at most the region size. */\r\n  resolution: [number, number, number];\r\n}\r\n\r\ninterface Entry {\r\n  slot: VoxelAtlasSlot;\r\n  box: VolumeBox;\r\n}\r\n\r\n/**\r\n * Material atlases of the voxel scene: two same-layout 3D textures, albedo\r\n * (rgba8unorm, a = 1 where a surface was rasterized) and emissive (rgba8unorm as RGBE),\r\n * one block-aligned region per voxelized mesh. GPU-written only, so evicted regions are\r\n * re-rasterized and a fragmented atlas is cleared and refilled rather than repacked.\r\n * WebGPU only.\r\n *\r\n * @public\r\n */\r\nexport class VoxelMaterialAtlas {\r\n  readonly size: [number, number, number];\r\n  private _albedo: Nullable<Texture3D>;\r\n  private _emissive: Nullable<Texture3D>;\r\n  private _allocator: VolumeBoxAllocator;\r\n  private readonly _entries: Map<object, Entry>;\r\n  private _usedVoxels: number;\r\n  private _version: number;\r\n  constructor(size: [number, number, number] = [256, 256, 256]) {\r\n    this.size = size.map((v) =>\r\n      Math.max(VOXEL_ATLAS_BLOCK, Math.ceil(v / VOXEL_ATLAS_BLOCK) * VOXEL_ATLAS_BLOCK)\r\n    ) as [number, number, number];\r\n    this._albedo = null;\r\n    this._emissive = null;\r\n    this._allocator = new VolumeBoxAllocator(this.size);\r\n    this._entries = new Map();\r\n    this._usedVoxels = 0;\r\n    this._version = 0;\r\n  }\r\n  /** The albedo atlas, created on first use. */\r\n  get albedo() {\r\n    if (!this._albedo) {\r\n      this._albedo = this.createTexture('@VoxelAlbedoAtlas');\r\n    }\r\n    return this._albedo;\r\n  }\r\n  /** The emissive atlas (RGBE), created on first use. */\r\n  get emissive() {\r\n    if (!this._emissive) {\r\n      this._emissive = this.createTexture('@VoxelEmissiveAtlas');\r\n    }\r\n    return this._emissive;\r\n  }\r\n  /** Meshes resident in the atlas. */\r\n  get count() {\r\n    return this._entries.size;\r\n  }\r\n  /** Share of the atlas allocated, 0 to 1. */\r\n  get occupancy() {\r\n    return this._usedVoxels / (this.size[0] * this.size[1] * this.size[2]);\r\n  }\r\n  /** Bumped whenever a slot is removed, so users of slot offsets can refresh them. */\r\n  get version() {\r\n    return this._version;\r\n  }\r\n  /** The slot of a resident mesh, or null. */\r\n  getSlot(key: object) {\r\n    return this._entries.get(key)?.slot ?? null;\r\n  }\r\n  /**\r\n   * Allocates a region for a mesh.\r\n   * @param key - Identity of the mesh, used to look it up and free it.\r\n   * @param resolution - Voxels per axis.\r\n   * @returns The slot, or null when nothing fits.\r\n   */\r\n  add(key: object, resolution: [number, number, number]): Nullable<VoxelAtlasSlot> {\r\n    const existing = this._entries.get(key);\r\n    if (existing) {\r\n      return existing.slot;\r\n    }\r\n    const need = this.blockAligned(resolution);\r\n    if (need[0] > this.size[0] || need[1] > this.size[1] || need[2] > this.size[2]) {\r\n      return null;\r\n    }\r\n    const box = this._allocator.allocate(need);\r\n    if (!box) {\r\n      return null;\r\n    }\r\n    const entry: Entry = {\r\n      slot: { offset: [box.x, box.y, box.z], resolution: [...resolution] },\r\n      box\r\n    };\r\n    this._entries.set(key, entry);\r\n    this._usedVoxels += box.w * box.h * box.d;\r\n    return entry.slot;\r\n  }\r\n  /**\r\n   * True when meshes of the given resolutions would fit an empty atlas, packed\r\n   * in {@link VoxelMaterialAtlas.packOrder}. Changes nothing.\r\n   */\r\n  fits(resolutions: [number, number, number][]) {\r\n    const allocator = new VolumeBoxAllocator(this.size);\r\n    return VoxelMaterialAtlas.packOrder(resolutions).every((r) => !!allocator.allocate(this.blockAligned(r)));\r\n  }\r\n  /**\r\n   * The order an atlas cleared for a set of meshes adds them in, largest\r\n   * first, for which {@link VoxelMaterialAtlas.fits} answers.\r\n   */\r\n  static packOrder<T extends [number, number, number] | { resolution: [number, number, number] }>(\r\n    items: T[]\r\n  ) {\r\n    const volume = (item: T) => {\r\n      const r = Array.isArray(item) ? item : item.resolution;\r\n      return r[0] * r[1] * r[2];\r\n    };\r\n    return [...items].sort((a, b) => volume(b) - volume(a));\r\n  }\r\n  /**\r\n   * Packs the given meshes from an empty atlas in\r\n   * {@link VoxelMaterialAtlas.packOrder}, freeing every other region. Fails,\r\n   * changing nothing, when they do not all fit (see {@link VoxelMaterialAtlas.fits}).\r\n   * @returns The keys whose region moved, whose content is lost, or null.\r\n   */\r\n  repack(items: { key: object; resolution: [number, number, number] }[]): Nullable<Set<object>> {\r\n    const allocator = new VolumeBoxAllocator(this.size);\r\n    const placed: { key: object; resolution: [number, number, number]; box: VolumeBox }[] = [];\r\n    for (const item of VoxelMaterialAtlas.packOrder(items)) {\r\n      const box = allocator.allocate(this.blockAligned(item.resolution));\r\n      if (!box) {\r\n        return null;\r\n      }\r\n      placed.push({ ...item, box });\r\n    }\r\n    const moved = new Set<object>();\r\n    const entries = new Map<object, Entry>();\r\n    this._usedVoxels = 0;\r\n    for (const { key, resolution, box } of placed) {\r\n      const old = this._entries.get(key)?.box;\r\n      if (!old || old.x !== box.x || old.y !== box.y || old.z !== box.z) {\r\n        moved.add(key);\r\n      }\r\n      entries.set(key, { slot: { offset: [box.x, box.y, box.z], resolution: [...resolution] }, box });\r\n      this._usedVoxels += box.w * box.h * box.d;\r\n    }\r\n    this._entries.clear();\r\n    for (const [key, entry] of entries) {\r\n      this._entries.set(key, entry);\r\n    }\r\n    this._allocator = allocator;\r\n    this._version++;\r\n    return moved;\r\n  }\r\n  /** Frees the region of a mesh. */\r\n  remove(key: object) {\r\n    const entry = this._entries.get(key);\r\n    if (entry) {\r\n      this._entries.delete(key);\r\n      this._allocator.free(entry.box);\r\n      this._usedVoxels -= entry.box.w * entry.box.h * entry.box.d;\r\n      this._version++;\r\n    }\r\n  }\r\n  /** Frees every region; the textures keep their content until written again. */\r\n  clear() {\r\n    this._entries.clear();\r\n    this._allocator.reset();\r\n    this._usedVoxels = 0;\r\n    this._version++;\r\n  }\r\n  dispose() {\r\n    this._albedo?.dispose();\r\n    this._emissive?.dispose();\r\n    this._albedo = null;\r\n    this._emissive = null;\r\n    this.clear();\r\n  }\r\n  /** @internal */\r\n  private blockAligned(resolution: [number, number, number]) {\r\n    return resolution.map((v) => Math.ceil(v / VOXEL_ATLAS_BLOCK) * VOXEL_ATLAS_BLOCK) as [\r\n      number,\r\n      number,\r\n      number\r\n    ];\r\n  }\r\n  /** @internal */\r\n  private createTexture(name: string) {\r\n    const [w, h, d] = this.size;\r\n    const tex = getDevice().createTexture3D('rgba8unorm', w, h, d, { mipmapping: false, writable: true })!;\r\n    tex.name = name;\r\n    return tex;\r\n  }\r\n}\r\n"],"names":["VOXEL_ATLAS_BLOCK","VoxelMaterialAtlas","size","_albedo","_emissive","_allocator","_entries","_usedVoxels","_version","map","v","Math","max","ceil","VolumeBoxAllocator","Map","albedo","createTexture","emissive","count","occupancy","version","getSlot","key","get","slot","add","resolution","existing","need","blockAligned","box","allocate","entry","offset","x","y","z","set","w","h","d","fits","resolutions","allocator","packOrder","every","r","items","volume","item","Array","isArray","sort","a","b","repack","placed","push","moved","Set","entries","old","clear","remove","delete","free","reset","dispose","name","tex","getDevice","createTexture3D","mipmapping","writable"],"mappings":"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"}