@zephyr3d/scene 0.6.1 → 0.7.0

package/dist/material/shader/helper.js

@@ -1,16 +1,28 @@
-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, MaterialVaryingFlags } from '../../values.js';
-import { ScatteringLut } from '../../render/scatteringlut.js';
+import { Vector3, Vector4, Vector2 } from '@zephyr3d/base';
+import { RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_LIGHT, MaterialVaryingFlags, MAX_CLUSTERED_LIGHTS, MORPH_WEIGHTS_VECTOR_COUNT, MORPH_TARGET_POSITION, MORPH_TARGET_NORMAL, MORPH_TARGET_TANGENT, MORPH_ATTRIBUTE_VECTOR_COUNT } from '../../values.js';
 import { ProgramBuilder } from '@zephyr3d/device';
-import { linearToGamma } from '../../shaders/misc.js';
-import { Application } from '../../app.js';
+import { decodeNormalizedFloatFromRGBA, linearToGamma } from '../../shaders/misc.js';
+import { fetchSampler } from '../../utility/misc.js';
+import { getDevice } from '../../app/api.js';
+import { getDefaultAtmosphereParams, getAtmosphereParamsStruct } from '../../shaders/atmosphere.js';
+import { getDefaultHeightFogParams, getHeightFogParamsStruct, calculateFog } from '../../shaders/fog.js';
 
-const UNIFORM_NAME_GLOBAL = 'Z_UniformGlobal';
 const UNIFORM_NAME_LIGHT_BUFFER = 'Z_UniformLightBuffer';
 const UNIFORM_NAME_LIGHT_INDEX_TEXTURE = 'Z_UniformLightIndexTex';
+const UNIFORM_NAME_BAKED_SKY_MAP = 'Z_UniformBakedSky';
 const UNIFORM_NAME_AERIALPERSPECTIVE_LUT = 'Z_UniformAerialPerspectiveLUT';
+const UNIFORM_NAME_SKYDISTANTLIGHT_LUT = 'Z_UniformSkyDistantLightLUT';
 const UNIFORM_NAME_SHADOW_MAP = 'Z_UniformShadowMap';
+const UNIFORM_NAME_LINEAR_DEPTH_MAP = 'Z_UniformLinearDepth';
+const UNIFORM_NAME_LINEAR_DEPTH_MAP_SIZE = 'Z_UniformLinearDepthSize';
+const UNIFORM_NAME_SCENE_COLOR_MAP = 'Z_UniformSceneColor';
+const UNIFORM_NAME_SCENE_COLOR_MAP_SIZE = 'Z_UniformSceneColorSize';
+const UNIFORM_NAME_HIZ_DEPTH_MAP = 'Z_UniformHiZDepth';
+const UNIFORM_NAME_HIZ_DEPTH_MAP_INFO = 'Z_UniformHiZDepthInfo';
+const UNIFORM_NAME_OBJECT_COLOR = 'Z_ObjectColor';
 const UNIFORM_NAME_WORLD_MATRIX = 'Z_UniformWorldMatrix';
+const UNIFORM_NAME_PREV_WORLD_MATRIX = 'Z_UniformPrevWorldMatrix';
+const UNIFORM_NAME_PREV_WORLD_MATRXI_FRAME = 'Z_UniformPrevWorldMatrixFrame';
 const UNIFORM_NAME_INSTANCE_DATA_STRIDE = 'Z_UniformInstanceDataStride';
 const UNIFORM_NAME_INSTANCE_DATA = 'Z_UniformInstanceData';
 const UNIFORM_NAME_INSTANCE_DATA_OFFSET = 'Z_UniformInstanceDataOffset';
