@zephyr3d/scene 0.3.1 → 0.5.0

package/dist/posteffect/compositor.js

@@ -1,23 +1,4 @@
-import { Application } from '../app.js';
 import { linearToGamma } from '../shaders/misc.js';
-import '@zephyr3d/base';
-import '../scene/octree.js';
-import '../material/shader/helper.js';
-import '../material/lambert.js';
-import '../material/blinn.js';
-import '../material/unlit.js';
-import '../material/material.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '@zephyr3d/device';
-import '../render/renderer.js';
-import '../render/sky.js';
-import '../render/clipmap.js';
-import { TemporalCache } from '../render/temporalcache.js';
-import '../render/watermesh.js';
 
 /**
  * Post processing compositor
@@ -95,26 +76,20 @@ import '../render/watermesh.js';
         ];
     }
     /** @internal */ begin(ctx) {
-        const device = Application.instance.device;
+        const device = ctx.device;
         const format = device.getDeviceCaps().textureCaps.supportHalfFloatColorBuffer ? 'rgba16f' : 'rgba8unorm';
         const finalFramebuffer = device.getFramebuffer();
         const depth = finalFramebuffer?.getDepthAttachment();
-        let pingpongFramebuffers;
         let msFramebuffer = null;
+        const w = depth ? depth.width : ctx.viewportWidth;
+        const h = depth ? depth.height : ctx.viewportHeight;
         if (ctx.primaryCamera.sampleCount > 1) {
-            msFramebuffer = depth ? TemporalCache.getFramebufferVariantSizeWithDepth(depth, 1, format, '2d', false, ctx.primaryCamera.sampleCount) : TemporalCache.getFramebufferVariantSize(ctx.viewportWidth, ctx.viewportHeight, 1, format, ctx.depthFormat, '2d', '2d', false, ctx.primaryCamera.sampleCount);
-        }
-        if (ctx.defaultViewport) {
-            pingpongFramebuffers = [
-                depth ? TemporalCache.getFramebufferVariantSizeWithDepth(depth, 1, format, '2d', false, 1) : TemporalCache.getFramebufferVariantSize(ctx.viewportWidth, ctx.viewportHeight, 1, format, ctx.depthFormat, '2d', '2d', false, 1),
-                depth ? TemporalCache.getFramebufferVariantSizeWithDepth(depth, 1, format, '2d', false, 1) : TemporalCache.getFramebufferVariantSize(ctx.viewportWidth, ctx.viewportHeight, 1, format, ctx.depthFormat, '2d', '2d', false, 1)
-            ];
-        } else {
-            pingpongFramebuffers = [
-                depth ? TemporalCache.getFramebufferFixedSizeWithDepth(depth, 1, format, '2d', false, 4) : TemporalCache.getFramebufferFixedSize(ctx.viewportWidth, ctx.viewportHeight, 1, format, ctx.depthFormat, '2d', '2d', false, 4),
-                depth ? TemporalCache.getFramebufferFixedSizeWithDepth(depth, 1, format, '2d', false, 4) : TemporalCache.getFramebufferFixedSize(ctx.viewportWidth, ctx.viewportHeight, 1, format, ctx.depthFormat, '2d', '2d', false, 4)
-            ];
+            msFramebuffer = device.pool.fetchTemporalFramebuffer(true, w, h, format, depth, false, ctx.primaryCamera.sampleCount);
         }
+        const pingpongFramebuffers = [
+            device.pool.fetchTemporalFramebuffer(true, w, h, format, depth ?? ctx.depthFormat, false),
+            device.pool.fetchTemporalFramebuffer(true, w, h, format, depth ?? ctx.depthFormat, false)
+        ];
         let writeIndex;
         if (msFramebuffer) {
             writeIndex = 3;
@@ -128,14 +103,14 @@ import '../render/watermesh.js';
         ctx.compositorContex = {
             finalFramebuffer,
             pingpongFramebuffers,
-            msFramebuffer,
+            msTexture: msFramebuffer,
             writeIndex
         };
     }
     /** @internal */ drawPostEffects(ctx, opaque, sceneDepthTexture) {
         const postEffects = opaque ? this._postEffectsOpaque : this._postEffectsTransparency;
         if (postEffects.length > 0) {
-            const device = Application.instance.device;
+            const device = ctx.device;
             for(let i = 0; i < postEffects.length; i++){
                 const postEffect = postEffects[i];
                 if (!postEffect.enabled) {
@@ -159,7 +134,7 @@ import '../render/watermesh.js';
         }
     }
     /** @internal */ end(ctx) {
-        const device = Application.instance.device;
+        const device = ctx.device;
         if (device.getFramebuffer() !== ctx.compositorContex.finalFramebuffer) {
             const srcTex = device.getFramebuffer().getColorAttachments()[0];
             device.setFramebuffer(ctx.compositorContex.finalFramebuffer);
@@ -167,11 +142,6 @@ import '../render/watermesh.js';
             device.setScissor(null);
             Compositor._blit(device, srcTex, !ctx.compositorContex.finalFramebuffer);
         }
-        TemporalCache.releaseFramebuffer(ctx.compositorContex.pingpongFramebuffers[0]);
-        TemporalCache.releaseFramebuffer(ctx.compositorContex.pingpongFramebuffers[1]);
-        if (ctx.compositorContex.msFramebuffer) {
-            TemporalCache.releaseFramebuffer(ctx.compositorContex.msFramebuffer);
-        }
         ctx.compositorContex = null;
     }
     /** @internal */ isLastPostEffect(opaque, index) {

package/dist/posteffect/compositor.js.map

@@ -1 +1 @@
-{"version":3,"file":"compositor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"compositor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/posteffect/fxaa.js

@@ -1,5 +1,4 @@
 import { Vector2 } from '@zephyr3d/base';
-import { Application } from '../app.js';
 import { AbstractPostEffect } from './posteffect.js';
 import { linearToGamma } from '../shaders/misc.js';
 
@@ -31,7 +30,7 @@ import { linearToGamma } from '../shaders/misc.js';
         return false;
     }
     /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
-        const device = Application.instance.device;
+        const device = ctx.device;
         this._prepare(device);
         this._invTexSize.setXY(1 / inputColorTexture.width, 1 / inputColorTexture.height);
         this._bindgroup.setTexture('srcTex', inputColorTexture, FXAA._sampler);

package/dist/posteffect/fxaa.js.map

@@ -1 +1 @@
-{"version":3,"file":"fxaa.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"fxaa.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/posteffect/grayscale.js

@@ -1,4 +1,3 @@
-import { Application } from '../app.js';
 import { AbstractPostEffect } from './posteffect.js';
 import { linearToGamma } from '../shaders/misc.js';
 
@@ -28,7 +27,7 @@ import { linearToGamma } from '../shaders/misc.js';
         return false;
     }
     /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
-        const device = Application.instance.device;
+        const device = ctx.device;
         this._prepare(device);
         this._bindgroup.setTexture('srcTex', inputColorTexture, Grayscale._sampler);
         this._bindgroup.setValue('flip', this.needFlip(device) ? 1 : 0);

package/dist/posteffect/grayscale.js.map

@@ -1 +1 @@
-{"version":3,"file":"grayscale.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"grayscale.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/posteffect/posteffect.js

@@ -1,4 +1,3 @@
-import { Application } from '../app.js';
 import { drawFullscreenQuad } from '../render/fullscreenquad.js';
 
 /**
@@ -10,7 +9,6 @@ import { drawFullscreenQuad } from '../render/fullscreenquad.js';
     _quadRenderStateSet;
     _enabled;
     _opaque;
-    _intermediateFramebuffers;
     /**
    * Creates an instance of a post effect
    * @param name - Name of the post effect
@@ -20,7 +18,6 @@ import { drawFullscreenQuad } from '../render/fullscreenquad.js';
         this._quadRenderStateSet = null;
         this._enabled = true;
         this._opaque = false;
-        this._intermediateFramebuffers = {};
     }
     /** Whether this post effect is enabled */ get enabled() {
         return this._enabled;
@@ -39,82 +36,11 @@ import { drawFullscreenQuad } from '../render/fullscreenquad.js';
         return device.type === 'webgpu' && !!device.getFramebuffer();
     }
     /**
-   * Adds an intermediate frame buffer
-   * @param name - Name of the frame buffer
-   * @param format - Render target texture format
-   * @param useDepth - Whether the scene depth buffer should be attached to the frame buffer
-   */ addIntermediateFramebuffer(name, depth) {
-        if (this._intermediateFramebuffers[name]) {
-            throw new Error(`Intermediate framebuffer already exists: ${name}`);
-        }
-        this._intermediateFramebuffers[name] = {
-            depth,
-            framebuffer: null
-        };
-    }
-    /**
-   * Gets the intermediate frame buffer by name
-   * @param name - Name of the intermediate frame buffer
-   * @param width - Width of the frame buffer
-   * @param height - Height of the frame buffer
-   * @returns The intermediate frame buffer or null if not exists
-   *
-   * @remarks
-   * The intemediate buffer will be resized to fit the given size if needed
-   */ getIntermediateFramebuffer(name, format, width, height) {
-        const fb = this._intermediateFramebuffers[name];
-        if (!fb) {
-            return null;
-        }
-        const device = Application.instance.device;
-        const currentDepthBuffer = device.getFramebuffer().getDepthAttachment();
-        if (fb.framebuffer) {
-            const colorTex = fb.framebuffer.getColorAttachments()[0];
-            const depthTex = fb.framebuffer.getDepthAttachment();
-            if (colorTex.width !== width || colorTex.height !== height || colorTex.format !== format) {
-                fb.framebuffer.dispose();
-                colorTex.dispose();
-                if (depthTex && depthTex !== currentDepthBuffer) {
-                    depthTex.dispose();
-                }
-                fb.framebuffer = null;
-            }
-        }
-        if (!fb.framebuffer) {
-            const colorTex = device.createTexture2D(format, width, height, {
-                samplerOptions: {
-                    mipFilter: 'none'
-                }
-            });
-            colorTex.name = `Intermediate-<${name}>`;
-            let depthTex = null;
-            if (fb.depth === 'current') {
-                depthTex = currentDepthBuffer;
-            } else if (fb.depth === 'temporal') {
-                depthTex = device.createTexture2D('d24s8', width, height);
-                depthTex.name = `Intermediate-<${name}>-depth`;
-            }
-            fb.framebuffer = device.createFrameBuffer([
-                colorTex
-            ], depthTex);
-        }
-        return fb.framebuffer;
-    }
-    /**
    * Disposes the post effect.
    */ dispose() {
         this._quadVertexLayout?.dispose();
         this._quadVertexLayout = null;
         this._quadRenderStateSet = null;
-        for(const k in this._intermediateFramebuffers){
-            const fb = this._intermediateFramebuffers[k];
-            if (fb) {
-                const colorAttachment = fb.framebuffer.getColorAttachments()[0];
-                fb.framebuffer.dispose();
-                colorAttachment.dispose();
-            }
-        }
-        this._intermediateFramebuffers = {};
     }
     /**
    * Draws a fullscreen quad

package/dist/posteffect/posteffect.js.map

@@ -1 +1 @@
-{"version":3,"file":"posteffect.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"posteffect.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/posteffect/sao.js

@@ -1,26 +1,10 @@
 import { isFloatTextureFormat } from '@zephyr3d/device';
-import { Application } from '../app.js';
 import { AbstractPostEffect } from './posteffect.js';
 import { decodeNormalizedFloatFromRGBA, encodeNormalizedFloatToRGBA } from '../shaders/misc.js';
 import { Vector2, Vector4, Matrix4x4 } from '@zephyr3d/base';
 import { AOBilateralBlurBlitter } from '../blitter/depthlimitedgaussion.js';
+import '../app.js';
 import { CopyBlitter } from '../blitter/copy.js';
-import '../scene/octree.js';
-import '../material/shader/helper.js';
-import '../material/lambert.js';
-import '../material/blinn.js';
-import '../material/unlit.js';
-import '../material/material.js';
-import '../material/meshmaterial.js';
-import '../material/grassmaterial.js';
-import '../material/terrainmaterial.js';
-import '../material/pbrmr.js';
-import '../material/pbrsg.js';
-import '../render/renderer.js';
-import '../render/sky.js';
-import '../render/clipmap.js';
-import { TemporalCache } from '../render/temporalcache.js';
-import '../render/watermesh.js';
 
 const NUM_SAMPLES = 7;
 const NUM_RINGS = 4;
@@ -56,7 +40,7 @@ const NUM_RINGS = 4;
         this._opaque = true;
         this._saoScale = 10;
         this._saoBias = 1;
-        this._saoIntensity = 0.05;
+        this._saoIntensity = 0.025;
         this._saoRadius = 100;
         this._saoMinResolution = 0;
         this._saoRandomSeed = 0;
@@ -68,8 +52,6 @@ const NUM_RINGS = 4;
         this._blitterV.kernelRadius = 8;
         this._blitterV.stdDev = 10;
         this._copyBlitter = new CopyBlitter();
-        this.addIntermediateFramebuffer('ao', 'current');
-        this.addIntermediateFramebuffer('blur', 'current');
     }
     /** Scale value */ get scale() {
         return this._saoScale;
@@ -129,7 +111,7 @@ const NUM_RINGS = 4;
         return true;
     }
     /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
-        const device = Application.instance.device;
+        const device = ctx.device;
         const viewport = device.getViewport();
         this._prepare(device, inputColorTexture);
         this._copyBlitter.srgbOut = srgbOutput;
@@ -139,12 +121,14 @@ const NUM_RINGS = 4;
         }
         const fmt = this._getIntermediateTextureFormat(device);
         const depth = device.getFramebuffer().getDepthAttachment();
-        const fbao = ctx.defaultViewport ? TemporalCache.getFramebufferVariantSizeWithDepth(depth, 1, fmt, '2d', false) : TemporalCache.getFramebufferFixedSizeWithDepth(depth, 1, fmt, '2d', false);
-        const fbblur = ctx.defaultViewport ? TemporalCache.getFramebufferVariantSizeWithDepth(depth, 1, fmt, '2d', false) : TemporalCache.getFramebufferFixedSizeWithDepth(depth, 1, fmt, '2d', false);
-        const packed = fbao.getColorAttachments()[0].format === 'rgba8unorm';
+        const fbao = device.pool.fetchTemporalTexture2D(false, fmt, depth.width, depth.height, false);
+        const fbblur = device.pool.fetchTemporalTexture2D(false, fmt, depth.width, depth.height, false);
+        const packed = fbao.format === 'rgba8unorm';
         const cameraNearFar = new Vector2(ctx.camera.getNearPlane(), ctx.camera.getFarPlane());
         device.pushDeviceStates();
-        device.setFramebuffer(fbao);
+        device.setFramebuffer([
+            fbao
+        ], depth);
         device.clearFrameBuffer(packed ? new Vector4(0, 0, 0, 1) : new Vector4(1, 0, 0, 1), null, null);
         const bindgroup = packed ? this._bindgroupPacked : this._bindgroup;
         bindgroup.setValue('flip', this.needFlip(device) ? 1 : 0);
@@ -177,11 +161,11 @@ const NUM_RINGS = 4;
         this._blitterV.packed = packed;
         this._blitterV.srgbOut = srgbOutput;
         this._blitterV.renderStates = SAO._renderStateBlend;
-        this._blitterH.blit(fbao.getColorAttachments()[0], fbblur);
+        this._blitterH.blit(fbao, fbblur);
         device.popDeviceStates();
-        this._blitterV.blit(fbblur.getColorAttachments()[0], device.getFramebuffer());
-        TemporalCache.releaseFramebuffer(fbao);
-        TemporalCache.releaseFramebuffer(fbblur);
+        this._blitterV.blit(fbblur, device.getFramebuffer());
+        device.pool.releaseTexture(fbao);
+        device.pool.releaseTexture(fbblur);
     }
     _getIntermediateTextureFormat(device) {
         const texCaps = device.getDeviceCaps().textureCaps;

package/dist/posteffect/sao.js.map

@@ -1 +1 @@
-{"version":3,"file":"sao.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"sao.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/posteffect/tonemap.js

@@ -1,4 +1,3 @@
-import { Application } from '../app.js';
 import { AbstractPostEffect } from './posteffect.js';
 import { linearToGamma } from '../shaders/misc.js';
 
@@ -31,7 +30,7 @@ import { linearToGamma } from '../shaders/misc.js';
         return false;
     }
     /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
-        const device = Application.instance.device;
+        const device = ctx.device;
         this._prepare(device, inputColorTexture);
         this._tonemap(device, inputColorTexture, srgbOutput);
     }

package/dist/posteffect/tonemap.js.map

@@ -1 +1 @@
-{"version":3,"file":"tonemap.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"tonemap.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/posteffect/water.js

@@ -1,21 +1,19 @@
-import { Application } from '../app.js';
 import { Vector4, Interpolator, Vector2, Plane, Matrix4x4, Vector3 } from '@zephyr3d/base';
 import '../scene/octree.js';
+import '../app.js';
+import '@zephyr3d/device';
 import '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import '../material/material.js';
 import '../material/meshmaterial.js';
 import '../material/grassmaterial.js';
 import '../material/terrainmaterial.js';
 import '../material/pbrmr.js';
 import '../material/pbrsg.js';
-import '@zephyr3d/device';
 import '../render/renderer.js';
 import '../render/sky.js';
 import '../render/clipmap.js';
-import { TemporalCache } from '../render/temporalcache.js';
 import { WaterMesh } from '../render/watermesh.js';
 import { AbstractPostEffect } from './posteffect.js';
 import { decodeNormalizedFloatFromRGBA, linearToGamma } from '../shaders/misc.js';
@@ -115,7 +113,6 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
             0.6
         ]));
         this._rampTex = null;
-        this.addIntermediateFramebuffer('reflection', 'temporal');
         this._foamWidth = 1.2;
         this._foamContrast = 7.2;
         this._waterWireframe = false;
@@ -312,7 +309,7 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
         return true;
     }
     /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
