@zephyr3d/scene 0.5.0 → 0.6.0

package/dist/material/mixins/lightmodel/pbrspecularglossness.js

@@ -3,6 +3,7 @@ import { mixinTextureProps } from '../texture.js';
 import { mixinPBRCommon } from '../pbr/common.js';
 import { Vector4 } from '@zephyr3d/base';
 import { mixinLight } from '../lit.js';
+import { ShaderHelper } from '../../shader/helper.js';
 
 /**
  * PBRSpecularGlossiness mixin
@@ -58,7 +59,7 @@ import { mixinLight } from '../lit.js';
                 bindGroup.setValue('zGlossinessFactor', this._glossinessFactor);
             }
         }
-        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN) {
+        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN, outRoughness) {
             const pb = scope.$builder;
             const funcName = 'Z_PBRSpecularGlossinessLight';
             const that = this;
@@ -67,12 +68,19 @@ import { mixinLight } from '../lit.js';
                 pb.vec3('normal'),
                 pb.mat3('TBN'),
                 pb.vec3('viewVec'),
-                pb.vec4('albedo')
+                pb.vec4('albedo'),
+                ...outRoughness ? [
+                    pb.vec4('outRoughness').out()
+                ] : []
             ], function() {
                 this.$l.pbrData = that.getCommonData(this, this.albedo, this.normal, this.viewVec, this.TBN);
                 this.$l.lightingColor = pb.vec3(0);
                 this.$l.emissiveColor = that.calculateEmissiveColor(this);
-                that.indirectLighting(this, this.normal, this.viewVec, this.pbrData, this.lightingColor);
+                if (outRoughness) {
+                    that.indirectLighting(this, this.normal, this.viewVec, this.pbrData, this.lightingColor, this.outRoughness);
+                } else {
+                    that.indirectLighting(this, this.normal, this.viewVec, this.pbrData, this.lightingColor);
+                }
                 that.forEachLight(this, function(type, posRange, dirCutoff, colorIntensity, shadow) {
                     this.$l.diffuse = pb.vec3();
                     this.$l.specular = pb.vec3();
@@ -87,7 +95,7 @@ import { mixinLight } from '../lit.js';
                 });
                 this.$return(pb.add(this.lightingColor, this.emissiveColor));
             });
-            return pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
+            return outRoughness ? pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo, outRoughness) : pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
         }
         calculateCommonData(scope, albedo, normal, viewVec, TBN, data) {
             super.calculateCommonData(scope, albedo, normal, viewVec, TBN, data);
@@ -100,6 +108,7 @@ import { mixinLight } from '../lit.js';
                 data.roughness = pb.sub(1, scope.zGlossinessFactor);
                 data.f0 = pb.vec4(scope.zSpecularFactor.rgb, this.getF0(scope).a);
             }
+            data.roughness = pb.mul(data.roughness, ShaderHelper.getCameraRoughnessFactor(scope));
             data.metallic = pb.max(pb.max(data.f0.r, data.f0.g), data.f0.b);
             data.diffuse = pb.vec4(pb.mul(albedo.rgb, pb.sub(1, data.metallic)), albedo.a);
             data.specularWeight = 1;

package/dist/material/mixins/lightmodel/pbrspecularglossness.js.map

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

package/dist/material/mixins/pbr/common.js

@@ -1,8 +1,9 @@
 import { applyMaterialMixins } from '../../meshmaterial.js';
 import { Vector4, Vector3, Vector2 } from '@zephyr3d/base';
-import { getGGXLUT } from '../ggxlut.js';
+import { getGGXLUT } from '../../../utility/textures/ggxlut.js';
 import { mixinTextureProps } from '../texture.js';
 import { ShaderHelper } from '../../shader/helper.js';
+import { RENDER_PASS_TYPE_LIGHT } from '../../../values.js';
 
 /**
  * PBR common stuff mixin
@@ -244,7 +245,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                 if (this.clearcoat) {
                     scope.zClearcoatFactor = pb.vec4().uniform(2);
                 }
-                if (this.transmission) {
+                if (this.transmission && this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
                     scope.zTransmissionFactor = pb.float().uniform(2);
                     scope.zThicknessFactor = pb.float().uniform(2);
                     scope.zAttenuationColor = pb.vec3().uniform(2);
@@ -277,7 +278,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                 if (this.clearcoat) {
                     bindGroup.setValue('zClearcoatFactor', this._clearcoatFactor);
                 }
-                if (this.transmission) {
+                if (this.transmission && ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
                     bindGroup.setValue('zTransmissionFactor', this._transmissionFactor);
                     bindGroup.setValue('zThicknessFactor', this._thicknessFactor);
                     bindGroup.setValue('zAttenuationColor', this._attenuationColor);
@@ -317,7 +318,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                     pb.float('ccNoV'),
                     pb.float('ccFresnel')
                 ] : [],
-                ...this.transmission ? [
+                ...this.transmission && this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT ? [
                     pb.float('transmissionFactor'),
                     pb.float('thicknessFactor'),
                     pb.vec3('attenuationColor'),
@@ -378,7 +379,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                     data.ccFactor.y = pb.clamp(pb.mul(data.ccFactor.y, this.sampleClearcoatRoughnessTexture(scope).g), 0, 1);
                 }
             }
-            if (this.transmission) {
+            if (this.transmission && this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
                 if (this.transmissionTexture) {
                     data.transmissionFactor = pb.mul(this.sampleTransmissionTexture(scope).r, scope.zTransmissionFactor);
                 } else {
@@ -577,7 +578,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                     }
                     this.$l.diffuseBRDF = pb.mul(pb.sub(pb.vec3(1), pb.mul(this.F, this.data.specularWeight)), pb.div(this.data.diffuse.rgb, Math.PI));
                     this.$l.diffuse = pb.mul(this.lightColor, pb.max(this.diffuseBRDF, pb.vec3(0)));
-                    if (that.transmission) {
+                    if (that.transmission && that.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
                         this.$l.transmissionRay = that.getVolumeTransmissionRay(this, this.normal, this.viewVec, this.data.thicknessFactor, this.data.f0.a);
                         this.$l.pointToLight = pb.normalize(pb.sub(this.L, this.transmissionRay));
                         this.$l.transmittedLight = pb.mul(this.lightColor, that.getPunctualRadianceTransmission(this, this.normal, this.viewVec, this.pointToLight, this.alphaRoughness, this.data.f0.rgb, this.data.f90.rgb, this.data.diffuse.rgb, this.data.f0.a));
@@ -733,7 +734,7 @@ import { ShaderHelper } from '../../shader/helper.js';
             });
             return pb.getGlobalScope()[funcName](outsideIOR, eta2, cosTheta1, thinFilmThickness, baseF0);
         }
-        indirectLighting(scope, normal, viewVec, commonData, outColor) {
+        indirectLighting(scope, normal, viewVec, commonData, outColor, outRoughness) {
             const pb = scope.$builder;
             const that = this;
             const ctx = that.drawContext;
@@ -742,7 +743,10 @@ import { ShaderHelper } from '../../shader/helper.js';
                 pb.vec3('normal'),
                 pb.vec3('viewVec'),
                 that.getCommonDatasStruct(scope)('data'),
-                pb.vec3('outColor').inout()
+                pb.vec3('outColor').inout(),
+                ...outRoughness ? [
+                    pb.vec4('outRoughness').out()
+                ] : []
             ], function() {
                 if (!ctx.drawEnvLight || !ctx.env.light.envLight.hasRadiance() && !ctx.env.light.envLight.hasIrradiance()) {
                     return;
@@ -763,14 +767,18 @@ import { ShaderHelper } from '../../shader/helper.js';
                 } else {
                     this.$l.k_S = pb.add(this.data.f0.rgb, pb.mul(this.Fr, pb.pow(pb.sub(1, this.NoV), 5)));
                 }
-                if (ctx.env.light.envLight.hasRadiance()) {
-                    this.$l.radiance = ctx.env.light.envLight.getRadiance(this, pb.reflect(pb.neg(this.viewVec), this.normal), this.data.roughness);
+                if (outRoughness || ctx.env.light.envLight.hasRadiance()) {
                     this.$l.FssEss = pb.add(pb.mul(this.k_S, this.f_ab.x), pb.vec3(this.f_ab.y));
-                    this.$l.iblSpecular = pb.mul(this.radiance, this.FssEss, this.data.specularWeight, this.occlusion);
+                    this.$l.specularFactor = pb.mul(this.FssEss, this.data.specularWeight, this.occlusion);
                     if (that.sheen) {
-                        this.iblSpecular = pb.mul(this.iblSpecular, this.data.sheenAlbedoScaling);
+                        this.specularFactor = pb.mul(this.specularFactor, this.data.sheenAlbedoScaling);
+                    }
+                    if (outRoughness) {
+                        this.outRoughness = pb.vec4(this.specularFactor /*this.data.f0.rgb*/ , this.data.roughness);
+                    } else if (ctx.env.light.envLight.hasRadiance()) {
+                        this.$l.radiance = ctx.env.light.envLight.getRadiance(this, pb.reflect(pb.neg(this.viewVec), this.normal), this.data.roughness);
+                        this.outColor = pb.add(this.outColor, pb.mul(this.radiance, this.specularFactor));
                     }
