@zephyr3d/scene 0.4.0 → 0.5.0

package/dist/material/pbrsg.js

@@ -2,6 +2,7 @@ import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
 import { mixinVertexColor } from './mixins/vertexcolor.js';
 import { mixinPBRSpecularGlossness } from './mixins/lightmodel/pbrspecularglossness.js';
 import { ShaderHelper } from './shader/helper.js';
+import { RENDER_PASS_TYPE_LIGHT } from '../values.js';
 
 /**
  * PBRSpecularGlossinessMaterial class
@@ -30,9 +31,15 @@ import { ShaderHelper } from './shader/helper.js';
     vertexShader(scope) {
         super.vertexShader(scope);
         const pb = scope.$builder;
+        const worldMatrix = ShaderHelper.getWorldMatrix(scope);
         scope.$l.oPos = ShaderHelper.resolveVertexPosition(scope);
-        scope.$outputs.worldPos = pb.mul(ShaderHelper.getWorldMatrix(scope), pb.vec4(scope.oPos, 1)).xyz;
-        ShaderHelper.setClipSpacePosition(scope, pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1)));
+        scope.$outputs.worldPos = pb.mul(worldMatrix, pb.vec4(scope.oPos, 1)).xyz;
+        scope.$l.csPos = pb.mul(ShaderHelper.getViewProjectionMatrix(scope), pb.vec4(scope.$outputs.worldPos, 1));
+        ShaderHelper.setClipSpacePosition(scope, scope.csPos);
+        if (this.transmission) {
+            scope.$outputs.screenUV = pb.add(pb.mul(pb.div(scope.csPos.xy, scope.csPos.w), 0.5), pb.vec2(0.5));
+            scope.$outputs.modelScale = pb.vec3(pb.length(worldMatrix[0].xyz), pb.length(worldMatrix[1].xyz), pb.length(worldMatrix[2].xyz));
+        }
         if (this.vertexNormal) {
             scope.$l.oNorm = ShaderHelper.resolveVertexNormal(scope);
             scope.$outputs.wNorm = pb.mul(ShaderHelper.getNormalMatrix(scope), pb.vec4(scope.oNorm, 0)).xyz;
@@ -51,14 +58,14 @@ import { ShaderHelper } from './shader/helper.js';
             if (this.vertexColor) {
                 scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));
             }
-            scope.$l.albedo = this.calculateAlbedoColor(scope);
-            if (this.vertexColor) {
-                scope.albedo = pb.mul(scope.albedo, this.getVertexColor(scope));
+            if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+                scope.$l.normalInfo = this.calculateNormalAndTBN(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
+                scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
+                scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.normalInfo.normal, scope.viewVec, scope.albedo, scope.normalInfo.TBN);
+                this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));
+            } else {
+                this.outputFragmentColor(scope, scope.$inputs.worldPos, scope.albedo);
             }
-            scope.$l.normalInfo = this.calculateNormalAndTBN(scope, scope.$inputs.worldPos, scope.$inputs.wNorm, scope.$inputs.wTangent, scope.$inputs.wBinormal);
-            scope.$l.viewVec = this.calculateViewVector(scope, scope.$inputs.worldPos);
-            scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.normalInfo.normal, scope.viewVec, scope.albedo, scope.normalInfo.TBN);
-            this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a));
         } else {
             this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
         }

package/dist/material/pbrsg.js.map

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

package/dist/material/shader/helper.js

@@ -1,5 +1,5 @@
 import { Vector3, Vector4 } from '@zephyr3d/base';
-import { RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, MAX_CLUSTERED_LIGHTS } from '../../values.js';
+import { RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_LIGHT, MAX_CLUSTERED_LIGHTS, MORPH_WEIGHTS_VECTOR_COUNT, MORPH_TARGET_POSITION, MORPH_TARGET_NORMAL, MORPH_TARGET_TANGENT, MORPH_ATTRIBUTE_VECTOR_COUNT } from '../../values.js';
 import { ScatteringLut } from '../../render/scatteringlut.js';
 import { linearToGamma } from '../../shaders/misc.js';
 import '../../app.js';
@@ -16,6 +16,8 @@ const UNIFORM_NAME_INSTANCE_DATA_OFFSET = 'Z_UniformInstanceDataOffset';
 const UNIFORM_NAME_BONE_MATRICES = 'Z_UniformBoneMatrices';
 const UNIFORM_NAME_BONE_TEXTURE_SIZE = 'Z_UniformBoneTexSize';
 const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
+const UNIFORM_NAME_MORPH_DATA = 'Z_UniformMorphData';
+const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
 /**
  * Helper shader functions for the builtin material system
  * @public
@@ -75,6 +77,12 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
     static getBoneInvBindMatrixUniformName() {
         return UNIFORM_NAME_BONE_INV_BIND_MATRIX;
     }
+    static getMorphDataUniformName() {
+        return UNIFORM_NAME_MORPH_DATA;
+    }
+    static getMorphInfoUniformName() {
+        return UNIFORM_NAME_MORPH_INFO;
+    }
     static getLightBufferUniformName() {
         return UNIFORM_NAME_LIGHT_BUFFER;
     }
@@ -124,7 +132,7 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
                 lightStruct('light')
             ]);
             scope[UNIFORM_NAME_GLOBAL] = globalStruct().uniform(0);
-        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH) {
+        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH || ctx.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {
             const globalStruct = pb.defineStruct([
                 cameraStruct('camera')
             ]);
@@ -191,6 +199,15 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
         return !!scope[UNIFORM_NAME_BONE_MATRICES];
     }
     /**
+   * This function checks if the shader needs to process morph target animation.
+   *
+   * @param scope - Current shader scope
+   *
+   * @returns true if the shader needs to process morph target animation, otherwise false.
+   */ static hasMorphing(scope) {
+        return !!scope[UNIFORM_NAME_MORPH_DATA];
+    }
+    /**
    * Calculate skinning matrix for current vertex
    *
    * @param scope - Current shader scope
@@ -235,6 +252,66 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
         });
         return scope.$g[funcNameGetSkinningMatrix]();
     }
+    static calculateMorphDelta(scope, attrib) {
+        const pb = scope.$builder;
+        const isWebGL1 = pb.getDevice().type === 'webgl';
+        if (pb.shaderKind !== 'vertex') {
+            throw new Error(`ShaderHelper.calculateMorphDelta(): must be called at vertex stage`);
+        }
+        const funcName = 'Z_calculateMorph';
+        const that = this;
+        pb.func(funcName, [
+            pb.int('offset')
+        ], function() {
+            this.$if(pb.lessThan(this.offset, 0), function() {
+                this.$return(pb.vec4(0));
+            });
+            this.$l.vertexIndex = isWebGL1 ? pb.int(scope.$inputs.zFakeVertexID) : pb.int(scope.$builtins.vertexIndex);
+            const morphInfo = scope[that.getMorphInfoUniformName()];
+            this.$l.metaData = pb.ivec4(morphInfo[0]);
+            this.$l.texWidth = pb.float(this.metaData.x);
+            this.$l.texHeight = pb.float(this.metaData.y);
+            this.$l.numVertices = this.metaData.z;
+            this.$l.numTargets = this.metaData.w;
+            this.$l.value = pb.vec4(0);
+            if (isWebGL1) {
+                this.$for(pb.int('i'), 0, MORPH_WEIGHTS_VECTOR_COUNT, function() {
+                    this.$for(pb.int('j'), 0, 4, function() {
+                        this.$l.index = pb.add(pb.mul(this.i, 4), this.j);
+                        this.$if(pb.greaterThanEqual(this.index, this.numTargets), function() {
+                            this.$return(this.value);
+                        });
+                        this.$l.weight = morphInfo.at(pb.add(1, this.i)).at(this.j);
+                        this.$l.pixelIndex = pb.float(pb.add(this.offset, pb.mul(this.index, this.numVertices), this.vertexIndex));
+                        this.$l.xIndex = pb.mod(this.pixelIndex, this.texWidth);
+                        this.$l.yIndex = pb.floor(pb.div(this.pixelIndex, this.texWidth));
+                        this.$l.u = pb.div(pb.add(this.xIndex, 0.5), this.texWidth);
+                        this.$l.v = pb.div(pb.add(this.yIndex, 0.5), this.texHeight);
+                        this.$l.morphValue = pb.textureSampleLevel(this[that.getMorphDataUniformName()], pb.vec2(this.u, this.v), 0);
+                        this.value = pb.add(this.value, pb.mul(this.morphValue, this.weight));
+                    });
+                });
+            } else {
+                this.$for(pb.int('t'), 0, this.numTargets, function() {
+                    this.$l.i = pb.sar(this.t, 2);
+                    this.$l.j = pb.compAnd(this.t, 3);
+                    this.$l.weight = morphInfo.at(pb.add(1, this.i)).at(this.j);
+                    this.$l.pixelIndex = pb.float(pb.add(this.offset, pb.mul(this.t, this.numVertices), this.vertexIndex));
+                    this.$l.xIndex = pb.mod(this.pixelIndex, this.texWidth);
+                    this.$l.yIndex = pb.floor(pb.div(this.pixelIndex, this.texWidth));
+                    this.$l.u = pb.div(pb.add(this.xIndex, 0.5), this.texWidth);
+                    this.$l.v = pb.div(pb.add(this.yIndex, 0.5), this.texHeight);
+                    this.$l.morphValue = pb.textureSampleLevel(this[that.getMorphDataUniformName()], pb.vec2(this.u, this.v), 0);
+                    this.value = pb.add(this.value, pb.mul(this.morphValue, this.weight));
+                });
+            }
+            this.$return(this.value);
+        });
+        const pos = 1 + MORPH_WEIGHTS_VECTOR_COUNT + (attrib >> 2);
+        const comp = attrib & 3;
+        const offset = scope[this.getMorphInfoUniformName()][pos][comp];
+        return scope[funcName](pb.int(offset));
+    }
     /**
    * Calculates the vertex position of type vec3 in object space
    *
@@ -257,6 +334,9 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
             }
             pos = scope.$getVertexAttrib('position');
         }
+        if (this.hasMorphing(scope)) {
+            pos = pb.add(pos, this.calculateMorphDelta(scope, MORPH_TARGET_POSITION).xyz);
+        }
         if (this.hasSkinning(scope)) {
             if (!funcScope[this.SKIN_MATRIX_NAME]) {
                 funcScope[this.SKIN_MATRIX_NAME] = this.calculateSkinMatrix(funcScope);
@@ -288,6 +368,9 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
             }
             normal = scope.$getVertexAttrib('normal');
         }
+        if (this.hasMorphing(scope)) {
+            normal = pb.normalize(pb.add(normal, this.calculateMorphDelta(scope, MORPH_TARGET_NORMAL).xyz));
+        }
         if (this.hasSkinning(scope)) {
             if (!funcScope[this.SKIN_MATRIX_NAME]) {
                 funcScope[this.SKIN_MATRIX_NAME] = this.calculateSkinMatrix(funcScope);
@@ -319,6 +402,9 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
             }
             tangent = scope.$getVertexAttrib('tangent');
         }
+        if (this.hasMorphing(scope)) {
+            tangent = pb.normalize(pb.add(tangent, pb.vec4(this.calculateMorphDelta(scope, MORPH_TARGET_TANGENT).xyz, 0)));
+        }
         if (this.hasSkinning(scope)) {
             if (!funcScope[this.SKIN_MATRIX_NAME]) {
                 funcScope[this.SKIN_MATRIX_NAME] = this.calculateSkinMatrix(funcScope);
@@ -358,7 +444,7 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
    * @param scope - Current shader scope
    * @param skinning - true if skinning is used, otherwise false.
    * @param instanced - true if instancing is used, otherwise false.
-   */ static vertexShaderDrawableStuff(scope, skinning, instanced) {
+   */ static vertexShaderDrawableStuff(scope, skinning, morphing, instanced) {
         const pb = scope.$builder;
         if (instanced) {
             scope[UNIFORM_NAME_INSTANCE_DATA_STRIDE] = pb.uint().uniform(1);
@@ -372,9 +458,13 @@ const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
             scope[UNIFORM_NAME_BONE_INV_BIND_MATRIX] = pb.mat4().uniform(1);
             scope[UNIFORM_NAME_BONE_TEXTURE_SIZE] = pb.int().uniform(1);
         }
+        if (morphing) {
+            scope[UNIFORM_NAME_MORPH_DATA] = pb.tex2D().uniform(1).sampleType('unfilterable-float');
+            scope[UNIFORM_NAME_MORPH_INFO] = pb.vec4[1 + MORPH_WEIGHTS_VECTOR_COUNT + MORPH_ATTRIBUTE_VECTOR_COUNT]().uniformBuffer(1);
+        }
     }
     /** @internal */ static prepareVertexShaderCommon(pb, ctx) {
-        this.vertexShaderDrawableStuff(pb.getGlobalScope(), !!ctx.skinAnimation, !!ctx.instancing);
+        this.vertexShaderDrawableStuff(pb.getGlobalScope(), !!ctx.skinAnimation, !!ctx.morphAnimation, !!ctx.instancing);
     /*
     const skinning = !!ctx.target?.getBoneMatrices();
     const scope = pb.getGlobalScope();

package/dist/material/shader/helper.js.map

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

package/dist/material/unlit.js

@@ -20,11 +20,15 @@ import { ShaderHelper } from './shader/helper.js';
     }
     fragmentShader(scope) {
         super.fragmentShader(scope);
-        let color = this.calculateAlbedoColor(scope);
-        if (this.vertexColor) {
-            color = scope.$builder.mul(color, this.getVertexColor(scope));
+        if (this.needFragmentColor()) {
+            let color = this.calculateAlbedoColor(scope);
+            if (this.vertexColor) {
+                color = scope.$builder.mul(color, this.getVertexColor(scope));
+            }
+            this.outputFragmentColor(scope, scope.$inputs.worldPos, color);
+        } else {
+            this.outputFragmentColor(scope, scope.$inputs.worldPos, null);
         }
-        this.outputFragmentColor(scope, scope.$inputs.worldPos, this.needFragmentColor() ? color : null);
     }
 }
 

package/dist/material/unlit.js.map

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

package/dist/posteffect/bloom.js

@@ -1,22 +1,5 @@
 import { AbstractPostEffect } from './posteffect.js';
 import { Vector4, Vector2 } 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/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';
 
 /**
  * The bloom post effect
@@ -97,29 +80,31 @@ import '../render/watermesh.js';
     }
     /** {@inheritDoc AbstractPostEffect.apply} */ apply(ctx, inputColorTexture, sceneDepthTexture, srgbOutput) {
         const device = ctx.device;
-        const downsampleFramebuffers = [];
+        const downsampleTextures = [];
         this._prepare(device, inputColorTexture);
         device.pushDeviceStates();
         const w = Math.max(inputColorTexture.width >> 1, 1);
         const h = Math.max(inputColorTexture.height >> 1, 1);
-        const prefilterFramebuffer = TemporalCache.getFramebufferFixedSize(w, h, 1, inputColorTexture.format, null, '2d', null, false);
-        this.prefilter(device, inputColorTexture, prefilterFramebuffer);
-        this.downsample(device, prefilterFramebuffer.getColorAttachments()[0], downsampleFramebuffers);
-        this.upsample(device, downsampleFramebuffers);
+        const colorTex = device.pool.fetchTemporalTexture2D(false, inputColorTexture.format, w, h, false);
+        this.prefilter(device, inputColorTexture, colorTex);
+        this.downsample(device, colorTex, downsampleTextures);
+        this.upsample(device, downsampleTextures);
         device.popDeviceStates();
-        this.finalCompose(device, inputColorTexture, downsampleFramebuffers[0].getColorAttachments()[0]);
-        for (const fb of downsampleFramebuffers){
-            TemporalCache.releaseFramebuffer(fb);
+        this.finalCompose(device, inputColorTexture, downsampleTextures[0]);
+        for (const tex of downsampleTextures){
+            device.pool.releaseTexture(tex);
         }
-        TemporalCache.releaseFramebuffer(prefilterFramebuffer);
+        device.pool.releaseTexture(colorTex);
     }
-    /** @internal */ prefilter(device, srcTexture, fb) {
+    /** @internal */ prefilter(device, srcTexture, rt) {
         this._thresholdValue.x = this._threshold * this._threshold;
         this._thresholdValue.y = this._thresholdValue.x * this._thresholdKnee;
         this._thresholdValue.z = 2 * this._thresholdValue.y;
         this._thresholdValue.w = 0.25 / (this._thresholdValue.y + 0.00001);
         this._thresholdValue.y -= this._thresholdValue.x;
-        device.setFramebuffer(fb);
+        device.setFramebuffer([
+            rt
+        ]);
         device.setProgram(Bloom._programPrefilter);
         device.setBindGroup(0, this._bindgroupPrefilter);
         this._bindgroupPrefilter.setTexture('tex', srcTexture);
@@ -136,17 +121,19 @@ import '../render/watermesh.js';
         this._bindgroupFinalCompose.setValue('flip', device.type === 'webgpu' && device.getFramebuffer() ? 1 : 0);
         this.drawFullscreenQuad();
     }
-    /** @internal */ upsample(device, framebuffers) {
+    /** @internal */ upsample(device, textures) {
         device.setProgram(Bloom._programUpsample);
         device.setBindGroup(0, this._bindgroupUpsample);
         this._bindgroupUpsample.setValue('flip', device.type === 'webgpu' ? 1 : 0);
-        for(let i = framebuffers.length - 2; i >= 0; i--){
-            this._bindgroupUpsample.setTexture('tex', framebuffers[i + 1].getColorAttachments()[0]);
-            device.setFramebuffer(framebuffers[i]);
+        for(let i = textures.length - 2; i >= 0; i--){
+            this._bindgroupUpsample.setTexture('tex', textures[i + 1]);
+            device.setFramebuffer([
+                textures[i]
+            ]);
             this.drawFullscreenQuad(Bloom._renderStateAdditive);
         }
     }
-    /** @internal */ downsample(device, inputColorTexture, framebuffers) {
+    /** @internal */ downsample(device, inputColorTexture, textures) {
         const t = Math.max(2, this._downsampleLimit);
         let w = Math.max(t, inputColorTexture.width >> 1);
         let h = Math.max(t, inputColorTexture.height >> 1);
@@ -155,31 +142,34 @@ import '../render/watermesh.js';
         this._bindgroupDownsampleH.setValue('flip', device.type === 'webgpu' ? 1 : 0);
         this._bindgroupDownsampleV.setValue('flip', device.type === 'webgpu' ? 1 : 0);
         while((w >= t || h >= t) && maxLevels > 0){
-            const fb = TemporalCache.getFramebufferFixedSize(w, h, 1, inputColorTexture.format, null, '2d', '2d', false);
-            const fbMiddle = TemporalCache.getFramebufferFixedSize(w, h, 1, inputColorTexture.format, null, '2d', '2d', false);
-            framebuffers.push(fb);
+            const tex = device.pool.fetchTemporalTexture2D(false, inputColorTexture.format, w, h, false);
+            textures.push(tex);
+            const texMiddle = device.pool.fetchTemporalTexture2D(false, inputColorTexture.format, w, h, false);
             // horizonal blur
             this._invTexSize.setXY(1 / sourceTex.width, 1 / sourceTex.height);
-            device.setFramebuffer(fbMiddle);
+            device.setFramebuffer([
+                texMiddle
+            ]);
             device.setProgram(Bloom._programDownsampleH);
             device.setBindGroup(0, this._bindgroupDownsampleH);
             this._bindgroupDownsampleH.setTexture('tex', sourceTex);
             this._bindgroupDownsampleH.setValue('invTexSize', this._invTexSize);
             this.drawFullscreenQuad();
             // vertical blur
-            const midTex = fbMiddle.getColorAttachments()[0];
-            this._invTexSize.setXY(1 / midTex.width, 1 / midTex.height);
-            device.setFramebuffer(fb);
+            this._invTexSize.setXY(1 / texMiddle.width, 1 / texMiddle.height);
+            device.setFramebuffer([
+                tex
+            ]);
             device.setProgram(Bloom._programDownsampleV);
             device.setBindGroup(0, this._bindgroupDownsampleV);
-            this._bindgroupDownsampleV.setTexture('tex', midTex);
+            this._bindgroupDownsampleV.setTexture('tex', texMiddle);
             this._bindgroupDownsampleV.setValue('invTexSize', this._invTexSize);
             this.drawFullscreenQuad();
             maxLevels--;
             w = Math.max(1, w >> 1);
             h = Math.max(1, h >> 1);
-            sourceTex = fb.getColorAttachments()[0];
-            TemporalCache.releaseFramebuffer(fbMiddle);
+            sourceTex = tex;
+            device.pool.releaseTexture(texMiddle);
         }
     }
     /** @internal */ _prepare(device, srcTexture) {

package/dist/posteffect/bloom.js.map

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

package/dist/posteffect/compositor.js

@@ -1,22 +1,4 @@
 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';
 
 /**
  * Post processing compositor
@@ -98,22 +80,16 @@ import '../render/watermesh.js';
         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;
@@ -127,7 +103,7 @@ import '../render/watermesh.js';
         ctx.compositorContex = {
             finalFramebuffer,
             pingpongFramebuffers,
-            msFramebuffer,
+            msTexture: msFramebuffer,
             writeIndex
         };
     }
@@ -166,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/sao.js

@@ -5,21 +5,6 @@ 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';
 
 const NUM_SAMPLES = 7;
 const NUM_RINGS = 4;
@@ -55,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;
@@ -136,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);
@@ -174,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/water.js

@@ -14,7 +14,6 @@ import '../material/pbrsg.js';
 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';
@@ -324,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));
@@ -381,7 +380,6 @@ import { fresnelSchlick, distributionGGX, visGGX } from '../shaders/pbr.js';
             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;

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

package/dist/render/cull_visitor.js

@@ -51,8 +51,8 @@ import { RENDER_PASS_TYPE_SHADOWMAP } from '../values.js';
     /** Frustum for culling */ get frustum() {
         return this._camera?.frustum || null;
     }
-    /** @internal */ push(camera, drawable, renderOrder) {
-        this.renderQueue.push(camera, drawable, renderOrder);
+    /** @internal */ push(camera, drawable) {
+        this.renderQueue.push(camera, drawable);
     }
     /** @internal */ pushRenderQueue(renderQueue) {
         this.renderQueue.pushRenderQueue(renderQueue);
@@ -104,7 +104,7 @@ import { RENDER_PASS_TYPE_SHADOWMAP } from '../values.js';
         if (!node.hidden && (node.castShadow || this._renderPass.type !== RENDER_PASS_TYPE_SHADOWMAP)) {
             const clipState = this.getClipStateWithNode(node);
             if (clipState !== ClipState.NOT_CLIPPED) {
-                this.push(this._camera, node, node.renderOrder);
+                this.push(this._camera, node);
                 return true;
             }
         }