@zephyr3d/scene 0.4.0 → 0.6.0

package/dist/posteffect/compositor.js

@@ -1,30 +1,15 @@
 import { linearToGamma } from '../shaders/misc.js';
-import '@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/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';
+import { MaterialVaryingFlags } from '../values.js';
+import { SSR } from './ssr.js';
+import { fetchSampler } from '../utility/misc.js';
 
 /**
  * Post processing compositor
  * @public
  */ class Compositor {
+    /** @internal */ static _SSRPostEffect = null;
     /** @internal */ _postEffectsOpaque;
     /** @internal */ _postEffectsTransparency;
-    /** @internal */ static _blitSampler = null;
     /** @internal */ static _blitProgram = null;
     /** @internal */ static _blitBindgroup = null;
     /** @internal */ static _blitRenderStates = null;
@@ -35,14 +20,14 @@ import '../render/watermesh.js';
         this._postEffectsOpaque = [];
         this._postEffectsTransparency = [];
     }
-    /** @internal */ requireLinearDepth() {
+    /** @internal */ requireLinearDepth(ctx) {
         for (const postEffect of this._postEffectsOpaque){
-            if (postEffect.requireLinearDepthTexture()) {
+            if (postEffect.requireLinearDepthTexture(ctx)) {
                 return true;
             }
         }
         for (const postEffect of this._postEffectsTransparency){
-            if (postEffect.requireLinearDepthTexture()) {
+            if (postEffect.requireLinearDepthTexture(ctx)) {
                 return true;
             }
         }
@@ -94,26 +79,30 @@ import '../render/watermesh.js';
         ];
     }
     /** @internal */ begin(ctx) {
+        const ssr = !!(ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS);
+        if (this._postEffectsOpaque.length === 0 && this._postEffectsTransparency.length === 0 && ctx.primaryCamera.sampleCount === 1 && !ssr) {
+            ctx.compositorContex = null;
+            return;
+        }
         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;
-        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)
-            ];
+        const w = depth ? depth.width : ctx.viewportWidth;
+        const h = depth ? depth.height : ctx.viewportHeight;
+        if (ctx.primaryCamera.sampleCount > 1 || ssr) {
+            const fmt2 = ssr ? device.type === 'webgl' ? format : 'rgba8unorm' : format;
+            msFramebuffer = device.pool.fetchTemporalFramebuffer(true, w, h, ssr ? [
+                format,
+                fmt2,
+                fmt2
+            ] : format, depth, ssr, 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;
@@ -127,9 +116,17 @@ import '../render/watermesh.js';
         ctx.compositorContex = {
             finalFramebuffer,
             pingpongFramebuffers,
-            msFramebuffer,
+            msTexture: msFramebuffer,
             writeIndex
         };
+        if (ssr) {
+            if (!Compositor._SSRPostEffect) {
+                Compositor._SSRPostEffect = new SSR();
+            }
+            Compositor._SSRPostEffect.roughnessTexture = msFramebuffer.getColorAttachments()[1];
+            Compositor._SSRPostEffect.normalTexture = msFramebuffer.getColorAttachments()[2];
+            this._postEffectsOpaque.unshift(Compositor._SSRPostEffect);
+        }
     }
     /** @internal */ drawPostEffects(ctx, opaque, sceneDepthTexture) {
         const postEffects = opaque ? this._postEffectsOpaque : this._postEffectsTransparency;
@@ -142,7 +139,7 @@ import '../render/watermesh.js';
                 }
                 const inputTexture = device.getFramebuffer().getColorAttachments()[0];
                 const isLast = this.isLastPostEffect(opaque, i);
-                const finalEffect = isLast && (!postEffect.requireDepthAttachment() || !!ctx.compositorContex.finalFramebuffer);
+                const finalEffect = isLast && (!postEffect.requireDepthAttachment(ctx) || !!ctx.compositorContex.finalFramebuffer);
                 if (finalEffect) {
                     device.setFramebuffer(ctx.compositorContex.finalFramebuffer);
                     device.setViewport(null);
@@ -158,20 +155,20 @@ import '../render/watermesh.js';
         }
     }
     /** @internal */ end(ctx) {
-        const device = ctx.device;
-        if (device.getFramebuffer() !== ctx.compositorContex.finalFramebuffer) {
-            const srcTex = device.getFramebuffer().getColorAttachments()[0];
-            device.setFramebuffer(ctx.compositorContex.finalFramebuffer);
-            device.setViewport(null);
-            device.setScissor(null);
-            Compositor._blit(device, srcTex, !ctx.compositorContex.finalFramebuffer);
+        if (ctx.compositorContex) {
+            const device = ctx.device;
+            if (device.getFramebuffer() !== ctx.compositorContex.finalFramebuffer) {
+                const srcTex = device.getFramebuffer().getColorAttachments()[0];
+                device.setFramebuffer(ctx.compositorContex.finalFramebuffer);
+                device.setViewport(null);
+                device.setScissor(null);
+                Compositor._blit(device, srcTex, !ctx.compositorContex.finalFramebuffer);
+            }
+            ctx.compositorContex = null;
         }
-        TemporalCache.releaseFramebuffer(ctx.compositorContex.pingpongFramebuffers[0]);
-        TemporalCache.releaseFramebuffer(ctx.compositorContex.pingpongFramebuffers[1]);
-        if (ctx.compositorContex.msFramebuffer) {
-            TemporalCache.releaseFramebuffer(ctx.compositorContex.msFramebuffer);
+        if (this._postEffectsOpaque[0] === Compositor._SSRPostEffect) {
+            this._postEffectsOpaque.shift();
         }
-        ctx.compositorContex = null;
     }
     /** @internal */ isLastPostEffect(opaque, index) {
         const list = opaque ? this._postEffectsOpaque : this._postEffectsTransparency;
@@ -246,18 +243,11 @@ import '../render/watermesh.js';
                     }
                 ]
             });