-                    this.outColor = pb.add(this.outColor, this.iblSpecular);
                 }
                 if (ctx.env.light.envLight.hasIrradiance()) {
                     this.$l.irradiance = ctx.env.light.envLight.getIrradiance(this, this.normal);
@@ -791,7 +799,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                     if (that.sheen) {
                         this.iblDiffuse = pb.mul(this.iblDiffuse, this.data.sheenAlbedoScaling);
                     }
-                    if (that.transmission) {
+                    if (that.transmission && that.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
                         this.$l.iblTransmission = that.getIBLVolumnRefraction(this, this.ggxLutSample.rg, this.normal, this.viewVec, this.data.roughness, this.data.diffuse.rgb, this.data.f0.rgb, this.data.f90, this.$inputs.worldPos, this.data.f0.a, this.data.thicknessFactor, this.data.attenuationColor, this.data.attenuationDistance);
                         this.iblDiffuse = pb.mix(this.iblDiffuse, this.iblTransmission, this.data.transmissionFactor);
                     }
@@ -814,7 +822,11 @@ import { ShaderHelper } from '../../shader/helper.js';
                     this.outColor = pb.add(this.outColor, pb.mul(this.ccSpecular, this.data.ccFactor.x));
                 }
             });
-            scope.$g[funcName](normal, viewVec, commonData, outColor);
+            if (outRoughness) {
+                scope.$g[funcName](normal, viewVec, commonData, outColor, outRoughness);
+            } else {
+                scope.$g[funcName](normal, viewVec, commonData, outColor);
+            }
         }
         fresnelSchlick(scope, cosTheta, F0, F90) {
             const pb = scope.$builder;

package/dist/material/mixins/pbr/common.js.map

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

package/dist/material/pbrmr.js

@@ -2,7 +2,7 @@ import { applyMaterialMixins, MeshMaterial } from './meshmaterial.js';
 import { mixinVertexColor } from './mixins/vertexcolor.js';
 import { mixinPBRMetallicRoughness } from './mixins/lightmodel/pbrmetallicroughness.js';
 import { ShaderHelper } from './shader/helper.js';
-import { RENDER_PASS_TYPE_LIGHT } from '../values.js';
+import { RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags } from '../values.js';
 
 /**
  * PBRMetallicRoughnessMaterial class
@@ -61,8 +61,19 @@ import { RENDER_PASS_TYPE_LIGHT } from '../values.js';
             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));
+                if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
+                    scope.$l.outRoughness = pb.vec4();
+                    scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.normalInfo.normal, scope.viewVec, scope.albedo, scope.normalInfo.TBN, scope.outRoughness);
+                    /*
+          scope.outRoughness = pb.vec4(
+            pb.add(pb.mul(scope.normalInfo.normal, 0.5), pb.vec3(0.5)),
+            scope.outRoughness.a
+          );
+          */ this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a), scope.outRoughness, pb.vec4(pb.add(pb.mul(scope.normalInfo.normal, 0.5), pb.vec3(0.5)), 1));
+                } else {
+                    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);
             }

