@zephyr3d/scene 0.9.4 → 0.9.6

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

@@ -1,1209 +0,0 @@
-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 { decodeNormalizedFloatFromRGBA, linearToGamma } from '../../shaders/misc.js';
-import { Application } from '../../app/app.js';
-import { fetchSampler } from '../../utility/misc.js';
-import { getDefaultAtmosphereParams, getAtmosphereParamsStruct } from '../../shaders/atmosphere.js';
-import { getDefaultHeightFogParams, getHeightFogParamsStruct, calculateFog } from '../../shaders/fog.js';
-
-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_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';
-const UNIFORM_NAME_BONE_MATRICES = 'Z_UniformBoneMatrices';
-const UNIFORM_NAME_BONE_TEXTURE_SIZE = 'Z_UniformBoneTexSize';
-const UNIFORM_NAME_BONE_INV_BIND_MATRIX = 'Z_UniformBoneInvBindMatrix';
-const UNIFORM_NAME_MORPH_DATA = 'Z_UniformMorphData';
-const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
-/**
- * Helper shader functions for the builtin material system
- * @public
- */ class ShaderHelper {
-    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 = {
-        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 = {
-        withAerialPerspective: 0,
-        fogType: 0,
-        additive: 0,
-        atmosphereParams: getDefaultAtmosphereParams(),
-        heightFogParams: getDefaultHeightFogParams()
-    };
-    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;
-    }
-    static getInstanceDataOffsetUniformName() {
-        return UNIFORM_NAME_INSTANCE_DATA_OFFSET;
-    }
-    static getInstanceDataStrideUniformName() {
-        return UNIFORM_NAME_INSTANCE_DATA_STRIDE;
-    }
-    static getBoneMatricesUniformName() {
-        return UNIFORM_NAME_BONE_MATRICES;
-    }
-    static getBoneTextureSizeUniformName() {
-        return UNIFORM_NAME_BONE_TEXTURE_SIZE;
-    }
-    static getBoneInvBindMatrixUniformName() {
-        return UNIFORM_NAME_BONE_INV_BIND_MATRIX;
-    }
-    static getMorphDataUniformName() {
-        return UNIFORM_NAME_MORPH_DATA;
-    }
-    static getMorphInfoUniformName() {
-        return UNIFORM_NAME_MORPH_INFO;
-    }
-    static getLightBufferUniformName() {
-        return UNIFORM_NAME_LIGHT_BUFFER;
-    }
-    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
-   *
-   * @remarks
-   * This function will setup all nessesary uniforms acoording to the drawing context
-   *
-   * @param pb - The program builder
-   * @param ctx - The drawing context
-   */ static prepareFragmentShader(pb, ctx) {
-        this.setupGlobalUniforms(pb, ctx);
-    }
-    /**
-   * Prepares the vertex shader which is going to be used in our material system
-   *
-   * @remarks
-   * This function will setup all nessesary uniforms according to the drawing context
-   *
-   * @param pb - The program builder
-   * @param ctx - The drawing context
-   */ static prepareVertexShader(pb, ctx) {
-        this.setupGlobalUniforms(pb, ctx);
-        this.prepareVertexShaderCommon(pb, ctx);
-    }
-    /** @internal */ static setupGlobalUniforms(pb, ctx) {
-        const scope = pb.getGlobalScope();
-        const cameraStruct = pb.defineStruct([
-            pb.vec4('position'),
-            pb.vec4('clipPlane'),
-            pb.mat4('viewProjectionMatrix'),
-            pb.mat4('invViewProjectionMatrix'),
-            pb.mat4('unjitteredVPMatrix'),
-            pb.mat4('jitteredInvVPMatrix'),
-            pb.mat4('viewMatrix'),
-            pb.mat4('projectionMatrix'),
-            pb.mat4('invProjectionMatrix'),
-            pb.vec4('params'),
-            ...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([
-                pb.vec4('positionAndRange'),
-                pb.vec4('directionCutoff'),
-                pb.mat4('viewMatrix'),
-                pb.vec4('depthBias'),
-                pb.int('lightType')
-            ]);
-            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) {
-            scope.camera = cameraStruct().uniform(0);
-        } else if (ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT) {
-            const useClusteredLighting = !ctx.currentShadowLight;
-            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'),
-                pb.vec4('positionAndRange'),
-                pb.vec4('directionAndCutoff'),
-                pb.vec4('diffuseAndIntensity'),
-                pb.vec4('cascadeDistances'),
-                pb.vec4('depthBiasValues'),
-                pb.vec4('shadowCameraParams'),
-                pb.vec4('depthBiasScales'),
-                pb.vec4[16]('shadowMatrices'),
-                pb.float('envLightStrength')
-            ]) : pb.defineStruct([
-                pb.vec3('sunDir'),
-                pb.float('envLightStrength'),
-                pb.vec4('clusterParams'),
-                pb.ivec4('countParams'),
-                pb.ivec2('lightIndexTexSize')
-            ]);
-            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);
-            }
-            scope[UNIFORM_NAME_BAKED_SKY_MAP] = pb.texCube().uniform(0);
-            if (ctx.currentShadowLight) {
-                const scope = pb.getGlobalScope();
-                const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-                const tex = shadowMapParams.shadowMap.isTextureCube() ? shadowMapParams.shadowMap.isDepth() ? scope.$builder.texCubeShadow() : scope.$builder.texCube() : shadowMapParams.shadowMap.isTexture2D() ? shadowMapParams.shadowMap.isDepth() ? scope.$builder.tex2DShadow() : scope.$builder.tex2D() : shadowMapParams.shadowMap.isDepth() ? scope.$builder.tex2DArrayShadow() : scope.$builder.tex2DArray();
-                if (!shadowMapParams.shadowMap.isDepth() && !ctx.device.getDeviceCaps().textureCaps.getTextureFormatInfo(shadowMapParams.shadowMap.format).filterable) {
-                    tex.sampleType('unfilterable-float');
-                }
-                scope[UNIFORM_NAME_SHADOW_MAP] = tex.uniform(0);
-            }
-            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);
-            }
-        }
-    }
-    /**
-   * This function checks if the shader needs to process skeletal animation.
-   *
-   * @param scope - Current shader scope
-   *
-   * @returns true if the shader needs to process skeletal animation, otherwise false.
-   */ static hasSkinning(scope) {
-        return !!scope[UNIFORM_NAME_BONE_MATRICES];
-    }
-    /**
-   * This function checks if the shader needs to process morph target animation.
-   *
-   * @param scope - Current shader scope
-   *
-   * @returns true if the shader needs to process morph target animation, otherwise false.
-   */ static hasMorphing(scope) {
-        return !!scope[UNIFORM_NAME_MORPH_DATA];
-    }
-    /**
-   * Calculate skinning matrix for current vertex
-   *
-   * @param scope - Current shader scope
-   *
-   * @returns Skinning matrix for current vertex, or null if there is not skeletal animation
-   */ static calculateSkinMatrix(scope) {
-        if (!this.hasSkinning(scope)) {
-            return null;
-        }
-        const pb = scope.$builder;
-        const funcNameGetBoneMatrixFromTexture = 'Z_getBoneMatrixFromTexture';
-        pb.func(funcNameGetBoneMatrixFromTexture, [
-            pb.int('boneIndex')
-        ], function() {
-            const boneTexture = this[UNIFORM_NAME_BONE_MATRICES];
-            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);
-            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, [], 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](pb.int(blendIndices[0]));
-            this.$l.m1 = scope.$g[funcNameGetBoneMatrixFromTexture](pb.int(blendIndices[1]));
-            this.$l.m2 = scope.$g[funcNameGetBoneMatrixFromTexture](pb.int(blendIndices[2]));
-            this.$l.m3 = scope.$g[funcNameGetBoneMatrixFromTexture](pb.int(blendIndices[3]));
-            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));
-        });
-        return scope.$g[funcNameGetSkinningMatrix]();
-    }
-    static calculateMorphDelta(scope, attrib) {
-        const pb = scope.$builder;
-        const isWebGL1 = pb.getDevice().type === 'webgl';
-        if (pb.shaderKind !== 'vertex') {
-            throw new Error(`ShaderHelper.calculateMorphDelta(): must be called at vertex stage`);
-        }
-        const funcName = 'Z_calculateMorph';
-        const that = this;
-        pb.func(funcName, [
-            pb.int('offset')
-        ], function() {
-            this.$if(pb.lessThan(this.offset, 0), function() {
-                this.$return(pb.vec4(0));
-            });
-            this.$l.vertexIndex = isWebGL1 ? pb.int(scope.$inputs.zFakeVertexID) : pb.int(scope.$builtins.vertexIndex);
-            const morphInfo = scope[that.getMorphInfoUniformName()];
-            this.$l.metaData = pb.ivec4(morphInfo[0]);
-            this.$l.texWidth = pb.float(this.metaData.x);
-            this.$l.texHeight = pb.float(this.metaData.y);
-            this.$l.numVertices = this.metaData.z;
-            this.$l.numTargets = this.metaData.w;
-            this.$l.value = pb.vec4(0);
-            if (isWebGL1) {
-                this.$for(pb.int('i'), 0, MORPH_WEIGHTS_VECTOR_COUNT, function() {
-                    this.$for(pb.int('j'), 0, 4, function() {
-                        this.$l.index = pb.add(pb.mul(this.i, 4), this.j);
-                        this.$if(pb.greaterThanEqual(this.index, this.numTargets), function() {
-                            this.$return(this.value);
-                        });
-                        this.$l.weight = morphInfo.at(pb.add(1, this.i)).at(this.j);
-                        this.$l.pixelIndex = pb.float(pb.add(this.offset, pb.mul(this.index, this.numVertices), this.vertexIndex));
-                        this.$l.xIndex = pb.mod(this.pixelIndex, this.texWidth);
-                        this.$l.yIndex = pb.floor(pb.div(this.pixelIndex, this.texWidth));
-                        this.$l.u = pb.div(pb.add(this.xIndex, 0.5), this.texWidth);
-                        this.$l.v = pb.div(pb.add(this.yIndex, 0.5), this.texHeight);
-                        this.$l.morphValue = pb.textureSampleLevel(this[that.getMorphDataUniformName()], pb.vec2(this.u, this.v), 0);
-                        this.value = pb.add(this.value, pb.mul(this.morphValue, this.weight));
-                    });
-                });
-            } else {
-                this.$for(pb.int('t'), 0, this.numTargets, function() {
-                    this.$l.i = pb.sar(this.t, 2);
-                    this.$l.j = pb.compAnd(this.t, 3);
-                    this.$l.weight = morphInfo.at(pb.add(1, this.i)).at(this.j);
-                    this.$l.pixelIndex = pb.float(pb.add(this.offset, pb.mul(this.t, this.numVertices), this.vertexIndex));
-                    this.$l.xIndex = pb.mod(this.pixelIndex, this.texWidth);
-                    this.$l.yIndex = pb.floor(pb.div(this.pixelIndex, this.texWidth));
-                    this.$l.u = pb.div(pb.add(this.xIndex, 0.5), this.texWidth);
-                    this.$l.v = pb.div(pb.add(this.yIndex, 0.5), this.texHeight);
-                    this.$l.morphValue = pb.textureSampleLevel(this[that.getMorphDataUniformName()], pb.vec2(this.u, this.v), 0);
-                    this.value = pb.add(this.value, pb.mul(this.morphValue, this.weight));
-                });
-            }
-            this.$return(this.value);
-        });
-        const pos = 1 + MORPH_WEIGHTS_VECTOR_COUNT + (attrib >> 2);
-        const comp = attrib & 3;
-        const offset = scope[this.getMorphInfoUniformName()][pos][comp];
-        return scope[funcName](pb.int(offset));
-    }
-    /** @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 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) {
-        const pb = scope.$builder;
-        if (pb.shaderKind !== 'vertex') {
-            throw new Error(`ShaderHelper.resolveVertexPosition(): must be called at vertex stage`);
-        }
-        if (!pb.getGlobalScope().$getVertexAttrib('position')) {
-            pb.getGlobalScope().$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);
-            }
-            if (this.skinMatrix) {
-                this.$l.pos = pb.mul(this.skinMatrix, pb.vec4(this.opos, 1)).xyz;
-            } else {
-                this.$l.pos = this.opos;
-            }
-            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));
-        }
-    }
-    /**
-   * Calculates the normal vector of type vec3 in object space
-   *
-   * @param scope - Current shader scope
-   * @param normal - Vertex normal input, must be type of vec3, null if no vertex normal input
-   * @param skinMatrix - The skinning matrix if there is skeletal animation, otherwise null
-   * @returns The calculated normal vector in object space, or null if normal is null
-   */ static resolveVertexNormal(scope, normal) {
-        const pb = scope.$builder;
-        if (pb.shaderKind !== 'vertex') {
-            throw new Error(`ShaderHelper.resolveVertexNormal(): must be called in vertex stage`);
-        }
-        const funcScope = pb.getCurrentFunctionScope();
-        if (!funcScope || !funcScope.$isMain()) {
-            throw new Error(`ShaderHelper.resolveVertexNormal(): must be called at entry function`);
-        }
-        if (!normal) {
-            if (!scope.$getVertexAttrib('normal')) {
-                scope.$inputs.Z_normal = pb.vec3().attrib('normal');
-            }
-            normal = scope.$getVertexAttrib('normal');
-        }
-        if (this.hasMorphing(scope)) {
-            normal = pb.normalize(pb.add(normal, this.calculateMorphDelta(scope, MORPH_TARGET_NORMAL).xyz));
-        }
-        if (scope[this.SKIN_MATRIX_NAME]) {
-            return pb.mul(scope[this.SKIN_MATRIX_NAME], pb.vec4(normal, 0)).xyz;
-        } else {
-            return normal;
-        }
-    }
-    /**
-   * Calculates the tangent vector of type vec3 in object space
-   *
-   * @param scope - Current shader scope
-   * @param tangent - Vertex tangent input, must be type of vec4, null if no vertex tangent input
-   * @param skinMatrix - The skinning matrix if there is skeletal animation, otherwise null
-   * @returns The calculated tangent vector of type vec4 in object space, or null if tangent is null
-   */ static resolveVertexTangent(scope, tangent) {
-        const pb = scope.$builder;
-        if (pb.shaderKind !== 'vertex') {
-            throw new Error(`ShaderHelper.resolveVertexTangent(): must be called in vertex stage`);
-        }
-        const funcScope = pb.getCurrentFunctionScope();
-        if (!funcScope || !funcScope.$isMain()) {
-            throw new Error(`ShaderHelper.resolveVertexTangent(): must be called at entry function`);
-        }
-        if (!tangent) {
-            if (!scope.$getVertexAttrib('tangent')) {
-                scope.$inputs.Z_tangent = pb.vec4().attrib('tangent');
-            }
-            tangent = scope.$getVertexAttrib('tangent');
-        }
-        if (this.hasMorphing(scope)) {
-            tangent = pb.normalize(pb.add(tangent, pb.vec4(this.calculateMorphDelta(scope, MORPH_TARGET_TANGENT).xyz, 0)));
-        }
-        if (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;
-        }
-    }
-    /**
-   * Gets the uniform variable of type mat4 which holds the world matrix of current object to be drawn
-   * @param scope - Current shader scope
-   * @returns The world matrix of current object to be drawn
-   */ static getWorldMatrix(scope) {
-        const pb = scope.$builder;
-        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], pb.uint(uniformIndex)));
-    }
-    /**
-   * Gets the uniform variable of type mat4 which holds the normal matrix of current object to be drawn
-   *
-   * @param scope - Current shader scope
-   * @returns The normal matrix of current object to be drawn
-   */ static getNormalMatrix(scope) {
-        return this.getWorldMatrix(scope);
-    }
-    /**
-   * Vertex shader drawable stuff
-   *
-   * @param scope - Current shader scope
-   * @param skinning - true if skinning is used, otherwise false.
-   * @param instanced - true if instancing is used, otherwise false.
-   */ static vertexShaderDrawableStuff(scope, skinning, morphing, instanced) {
-        const pb = scope.$builder;
-        if (instanced) {
-            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);
-            scope[UNIFORM_NAME_PREV_WORLD_MATRIX] = pb.mat4().uniform(1);
-            scope[UNIFORM_NAME_PREV_WORLD_MATRXI_FRAME] = pb.int().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.vec2().uniform(1);
-        }
-        if (morphing) {
-            scope[UNIFORM_NAME_MORPH_DATA] = pb.tex2D().uniform(1).sampleType('unfilterable-float');
-            scope[UNIFORM_NAME_MORPH_INFO] = pb.vec4[1 + MORPH_WEIGHTS_VECTOR_COUNT + MORPH_ATTRIBUTE_VECTOR_COUNT]().uniformBuffer(1);
-        }
-    }
-    /** @internal */ static prepareVertexShaderCommon(pb, ctx) {
-        this.vertexShaderDrawableStuff(pb.getGlobalScope(), !!(ctx.materialFlags & MaterialVaryingFlags.SKIN_ANIMATION), !!(ctx.materialFlags & MaterialVaryingFlags.MORPH_ANIMATION), !!(ctx.materialFlags & MaterialVaryingFlags.INSTANCING));
-    }
-    /** @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, 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,
-            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: Application.instance.device.frameInfo.elapsedFrame * 0.001,
-            elapsedTime: Application.instance.device.frameInfo.elapsedOverall * 0.001,
-            framestamp: Application.instance.device.frameInfo.frameCounter
-        };
-        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('light', {
-                positionAndRange: light.positionAndRange,
-                directionCutoff: light.directionAndCutoff,
-                viewMatrix: light.viewMatrix,
-                depthBias: shadowMapParams.depthBiasValues[0],
-                lightType: light.lightType
-            });
-        }
-    }
-    /** @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('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);
-        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.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);
-        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
-   *
-   * @remarks
-   * This function can only be used in the fragment shader
-   *
-   * @param scope - Current shader scope
-   * @returns The uniform variable of which presents the strength of the environment light
-   */ static getEnvLightStrength(scope) {
-        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.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.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
-   * @param scope - Current shader scope
-   */ static discardIfClipped(scope, worldPos) {
-        const funcName = 'Z_discardIfClippped';
-        const pb = scope.$builder;
-        const that = this;
-        pb.func(funcName, [
-            pb.vec3('worldPos')
-        ], function() {
-            this.$if(pb.notEqual(that.getCameraClipPlaneFlag(this), 0), function() {
-                this.$l.clipPlane = that.getCameraClipPlane(this);
-                this.$if(pb.greaterThan(pb.add(pb.dot(this.worldPos.xyz, this.clipPlane.xyz), this.clipPlane.w), 0), function() {
-                    pb.discard();
-                });
-            });
-        });
-        pb.getGlobalScope()[funcName](worldPos);
-    }
-    /**
-   * Gets the clip plane flag
-   * @param scope - Current shader scope
-   * @returns A float value of 1 indices the clip plane presents, otherwise 0
-   */ static getCameraClipPlaneFlag(scope) {
-        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.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.camera.params;
-    }
-    /** @internal */ static getClusterParams(scope) {
-        return scope.light.clusterParams;
-    }
-    /** @internal */ static getCountParams(scope) {
-        return scope.light.countParams;
-    }
-    /** @internal */ static getClusteredLightIndexTexture(scope) {
-        return scope[UNIFORM_NAME_LIGHT_INDEX_TEXTURE];
-    }
-    /**
-   * Gets the uniform variable that contains atmosphere parameters
-   * @param scope - Current shader scope
-   * @returns The atmosphere parameters
-   */ static getAtmosphereParams(scope) {
-        return scope.fog.atmosphereParams;
-    }
-    /**
-   * Gets the aerial perspective LUT
-   * @param scope - Current shader scope
-   * @returns The aerial perspective LUT texture
-   */ static getAerialPerspectiveLUT(scope) {
-        return scope[UNIFORM_NAME_AERIALPERSPECTIVE_LUT];
-    }
-    /**
-   * Gets the uniform variable of type mat4 which holds the view projection matrix of current camera
-   * @param scope - Current shader scope
-   * @returns The view projection matrix of current camera
-   */ static getViewProjectionMatrix(scope) {
-        return scope.camera.viewProjectionMatrix;
-    }
-    /**
-   * Gets the uniform variable of type mat4 which holds the inversed view projection matrix of current camera
-   * @param scope - Current shader scope
-   * @returns The inversed view projection matrix of current camera
-   */ static getInvViewProjectionMatrix(scope) {
-        return scope.camera.invViewProjectionMatrix;
-    }
-    /**
-   * Gets the uniform variable of type mat4 which holds the projection matrix of current camera
-   * @param scope - Current shader scope
-   * @returns The projection matrix of current camera
-   */ static getProjectionMatrix(scope) {
-        return scope.camera.projectionMatrix;
-    }
-    /**
-   * Gets the uniform variable of type mat4 which holds the inversed projection matrix of current camera
-   * @param scope - Current shader scope
-   * @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 unjittered view projection matrix of current camera
-   * @param scope - Current shader scope
-   * @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 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
-   * @param scope - Current shader scope
-   * @returns The view matrix of current camera
-   */ static getViewMatrix(scope) {
-        return scope.camera.viewMatrix;
-    }
-    /** @internal */ static getCascadeDistances(scope) {
-        return scope.light.cascadeDistances;
-    }
-    /** @internal */ static getDepthBiasValues(scope) {
-        return scope.light.depthBiasValues;
-    }
-    /** @internal */ static getShadowCameraParams(scope) {
-        return scope.light.shadowCameraParams;
-    }
-    /** @internal */ static getDepthBiasScales(scope) {
-        return scope.light.depthBiasScales;
-    }
-    /** @internal */ static getNumLights(scope) {
-        return scope.light.numLights;
-    }
-    /** @internal */ static getSunLightDir(scope) {
-        return scope.light.sunDir;
-    }
-    /** @internal */ static getLightTypeForShadow(scope) {
-        return scope.light.lightType;
-    }
-    /** @internal */ static getLightPositionAndRangeForShadow(scope) {
-        return scope.light.positionAndRange;
-    }
-    /** @internal */ static getLightViewMatrixForShadow(scope) {
-        return scope.light.viewMatrix;
-    }
-    /** @internal */ static calculateShadowSpaceVertex(scope, worldPos, cascade = 0) {
-        const pb = scope.$builder;
-        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));
-    }
-    /** @internal */ static getLightDirectionAndCutoff(scope, lightIndex) {
-        return scope[UNIFORM_NAME_LIGHT_BUFFER].at(scope.$builder.add(scope.$builder.mul(lightIndex, 3), 1));
-    }
-    /** @internal */ static getLightColorAndIntensity(scope, lightIndex) {
-        return scope[UNIFORM_NAME_LIGHT_BUFFER].at(scope.$builder.add(scope.$builder.mul(lightIndex, 3), 2));
-    }
-    /**
-   * Sets the clip space position in vertex shader
-   *
-   * @remarks
-   * Use this function instead of using
-   * <pre>
-   * // Do not use this
-   * this.$builtins.position = some_value;
-   * // Use this
-   * ShaderFramework.setClipSpacePosition(some_value);
-   * </pre>,
-   *
-   * @param scope - Current shader scope
-   * @param pos - The clip space position to be set
-   */ static setClipSpacePosition(scope, pos) {
-        const pb = scope.$builder;
-        const cameraParams = this.getCameraParams(scope);
-        if (cameraParams) {
-            scope.$builtins.position = pb.mul(pos, pb.vec4(1, cameraParams.z, 1, 1));
-        } else {
-            scope.$builtins.position = pos;
-        }
-    }
-    /**
-   * Get shadow map uniform value
-   *
-   * @param scope - Shader scope
-   * @returns The shadow map texture uniform
-   */ static getShadowMap(scope) {
-        return scope[UNIFORM_NAME_SHADOW_MAP];
-    }
-    /**
-   * Calculates shadow of current fragment
-   *
-   * @param scope - Shader scope
-   * @param NoL - NdotL vector
-   * @returns Shadow of current fragment, 1 means no shadow and 0 means full shadowed.
-   */ static calculateShadow(scope, worldPos, NoL, ctx) {
-        const pb = scope.$builder;
-        const that = this;
-        const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-        const funcName = 'Z_calculateShadow';
-        pb.func(funcName, [
-            pb.vec3('worldPos'),
-            pb.float('NoL')
-        ], function() {
-            if (shadowMapParams.numShadowCascades > 1) {
-                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);
-                this.$l.comparison = pb.vec4(pb.greaterThan(pb.vec4(this.linearDepth), this.splitDistances));
-                this.$l.cascadeFlags = pb.vec4(pb.float(pb.greaterThan(this.shadowCascades, 0)), pb.float(pb.greaterThan(this.shadowCascades, 1)), pb.float(pb.greaterThan(this.shadowCascades, 2)), pb.float(pb.greaterThan(this.shadowCascades, 3)));
-                this.$l.split = pb.int(pb.dot(this.comparison, this.cascadeFlags));
-                if (ctx.device.type === 'webgl') {
-                    this.$l.shadowVertex = pb.vec4();
-                    this.$for(pb.int('cascade'), 0, 4, function() {
-                        this.$if(pb.equal(this.cascade, this.split), function() {
-                            this.shadowVertex = that.calculateShadowSpaceVertex(this, pb.vec4(this.worldPos, 1), this.cascade);
-                            this.$break();
-                        });
-                    });
-                } else {
-                    this.$l.shadowVertex = that.calculateShadowSpaceVertex(this, pb.vec4(this.worldPos, 1), this.split);
-                }
-                const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-                this.$l.shadow = shadowMapParams.impl.computeShadowCSM(shadowMapParams, this, this.shadowVertex, this.NoL, this.split);
-                this.$l.shadowDistance = that.getShadowCameraParams(scope).w;
-                this.shadow = pb.mix(this.shadow, 1, pb.smoothStep(pb.mul(this.shadowDistance, 0.8), this.shadowDistance, pb.distance(that.getCameraPosition(this), this.worldPos)));
-                this.$return(this.shadow);
-            } else {
-                this.$l.shadowVertex = that.calculateShadowSpaceVertex(this, pb.vec4(this.worldPos, 1));
-                const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-                this.$l.shadow = shadowMapParams.impl.computeShadow(shadowMapParams, this, this.shadowVertex, this.NoL);
-                this.$l.shadowDistance = that.getShadowCameraParams(scope).w;
-                this.shadow = pb.mix(this.shadow, 1, pb.smoothStep(pb.mul(this.shadowDistance, 0.8), this.shadowDistance, pb.distance(that.getCameraPosition(this), this.worldPos)));
-                this.$return(this.shadow);
-            }
-        });
-        return pb.getGlobalScope()[funcName](worldPos, NoL);
-    }
-    static applyFog(scope, worldPos, color, ctx) {
-        const pb = scope.$builder;
-        const that = this;
-        if (ctx.materialFlags & MaterialVaryingFlags.APPLY_FOG) {
-            const funcName = 'Z_applyFog';
-            pb.func(funcName, [
-                pb.vec3('worldPos'),
-                pb.vec4('color').inout()
-            ], function() {
-                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);
-        }
-    }
-    /**
-   * Calculates the non-linear depth from linear depth
-   *
-   * @param scope - Current shader scope
-   * @param depth - The linear depth
-   * @param nearFar - A vector that contains the near clip plane in x component and the far clip plane in y component
-   * @returns The calculated non-linear depth
-   */ static linearDepthToNonLinear(scope, depth, nearFar) {
-        const pb = scope.$builder;
-        nearFar = nearFar ?? this.getCameraParams(scope);
-        return pb.div(pb.sub(nearFar.y, pb.div(pb.mul(nearFar.x, nearFar.y), depth)), pb.sub(nearFar.y, nearFar.x));
-    }
-    /**
-   * Calculates the linear depth from non-linear depth
-   *
-   * @param scope - Current shader scope
-   * @param depth - The non-linear depth
-   * @param nearFar - A vector that contains the near clip plane in x component and the far clip plane in y component
-   * @returns The calculated linear depth
-   */ static nonLinearDepthToLinear(scope, depth, nearFar) {
-        const pb = scope.$builder;
-        nearFar = nearFar ?? this.getCameraParams(scope);
-        return pb.div(pb.mul(nearFar.x, nearFar.y), pb.mix(nearFar.y, nearFar.x, depth));
-    }
-    /**
-   * Calculates the normalized linear depth from non-linear depth
-   *
-   * @param scope - Current shader scope
-   * @param depth - The non-linear depth
-   * @param nearFar - A vector that contains the near clip plane in x component and the far clip plane in y component
-   * @returns The calculated normalized linear depth
-   */ static nonLinearDepthToLinearNormalized(scope, depth, nearFar) {
-        const pb = scope.$builder;
-        nearFar = nearFar ?? this.getCameraParams(scope);
-        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
-   * @param outputColor - The color to be transformed
-   * @returns The transformed color
-   */ static encodeColorOutput(scope, outputColor) {
-        const pb = scope.$builder;
-        const that = this;
-        const funcName = 'Z_encodeColorOutput';
-        pb.func(funcName, [
-            pb.vec4('outputColor')
-        ], function() {
-            const params = that.getCameraParams(this);
-            this.$if(pb.notEqual(params.w, 0), function() {
-                this.$return(pb.vec4(linearToGamma(this, this.outputColor.rgb), this.outputColor.w));
-            }).$else(function() {
-                this.$return(this.outputColor);
-            });
-        });
-        return pb.getGlobalScope()[funcName](outputColor);
-    }
-}
-
-export { ShaderHelper };
-//# sourceMappingURL=helper.js.map