@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/core/src/render/hdr.js

@@ -0,0 +1,69 @@
+export class HDRSupport {
+    config = {
+        enabled: false,
+        format: "bgra8unorm",
+        colorSpace: "srgb",
+        maxLuminance: 80.0,
+    };
+    async detect(adapter) {
+        const features = adapter.features;
+        const hasFloat32Filterable = features.has("float32-filterable");
+        if (hasFloat32Filterable) {
+            this.config = {
+                enabled: true,
+                format: "rgba16float",
+                colorSpace: "scrgb",
+                maxLuminance: 1000.0,
+            };
+        }
+        else {
+            this.config = {
+                enabled: false,
+                format: "bgra8unorm",
+                colorSpace: "srgb",
+                maxLuminance: 80.0,
+            };
+        }
+        return this.config;
+    }
+    getConfig() {
+        return this.config;
+    }
+    isEnabled() {
+        return this.config.enabled;
+    }
+    getFormat() {
+        return this.config.format;
+    }
+    getColorSpace() {
+        return this.config.colorSpace;
+    }
+    getMaxLuminance() {
+        return this.config.maxLuminance;
+    }
+    getSurfaceConfig() {
+        if (this.config.enabled) {
+            return {
+                format: "rgba16float",
+                viewFormats: ["rgba16float"],
+                alphaMode: "opaque",
+            };
+        }
+        return {
+            format: "bgra8unorm",
+            viewFormats: [],
+            alphaMode: "opaque",
+        };
+    }
+    setEnabled(enabled) {
+        this.config.enabled = enabled;
+        if (enabled) {
+            this.config.format = "rgba16float";
+            this.config.colorSpace = "scrgb";
+        }
+        else {
+            this.config.format = "bgra8unorm";
+            this.config.colorSpace = "srgb";
+        }
+    }
+}

package/dist/core/src/render/hot-reload.js