package/dist/material/pbrmr.js.map

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

package/dist/material/pbrsg.js

@@ -2,7 +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';
+import { RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags } from '../values.js';
 
 /**
  * PBRSpecularGlossinessMaterial class
@@ -61,8 +61,19 @@ import { RENDER_PASS_TYPE_LIGHT } from '../values.js';
             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));
+                if (this.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {
+                    scope.$l.outRoughness = pb.vec4();
+                    scope.$l.litColor = this.PBRLight(scope, scope.$inputs.worldPos, scope.normalInfo.normal, scope.viewVec, scope.albedo, scope.normalInfo.TBN, scope.outRoughness);
+                    /*
+          scope.outRoughness = pb.vec4(
+            pb.add(pb.mul(scope.normalInfo.normal, 0.5), pb.vec3(0.5)),
+            scope.outRoughness.a
+          );
+          */ this.outputFragmentColor(scope, scope.$inputs.worldPos, pb.vec4(scope.litColor, scope.albedo.a), scope.outRoughness, pb.vec4(pb.add(pb.mul(scope.normalInfo.normal, 0.5), pb.vec3(0.5)), 1));
+                } else {
+                    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);
             }

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,8 +1,9 @@
 import { Vector3, Vector4 } from '@zephyr3d/base';
-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 { 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, MaterialVaryingFlags } from '../../values.js';
 import { ScatteringLut } from '../../render/scatteringlut.js';