@@ -23,44 +35,46 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
  * Helper shader functions for the builtin material system
  * @public
  */ class ShaderHelper {
-    static FOG_TYPE_NONE = 0;
-    static FOG_TYPE_LINEAR = 1;
-    static FOG_TYPE_EXP = 2;
-    static FOG_TYPE_EXP2 = 3;
-    static FOG_TYPE_SCATTER = 4;
     static BILLBOARD_SPHERICAL = 1;
     static BILLBOARD_SYLINDRAL = 2;
+    static MATERIAL_INSTANCE_DATA_OFFSET = 9;
     /** @internal */ static defaultSunDir = Vector3.one().inplaceNormalize();
     /** @internal */ static SKIN_MATRIX_NAME = 'Z_SkinMatrix';
+    static SKIN_PREV_MATRIX_NAME = 'Z_PrevSkinMatrix';
+    static SKIN_BONE_OFFSET = 'Z_boneOffset';
     /** @internal */ static _drawableBindGroupLayouts = {};
     /** @internal */ static _lightUniformShadow = {
-        light: {
-            sunDir: new Vector3(),
-            envLightStrength: 1,
-            shadowCascades: 1,
-            positionAndRange: new Vector4(),
-            directionAndCutoff: new Vector4(),
-            diffuseAndIntensity: new Vector4(),
-            cascadeDistances: new Vector4(),
-            depthBiasValues: new Vector4(),
-            shadowCameraParams: new Vector4(),
-            depthBiasScales: new Vector4(),
-            shadowMatrices: new Float32Array(16 * 4)
-        }
+        sunDir: new Vector3(),
+        envLightStrength: 1,
+        shadowCascades: 1,
+        positionAndRange: new Vector4(),
+        directionAndCutoff: new Vector4(),
+        diffuseAndIntensity: new Vector4(),
+        cascadeDistances: new Vector4(),
+        depthBiasValues: new Vector4(),
+        shadowCameraParams: new Vector4(),
+        depthBiasScales: new Vector4(),
+        shadowMatrices: new Float32Array(16 * 4)
     };
     /** @internal */ static _fogUniforms = {
-        fog: {
-            fogType: 0,
-            fogColor: null,
-            // [near, far, top, density]
-            fogParams: null,
-            // aerial perspective density
-            apDensity: 1
-        }
+        withAerialPerspective: 0,
+        fogType: 0,
+        additive: 0,
+        atmosphereParams: getDefaultAtmosphereParams(),
+        heightFogParams: getDefaultHeightFogParams()
     };
+    static getObjectColorUniformName() {
+        return UNIFORM_NAME_OBJECT_COLOR;
+    }
     static getWorldMatrixUniformName() {
         return UNIFORM_NAME_WORLD_MATRIX;
     }
+    static getPrevWorldMatrixUniformName() {
+        return UNIFORM_NAME_PREV_WORLD_MATRIX;
+    }
+    static getPrevWorldMatrixFrameUniformName() {
+        return UNIFORM_NAME_PREV_WORLD_MATRXI_FRAME;
+    }
     static getInstanceDataUniformName() {
         return UNIFORM_NAME_INSTANCE_DATA;
     }
@@ -92,7 +106,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         const hash = `${skinning ? 1 : 0}${morphing ? 1 : 0}${instancing ? 1 : 0}`;
         let bindGroupLayout = this._drawableBindGroupLayouts[hash];
         if (!bindGroupLayout) {
-            const device = Application.instance.device;
+            const device = getDevice();
             const buildInfo = new ProgramBuilder(device).buildRender({
                 vertex (pb) {
                     ShaderHelper.vertexShaderDrawableStuff(this, skinning, morphing, instancing);
@@ -136,10 +150,23 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
             pb.vec4('position'),
             pb.vec4('clipPlane'),
             pb.mat4('viewProjectionMatrix'),
+            pb.mat4('invViewProjectionMatrix'),
+            pb.mat4('unjitteredVPMatrix'),
+            pb.mat4('jitteredInvVPMatrix'),
             pb.mat4('viewMatrix'),
+            pb.mat4('worldMatrix'),
             pb.mat4('projectionMatrix'),
+            pb.mat4('invProjectionMatrix'),
             pb.vec4('params'),
-            pb.float('roughnessFactor')
+            ...ctx.motionVectors && ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH ? [
+                pb.mat4('prevUnjitteredVPMatrix')
+            ] : [],
+            pb.vec2('renderSize'),
+            pb.vec2('jitterValue'),
+            pb.float('roughnessFactor'),
+            pb.float('frameDeltaTime'),
+            pb.float('elapsedTime'),
+            pb.int('framestamp')
         ]);
         if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {
             const lightStruct = pb.defineStruct([
@@ -149,24 +176,25 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
                 pb.vec4('depthBias'),
                 pb.int('lightType')
             ]);
-            const globalStruct = pb.defineStruct([
-                cameraStruct('camera'),
-                lightStruct('light')
-            ]);
-            scope[UNIFORM_NAME_GLOBAL] = globalStruct().uniform(0);
+            scope.camera = cameraStruct().uniform(0);
+            scope.light = lightStruct().uniform(0);
         } else if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH || ctx.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {
-            const globalStruct = pb.defineStruct([
-                cameraStruct('camera')
-            ]);
-            scope[UNIFORM_NAME_GLOBAL] = globalStruct().uniform(0);
+            scope.camera = cameraStruct().uniform(0);
         } else if (ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
             const useClusteredLighting = !ctx.currentShadowLight;
-            const fogStruct = pb.defineStruct([
-                pb.int('fogType'),
-                pb.vec4('fogColor'),
-                pb.vec4('fogParams'),
-                pb.float('apDensity')
-            ]);
+            if (ctx.materialFlags & MaterialVaryingFlags.APPLY_FOG) {
+                const fogStructMembers = [
+                    pb.int('withAerialPerspective'),
+                    pb.int('fogType'),
+                    pb.int('additive'),
+                    getAtmosphereParamsStruct(pb)('atmosphereParams'),
+                    getHeightFogParamsStruct(pb)('heightFogParams')
+                ];
+                const fogStruct = pb.defineStruct(fogStructMembers);
+                scope.fog = fogStruct().uniform(0);
+                scope[UNIFORM_NAME_AERIALPERSPECTIVE_LUT] = pb.tex2D().uniform(0);
+                scope[UNIFORM_NAME_SKYDISTANTLIGHT_LUT] = pb.tex2D().uniform(0);
+            }
             const lightStruct = ctx.currentShadowLight ? pb.defineStruct([
                 pb.vec3('sunDir'),
                 pb.int('shadowCascades'),
@@ -186,19 +214,13 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
                 pb.ivec4('countParams'),
                 pb.ivec2('lightIndexTexSize')
             ]);
-            const globalStruct = pb.defineStruct([
-                cameraStruct('camera'),
-                lightStruct('light'),
-                fogStruct('fog')
-            ]);
-            scope[UNIFORM_NAME_GLOBAL] = globalStruct().uniform(0);
+            scope.camera = cameraStruct().uniform(0);
+            scope.light = lightStruct().uniform(0);
             if (useClusteredLighting) {
                 scope[UNIFORM_NAME_LIGHT_BUFFER] = pb.vec4[(MAX_CLUSTERED_LIGHTS + 1) * 3]().uniformBuffer(0);
                 scope[UNIFORM_NAME_LIGHT_INDEX_TEXTURE] = (pb.getDevice().type === 'webgl' ? pb.tex2D() : pb.utex2D()).uniform(0);
             }
-            if (ctx.applyFog === 'scatter') {
-                scope[UNIFORM_NAME_AERIALPERSPECTIVE_LUT] = pb.tex2D().uniform(0);
-            }
+            scope[UNIFORM_NAME_BAKED_SKY_MAP] = pb.texCube().uniform(0);
             if (ctx.currentShadowLight) {
                 const scope = pb.getGlobalScope();
                 const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
@@ -208,7 +230,21 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
                 }
                 scope[UNIFORM_NAME_SHADOW_MAP] = tex.uniform(0);
             }
-            ctx.drawEnvLight && ctx.env.light.envLight.initShaderBindings(pb);
+            if (ctx.drawEnvLight) {
+                ctx.env.light.envLight.initShaderBindings(pb);
+            }
+            if (ctx.linearDepthTexture) {
+                scope[UNIFORM_NAME_LINEAR_DEPTH_MAP] = pb.tex2D().uniform(0);
+                scope[UNIFORM_NAME_LINEAR_DEPTH_MAP_SIZE] = pb.vec2().uniform(0);
+            }
+            if (ctx.sceneColorTexture) {
+                scope[UNIFORM_NAME_SCENE_COLOR_MAP] = pb.tex2D().uniform(0);
+                scope[UNIFORM_NAME_SCENE_COLOR_MAP_SIZE] = pb.vec2().uniform(0);
+            }
+            if (ctx.HiZTexture) {
+                scope[UNIFORM_NAME_HIZ_DEPTH_MAP] = pb.tex2D().uniform(0);
+                scope[UNIFORM_NAME_HIZ_DEPTH_MAP_INFO] = pb.vec4().uniform(0);
+            }
         }
     }
     /**
@@ -245,8 +281,10 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
             pb.int('boneIndex')
         ], function() {
             const boneTexture = this[UNIFORM_NAME_BONE_MATRICES];
-            this.$l.w = pb.float(this[UNIFORM_NAME_BONE_TEXTURE_SIZE]);
-            this.$l.pixelIndex = pb.float(pb.mul(this.boneIndex, 4));
+            this.$l.uvOffsets = pb.textureSampleLevel(boneTexture, pb.div(pb.vec2(0.5), this[UNIFORM_NAME_BONE_TEXTURE_SIZE]), 0);
+            this.$l.currentOffset = pb.int(this.uvOffsets.x);
+            this.$l.w = this[UNIFORM_NAME_BONE_TEXTURE_SIZE].x;
+            this.$l.pixelIndex = pb.float(pb.mul(pb.add(this.boneIndex, this.currentOffset), 4));
             this.$l.xIndex = pb.mod(this.pixelIndex, this.w);
             this.$l.yIndex = pb.floor(pb.div(this.pixelIndex, this.w));
             this.$l.u1 = pb.div(pb.add(this.xIndex, 0.5), this.w);
@@ -334,38 +372,116 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         const offset = scope[this.getMorphInfoUniformName()][pos][comp];
         return scope[funcName](pb.int(offset));
     }
+    /** @internal */ static prepareSkinAnimation(scope) {
+        if (!this.hasSkinning(scope)) {
+            return;
+        }
+        const that = this;
+        const pb = scope.$builder;
+        const funcNameGetBoneMatrixFromTexture = 'Z_getBoneMatrixFromTexture';
+        pb.func(funcNameGetBoneMatrixFromTexture, [
+            pb.float('boneIndex'),
+            pb.float('boneOffset')
+        ], function() {
+            const boneTexture = this[UNIFORM_NAME_BONE_MATRICES];
+            this.$l.w = this[UNIFORM_NAME_BONE_TEXTURE_SIZE].x;
+            this.$l.pixelIndex = pb.mul(pb.add(this.boneIndex, this.boneOffset), 4);
+            this.$l.xIndex = pb.mod(this.pixelIndex, this.w);
+            this.$l.yIndex = pb.floor(pb.div(this.pixelIndex, this.w));
+            this.$l.u1 = pb.div(pb.add(this.xIndex, 0.5), this.w);
+            this.$l.u2 = pb.div(pb.add(this.xIndex, 1.5), this.w);
+            this.$l.u3 = pb.div(pb.add(this.xIndex, 2.5), this.w);
+            this.$l.u4 = pb.div(pb.add(this.xIndex, 3.5), this.w);
+            this.$l.v = pb.div(pb.add(this.yIndex, 0.5), this.w);
+            this.$l.row1 = pb.textureSampleLevel(boneTexture, pb.vec2(this.u1, this.v), 0);
+            this.$l.row2 = pb.textureSampleLevel(boneTexture, pb.vec2(this.u2, this.v), 0);
+            this.$l.row3 = pb.textureSampleLevel(boneTexture, pb.vec2(this.u3, this.v), 0);
+            this.$l.row4 = pb.textureSampleLevel(boneTexture, pb.vec2(this.u4, this.v), 0);
+            this.$return(pb.mat4(this.row1, this.row2, this.row3, this.row4));
+        });
+        const funcNameGetSkinningMatrix = 'Z_getSkinningMatrix';
+        pb.func(funcNameGetSkinningMatrix, [
+            pb.float('boneOffset')
+        ], function() {
+            const invBindMatrix = this[UNIFORM_NAME_BONE_INV_BIND_MATRIX];
+            const blendIndices = scope.$getVertexAttrib('blendIndices');
+            const blendWeights = scope.$getVertexAttrib('blendWeights');
+            this.$l.m0 = scope.$g[funcNameGetBoneMatrixFromTexture](blendIndices[0], this.boneOffset);
+            this.$l.m1 = scope.$g[funcNameGetBoneMatrixFromTexture](blendIndices[1], this.boneOffset);
+            this.$l.m2 = scope.$g[funcNameGetBoneMatrixFromTexture](blendIndices[2], this.boneOffset);
+            this.$l.m3 = scope.$g[funcNameGetBoneMatrixFromTexture](blendIndices[3], this.boneOffset);
+            this.$l.m = pb.add(pb.mul(this.m0, blendWeights.x), pb.mul(this.m1, blendWeights.y), pb.mul(this.m2, blendWeights.z), pb.mul(this.m3, blendWeights.w));
+            this.$return(pb.mul(invBindMatrix, this.m));
+        });
+        const motionVector = !!this.getUnjitteredViewProjectionMatrix(scope);
+        const boneTexture = scope[UNIFORM_NAME_BONE_MATRICES];
+        scope.$l[that.SKIN_BONE_OFFSET] = pb.textureSampleLevel(boneTexture, pb.div(pb.vec2(0.5), scope[UNIFORM_NAME_BONE_TEXTURE_SIZE]), 0).xy;
+        scope.$l[that.SKIN_MATRIX_NAME] = scope[funcNameGetSkinningMatrix](scope[that.SKIN_BONE_OFFSET].x);
+        if (motionVector) {
+            scope.$l[that.SKIN_PREV_MATRIX_NAME] = scope[funcNameGetSkinningMatrix](scope[that.SKIN_BONE_OFFSET].y);
+        }
+    }
     /**
    * Calculates the vertex position of type vec3 in object space
    *
    * @param scope - Current shader scope
-   * @param pos - Vertex position input, must be type of vec3, null if no vertex position input
    * @param skinMatrix - The skinning matrix if there is skeletal animation, otherwise null
    * @returns The calculated vertex position in object space, or null if pos is null
-   */ static resolveVertexPosition(scope, pos) {
+   */ static resolveVertexPosition(scope) {
         const pb = scope.$builder;
         if (pb.shaderKind !== 'vertex') {
             throw new Error(`ShaderHelper.resolveVertexPosition(): must be called at vertex stage`);
         }
-        const funcScope = pb.getCurrentFunctionScope();
-        if (!funcScope || !funcScope.$isMain()) {
-            throw new Error(`ShaderHelper.resolveVertexPosition(): must be called at entry function`);
+        if (!pb.getGlobalScope().$getVertexAttrib('position')) {
+            pb.getGlobalScope().$inputs.Z_pos = pb.vec3().attrib('position');
         }
-        if (!pos) {
-            if (!scope.$getVertexAttrib('position')) {
-                scope.$inputs.Z_pos = pb.vec3().attrib('position');
+        const that = this;
+        const params = scope[that.SKIN_MATRIX_NAME] && scope[that.SKIN_PREV_MATRIX_NAME] ? [
+            pb.mat4('skinMatrix'),
+            pb.mat4('prevSkinMatrix')
+        ] : scope[that.SKIN_MATRIX_NAME] ? [
+            pb.mat4('skinMatrix')
+        ] : [];
+        pb.func('Z_resolveVertexPosition', params, function() {
+            this.$l.opos = this.$getVertexAttrib('position').xyz;
+            if (that.hasMorphing(scope)) {
+                this.opos = pb.add(this.opos, that.calculateMorphDelta(this, MORPH_TARGET_POSITION).xyz);
             }
-            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);
+            if (this.skinMatrix) {
+                this.$l.pos = pb.mul(this.skinMatrix, pb.vec4(this.opos, 1)).xyz;
+            } else {
+                this.$l.pos = this.opos;
             }
-            return pb.mul(scope[this.SKIN_MATRIX_NAME], pb.vec4(pos, 1)).xyz;
-        } else {
-            return pos;
+            const prevUnjitteredVPMatrix = that.getPrevUnjitteredViewProjectionMatrix(this);
+            if (prevUnjitteredVPMatrix) {
+                this.$l.unjitteredVPMatrix = that.getUnjitteredViewProjectionMatrix(this);
+                this.$l.worldPos = pb.mul(that.getWorldMatrix(this), pb.vec4(this.pos, 1));
+                if (this.prevSkinMatrix) {
+                    this.$l.prevWorldPos = pb.mul(that.getPrevWorldMatrix(this), pb.mul(this.prevSkinMatrix, pb.vec4(this.opos, 1)));
+                } else {
+                    this.$l.prevWorldPos = pb.mul(that.getPrevWorldMatrix(this), pb.vec4(this.pos, 1));
+                }
+                this.$outputs.zMotionVectorPosCurrent = pb.mul(this.unjitteredVPMatrix, this.worldPos);
+                this.$outputs.zMotionVectorPosPrev = pb.mul(prevUnjitteredVPMatrix, this.prevWorldPos);
+            }
+            this.$return(this.pos);
+        });
+        return scope[that.SKIN_MATRIX_NAME] && scope[that.SKIN_PREV_MATRIX_NAME] ? scope.Z_resolveVertexPosition(scope[that.SKIN_MATRIX_NAME], scope[that.SKIN_PREV_MATRIX_NAME]) : scope[that.SKIN_MATRIX_NAME] ? scope.Z_resolveVertexPosition(scope[that.SKIN_MATRIX_NAME]) : scope.Z_resolveVertexPosition();
+    }
+    /**
+   * Resolve motion vector
+   *
+   * @param scope - Current shader scope
+   * @param worldPos - Current object position in world space
+   * @param prevWorldPos - Previous object position in world space
+   */ static resolveMotionVector(scope, worldPos, prevWorldPos) {
+        const that = this;
+        const pb = scope.$builder;
+        const prevUnjitteredVPMatrix = that.getPrevUnjitteredViewProjectionMatrix(scope);
+        if (prevUnjitteredVPMatrix) {
+            const unjitteredVPMatrix = that.getUnjitteredViewProjectionMatrix(scope);
+            scope.$outputs.zMotionVectorPosCurrent = pb.mul(unjitteredVPMatrix, pb.vec4(worldPos.xyz, 1));
+            scope.$outputs.zMotionVectorPosPrev = pb.mul(prevUnjitteredVPMatrix, pb.vec4(prevWorldPos.xyz, 1));
         }
     }
     /**
@@ -393,10 +509,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         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);
-            }
+        if (scope[this.SKIN_MATRIX_NAME]) {
             return pb.mul(scope[this.SKIN_MATRIX_NAME], pb.vec4(normal, 0)).xyz;
         } else {
             return normal;
@@ -427,10 +540,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         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);
-            }
+        if (scope[this.SKIN_MATRIX_NAME]) {
             return pb.vec4(pb.mul(scope[this.SKIN_MATRIX_NAME], pb.vec4(tangent.xyz, 0)).xyz, tangent.w);
         } else {
             return tangent;
@@ -445,12 +555,46 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         return scope[UNIFORM_NAME_WORLD_MATRIX] ?? pb.mat4(this.getInstancedUniform(scope, 0), this.getInstancedUniform(scope, 1), this.getInstancedUniform(scope, 2), this.getInstancedUniform(scope, 3));
     }
     /**
+   * Gets the uniform variable of type mat4 which holds the world matrix at previous frame of current object to be drawn
+   * @param scope - Current shader scope
+   * @returns The world matrix at previous frame of current object to be drawn
+   */ static getPrevWorldMatrix(scope) {
+        const pb = scope.$builder;
+        const that = this;
+        const framestamp = this.getFramestamp(scope);
+        if (scope[UNIFORM_NAME_WORLD_MATRIX]) {
+            if (pb.getDevice().type === 'webgpu') {
+                pb.func('Z_getPrevWorldMatrix', [
+                    pb.int('framestamp')
+                ], function() {
+                    this.$if(pb.equal(this.framestamp, this[UNIFORM_NAME_PREV_WORLD_MATRXI_FRAME]), function() {
+                        this.$return(this[UNIFORM_NAME_PREV_WORLD_MATRIX]);
+                    }).$else(function() {
+                        this.$return(this[UNIFORM_NAME_WORLD_MATRIX]);
+                    });
+                });
+                return scope.Z_getPrevWorldMatrix(framestamp);
+            } else {
+                return scope.$choice(pb.equal(framestamp, scope[UNIFORM_NAME_PREV_WORLD_MATRXI_FRAME]), scope[UNIFORM_NAME_PREV_WORLD_MATRIX], scope[UNIFORM_NAME_WORLD_MATRIX]);
+            }
+        } else {
+            pb.func('Z_getPrevWorldMatrix', [
+                pb.int('framestamp')
+            ], function() {
+                this.$l.prevFrame = pb.floatBitsToInt(that.getInstancedUniform(this, 4).x);
+                this.$l.index = this.$choice(pb.equal(this.framestamp, this.prevFrame), pb.int(5), pb.int(0));
+                this.$return(pb.mat4(that.getInstancedUniform(scope, this.index), that.getInstancedUniform(scope, pb.add(this.index, 1)), that.getInstancedUniform(scope, pb.add(this.index, 2)), that.getInstancedUniform(scope, pb.add(this.index, 3))));
+            });
+            return scope.Z_getPrevWorldMatrix(framestamp);
+        }
+    }
+    /**
    * Gets the instance uniform value of type vec4 by uniform index
    * @param scope - Current shader scope
    * @returns instance uniform value
    */ static getInstancedUniform(scope, uniformIndex) {
         const pb = scope.$builder;
-        return scope[UNIFORM_NAME_INSTANCE_DATA].at(pb.add(pb.mul(scope[UNIFORM_NAME_INSTANCE_DATA_STRIDE], pb.uint(scope.$builtins.instanceIndex)), scope[UNIFORM_NAME_INSTANCE_DATA_OFFSET], uniformIndex));
+        return scope[UNIFORM_NAME_INSTANCE_DATA].at(pb.add(pb.mul(scope[UNIFORM_NAME_INSTANCE_DATA_STRIDE], pb.uint(scope.$builtins.instanceIndex)), scope[UNIFORM_NAME_INSTANCE_DATA_OFFSET], pb.uint(uniformIndex)));
     }
     /**
    * Gets the uniform variable of type mat4 which holds the normal matrix of current object to be drawn
@@ -474,11 +618,14 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
             scope[UNIFORM_NAME_INSTANCE_DATA] = pb.vec4[65536 >> 4]().uniformBuffer(3);
         } else {
             scope[UNIFORM_NAME_WORLD_MATRIX] = pb.mat4().uniform(1);
+            scope[UNIFORM_NAME_PREV_WORLD_MATRIX] = pb.mat4().uniform(1);
+            scope[UNIFORM_NAME_PREV_WORLD_MATRXI_FRAME] = pb.int().uniform(1);
+            scope[UNIFORM_NAME_OBJECT_COLOR] = pb.vec4().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);
+            scope[UNIFORM_NAME_BONE_TEXTURE_SIZE] = pb.vec2().uniform(1);
         }
         if (morphing) {
             scope[UNIFORM_NAME_MORPH_DATA] = pb.tex2D().uniform(1).sampleType('unfilterable-float');
@@ -488,77 +635,106 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
     /** @internal */ static prepareVertexShaderCommon(pb, ctx) {
         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();
+    /** @internal */ static setCameraUniforms(bindGroup, ctx, linear) {
+        const pos = ctx.camera.getWorldPosition();
+        const useJitter = ctx.motionVectors && ctx.renderPass.type !== RENDER_PASS_TYPE_SHADOWMAP && ctx.renderPass.type !== RENDER_PASS_TYPE_OBJECT_COLOR;
         const cameraStruct = {
-            position: new Vector4(pos.x, pos.y, pos.z, camera.clipPlane ? 1 : 0),
-            clipPlane: camera.clipPlane ?? Vector4.zero(),
-            viewProjectionMatrix: camera.viewProjectionMatrix,
-            viewMatrix: camera.viewMatrix,
-            projectionMatrix: camera.getProjectionMatrix(),
-            params: new Vector4(camera.getNearPlane(), camera.getFarPlane(), flip ? -1 : 1, linear ? 0 : 1),
-            roughnessFactor: camera.SSR ? camera.ssrRoughnessFactor : 1
+            position: new Vector4(pos.x, pos.y, pos.z, ctx.camera.clipPlane ? 1 : 0),
+            clipPlane: ctx.camera.clipPlane ?? Vector4.zero(),
+            renderSize: new Vector2(ctx.renderWidth, ctx.renderHeight),
+            viewProjectionMatrix: useJitter ? ctx.camera.jitteredVPMatrix : ctx.camera.viewProjectionMatrix,
+            unjitteredVPMatrix: ctx.camera.viewProjectionMatrix,
+            jitteredInvVPMatrix: useJitter ? ctx.camera.jitteredInvVPMatrix : ctx.camera.invViewProjectionMatrix,
+            jitterValue: ctx.camera.jitterValue,
+            invViewProjectionMatrix: ctx.camera.invViewProjectionMatrix,
+            projectionMatrix: ctx.camera.getProjectionMatrix(),
+            invProjectionMatrix: ctx.camera.getInvProjectionMatrix(),
+            viewMatrix: ctx.camera.viewMatrix,
+            worldMatrix: ctx.camera.worldMatrix,
+            params: new Vector4(ctx.camera.getNearPlane(), ctx.camera.getFarPlane(), ctx.flip ? -1 : 1, linear ? 0 : 1),
+            roughnessFactor: ctx.camera.SSR ? ctx.camera.ssrRoughnessFactor : 1,
+            frameDeltaTime: getDevice().frameInfo.elapsedFrame * 0.001,
+            elapsedTime: getDevice().frameInfo.elapsedOverall * 0.001,
+            framestamp: getDevice().frameInfo.frameCounter
         };
-        bindGroup.setValue(UNIFORM_NAME_GLOBAL, {
-            camera: cameraStruct
-        });
+        if (ctx.motionVectors && ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH) {
+            cameraStruct.prevUnjitteredVPMatrix = ctx.camera.prevVPMatrix;
+        }
+        if (ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
+            if (ctx.linearDepthTexture) {
+                bindGroup.setTexture(UNIFORM_NAME_LINEAR_DEPTH_MAP, ctx.linearDepthTexture);
+                bindGroup.setValue(UNIFORM_NAME_LINEAR_DEPTH_MAP_SIZE, new Vector2(ctx.linearDepthTexture.width, ctx.linearDepthTexture.height));
+            }
+            if (ctx.sceneColorTexture) {
+                bindGroup.setTexture(UNIFORM_NAME_SCENE_COLOR_MAP, ctx.sceneColorTexture);
+                bindGroup.setValue(UNIFORM_NAME_SCENE_COLOR_MAP_SIZE, new Vector2(ctx.sceneColorTexture.width, ctx.sceneColorTexture.height));
+            }
+            if (ctx.HiZTexture) {
+                bindGroup.setTexture(UNIFORM_NAME_HIZ_DEPTH_MAP, ctx.HiZTexture, fetchSampler('clamp_nearest'));
+                bindGroup.setValue(UNIFORM_NAME_HIZ_DEPTH_MAP_INFO, new Vector4(ctx.HiZTexture.width, ctx.HiZTexture.height, ctx.HiZTexture.mipLevelCount, 0));
+            }
+        }
+        bindGroup.setValue('camera', cameraStruct);
     }
     /** @internal */ static setLightUniformsShadowMap(bindGroup, ctx, light) {
         if (light) {
             const shadowMapParams = ctx.shadowMapInfo.get(light);
-            bindGroup.setValue(UNIFORM_NAME_GLOBAL, {
-                light: {
-                    positionAndRange: light.positionAndRange,
-                    directionCutoff: light.directionAndCutoff,
-                    viewMatrix: light.viewMatrix,
-                    depthBias: shadowMapParams.depthBiasValues[0],
-                    lightType: light.lightType
-                }
+            bindGroup.setValue('light', {
+                positionAndRange: light.positionAndRange,
+                directionCutoff: light.directionAndCutoff,
+                viewMatrix: light.viewMatrix,
+                depthBias: shadowMapParams.depthBiasValues[0],
+                lightType: light.lightType
             });
         }
     }
-    /** @internal */ static setFogUniforms(bindGroup, fogType, fogColor, fogParams, apDensity, aerialPerspectiveLUT) {
-        this._fogUniforms.fog.fogColor = fogColor;
-        this._fogUniforms.fog.fogParams = fogParams;
-        this._fogUniforms.fog.fogType = fogType;
-        this._fogUniforms.fog.apDensity = apDensity;
-        bindGroup.setValue(UNIFORM_NAME_GLOBAL, this._fogUniforms);
-        if (aerialPerspectiveLUT) {
-            bindGroup.setTexture(UNIFORM_NAME_AERIALPERSPECTIVE_LUT, aerialPerspectiveLUT);
-        }
+    /** @internal */ static setFogUniforms(bindGroup, withAerialPerspective, fogType, additive, atmosphereParams, heightFogParams, aerialPerspectiveLUT, skyDistantLightLUT) {
+        this._fogUniforms.withAerialPerspective = withAerialPerspective;
+        this._fogUniforms.fogType = fogType;
+        this._fogUniforms.additive = additive;
+        this._fogUniforms.atmosphereParams = atmosphereParams;
+        this._fogUniforms.heightFogParams = heightFogParams;
+        bindGroup.setValue('fog', this._fogUniforms);
+        bindGroup.setTexture(UNIFORM_NAME_AERIALPERSPECTIVE_LUT, aerialPerspectiveLUT);
+        bindGroup.setTexture(UNIFORM_NAME_SKYDISTANTLIGHT_LUT, skyDistantLightLUT);
     }
     /** @internal */ static setLightUniforms(bindGroup, ctx, clusterParams, countParams, lightBuffer, lightIndexTexture) {
-        bindGroup.setValue(UNIFORM_NAME_GLOBAL, {
-            light: {
-                sunDir: ctx.sunLight ? ctx.sunLight.directionAndCutoff.xyz().scaleBy(-1) : this.defaultSunDir,
-                clusterParams: clusterParams,
-                countParams: countParams,
-                envLightStrength: ctx.env.light.strength ?? 0,
-                lightIndexTexSize: new Int32Array([
-                    lightIndexTexture.width,
-                    lightIndexTexture.height
-                ])
-            }
+        bindGroup.setValue('light', {
+            sunDir: ctx.sunLight ? ctx.sunLight.directionAndCutoff.xyz().scaleBy(-1) : this.defaultSunDir,
+            clusterParams: clusterParams,
+            countParams: countParams,
+            envLightStrength: ctx.env.light.strength ?? 0,
+            lightIndexTexSize: new Int32Array([
+                lightIndexTexture.width,
+                lightIndexTexture.height
+            ])
         });
         bindGroup.setBuffer(UNIFORM_NAME_LIGHT_BUFFER, lightBuffer);
         bindGroup.setTexture(UNIFORM_NAME_LIGHT_INDEX_TEXTURE, lightIndexTexture);
-        ctx.drawEnvLight && ctx.env.light.envLight.updateBindGroup(bindGroup);
+        bindGroup.setTexture(UNIFORM_NAME_BAKED_SKY_MAP, ctx.scene.env.sky.getBakedSkyTexture(ctx));
+        if (ctx.drawEnvLight) {
+            ctx.env.light.envLight.updateBindGroup(bindGroup);
+        }
     }
     /** @internal */ static setLightUniformsShadow(bindGroup, ctx, light) {
         const shadowMapParams = ctx.shadowMapInfo.get(light);
-        this._lightUniformShadow.light.sunDir = ctx.sunLight ? ctx.sunLight.directionAndCutoff.xyz().scaleBy(-1) : this.defaultSunDir, this._lightUniformShadow.light.envLightStrength = ctx.env?.light.strength ?? 0;
-        this._lightUniformShadow.light.shadowCascades = shadowMapParams.numShadowCascades;
-        this._lightUniformShadow.light.positionAndRange.set(light.positionAndRange);
-        this._lightUniformShadow.light.directionAndCutoff.set(light.directionAndCutoff);
-        this._lightUniformShadow.light.diffuseAndIntensity.set(light.diffuseAndIntensity);
-        this._lightUniformShadow.light.cascadeDistances.set(shadowMapParams.cascadeDistances);
-        this._lightUniformShadow.light.depthBiasValues.set(shadowMapParams.depthBiasValues[0]);
-        this._lightUniformShadow.light.shadowCameraParams.set(shadowMapParams.cameraParams);
-        this._lightUniformShadow.light.depthBiasScales.set(shadowMapParams.depthBiasScales);
-        this._lightUniformShadow.light.shadowMatrices.set(shadowMapParams.shadowMatrices);
-        bindGroup.setValue(UNIFORM_NAME_GLOBAL, this._lightUniformShadow);
+        this._lightUniformShadow.sunDir = ctx.sunLight ? ctx.sunLight.directionAndCutoff.xyz().scaleBy(-1) : this.defaultSunDir;
+        this._lightUniformShadow.envLightStrength = ctx.env?.light.strength ?? 0;
+        this._lightUniformShadow.shadowCascades = shadowMapParams.numShadowCascades;
+        this._lightUniformShadow.positionAndRange.set(light.positionAndRange);
+        this._lightUniformShadow.directionAndCutoff.set(light.directionAndCutoff);
+        this._lightUniformShadow.diffuseAndIntensity.set(light.diffuseAndIntensity);
+        this._lightUniformShadow.cascadeDistances.set(shadowMapParams.cascadeDistances);
+        this._lightUniformShadow.depthBiasValues.set(shadowMapParams.depthBiasValues[0]);
+        this._lightUniformShadow.shadowCameraParams.set(shadowMapParams.cameraParams);
+        this._lightUniformShadow.depthBiasScales.set(shadowMapParams.depthBiasScales);
+        this._lightUniformShadow.shadowMatrices.set(shadowMapParams.shadowMatrices);
+        bindGroup.setValue('light', this._lightUniformShadow);
         bindGroup.setTexture(UNIFORM_NAME_SHADOW_MAP, shadowMapParams.shadowMap, shadowMapParams.shadowMapSampler);
-        ctx.drawEnvLight && ctx.env.light.envLight.updateBindGroup(bindGroup);
+        bindGroup.setTexture(UNIFORM_NAME_BAKED_SKY_MAP, ctx.scene.env.sky.getBakedSkyTexture(ctx));
+        if (ctx.drawEnvLight) {
+            ctx.env.light.envLight.updateBindGroup(bindGroup);
+        }
     }
     /**
    * Gets the uniform variable of type float which holds the strength of the environment light
@@ -569,21 +745,105 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
    * @param scope - Current shader scope
    * @returns The uniform variable of which presents the strength of the environment light
    */ static getEnvLightStrength(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.envLightStrength;
+        return scope.light.envLightStrength;
+    }
+    /**
+   * Gets current scene color texture
+   * @param scope - Current shader scope
+   * @returns current scene color texture
+   */ static getSceneColorTexture(scope) {
+        return scope[UNIFORM_NAME_SCENE_COLOR_MAP];
+    }
+    /**
+   * Gets the size of current scene color texture
+   * @param scope - Current shader scope
+   * @returns The size of current scene color texture
+   */ static getSceneColorTextureSize(scope) {
+        return scope[UNIFORM_NAME_SCENE_COLOR_MAP_SIZE];
+    }
+    /**
+   * Gets current linear depth texture
+   * @param scope - Current shader scope
+   * @returns current linear depth texture
+   */ static getLinearDepthTexture(scope) {
+        return scope[UNIFORM_NAME_LINEAR_DEPTH_MAP];
+    }
+    /**
+   * Gets the size of current linear depth texture
+   * @param scope - Current shader scope
+   * @returns The size of current linear depth texture
+   */ static getLinearDepthTextureSize(scope) {
+        return scope[UNIFORM_NAME_LINEAR_DEPTH_MAP_SIZE];
+    }
+    /**
+   * Gets current HiZ depth texture
+   * @param scope - Current shader scope
+   * @returns current HiZ depth texture
+   */ static getHiZDepthTexture(scope) {
+        return scope[UNIFORM_NAME_HIZ_DEPTH_MAP];
+    }
+    /**
+   * Gets the size of current HiZ depth texture
+   * @param scope - Current shader scope
+   * @returns The size of current HiZ depth texture
+   */ static getHiZDepthTextureSize(scope) {
+        return scope[UNIFORM_NAME_HIZ_DEPTH_MAP_INFO].xy;
+    }
+    /**
+   * Gets the mipmap levels count of current HiZ depth texture
+   * @param scope - Current shader scope
+   * @returns The mipmap levels count of current HiZ depth texture
+   */ static getHiZDepthTextureMipLevelCount(scope) {
+        return scope[UNIFORM_NAME_HIZ_DEPTH_MAP_INFO].z;
+    }
+    /**
+   * Gets current baked skybox texture
+   * @param scope - Current shader scope
+   * @returns current baked skybox texture
+   */ static getBakedSkyTexture(scope) {
+        return scope[UNIFORM_NAME_BAKED_SKY_MAP];
+    }
+    /**
+   * Gets the elapsed time in seconds
+   * @param scope - Current shader scope
+   * @returns The elapsed time in seconds
+   */ static getElapsedTime(scope) {
+        return scope.camera.elapsedTime;
+    }
+    /**
+   * Gets the elapsed time since last frame in seconds
+   * @param scope - Current shader scope
+   * @returns The elapsed time since last frame in seconds
+   */ static getElapsedTimeFrame(scope) {
+        return scope.camera.frameDeltaTime;
     }
     /**
    * Gets the uniform variable of type vec3 which holds the camera position
    * @param scope - Current shader scope
    * @returns The camera position
    */ static getCameraPosition(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].camera.position.xyz;
+        return scope.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;
+        return scope.camera.roughnessFactor;
+    }
+    /**
+   * Gets framebuffer size for rendering
+   * @param scope - Current shader scope
+   * @returns The roughness factor
+   */ static getRenderSize(scope) {
+        return scope.camera.renderSize;
+    }
+    /**
+   * Gets the uniform variable of type uint which holds the framestamp
+   * @param scope - Current shader scope
+   * @returns The framestamp
+   */ static getFramestamp(scope) {
+        return scope.camera.framestamp;
     }
     /**
    * Discard the fragment if it was clipped by the clip plane
@@ -609,44 +869,37 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
    * @param scope - Current shader scope
    * @returns A float value of 1 indices the clip plane presents, otherwise 0
    */ static getCameraClipPlaneFlag(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].camera.position.w;
+        return scope.camera.position.w;
     }
     /**
    * Gets the clip plane
    * @param scope - Current shader scope
    * @returns A vec4 presents the clip plane
    */ static getCameraClipPlane(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].camera.clipPlane;
+        return scope.camera.clipPlane;
     }
     /**
    * Gets the uniform variable of type vec4 which holds the camera parameters
    * @param scope - Current shader scope
    * @returns The camera parameters
    */ static getCameraParams(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].camera.params;
-    }
-    /**
-   * Gets the uniform variable of type vec4 which holds the fog color
-   * @param scope - Current shader scope
-   * @returns The fog color
-   */ static getFogColor(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].fog.fogColor;
+        return scope.camera.params;
     }
     /** @internal */ static getClusterParams(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.clusterParams;
+        return scope.light.clusterParams;
     }
     /** @internal */ static getCountParams(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.countParams;
+        return scope.light.countParams;
     }
     /** @internal */ static getClusteredLightIndexTexture(scope) {
         return scope[UNIFORM_NAME_LIGHT_INDEX_TEXTURE];
     }
     /**
-   * Gets the uniform variable of type vec4 which holds the fog color
+   * Gets the uniform variable that contains atmosphere parameters
    * @param scope - Current shader scope
-   * @returns The fog color
-   */ static getFogType(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].fog.fogType;
+   * @returns The atmosphere parameters
+   */ static getAtmosphereParams(scope) {
+        return scope.fog.atmosphereParams;
     }
     /**
    * Gets the aerial perspective LUT
@@ -656,134 +909,109 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         return scope[UNIFORM_NAME_AERIALPERSPECTIVE_LUT];
     }
     /**
-   * Gets the uniform variable of type vec4 which holds the fog parameters
+   * Gets the uniform variable of type mat4 which holds the view projection matrix of current camera
    * @param scope - Current shader scope
-   * @returns The fog parameters
-   */ static getFogParams(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].fog.fogParams;
+   * @returns The view projection matrix of current camera
+   */ static getViewProjectionMatrix(scope) {
+        return scope.camera.viewProjectionMatrix;
     }
     /**
-   * Gets the uniform variable of type float which holds the aerial perspective density
+   * Gets the uniform variable of type mat4 which holds the inversed view projection matrix of current camera
    * @param scope - Current shader scope
-   * @returns aerial perspective density
-   */ static getAPDensity(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].fog.apDensity;
+   * @returns The inversed view projection matrix of current camera
+   */ static getInvViewProjectionMatrix(scope) {
+        return scope.camera.invViewProjectionMatrix;
     }
     /**
-   * Computes the fog factor for a given view vector
+   * Gets the uniform variable of type mat4 which holds the projection matrix of current camera
    * @param scope - Current shader scope
-   * @param viewDir - the view vector
-   * @param fogType - Type of the fog
-   * @param fogParams - Fog parameters [start, end, top, density]
-   * @returns The computed fog factor
-   */ static computeFogFactor(scope, viewDir, fogType, fogParams) {
-        const pb = scope.$builder;
-        const funcName = 'Z_computeFogFactor';
-        const that = this;
-        pb.func(funcName, [
-            pb.vec3('viewDir'),
-            pb.int('fogType'),
-            pb.vec4('fogParams')
-        ], function() {
-            this.$l.distance = pb.length(this.viewDir);
-            this.$l.top = pb.max(this.viewDir.y, 0.0001);
-            this.$l.distance = pb.mul(this.$l.distance, pb.min(1, pb.div(this.fogParams.z, this.top)));
-            this.$if(pb.equal(this.fogType, that.FOG_TYPE_LINEAR), function() {
-                this.$return(pb.clamp(pb.div(pb.sub(this.distance, this.fogParams.x), pb.sub(this.fogParams.y, this.fogParams.x)), 0, 1));
-            }).$elseif(pb.equal(this.fogType, that.FOG_TYPE_EXP), function() {
-                this.$l.e = pb.mul(this.distance, this.fogParams.w);
-                this.$return(pb.sub(1, pb.div(1, pb.exp(this.e))));
-            }).$elseif(pb.equal(this.fogType, that.FOG_TYPE_EXP2), function() {
-                this.$l.e = pb.mul(this.distance, this.fogParams.w);
-                this.$return(pb.sub(1, pb.div(1, pb.exp(pb.mul(this.e, this.e)))));
-            }).$else(function() {
-                this.$return(0);
-            });
-        });
-        return pb.getGlobalScope()[funcName](viewDir, fogType, fogParams);
+   * @returns The projection matrix of current camera
+   */ static getProjectionMatrix(scope) {
+        return scope.camera.projectionMatrix;
     }
     /**
-   * Computes the fog factor with given type for a given view vector
+   * Gets the uniform variable of type mat4 which holds the inversed projection matrix of current camera
    * @param scope - Current shader scope
-   * @param viewDir - the view vector
-   * @param fogParams - The fog params [start, end, top, density]
-   * @param fogType - Type of the fog
-   * @returns The computed fog factor
-   */ static computeFogFactorForType(scope, viewDir, fogParams, fogType) {
-        const pb = scope.$builder;
-        const funcName = `Z_computeFogFactor${fogType[0].toUpperCase()}${fogType.slice(1)}`;
-        pb.func(funcName, [
-            pb.vec3('viewDir'),
-            pb.vec4('fogParams')
-        ], function() {
-            this.$l.distance = pb.length(this.viewDir);
-            this.$l.top = pb.max(this.viewDir.y, 0.0001);
-            this.$l.distance = pb.mul(this.$l.distance, pb.min(1, pb.div(this.fogParams.z, this.top)));
-            if (fogType === 'linear') {
-                this.$return(pb.clamp(pb.div(pb.sub(this.distance, this.fogParams.x), pb.sub(this.fogParams.y, this.fogParams.x)), 0, 1));
-            } else if (fogType === 'exp') {
-                this.$l.e = pb.mul(this.distance, this.fogParams.w);
-                this.$return(pb.sub(1, pb.div(1, pb.exp(this.e))));
-            } else if (fogType === 'exp2') {
-                this.$l.e = pb.mul(this.distance, this.fogParams.w);
-                this.$return(pb.sub(1, pb.div(1, pb.exp(pb.mul(this.e, this.e)))));
-            } else {
-                this.$return(0);
-            }
-        });
-        return pb.getGlobalScope()[funcName](viewDir, fogParams);
+   * @returns The inversed projection matrix of current camera
+   */ static getInvProjectionMatrix(scope) {
+        return scope.camera.invProjectionMatrix;
     }
     /**
-   * Gets the uniform variable of type mat4 which holds the view projection matrix of current camera
+   * Gets the uniform variable of type mat4 which holds the unjittered view projection matrix of current camera
    * @param scope - Current shader scope
-   * @returns The view projection matrix of current camera
-   */ static getViewProjectionMatrix(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].camera.viewProjectionMatrix;
+   * @returns The unjittered view projection matrix of current camera
+   */ static getUnjitteredViewProjectionMatrix(scope) {
+        return scope.camera.unjitteredVPMatrix;
+    }
+    /**
+   * Gets the uniform variable of type vec2 which holds the jitter value of the projection matrix of current camera
+   * @param scope - Current shader scope
+   * @returns The jitter value of projection matrix of current camera
+   */ static getProjectionMatrixJitterValue(scope) {
+        return scope.camera.jitterValue;
     }
     /**
-   * Gets the uniform variable of type mat4 which holds the view matrix of current camera
+   * Gets the uniform variable of type mat4 which holds the jittered inversed view-projection matrix
+   * @param scope - Current shader scope
+   * @returns The jittered inversed view-projection matrix
+   */ static getJitteredInvVPMatrix(scope) {
+        return scope.camera.jitteredInvVPMatrix;
+    }
+    /**
+   * Gets the uniform variable of type mat4 which holds the unjittered view projection at previous frame matrix of current camera
+   * @param scope - Current shader scope
+   * @returns The unjittered view projection matrix at previous frame of current camera
+   */ static getPrevUnjitteredViewProjectionMatrix(scope) {
+        return scope.camera.prevUnjitteredVPMatrix;
+    }
+    /**
+   * Gets the uniform variable of type mat4 which holds the view matrix of current camera (world space to camera space)
    * @param scope - Current shader scope
    * @returns The view matrix of current camera
    */ static getViewMatrix(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].camera.viewMatrix;
+        return scope.camera.viewMatrix;
     }
     /**
-   * Gets the uniform variable of type mat4 which holds the projection matrix of current camera
+   * Gets the uniform variable of type mat4 which holds the inv-view matrix of current camera (camera space to world space)
    * @param scope - Current shader scope
-   * @returns The projection matrix of current camera
-   */ static getProjectionMatrix(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].camera.projectionMatrix;
+   * @returns The inv-view matrix of current camera
+   */ static getInvViewMatrix(scope) {
+        return scope.camera.worldMatrix;
     }
     /** @internal */ static getCascadeDistances(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.cascadeDistances;
+        return scope.light.cascadeDistances;
     }
     /** @internal */ static getDepthBiasValues(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.depthBiasValues;
+        return scope.light.depthBiasValues;
     }
     /** @internal */ static getShadowCameraParams(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.shadowCameraParams;
+        return scope.light.shadowCameraParams;
     }
     /** @internal */ static getDepthBiasScales(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.depthBiasScales;
+        return scope.light.depthBiasScales;
     }
     /** @internal */ static getNumLights(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.numLights;
+        return scope.light.numLights;
     }
     /** @internal */ static getSunLightDir(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.sunDir;
+        return scope.light.sunDir;
     }
     /** @internal */ static getLightTypeForShadow(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.lightType;
+        return scope.light.lightType;
     }
     /** @internal */ static getLightPositionAndRangeForShadow(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.positionAndRange;
+        return scope.light.positionAndRange;
     }
     /** @internal */ static getLightViewMatrixForShadow(scope) {
-        return scope[UNIFORM_NAME_GLOBAL].light.viewMatrix;
+        return scope.light.viewMatrix;
     }
     /** @internal */ static calculateShadowSpaceVertex(scope, worldPos, cascade = 0) {
         const pb = scope.$builder;
-        return pb.vec4(pb.dot(scope[UNIFORM_NAME_GLOBAL].light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 0)), worldPos), pb.dot(scope[UNIFORM_NAME_GLOBAL].light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 1)), worldPos), pb.dot(scope[UNIFORM_NAME_GLOBAL].light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 2)), worldPos), pb.dot(scope[UNIFORM_NAME_GLOBAL].light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 3)), worldPos));
+        if (typeof cascade === 'number') {
+            return pb.vec4(pb.dot(scope.light.shadowMatrices.at(cascade * 4 + 0), worldPos), pb.dot(scope.light.shadowMatrices.at(cascade * 4 + 1), worldPos), pb.dot(scope.light.shadowMatrices.at(cascade * 4 + 2), worldPos), pb.dot(scope.light.shadowMatrices.at(cascade * 4 + 3), worldPos));
+        } else {
+            return pb.vec4(pb.dot(scope.light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 0)), worldPos), pb.dot(scope.light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 1)), worldPos), pb.dot(scope.light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 2)), worldPos), pb.dot(scope.light.shadowMatrices.at(pb.add(pb.mul(cascade, 4), 3)), worldPos));
+        }
     }
     /** @internal */ static getLightPositionAndRange(scope, lightIndex) {
         return scope[UNIFORM_NAME_LIGHT_BUFFER].at(scope.$builder.mul(lightIndex, 3));
@@ -818,13 +1046,6 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         }
     }
     /**
-   * Get global uniforms
-   *
-   * @param scope - Shader scope
-   */ static getGlobalUniforms(scope) {
-        return scope[UNIFORM_NAME_GLOBAL];
-    }
-    /**
    * Get shadow map uniform value
    *
    * @param scope - Shader scope
@@ -848,7 +1069,7 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
             pb.float('NoL')
         ], function() {
             if (shadowMapParams.numShadowCascades > 1) {
-                this.$l.shadowCascades = that.getGlobalUniforms(this).light.shadowCascades;
+                this.$l.shadowCascades = this.light.shadowCascades;
                 this.$l.shadowBound = pb.vec4(0, 0, 1, 1);
                 this.$l.linearDepth = that.nonLinearDepthToLinear(this, this.$builtins.fragCoord.z);
                 this.$l.splitDistances = that.getCascadeDistances(this);
@@ -885,42 +1106,16 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
     static applyFog(scope, worldPos, color, ctx) {
         const pb = scope.$builder;
         const that = this;
-        if (ctx.applyFog === 'scatter') {
-            const funcName = 'Z_applySkyFog';
-            pb.func(funcName, [
-                pb.vec3('worldPos'),
-                pb.vec4('color').inout()
-            ], function() {
-                this.$l.viewDir = pb.sub(this.worldPos, that.getCameraPosition(this));
-                this.viewDir.y = pb.max(this.viewDir.y, 0);
-                this.$l.distance = pb.mul(pb.length(this.viewDir), that.getAPDensity(this));
-                this.$l.sliceDist = pb.div(pb.mul(that.getCameraParams(this).y, that.getAPDensity(this)), ScatteringLut.aerialPerspectiveSliceZ);
-                this.$l.slice0 = pb.floor(pb.div(this.distance, this.sliceDist));
-                this.$l.slice1 = pb.add(this.slice0, 1);
-                this.$l.factor = pb.sub(pb.div(this.distance, this.sliceDist), this.slice0);
-                this.$l.viewNormal = pb.normalize(this.viewDir);
-                this.$l.horizonAngle = pb.acos(pb.clamp(pb.dot(pb.normalize(that.getSunLightDir(this).xz), pb.normalize(this.viewNormal.xz)), 0, 1));
-                this.$l.zenithAngle = pb.asin(this.viewNormal.y);
-                this.$l.sliceU = pb.max(pb.div(this.horizonAngle, Math.PI * 2), 0.5 / ScatteringLut.aerialPerspectiveSliceZ);
-                this.$l.u0 = pb.div(pb.add(this.slice0, this.sliceU), ScatteringLut.aerialPerspectiveSliceZ);
-                this.$l.u1 = pb.add(this.u0, 1 / ScatteringLut.aerialPerspectiveSliceZ);
-                this.$l.v = pb.div(this.zenithAngle, Math.PI / 2);
-                this.$l.t0 = pb.textureSampleLevel(that.getAerialPerspectiveLUT(this), pb.vec2(this.u0, this.v), 0);
-                this.$l.t1 = pb.textureSampleLevel(that.getAerialPerspectiveLUT(this), pb.vec2(this.u1, this.v), 0);
-                this.$l.t = pb.mix(this.t0, this.t1, this.factor);
-                this.color = pb.vec4(pb.add(pb.mul(this.color.rgb, this.t.a), this.t.rgb), this.color.a);
-            //this.color = pb.vec4(pb.vec3(pb.mix(this.u0, this.u1, this.factor)), this.color.a);
-            });
-            scope[funcName](worldPos, color);
-        } else if (ctx.applyFog) {
+        if (ctx.materialFlags & MaterialVaryingFlags.APPLY_FOG) {
             const funcName = 'Z_applyFog';
             pb.func(funcName, [
                 pb.vec3('worldPos'),
                 pb.vec4('color').inout()
             ], function() {
-                this.$l.viewDir = pb.sub(this.worldPos, that.getCameraPosition(this));
-                this.$l.fogFactor = that.computeFogFactor(this, this.viewDir, that.getFogType(this), that.getFogParams(this));
-                this.color = pb.vec4(pb.mix(this.color.rgb, that.getFogColor(this).rgb, this.fogFactor), this.color.a);
+                this.$l.uv = pb.div(pb.vec2(this.$builtins.fragCoord.xy), that.getRenderSize(this));
+                this.$l.fogging = calculateFog(this, this.fog.withAerialPerspective, this.fog.fogType, this.fog.atmosphereParams, this.fog.heightFogParams, this.uv, false, that.getCameraPosition(this).xyz, this.worldPos, this.fog.additive, this[UNIFORM_NAME_AERIALPERSPECTIVE_LUT], this[UNIFORM_NAME_SKYDISTANTLIGHT_LUT]);
+                this.color = pb.vec4(pb.add(pb.mul(this.color.rgb, this.fogging.a), this.fogging.rgb), this.color.a);
+            //this.color = pb.vec4(pb.vec3(pb.mix(this.u0, this.u1, this.factor)), this.color.a);
             });
             scope[funcName](worldPos, color);
         }
@@ -962,6 +1157,45 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         return pb.div(nearFar.x, pb.mix(nearFar.y, nearFar.x, depth));
     }
     /**
+   * Sample linear depth from linear depth texture
+   * @param scope - Current shader scope
+   * @param tex - The linear depth texture
+   * @param uv - The uv coordinates
+   * @param level - The mipmap level to sample
+   * @returns Linear depth value
+   */ static sampleLinearDepth(scope, tex, uv, level) {
+        const pb = scope.$builder;
+        const depth = pb.textureSampleLevel(tex, uv, level);
+        return pb.getDevice().type === 'webgl' ? decodeNormalizedFloatFromRGBA(scope, depth) : depth.r;
+    }
+    static samplePositionFromDepth(scope, depthTex, uv, mat, cameraNearFar) {
+        const pb = scope.$builder;
+        const that = this;
+        pb.func('zSamplePositionFromDepth', [
+            pb.vec2('uv'),
+            pb.vec2('cameraNearFar'),
+            pb.mat4('mat')
+        ], function() {
+            this.$l.linearDepth = that.sampleLinearDepth(this, depthTex, this.uv, 0);
+            this.$l.nonLinearDepth = pb.div(pb.sub(pb.div(this.cameraNearFar.x, this.linearDepth), this.cameraNearFar.y), pb.sub(this.cameraNearFar.x, this.cameraNearFar.y));
+            this.$l.clipSpacePos = pb.vec4(pb.sub(pb.mul(this.uv, 2), pb.vec2(1)), pb.sub(pb.mul(pb.clamp(this.nonLinearDepth, 0, 1), 2), 1), 1);
+            this.$l.wPos = pb.mul(this.mat, this.clipSpacePos);
+            this.$return(pb.vec4(pb.div(this.wPos.xyz, this.wPos.w), this.linearDepth));
+        });
+        return scope.zSamplePositionFromDepth(uv, cameraNearFar, mat);
+    }
+    /**
+   * Sample linear depth from linear depth texture with backface
+   * @param scope - Current shader scope
+   * @param tex - The linear depth texture
+   * @param uv - The uv coordinates
+   * @param level - The mipmap level to sample
+   * @returns Linear depth value
+   */ static sampleLinearDepthWithBackface(scope, tex, uv, level) {
+        const pb = scope.$builder;
+        return pb.textureSampleLevel(tex, uv, level).rg;
+    }
+    /**
    * Transform color to sRGB color space if nessesary
    *
    * @param scope - Current shader scope