@@ -0,0 +1,236 @@
+import { GLBLoader } from "../assets/loader-mesh.js";
+import { loadTexture } from "../assets/loader-texture.js";
+import { createLogger } from "../util/logger.js";
+const log = createLogger();
+export class MaterialHotReloader {
+    watchedShaders = new Map();
+    watchedMeshes = new Map();
+    watchedTextures = new Map();
+    pipelineCache = null;
+    intervalId = null;
+    checkInterval = 1000;
+    static MAX_WATCH_ENTRIES = 256;
+    constructor(pipelineCache) {
+        this.pipelineCache = pipelineCache ?? null;
+    }
+    setPipelineCache(cache) {
+        this.pipelineCache = cache;
+    }
+    /** Remove the oldest entry from a Map if it exceeds the max watch limit. */
+    enforceWatchLimit(map) {
+        if (map.size >= MaterialHotReloader.MAX_WATCH_ENTRIES) {
+            const oldestKey = map.keys().next().value;
+            if (oldestKey !== undefined) {
+                map.delete(oldestKey);
+            }
+        }
+    }
+    watch(material, shaderPath) {
+        if (!this.watchedShaders.has(shaderPath)) {
+            this.enforceWatchLimit(this.watchedShaders);
+        }
+        this.watchedShaders.set(shaderPath, {
+            path: shaderPath,
+            material,
+            lastModified: 0,
+        });
+    }
+    unwatch(shaderPath) {
+        this.watchedShaders.delete(shaderPath);
+    }
+    watchMesh(path, onReload) {
+        if (!this.watchedMeshes.has(path)) {
+            this.enforceWatchLimit(this.watchedMeshes);
+        }
+        this.watchedMeshes.set(path, {
+            path,
+            lastModified: 0,
+            onReload,
+        });
+    }
+    unwatchMesh(path) {
+        this.watchedMeshes.delete(path);
+    }
+    watchTexture(path, device, onReload, options) {
+        if (!this.watchedTextures.has(path)) {
+            this.enforceWatchLimit(this.watchedTextures);
+        }
+        this.watchedTextures.set(path, {
+            path,
+            lastModified: 0,
+            onReload,
+            device,
+            format: options?.format,
+            generateMips: options?.generateMips ?? true,
+        });
+    }
+    unwatchTexture(path) {
+        this.watchedTextures.delete(path);
+    }
+    start() {
+        if (this.intervalId)
+            return;
+        this.intervalId = setInterval(() => this.check(), this.checkInterval);
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    async checkNow() {
+        await this.check();
+    }
+    async check() {
+        await this.checkShaders();
+        await this.checkMeshes();
+        await this.checkTextures();
+    }
+    async checkShaders() {
+        for (const [path, watched] of this.watchedShaders.entries()) {
+            try {
+                const response = await fetch(path, { method: "HEAD" });
+                const lastMod = response.headers.get("last-modified");
+                if (!lastMod)
+                    continue;
+                const modTime = new Date(lastMod).getTime();
+                if (modTime > watched.lastModified) {
+                    watched.lastModified = modTime;
+                    await this.reloadShader(path, watched.material);
+                }
+            }
+            catch {
+                // File might not be accessible via fetch in all environments
+            }
+        }
+    }
+    async checkMeshes() {
+        for (const [path, watched] of this.watchedMeshes.entries()) {
+            try {
+                const response = await fetch(path, { method: "HEAD" });
+                const lastMod = response.headers.get("last-modified");
+                if (!lastMod)
+                    continue;
+                const modTime = new Date(lastMod).getTime();
+                if (modTime > watched.lastModified) {
+                    watched.lastModified = modTime;
+                    await this.reloadMesh(path, watched.onReload);
+                }
+            }
+            catch {
+                // File might not be accessible via fetch in all environments
+            }
+        }
+    }
+    async checkTextures() {
+        for (const [path, watched] of this.watchedTextures.entries()) {
+            try {
+                const response = await fetch(path, { method: "HEAD" });
+                const lastMod = response.headers.get("last-modified");
+                if (!lastMod)
+                    continue;
+                const modTime = new Date(lastMod).getTime();
+                if (modTime > watched.lastModified) {
+                    watched.lastModified = modTime;
+                    await this.reloadTexture(path, watched);
+                }
+            }
+            catch {
+                // File might not be accessible via fetch in all environments
+            }
+        }
+    }
+    async reloadShader(path, material) {
+        try {
+            const response = await fetch(path);
+            const wgsl = await response.text();
+            // Write into inlineShaderSource — the render path reads this, not shader.
+            material.inlineShaderSource = wgsl;
+            material.invalidateVariants();
+            if (this.pipelineCache) {
+                this.pipelineCache.invalidate(material.pipelineKey);
+            }
+        }
+        catch (e) {
+            log.warn("hot-reloader", `Failed to reload shader: ${path} ${e}`);
+        }
+    }
+    async reloadMesh(path, onReload) {
+        try {
+            const response = await fetch(path);
+            const buffer = await response.arrayBuffer();
+            const loader = new GLBLoader();
+            const result = await loader.parseGLB(buffer);
+            if (result.meshes.length > 0) {
+                onReload(result.meshes[0]);
+            }
+        }
+        catch (e) {
+            log.warn("hot-reloader", `Failed to reload mesh: ${path} ${e}`);
+        }
+    }
+    async reloadTexture(path, watched) {
+        try {
+            const textureData = await loadTexture(path, {
+                format: watched.format,
+                generateMips: watched.generateMips,
+            });
+            // Destroy the old texture before creating a new one to avoid GPU leaks.
+            watched.texture?.destroy();
+            const gpuTexture = watched.device.createTexture({
+                size: [textureData.width, textureData.height],
+                format: watched.format ?? "rgba8unorm",
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+            });
+            watched.texture = gpuTexture;
+            watched.device.queue.writeTexture({ texture: gpuTexture }, textureData.data, {
+                bytesPerRow: textureData.width * 4,
+                rowsPerImage: textureData.height,
+            }, [textureData.width, textureData.height]);
+            watched.onReload(gpuTexture);
+        }
+        catch (e) {
+            log.warn("hot-reloader", `Failed to reload texture: ${path} ${e}`);
+        }
+    }
+    async reloadNow(path) {
+        const shaderWatched = this.watchedShaders.get(path);
+        if (shaderWatched) {
+            await this.reloadShader(path, shaderWatched.material);
+            return true;
+        }
+        const meshWatched = this.watchedMeshes.get(path);
+        if (meshWatched) {
+            await this.reloadMesh(path, meshWatched.onReload);
+            return true;
+        }
+        const textureWatched = this.watchedTextures.get(path);
+        if (textureWatched) {
+            await this.reloadTexture(path, textureWatched);
+            return true;
+        }
+        return false;
+    }
+    getWatchedPaths() {
+        return [
+            ...this.watchedShaders.keys(),
+            ...this.watchedMeshes.keys(),
+            ...this.watchedTextures.keys(),
+        ];
+    }
+    getWatchedShaderPaths() {
+        return [...this.watchedShaders.keys()];
+    }
+    getWatchedMeshPaths() {
+        return [...this.watchedMeshes.keys()];
+    }
+    getWatchedTexturePaths() {
+        return [...this.watchedTextures.keys()];
+    }
+    destroy() {
+        this.stop();
+        this.watchedShaders.clear();
+        this.watchedMeshes.clear();
+        this.watchedTextures.clear();
+    }
+}

package/dist/core/src/render/ibl-bind-group.js

@@ -0,0 +1,232 @@
+export class IBLBindGroup {
+    device;
+    includeBRDFLUT;
+    bindGroup = null;
+    bindGroupLayout = null;
+    uniformBuffer = null;
+    irradianceSampler;
+    prefilterSampler;
+    brdfSampler;
+    defaultLUTTexture = null;
+    defaultIrradianceTex = null;
+    defaultPrefilterTex = null;
+    constructor(device, options = {}) {
+        this.device = device;
+        this.includeBRDFLUT = options.includeBRDFLUT ?? true;
+        this.irradianceSampler = device.createSampler({
+            magFilter: "linear",
+            minFilter: "linear",
+            mipmapFilter: "linear",
+            addressModeU: "clamp-to-edge",
+            addressModeV: "clamp-to-edge",
+        });
+        this.prefilterSampler = device.createSampler({
+            magFilter: "linear",
+            minFilter: "linear",
+            mipmapFilter: "linear",
+            addressModeU: "clamp-to-edge",
+            addressModeV: "clamp-to-edge",
+        });
+        this.brdfSampler = device.createSampler({
+            magFilter: "linear",
+            minFilter: "linear",
+            addressModeU: "clamp-to-edge",
+            addressModeV: "clamp-to-edge",
+        });
+        // Eagerly create the bind group layout so pipelines can reference @group(2)
+        // before any environment map has been captured.
+        const entries = this.includeBRDFLUT
+            ? [
+                { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+                { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+                { binding: 2, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+                { binding: 3, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+                { binding: 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+                { binding: 5, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+                { binding: 6, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+            ]
+            : [
+                { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+                { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+                { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+                { binding: 3, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+                { binding: 4, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+            ];
+        this.bindGroupLayout = device.createBindGroupLayout({ entries });
+        // Create a default bind group with placeholder textures so pipelines
+        // can render before any environment map has been captured.
+        this.createDefaultBindGroup();
+    }
+    getBindGroupLayout() {
+        return this.bindGroupLayout;
+    }
+    createBindGroup(envMap) {
+        if (!this.uniformBuffer) {
+            this.uniformBuffer = this.device.createBuffer({
+                size: 16,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+        }
+        const mipData = new Float32Array(4);
+        mipData[0] = envMap.prefilteredMaxMip;
+        this.device.queue.writeBuffer(this.uniformBuffer, 0, mipData);
+        const prefilteredView = envMap.prefilteredSpecular[0]?.createView({
+            dimension: "cube",
+        }) ?? envMap.cubemap.createView({ dimension: "cube" });
+        const entries = [
+            { binding: 0, resource: envMap.irradiance.createView({ dimension: "cube" }) },
+            { binding: 1, resource: prefilteredView },
+        ];
+        if (this.includeBRDFLUT) {
+            const brdfLUTView = envMap.brdfLUT?.createView() ?? this.createDefaultLUTView();
+            entries.push({ binding: 2, resource: brdfLUTView });
+            entries.push({ binding: 3, resource: this.irradianceSampler });
+            entries.push({ binding: 4, resource: this.prefilterSampler });
+            entries.push({ binding: 5, resource: this.brdfSampler });
+            entries.push({ binding: 6, resource: { buffer: this.uniformBuffer } });
+        }
+        else {
+            entries.push({ binding: 2, resource: this.irradianceSampler });
+            entries.push({ binding: 3, resource: this.prefilterSampler });
+            entries.push({ binding: 4, resource: { buffer: this.uniformBuffer } });
+        }
+        this.bindGroup = this.device.createBindGroup({
+            layout: this.bindGroupLayout,
+            entries,
+        });
+        return this.bindGroup;
+    }
+    getBindGroup() {
+        return this.bindGroup;
+    }
+    createDefaultLUTView() {
+        if (!this.defaultLUTTexture) {
+            this.defaultLUTTexture = this.device.createTexture({
+                size: [1, 1],
+                format: "rgba16float",
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+            });
+            const data = new Uint16Array([0x3C00, 0x3C00, 0, 0x3C00]);
+            this.device.queue.writeTexture({ texture: this.defaultLUTTexture }, data, { bytesPerRow: 8 }, { width: 1, height: 1 });
+        }
+        return this.defaultLUTTexture.createView();
+    }
+    createDefaultCubemapView(tex, label) {
+        if (!tex) {
+            tex = this.device.createTexture({
+                size: [1, 1, 6],
+                format: "rgba16float",
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+                label,
+            });
+            const faceData = new Uint16Array(6 * 4);
+            for (let i = 0; i < 6; i++) {
+                faceData[i * 4 + 0] = 0x3C00;
+                faceData[i * 4 + 1] = 0x3C00;
+                faceData[i * 4 + 2] = 0x3C00;
+                faceData[i * 4 + 3] = 0x3C00;
+            }
+            this.device.queue.writeTexture({ texture: tex }, faceData, { bytesPerRow: 8, rowsPerImage: 1 }, { width: 1, height: 1, depthOrArrayLayers: 6 });
+            if (label === "default_irradiance")
+                this.defaultIrradianceTex = tex;
+            else
+                this.defaultPrefilterTex = tex;
+        }
+        return tex.createView({ dimension: "cube" });
+    }
+    createDefaultBindGroup() {
+        if (!this.uniformBuffer) {
+            this.uniformBuffer = this.device.createBuffer({
+                size: 16,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+        }
+        const mipData = new Float32Array(4);
+        this.device.queue.writeBuffer(this.uniformBuffer, 0, mipData);
+        const irradianceView = this.createDefaultCubemapView(this.defaultIrradianceTex, "default_irradiance");
+        const prefilterView = this.createDefaultCubemapView(this.defaultPrefilterTex, "default_prefilter");
+        const entries = [
+            { binding: 0, resource: irradianceView },
+            { binding: 1, resource: prefilterView },
+        ];
+        if (this.includeBRDFLUT) {
+            entries.push({ binding: 2, resource: this.createDefaultLUTView() });
+            entries.push({ binding: 3, resource: this.irradianceSampler });
+            entries.push({ binding: 4, resource: this.prefilterSampler });
+            entries.push({ binding: 5, resource: this.brdfSampler });
+            entries.push({ binding: 6, resource: { buffer: this.uniformBuffer } });
+        }
+        else {
+            entries.push({ binding: 2, resource: this.irradianceSampler });
+            entries.push({ binding: 3, resource: this.prefilterSampler });
+            entries.push({ binding: 4, resource: { buffer: this.uniformBuffer } });
+        }
+        this.bindGroup = this.device.createBindGroup({
+            layout: this.bindGroupLayout,
+            entries,
+        });
+    }
+    destroy() {
+        this.uniformBuffer?.destroy();
+        this.defaultLUTTexture?.destroy();
+        this.defaultIrradianceTex?.destroy();
+        this.defaultPrefilterTex?.destroy();
+    }
+}
+export function createIBLShaderChunk(groupIndex, includeBRDFLUT) {
+    const g = groupIndex;
+    if (includeBRDFLUT) {
+        return /* wgsl */ `
+struct IBLUniforms {
+  maxMipLevel: f32,
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+};
+
+@group(${g}) @binding(0) var irradianceMap: texture_cube<f32>;
+@group(${g}) @binding(1) var prefilterMap: texture_cube<f32>;
+@group(${g}) @binding(2) var brdfLUT: texture_2d<f32>;
+@group(${g}) @binding(3) var irradianceSampler: sampler;
+@group(${g}) @binding(4) var prefilterSampler: sampler;
+@group(${g}) @binding(5) var brdfSampler: sampler;
+@group(${g}) @binding(6) var<uniform> iblUniforms: IBLUniforms;
+
+fn getIBLDiffuse(N: vec3<f32>) -> vec3<f32> {
+  return textureSample(irradianceMap, irradianceSampler, N).rgb;
+}
+
+fn getIBLSpecular(N: vec3<f32>, R: vec3<f32>, roughness: f32) -> vec3<f32> {
+  let lod = roughness * iblUniforms.maxMipLevel;
+  let prefilteredColor = textureSampleLevel(prefilterMap, prefilterSampler, R, lod);
+  let brdf = textureSample(brdfLUT, brdfSampler, vec2<f32>(max(dot(N, vec3<f32>(0.0, 0.0, 1.0)), 0.0), roughness)).rg;
+  return prefilteredColor.rgb * (brdf.x + brdf.y);
+}
+`;
+    }
+    return /* wgsl */ `
+struct IBLUniforms {
+  maxMipLevel: f32,
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+};
+
+@group(${g}) @binding(0) var irradianceMap: texture_cube<f32>;
+@group(${g}) @binding(1) var prefilterMap: texture_cube<f32>;
+@group(${g}) @binding(2) var irradianceSampler: sampler;
+@group(${g}) @binding(3) var prefilterSampler: sampler;
+@group(${g}) @binding(4) var<uniform> iblUniforms: IBLUniforms;
+
+fn getIBLDiffuse(N: vec3<f32>) -> vec3<f32> {
+  return textureSample(irradianceMap, irradianceSampler, N).rgb;
+}
+
+fn getIBLSpecular(N: vec3<f32>, R: vec3<f32>, roughness: f32) -> vec3<f32> {
+  let lod = roughness * iblUniforms.maxMipLevel;
+  let prefilteredColor = textureSampleLevel(prefilterMap, prefilterSampler, R, lod);
+  return prefilteredColor.rgb;
+}
+`;
+}
+export const IBL_SHADER_CHUNK = createIBLShaderChunk(2, true);

package/dist/core/src/render/ibl.js

@@ -0,0 +1,148 @@
+import { EnvironmentManager } from "../assets/environment-manager.js";
+import { IrradianceGenerator } from "../assets/irradiance-generator.js";
+import { PrefilteredSpecularGenerator } from "../assets/prefilter-generator.js";
+import { IBLBindGroup } from "./ibl-bind-group.js";
+import { CubemapCapturePass } from "./passes/cubemap-capture.js";
+export class IBLSystem {
+    device;
+    faceSize;
+    prefilterLevels;
+    prefilterSamples;
+    recaptureInterval;
+    includeBRDFLUT;
+    cubemapCapture;
+    irradianceGen;
+    prefilterGen;
+    envManager;
+    iblBindGroup;
+    currentEnv = null;
+    brdfLUTTexture = null;
+    frameCounter = 0;
+    lastTimeOfDay = -1;
+    initialized = false;
+    pendingDestroy = [];
+    constructor(device, options = {}) {
+        this.device = device;
+        this.faceSize = options.faceSize ?? 256;
+        this.prefilterLevels = options.prefilterLevels ?? 5;
+        this.prefilterSamples = options.prefilterSamples ?? 512;
+        this.recaptureInterval = options.recaptureInterval ?? 60;
+        this.includeBRDFLUT = options.includeBRDFLUT ?? true;
+        this.cubemapCapture = new CubemapCapturePass(device, { faceSize: this.faceSize });
+        this.irradianceGen = new IrradianceGenerator(device);
+        this.prefilterGen = new PrefilteredSpecularGenerator(device);
+        this.envManager = new EnvironmentManager({
+            device, faceSize: this.faceSize,
+            prefilterLevels: this.prefilterLevels, prefilterSamples: this.prefilterSamples,
+        });
+        this.iblBindGroup = new IBLBindGroup(device, { includeBRDFLUT: this.includeBRDFLUT });
+    }
+    init() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+    }
+    setBRDFLUT(lut) {
+        this.brdfLUTTexture = lut;
+    }
+    captureFromSkyDome(uniforms) {
+        const cubemap = this.cubemapCapture.capture(uniforms);
+        const irradiance = this.irradianceGen.generate(cubemap, { faceSize: 32 });
+        const prefilteredSpecular = this.prefilterGen.generateMipmapChain(cubemap, this.faceSize, this.prefilterLevels, this.prefilterSamples);
+        if (this.currentEnv) {
+            // Defer destruction — the old env textures may still be referenced by
+            // in-flight command buffers from the current frame's render passes.
+            // They will be destroyed after the frame completes via endFrame().
+            this.pendingDestroy.push(this.currentEnv.irradiance);
+            this.currentEnv.prefilteredSpecular.forEach((tex) => {
+                this.pendingDestroy.push(tex);
+            });
+            // The cubemap is also deferred (not destroyed immediately) because it
+            // may still be referenced by a previously submitted command buffer, and
+            // CubemapCapturePass now creates a fresh texture each capture so the
+            // old one is safe to release after the frame completes.
+            if (this.currentEnv.cubemap) {
+                this.pendingDestroy.push(this.currentEnv.cubemap);
+            }
+        }
+        this.currentEnv = {
+            cubemap,
+            irradiance,
+            prefilteredSpecular,
+            prefilteredMaxMip: this.prefilterLevels - 1,
+            brdfLUT: this.brdfLUTTexture,
+            faceSize: this.faceSize,
+        };
+        if (this.currentEnv) {
+            this.iblBindGroup.createBindGroup(this.currentEnv);
+        }
+    }
+    async loadFromEquirectangular(uri) {
+        const envMap = await this.envManager.loadFromEquirectangular(uri);
+        if (this.brdfLUTTexture) {
+            envMap.brdfLUT = this.brdfLUTTexture;
+        }
+        this.currentEnv = envMap;
+        this.iblBindGroup.createBindGroup(envMap);
+    }
+    async loadFromCubemapFiles(faceUris) {
+        const envMap = await this.envManager.loadFromCubemapFiles(faceUris);
+        if (this.brdfLUTTexture) {
+            envMap.brdfLUT = this.brdfLUTTexture;
+        }
+        this.currentEnv = envMap;
+        this.iblBindGroup.createBindGroup(envMap);
+    }
+    shouldRecapture(timeOfDay) {
+        this.frameCounter++;
+        if (this.frameCounter < this.recaptureInterval)
+            return false;
+        const timeDelta = Math.abs(timeOfDay - this.lastTimeOfDay);
+        if (this.lastTimeOfDay >= 0 && timeDelta < 0.02 && this.currentEnv)
+            return false;
+        return true;
+    }
+    updateFromSkyDome(uniforms, timeOfDay) {
+        if (!this.shouldRecapture(timeOfDay))
+            return;
+        this.captureFromSkyDome(uniforms);
+        this.lastTimeOfDay = timeOfDay;
+        this.frameCounter = 0;
+    }
+    getBindGroup() {
+        return this.iblBindGroup?.getBindGroup() ?? null;
+    }
+    getBindGroupLayout() {
+        return this.iblBindGroup?.getBindGroupLayout() ?? null;
+    }
+    getCurrentEnvironment() {
+        return this.currentEnv;
+    }
+    isReady() {
+        return this.currentEnv !== null && (this.iblBindGroup?.getBindGroup() ?? null) !== null;
+    }
+    /** Destroy textures deferred from a mid-frame recapture. Call after the frame's command buffers have been submitted. */
+    endFrame() {
+        this.pendingDestroy.forEach((tex) => {
+            try {
+                tex.destroy();
+            }
+            catch { }
+        });
+        this.pendingDestroy = [];
+    }
+    destroy() {
+        this.cubemapCapture?.destroy();
+        this.iblBindGroup?.destroy();
+        this.envManager?.destroy();
+        this.pendingDestroy.forEach((tex) => {
+            try {
+                tex.destroy();
+            }
+            catch { }
+        });
+        this.pendingDestroy = [];
+        this.currentEnv = null;
+        this.initialized = false;
+    }
+}