+import { ProgramBuilder } from '@zephyr3d/device';
 import { linearToGamma } from '../../shaders/misc.js';
-import '../../app.js';
+import { Application } from '../../app.js';
 
 const UNIFORM_NAME_GLOBAL = 'Z_UniformGlobal';
 const UNIFORM_NAME_LIGHT_BUFFER = 'Z_UniformLightBuffer';
@@ -31,6 +32,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
     static BILLBOARD_SYLINDRAL = 2;
     /** @internal */ static defaultSunDir = Vector3.one().inplaceNormalize();
     /** @internal */ static SKIN_MATRIX_NAME = 'Z_SkinMatrix';
+    /** @internal */ static _drawableBindGroupLayouts = {};
     /** @internal */ static _lightUniformShadow = {
         light: {
             sunDir: new Vector3(),
@@ -86,6 +88,25 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
     static getLightBufferUniformName() {
         return UNIFORM_NAME_LIGHT_BUFFER;
     }
+    static getDrawableBindGroupLayout(skinning, morphing, instancing) {
+        const hash = `${skinning ? 1 : 0}${morphing ? 1 : 0}${instancing ? 1 : 0}`;
+        let bindGroupLayout = this._drawableBindGroupLayouts[hash];
+        if (!bindGroupLayout) {
+            const device = Application.instance.device;
+            const buildInfo = new ProgramBuilder(device).buildRender({
+                vertex (pb) {
+                    ShaderHelper.vertexShaderDrawableStuff(this, skinning, morphing, instancing);
+                    pb.main(function() {});
+                },
+                fragment (pb) {
+                    pb.main(function() {});
+                }
+            });
+            bindGroupLayout = buildInfo[2][1];
+            this._drawableBindGroupLayouts[hash] = bindGroupLayout;
+        }
+        return bindGroupLayout;
+    }
     /**
    * Prepares the fragment shader which is going to be used in our material system
    *
@@ -117,7 +138,8 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
             pb.mat4('viewProjectionMatrix'),
             pb.mat4('viewMatrix'),
             pb.mat4('projectionMatrix'),
-            pb.vec4('params')
+            pb.vec4('params'),
+            pb.float('roughnessFactor')
         ]);
         if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
             const lightStruct = pb.defineStruct([
@@ -464,23 +486,8 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         }
     }
     /** @internal */ static prepareVertexShaderCommon(pb, ctx) {
-        this.vertexShaderDrawableStuff(pb.getGlobalScope(), !!ctx.skinAnimation, !!ctx.morphAnimation, !!ctx.instancing);
-    /*
-    const skinning = !!ctx.target?.getBoneMatrices();
-    const scope = pb.getGlobalScope();
-    if (ctx.instanceData) {
-      scope[UNIFORM_NAME_INSTANCE_DATA_STRIDE] = pb.uint().uniform(1);
-      scope[UNIFORM_NAME_INSTANCE_DATA_OFFSET] = pb.uint().uniform(1);
-      scope[UNIFORM_NAME_INSTANCE_DATA] = pb.vec4[65536 >> 4]().uniformBuffer(3);
-    } else {
-      scope[UNIFORM_NAME_WORLD_MATRIX] = pb.mat4().uniform(1);
-    }
-    if (skinning) {
-      scope[UNIFORM_NAME_BONE_MATRICES] = pb.tex2D().uniform(1).sampleType('unfilterable-float');
-      scope[UNIFORM_NAME_BONE_INV_BIND_MATRIX] = pb.mat4().uniform(1);
-      scope[UNIFORM_NAME_BONE_TEXTURE_SIZE] = pb.int().uniform(1);
-    }
-    */ }
+        this.vertexShaderDrawableStuff(pb.getGlobalScope(), !!(ctx.materialFlags & MaterialVaryingFlags.SKIN_ANIMATION), !!(ctx.materialFlags & MaterialVaryingFlags.MORPH_ANIMATION), !!(ctx.materialFlags & MaterialVaryingFlags.INSTANCING));
+    }
     /** @internal */ static setCameraUniforms(bindGroup, camera, flip, linear) {
         const pos = camera.getWorldPosition();
         const cameraStruct = {
@@ -489,7 +496,8 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
             viewProjectionMatrix: camera.viewProjectionMatrix,
             viewMatrix: camera.viewMatrix,
             projectionMatrix: camera.getProjectionMatrix(),
-            params: new Vector4(camera.getNearPlane(), camera.getFarPlane(), flip ? -1 : 1, linear ? 0 : 1)
+            params: new Vector4(camera.getNearPlane(), camera.getFarPlane(), flip ? -1 : 1, linear ? 0 : 1),
+            roughnessFactor: camera.SSR ? camera.ssrRoughnessFactor : 1
         };
         bindGroup.setValue(UNIFORM_NAME_GLOBAL, {
             camera: cameraStruct
@@ -571,6 +579,13 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         return scope[UNIFORM_NAME_GLOBAL].camera.position.xyz;
     }
     /**
+   * Gets the uniform variable of type float which holds the roughness factor
+   * @param scope - Current shader scope
+   * @returns The roughness factor
+   */ static getCameraRoughnessFactor(scope) {
+        return scope[UNIFORM_NAME_GLOBAL].camera.roughnessFactor;
+    }
+    /**
    * Discard the fragment if it was clipped by the clip plane
    * @param scope - Current shader scope
    */ static discardIfClipped(scope, worldPos) {

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/posteffect/bloom.js

@@ -5,7 +5,7 @@ import { Vector4, Vector2 } from '@zephyr3d/base';
  * The bloom post effect
  * @public
  */ class Bloom extends AbstractPostEffect {
-    static _nearestSampler = null;
+    static className = 'Bloom';
     static _programDownsampleH = null;
     static _programDownsampleV = null;
     static _programUpsample = null;
@@ -363,15 +363,6 @@ import { Vector4, Vector2 } from '@zephyr3d/base';
         if (!this._bindgroupDownsampleV) {
             this._bindgroupDownsampleV = device.createBindGroup(Bloom._programDownsampleV.bindGroupLayouts[0]);
         }
-        if (!Bloom._nearestSampler) {
-            Bloom._nearestSampler = device.createSampler({
-                magFilter: 'nearest',
-                minFilter: 'nearest',
-                mipFilter: 'none',
-                addressU: 'clamp',
-                addressV: 'clamp'
-            });
-        }
         if (!Bloom._renderStateAdditive) {
             Bloom._renderStateAdditive = device.createRenderStateSet();
             Bloom._renderStateAdditive.useRasterizerState().setCullMode('none');

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,12 +1,15 @@
 import { linearToGamma } from '../shaders/misc.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;
@@ -17,14 +20,14 @@ import { linearToGamma } from '../shaders/misc.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;
             }
         }
@@ -76,6 +79,11 @@ import { linearToGamma } from '../shaders/misc.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();
@@ -83,8 +91,13 @@ import { linearToGamma } from '../shaders/misc.js';
         let msFramebuffer = null;
         const w = depth ? depth.width : ctx.viewportWidth;
         const h = depth ? depth.height : ctx.viewportHeight;
-        if (ctx.primaryCamera.sampleCount > 1) {
-            msFramebuffer = device.pool.fetchTemporalFramebuffer(true, w, h, format, depth, false, ctx.primaryCamera.sampleCount);
+        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),
@@ -106,6 +119,14 @@ import { linearToGamma } from '../shaders/misc.js';
             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;
@@ -118,7 +139,7 @@ import { linearToGamma } from '../shaders/misc.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);
@@ -134,15 +155,20 @@ import { linearToGamma } from '../shaders/misc.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);
-        }
-        ctx.compositorContex = null;
+        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;
+        }
+        if (this._postEffectsOpaque[0] === Compositor._SSRPostEffect) {
+            this._postEffectsOpaque.shift();
+        }
     }
     /** @internal */ isLastPostEffect(opaque, index) {
         const list = opaque ? this._postEffectsOpaque : this._postEffectsTransparency;
@@ -217,18 +243,11 @@ import { linearToGamma } from '../shaders/misc.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}