-        const device = Application.instance.device;
+        const device = ctx.device;
         const rampTex = this._getRampTexture(device);
         this._copyBlitter.srgbOut = srgbOutput;
         this._copyBlitter.blit(inputColorTexture, device.getFramebuffer(), device.createSampler({
@@ -326,7 +323,7 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
             return;
         }
         this._renderingReflections = true;
-        const fbRefl = TemporalCache.getFramebufferFixedSize(this._reflectSize, this._reflectSize, 1, inputColorTexture.format, ctx.depthFormat, '2d', '2d', false);
+        const fbRefl = ctx.device.pool.fetchTemporalFramebuffer(true, this._reflectSize, this._reflectSize, inputColorTexture.format, ctx.depthFormat, false);
         const plane = new Plane(0, -1, 0, this._elevation);
         const clipPlane = new Plane(0, -1, 0, this._elevation - this._antiReflectanceLeak);
         const matReflectionR = Matrix4x4.invert(Matrix4x4.reflection(-plane.a, -plane.b, -plane.c, -plane.d));
@@ -371,7 +368,6 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
         waterMesh.bindGroup.setValue('depthMulti', this._depthMulti);
         waterMesh.bindGroup.setValue('refractionStrength', this._refractionStrength);
         waterMesh.bindGroup.setValue('targetSize', new Vector2(device.getViewport().width, device.getViewport().height));
-        waterMesh.bindGroup.setValue('envLightStrength', ctx.env.light.strength);
         waterMesh.bindGroup.setValue('waterLevel', this._elevation);
         waterMesh.bindGroup.setValue('srgbOut', srgbOutput ? 1 : 0);
         if (ctx.sunLight) {
@@ -379,9 +375,11 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
             waterMesh.bindGroup.setValue('lightShininess', 0.7);
             waterMesh.bindGroup.setValue('lightDiffuseAndIntensity', ctx.sunLight.diffuseAndIntensity);
         }
-        ctx.env.light.envLight.updateBindGroup(waterMesh.bindGroup);
+        if (ctx.env.light.envLight) {
+            waterMesh.bindGroup.setValue('envLightStrength', ctx.env.light.strength);
+            ctx.env.light.envLight.updateBindGroup(waterMesh.bindGroup);
+        }
         waterMesh.render(ctx.camera, this.needFlip(device));
-        TemporalCache.releaseFramebuffer(fbRefl);
     }
     /** @internal */ _getRampTexture(device) {
         if (!this._rampTex) {
@@ -397,7 +395,7 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
             const tmpcolor = new Vector3();
             for(let i = 0; i < numTexels; i++){
                 const grad = i >= numTexels / 2 ? this._scatterGrad : this._absorptionGrad;
-                grad.interpolate(i % width / width, 1, tmpcolor);
+                grad.interpolate(i % width / width, tmpcolor);
                 data[i * 4 + 0] = tmpcolor.x * 255 >> 0;
                 data[i * 4 + 1] = tmpcolor.y * 255 >> 0;
                 data[i * 4 + 2] = tmpcolor.z * 255 >> 0;
@@ -412,7 +410,7 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
         const hash = `${ctx.sunLight ? 1 : 0}:${ctx.env.light.getHash(ctx)}`;
         let waterMesh = this._waterMeshes[hash];
         if (!waterMesh) {
-            const device = Application.instance.device;
+            const device = ctx.device;
             waterMesh = new WaterMesh(device, {
                 setupUniforms (scope) {
                     const pb = scope.$builder;
@@ -428,7 +426,6 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
                         scope.cameraPos = pb.vec3().uniform(0);
                         scope.invViewProj = pb.mat4().uniform(0);
                         scope.targetSize = pb.vec2().uniform(0);
-                        scope.envLightStrength = pb.float().uniform(0);
                         scope.waterLevel = pb.float().uniform(0);
                         scope.srgbOut = pb.int().uniform(0);
                         if (ctx.sunLight) {
@@ -437,7 +434,10 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
                             scope.lightDiffuseAndIntensity = pb.vec4().uniform(0);
                         }
                     }
-                    ctx.env.light.envLight.initShaderBindings(pb);
+                    if (ctx.env.light.envLight) {
+                        scope.envLightStrength = pb.float().uniform(0);
+                        ctx.env.light.envLight.initShaderBindings(pb);
+                    }
                 },
                 shading (scope, worldPos, worldNormal, foamFactor) {
                     const pb = scope.$builder;
@@ -513,10 +513,12 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
                             this.$l.specular = pb.mul(this.D, this.VIS, this.F, this.lightDiffuseAndIntensity.rgb, this.lightDiffuseAndIntensity.a);
                             this.finalColor = pb.add(this.finalColor, this.specular);
                         }
-                        const irradiance = ctx.env.light.envLight.getIrradiance(this, this.myNormal);
-                        if (irradiance) {
-                            this.$l.sss = pb.mul(this.getScattering(this.depth), irradiance, this.envLightStrength);
-                            this.finalColor = pb.add(this.finalColor, this.sss);
+                        if (ctx.env.light.envLight) {
+                            const irradiance = ctx.env.light.envLight.getIrradiance(this, this.myNormal);
+                            if (irradiance) {
+                                this.$l.sss = pb.mul(this.getScattering(this.depth), irradiance, this.envLightStrength);
+                                this.finalColor = pb.add(this.finalColor, this.sss);
+                            }
                         }
                         this.$if(pb.notEqual(this.srgbOut, 0), function() {
                             this.finalColor = linearToGamma(this, this.finalColor);

package/dist/posteffect/water.js.map

@@ -1 +1 @@
-{"version":3,"file":"water.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"water.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}