-            this._blitSampler = device.createSampler({
-                minFilter: 'nearest',
-                magFilter: 'nearest',
-                mipFilter: 'none',
-                addressU: 'clamp',
-                addressV: 'clamp'
-            });
             this._blitRenderStates = device.createRenderStateSet();
             this._blitRenderStates.useRasterizerState().setCullMode('none');
             this._blitRenderStates.useDepthState().enableTest(false).enableWrite(false);
         }
-        this._blitBindgroup.setTexture('srcTex', srcTex, this._blitSampler);
+        this._blitBindgroup.setTexture('srcTex', srcTex, fetchSampler('clamp_nearest_nomip'));
         this._blitBindgroup.setValue('srgbOutput', srgbOutput ? 1 : 0);
         this._blitBindgroup.setValue('flip', device.type === 'webgpu' && !!device.getFramebuffer() ? 1 : 0);
         device.setRenderStates(this._blitRenderStates);

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,13 +1,14 @@
 import { Vector2 } from '@zephyr3d/base';
 import { AbstractPostEffect } from './posteffect.js';
 import { linearToGamma } from '../shaders/misc.js';
+import { fetchSampler } from '../utility/misc.js';
 
 /**
  * FXAA post effect
  * @public
  */ class FXAA extends AbstractPostEffect {
+    static className = 'FXAA';
     static _program = null;
-    static _sampler = null;
     _bindgroup;
     _invTexSize;
     /**
@@ -33,7 +34,7 @@ import { linearToGamma } from '../shaders/misc.js';
         const device = ctx.device;
         this._prepare(device);
         this._invTexSize.setXY(1 / inputColorTexture.width, 1 / inputColorTexture.height);
-        this._bindgroup.setTexture('srcTex', inputColorTexture, FXAA._sampler);
+        this._bindgroup.setTexture('srcTex', inputColorTexture, fetchSampler('clamp_linear_nomip'));
         this._bindgroup.setValue('flip', this.needFlip(device) ? 1 : 0);
         this._bindgroup.setValue('srgbOut', srgbOutput ? 1 : 0);
         this._bindgroup.setValue('invTexSize', this._invTexSize);
@@ -271,15 +272,6 @@ import { linearToGamma } from '../shaders/misc.js';
                 }
             });
         }
-        if (!FXAA._sampler) {
-            FXAA._sampler = device.createSampler({
-                magFilter: 'linear',
-                minFilter: 'linear',
-                mipFilter: 'none',
-                addressU: 'clamp',
-                addressV: 'clamp'
-            });
-        }
         if (!this._bindgroup) {
             this._bindgroup = device.createBindGroup(FXAA._program.bindGroupLayouts[0]);
         }

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,12 +1,13 @@
 import { AbstractPostEffect } from './posteffect.js';
 import { linearToGamma } from '../shaders/misc.js';
+import { fetchSampler } from '../utility/misc.js';
 
 /**
  * Grayscale post effect
  * @public
  */ class Grayscale extends AbstractPostEffect {
+    static className = 'Grayscale';
     static _program = null;
-    static _sampler = null;
     _bindgroup;
     /**
    * Creates an instance of grayscale post effect
@@ -29,7 +30,7 @@ import { linearToGamma } from '../shaders/misc.js';
     /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
         const device = ctx.device;
         this._prepare(device);
-        this._bindgroup.setTexture('srcTex', inputColorTexture, Grayscale._sampler);
+        this._bindgroup.setTexture('srcTex', inputColorTexture, fetchSampler('clamp_nearest_nomip'));
         this._bindgroup.setValue('flip', this.needFlip(device) ? 1 : 0);
         this._bindgroup.setValue('srgbOut', srgbOutput ? 1 : 0);
         device.setProgram(Grayscale._program);
@@ -67,15 +68,6 @@ import { linearToGamma } from '../shaders/misc.js';
                 }
             });
         }
-        if (!Grayscale._sampler) {
-            Grayscale._sampler = device.createSampler({
-                magFilter: 'nearest',
-                minFilter: 'nearest',
-                mipFilter: 'none',
-                addressU: 'clamp',
-                addressV: 'clamp'
-            });
-        }
         if (!this._bindgroup) {
             this._bindgroup = device.createBindGroup(Grayscale._program.bindGroupLayouts[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

@@ -4,6 +4,7 @@ import { drawFullscreenQuad } from '../render/fullscreenquad.js';
  * Base class for any type of post effect
  * @public
  */ class AbstractPostEffect {
+    static className;
     _outputTexture;
     _quadVertexLayout;
     _quadRenderStateSet;
@@ -19,6 +20,9 @@ import { drawFullscreenQuad } from '../render/fullscreenquad.js';
         this._enabled = true;
         this._opaque = false;
     }
+    /** Gets class name of this instance */ getClassName() {
+        return this.constructor.className;
+    }
     /** Whether this post effect is enabled */ get enabled() {
         return this._enabled;
     }

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

@@ -2,32 +2,49 @@ import { isFloatTextureFormat } from '@zephyr3d/device';
 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/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';
+import { BilateralBlurBlitter } from '../blitter/bilateralblur.js';
+import { copyTexture, fetchSampler } from '../utility/misc.js';
 
 const NUM_SAMPLES = 7;
 const NUM_RINGS = 4;
+class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
+    _packed;
+    constructor(finalPhase){
+        super(finalPhase);
+        this._packed = false;
+    }
+    get packed() {
+        return this._packed;
+    }
+    set packed(val) {
+        if (this._packed !== !!val) {
+            this._packed = !!val;
+            this.invalidateHash();
+        }
+    }
+    calcHash() {
+        return `${this._packed}:${super.calcHash()}`;
+    }
+    readTexel(scope, type, srcTex, srcUV, srcLayer, sampleType) {
+        const pb = scope.$builder;
+        const texel = super.readTexel(scope, type, srcTex, srcUV, srcLayer, sampleType);
+        if (this._packed) {
+            return pb.vec4(pb.vec3(decodeNormalizedFloatFromRGBA(scope, texel)), 1);
+        } else {
+            return pb.vec4(texel.rrr, 1);
+        }
+    }
+    writeTexel(scope, type, uv, texel) {
+        const pb = scope.$builder;
+        const outTexel = super.writeTexel(scope, type, uv, pb.vec4(texel.rrr, 1));
+        return this._finalPhase || !this._packed ? pb.vec4(outTexel.rrr, 1) : encodeNormalizedFloatToRGBA(scope, outTexel.r);
+    }
+}
 /**
  * The Scalable Ambient Obscurance (SAO) post effect
  * @public
  */ class SAO extends AbstractPostEffect {
-    static _nearestSampler = null;
+    static className = 'SAO';
     static _program = null;
     static _programPacked = null;
     static _renderState = null;
@@ -43,7 +60,6 @@ const NUM_RINGS = 4;
     _saoBlurDepthCutoff;
     _blitterH;
     _blitterV;
-    _copyBlitter;
     _supported;
     /**
    * Creates an instance of SAO post effect
@@ -55,18 +71,17 @@ 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;
-        this._saoBlurDepthCutoff = 1;
-        this._blitterH = new AOBilateralBlurBlitter(false);
+        this._saoBlurDepthCutoff = 2;
+        this._blitterH = new DepthLimitAOBlurBlitter(false);
         this._blitterH.kernelRadius = 8;
         this._blitterH.stdDev = 10;
-        this._blitterV = new AOBilateralBlurBlitter(true);
+        this._blitterV = new DepthLimitAOBlurBlitter(true);
         this._blitterV.kernelRadius = 8;
         this._blitterV.stdDev = 10;
-        this._copyBlitter = new CopyBlitter();
     }
     /** Scale value */ get scale() {
         return this._saoScale;
@@ -129,19 +144,20 @@ const NUM_RINGS = 4;
         const device = ctx.device;
         const viewport = device.getViewport();
         this._prepare(device, inputColorTexture);
-        this._copyBlitter.srgbOut = srgbOutput;
-        this._copyBlitter.blit(inputColorTexture, device.getFramebuffer(), SAO._nearestSampler);
+        copyTexture(inputColorTexture, device.getFramebuffer(), fetchSampler('clamp_nearest_nomip'), null, 0, srgbOutput);
         if (!this._supported) {
             return;
         }
         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);
@@ -161,24 +177,24 @@ const NUM_RINGS = 4;
         this.drawFullscreenQuad(SAO._renderState);
         this._blitterH.size = new Vector2(inputColorTexture.width, inputColorTexture.height);
         this._blitterH.depthTex = sceneDepthTexture;
-        this._blitterH.depthCutoff = this._saoBlurDepthCutoff / ctx.camera.getFarPlane();
-        this._blitterH.nearestSampler = SAO._nearestSampler;
+        this._blitterH.depthCutoff = this._saoBlurDepthCutoff;
+        this._blitterH.sampler = fetchSampler('clamp_nearest_nomip');
         this._blitterH.cameraNearFar = cameraNearFar;
         this._blitterH.packed = packed;
         this._blitterH.renderStates = SAO._renderState;
         this._blitterV.size = new Vector2(inputColorTexture.width, inputColorTexture.height);
         this._blitterV.depthTex = sceneDepthTexture;
-        this._blitterV.depthCutoff = this._saoBlurDepthCutoff / ctx.camera.getFarPlane();
-        this._blitterV.nearestSampler = SAO._nearestSampler;
+        this._blitterV.depthCutoff = this._saoBlurDepthCutoff;
+        this._blitterV.sampler = fetchSampler('clamp_nearest_nomip');
         this._blitterV.cameraNearFar = cameraNearFar;
         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;
@@ -189,15 +205,6 @@ const NUM_RINGS = 4;
         const isFloatFramebuffer = fb && isFloatTextureFormat(fb.getColorAttachments()[0].format);
         this._supported = !isFloatFramebuffer || device.getDeviceCaps().framebufferCaps.supportFloatBlending;
         if (this._supported) {
-            if (!SAO._nearestSampler) {
-                SAO._nearestSampler = device.createSampler({
-                    magFilter: 'nearest',
-                    minFilter: 'nearest',
-                    mipFilter: 'none',
-                    addressU: 'clamp',
-                    addressV: 'clamp'
-                });
-            }
             if (!SAO._renderState) {
                 SAO._renderState = device.createRenderStateSet();
                 SAO._renderState.useDepthState().enableTest(true).enableWrite(false).setCompareFunc('gt');

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}