@zephyr3d/scene 0.5.0 → 0.6.1

package/dist/material/lightmodel.js.map

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

package/dist/material/lit.js

@@ -1,578 +0,0 @@
-import { RENDER_PASS_TYPE_FORWARD, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_POINT, LIGHT_TYPE_SPOT } from '../values.js';
-import { ShaderFramework } from '../shaders/framework.js';
-import { nonLinearDepthToLinear } from '../shaders/misc.js';
-import { Application } from '../app.js';
-import { MeshMaterial } from './meshmaterial.js';
-
-class LitMaterial extends MeshMaterial {
-    static FEATURE_DOUBLE_SIDED_LIGHTING = 'lm_doublesided_lighting';
-    static FEATURE_VERTEX_NORMAL = 'lm_vertexnormal';
-    static FEATURE_VERTEX_TANGENT = 'lm_vertextangent';
-    static FEATURE_NORMAL_TEXTURE = 'lm_normaltexture';
-    static FEATURE_NORMAL_TEXCOORD_INDEX = 'lm_normaltexcoord';
-    static FEATURE_NORMAL_TEXTURE_MATRIX = 'lm_normal_texture_matrix';
-    static FEATURE_OBJECT_SPACE_NORMALMAP = 'lm_objectspace_normalmap';
-    _normalTexture;
-    _normalSampler;
-    _normalTexCoordIndex;
-    _normalTexCoordMatrix;
-    _normalScale;
-    constructor(){
-        super();
-        this._normalTexture = null;
-        this._normalSampler = null;
-        this._normalTexCoordIndex = 0;
-        this._normalTexCoordMatrix = null;
-        this._normalScale = 1;
-        this.useFeature(LitMaterial.FEATURE_VERTEX_NORMAL, true);
-    }
-    get normalScale() {
-        return this._normalScale;
-    }
-    set normalScale(val) {
-        if (val !== this._normalScale) {
-            this._normalScale = val;
-            this.optionChanged(false);
-        }
-    }
-    get normalMapMode() {
-        return this.featureUsed(LitMaterial.FEATURE_OBJECT_SPACE_NORMALMAP, RENDER_PASS_TYPE_FORWARD);
-    }
-    set normalMapMode(val) {
-        this.useFeature(LitMaterial.FEATURE_OBJECT_SPACE_NORMALMAP, val, RENDER_PASS_TYPE_FORWARD);
-    }
-    /** true if double sided lighting is used */ get doubleSidedLighting() {
-        return this.featureUsed(LitMaterial.FEATURE_DOUBLE_SIDED_LIGHTING, RENDER_PASS_TYPE_FORWARD);
-    }
-    set doubleSidedLighting(val) {
-        this.useFeature(LitMaterial.FEATURE_DOUBLE_SIDED_LIGHTING, !!val, RENDER_PASS_TYPE_FORWARD);
-    }
-    /** true if vertex normal attribute presents */ get vertexNormal() {
-        return this.featureUsed(LitMaterial.FEATURE_VERTEX_NORMAL, RENDER_PASS_TYPE_FORWARD);
-    }
-    set vertexNormal(val) {
-        this.useFeature(LitMaterial.FEATURE_VERTEX_NORMAL, !!val);
-    }
-    /** true if vertex normal attribute presents */ get vertexTangent() {
-        return this.featureUsed(LitMaterial.FEATURE_VERTEX_TANGENT, RENDER_PASS_TYPE_FORWARD);
-    }
-    set vertexTangent(val) {
-        this.useFeature(LitMaterial.FEATURE_VERTEX_TANGENT, !!val);
-    }
-    /** Normal texture */ get normalTexture() {
-        return this._normalTexture;
-    }
-    set normalTexture(tex) {
-        if (this._normalTexture !== tex) {
-            this.useFeature(LitMaterial.FEATURE_NORMAL_TEXTURE, !!tex);
-            if (tex) {
-                this.useFeature(LitMaterial.FEATURE_NORMAL_TEXCOORD_INDEX, this._normalTexCoordIndex);
-                this.useFeature(LitMaterial.FEATURE_NORMAL_TEXTURE_MATRIX, !!this._normalTexCoordMatrix);
-            }
-            this._normalTexture = tex ?? null;
-            this.optionChanged(false);
-        }
-    }
-    /** Normal texture sampler */ get normalTextureSampler() {
-        return this._normalSampler;
-    }
-    set normalTextureSampler(sampler) {
-        this._normalSampler = sampler ?? null;
-    }
-    /** Normal texture coordinate index */ get normalTexCoordIndex() {
-        return this._normalTexCoordIndex;
-    }
-    set normalTexCoordIndex(val) {
-        if (val !== this._normalTexCoordIndex) {
-            this._normalTexCoordIndex = val;
-            if (this._normalTexture) {
-                this.useFeature(LitMaterial.FEATURE_NORMAL_TEXCOORD_INDEX, this._normalTexCoordIndex);
-            }
-        }
-    }
-    /** Normal texture coordinate transform matrix */ get normalTexMatrix() {
-        return this._normalTexCoordMatrix;
-    }
-    set normalTexMatrix(val) {
-        if (val !== this._normalTexCoordMatrix) {
-            this._normalTexCoordMatrix = val;
-            if (this._normalTexture) {
-                this.useFeature(LitMaterial.FEATURE_NORMAL_TEXTURE_MATRIX, !!this._normalTexCoordMatrix);
-            }
-            this.optionChanged(false);
-        }
-    }
-    /**
-   * Calculates the normalized vector from world coordinates to the viewpoint.
-   *
-   * @param scope - Shader scope
-   * @returns The view vector
-   */ calculateViewVector(scope) {
-        const pb = scope.$builder;
-        return pb.normalize(pb.sub(ShaderFramework.getCameraPosition(scope), ShaderFramework.getWorldPosition(scope).xyz));
-    }
-    /**
-   * Calculate the reflection vector of the view vector with respect to the normal.
-   *
-   * @param scope - Shader scope
-   * @param normal - Surface normal
-   * @param viewVec - The view vector
-   * @returns The reflection vector
-   */ calculateReflectionVector(scope, normal, viewVec) {
-        const pb = scope.$builder;
-        return pb.reflect(pb.neg(viewVec), normal);
-    }
-    /**
-   * Calculate the normal vector for current fragment
-   * @param scope - The shader scope
-   * @param ctx - The drawing context
-   * @returns Normal vector for current fragment
-   */ calculateNormal(scope, ctx) {
-        const pb = scope.$builder;
-        const that = this;
-        const args = [];
-        const params = [];
-        const worldNormal = ShaderFramework.getWorldNormal(scope);
-        const worldTangent = ShaderFramework.getWorldTangent(scope);
-        const worldBinormal = ShaderFramework.getWorldBinormal(scope);
-        if (worldNormal) {
-            params.push(pb.vec3('worldNormal'));
-            args.push(worldNormal);
-            if (worldTangent) {
-                params.push(pb.vec3('worldTangent'), pb.vec3('worldBinormal'));
-                args.push(worldTangent, worldBinormal);
-            }
-        }
-        pb.func('kkCalculateNormal', params, function() {
-            const posW = ShaderFramework.getWorldPosition(this).xyz;
-            this.$l.uv = that.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type) ? scope.$inputs.kkNormalTexCoord ?? pb.vec2(0) : that.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type) ? scope.$inputs.kkAlbedoTexCoord ?? pb.vec2(0) : pb.vec2(0);
-            this.$l.TBN = pb.mat3();
-            if (!worldNormal) {
-                this.$l.uv_dx = pb.dpdx(pb.vec3(this.uv, 0));
-                this.$l.uv_dy = pb.dpdy(pb.vec3(this.uv, 0));
-                this.$if(pb.lessThanEqual(pb.add(pb.length(this.uv_dx), pb.length(this.uv_dy)), 0.000001), function() {
-                    this.uv_dx = pb.vec3(1, 0, 0);
-                    this.uv_dy = pb.vec3(0, 1, 0);
-                });
-                this.$l.t_ = pb.div(pb.sub(pb.mul(pb.dpdx(posW), this.uv_dy.y), pb.mul(pb.dpdy(posW), this.uv_dx.y)), pb.sub(pb.mul(this.uv_dx.x, this.uv_dy.y), pb.mul(this.uv_dx.y, this.uv_dy.x)));
-                this.$l.ng = pb.normalize(pb.cross(pb.dpdx(posW), pb.dpdy(posW)));
-                this.$l.t = pb.normalize(pb.sub(this.t_, pb.mul(this.ng, pb.dot(this.ng, this.t_))));
-                this.$l.b = pb.cross(this.ng, this.t);
-                if (that.doubleSidedLighting) {
-                    this.$if(pb.not(this.$builtins.frontFacing), function() {
-                        this.t = pb.mul(this.t, -1);
-                        this.b = pb.mul(this.b, -1);
-                        this.ng = pb.mul(this.ng, -1);
-                    });
-                }
-                this.TBN = pb.mat3(this.t, this.b, this.ng);
-            } else if (!worldTangent) {
-                this.$l.uv_dx = pb.dpdx(pb.vec3(this.uv, 0));
-                this.$l.uv_dy = pb.dpdy(pb.vec3(this.uv, 0));
-                this.$if(pb.lessThanEqual(pb.add(pb.length(this.uv_dx), pb.length(this.uv_dy)), 0.000001), function() {
-                    this.uv_dx = pb.vec3(1, 0, 0);
-                    this.uv_dy = pb.vec3(0, 1, 0);
-                });
-                this.$l.t_ = pb.div(pb.sub(pb.mul(pb.dpdx(posW), this.uv_dy.y), pb.mul(pb.dpdy(posW), this.uv_dx.y)), pb.sub(pb.mul(this.uv_dx.x, this.uv_dy.y), pb.mul(this.uv_dx.y, this.uv_dy.x)));
-                this.$l.ng = pb.normalize(this.worldNormal);
-                this.$l.t = pb.normalize(pb.sub(this.t_, pb.mul(this.ng, pb.dot(this.ng, this.t_))));
-                this.$l.b = pb.cross(this.ng, this.t);
-                if (that.doubleSidedLighting) {
-                    this.$if(pb.not(this.$builtins.frontFacing), function() {
-                        this.t = pb.mul(this.t, -1);
-                        this.b = pb.mul(this.b, -1);
-                        this.ng = pb.mul(this.ng, -1);
-                    });
-                }
-                this.TBN = pb.mat3(this.t, this.b, this.ng);
-            } else {
-                this.TBN = pb.mat3(pb.normalize(this.worldTangent), pb.normalize(this.worldBinormal), pb.normalize(this.worldNormal));
-            }
-            if (that.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type)) {
-                if (that.normalMapMode === 'object-space') {
-                    const pixel = pb.sub(pb.mul(pb.textureSample(this.kkNormalTexture, this.uv).rgb, 2), pb.vec3(1));
-                    const normalTex = pb.mul(pixel, pb.vec3(pb.vec3(this.kkNormalScale).xx, 1));
-                    this.$return(pb.normalize(normalTex));
-                } else {
-                    const pixel = pb.sub(pb.mul(pb.textureSample(this.kkNormalTexture, this.uv).rgb, 2), pb.vec3(1));
-                    const normalTex = pb.mul(pixel, pb.vec3(pb.vec3(this.kkNormalScale).xx, 1));
-                    this.$return(pb.normalize(pb.mul(this.TBN, normalTex)));
-                }
-            } else {
-                this.$return(this.TBN[2]);
-            }
-        });
-        return pb.getGlobalScope().kkCalculateNormal(...args);
-    }
-    /**
-   * Calculate the normal vector for current fragment
-   * @param scope - The shader scope
-   * @param ctx - The drawing context
-   * @returns Structure that contains normal vector and TBN matrix
-   */ calculateNormalAndTBN(scope, ctx) {
-        const pb = scope.$builder;
-        const NormalStruct = pb.defineStruct([
-            pb.mat3('TBN'),
-            pb.vec3('normal')
-        ]);
-        const that = this;
-        const args = [];
-        const params = [];
-        const worldNormal = ShaderFramework.getWorldNormal(scope);
-        const worldTangent = ShaderFramework.getWorldTangent(scope);
-        const worldBinormal = ShaderFramework.getWorldBinormal(scope);
-        if (worldNormal) {
-            params.push(pb.vec3('worldNormal'));
-            args.push(worldNormal);
-            if (worldTangent) {
-                params.push(pb.vec3('worldTangent'), pb.vec3('worldBinormal'));
-                args.push(worldTangent, worldBinormal);
-            }
-        }
-        pb.func('kkCalculateNormalAndTBN', params, function() {
-            const posW = ShaderFramework.getWorldPosition(this).xyz;
-            this.$l.uv = that.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type) ? scope.$inputs.kkNormalTexCoord ?? pb.vec2(0) : that.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type) ? scope.$inputs.kkAlbedoTexCoord ?? pb.vec2(0) : pb.vec2(0);
-            this.$l.TBN = pb.mat3();
-            if (!worldNormal) {
-                this.$l.uv_dx = pb.dpdx(pb.vec3(this.uv, 0));
-                this.$l.uv_dy = pb.dpdy(pb.vec3(this.uv, 0));
-                this.$if(pb.lessThanEqual(pb.add(pb.length(this.uv_dx), pb.length(this.uv_dy)), 0.000001), function() {
-                    this.uv_dx = pb.vec3(1, 0, 0);
-                    this.uv_dy = pb.vec3(0, 1, 0);
-                });
-                this.$l.t_ = pb.div(pb.sub(pb.mul(pb.dpdx(posW), this.uv_dy.y), pb.mul(pb.dpdy(posW), this.uv_dx.y)), pb.sub(pb.mul(this.uv_dx.x, this.uv_dy.y), pb.mul(this.uv_dx.y, this.uv_dy.x)));
-                this.$l.ng = pb.normalize(pb.cross(pb.dpdx(posW), pb.dpdy(posW)));
-                this.$l.t = pb.normalize(pb.sub(this.t_, pb.mul(this.ng, pb.dot(this.ng, this.t_))));
-                this.$l.b = pb.cross(this.ng, this.t);
-                if (that.doubleSidedLighting) {
-                    this.$if(pb.not(this.$builtins.frontFacing), function() {
-                        this.t = pb.mul(this.t, -1);
-                        this.b = pb.mul(this.b, -1);
-                        this.ng = pb.mul(this.ng, -1);
-                    });
-                }
-                this.TBN = pb.mat3(this.t, this.b, this.ng);
-            } else if (!worldTangent) {
-                this.$l.uv_dx = pb.dpdx(pb.vec3(this.uv, 0));
-                this.$l.uv_dy = pb.dpdy(pb.vec3(this.uv, 0));
-                this.$if(pb.lessThanEqual(pb.add(pb.length(this.uv_dx), pb.length(this.uv_dy)), 0.000001), function() {
-                    this.uv_dx = pb.vec3(1, 0, 0);
-                    this.uv_dy = pb.vec3(0, 1, 0);
-                });
-                this.$l.t_ = pb.div(pb.sub(pb.mul(pb.dpdx(posW), this.uv_dy.y), pb.mul(pb.dpdy(posW), this.uv_dx.y)), pb.sub(pb.mul(this.uv_dx.x, this.uv_dy.y), pb.mul(this.uv_dx.y, this.uv_dy.x)));
-                this.$l.ng = pb.normalize(this.worldNormal);
-                this.$l.t = pb.normalize(pb.sub(this.t_, pb.mul(this.ng, pb.dot(this.ng, this.t_))));
-                this.$l.b = pb.cross(this.ng, this.t);
-                if (that.doubleSidedLighting) {
-                    this.$if(pb.not(this.$builtins.frontFacing), function() {
-                        this.t = pb.mul(this.t, -1);
-                        this.b = pb.mul(this.b, -1);
-                        this.ng = pb.mul(this.ng, -1);
-                    });
-                }
-                this.TBN = pb.mat3(this.t, this.b, this.ng);
-            } else {
-                this.TBN = pb.mat3(pb.normalize(this.worldTangent), pb.normalize(this.worldBinormal), pb.normalize(this.worldNormal));
-            }
-            if (that.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type)) {
-                if (that.normalMapMode === 'object-space') {
-                    const pixel = pb.sub(pb.mul(pb.textureSample(this.kkNormalTexture, this.uv).rgb, 2), pb.vec3(1));
-                    const normalTex = pb.mul(pixel, pb.vec3(pb.vec3(this.kkNormalScale).xx, 1));
-                    this.$return(NormalStruct(this.TBN, pb.normalize(normalTex)));
-                } else {
-                    const pixel = pb.sub(pb.mul(pb.textureSample(this.kkNormalTexture, this.uv).rgb, 2), pb.vec3(1));
-                    const normalTex = pb.mul(pixel, pb.vec3(pb.vec3(this.kkNormalScale).xx, 1));
-                    this.$return(NormalStruct(this.TBN, pb.normalize(pb.mul(this.TBN, normalTex))));
-                }
-            } else {
-                this.$return(NormalStruct(this.TBN, this.TBN[2]));
-            }
-        });
-        return pb.getGlobalScope().kkCalculateNormalAndTBN(...args);
-    }
-    /**
-   * {@inheritDoc MeshMaterial.applyUniformsValues}
-   * @override
-   */ applyUniformValues(bindGroup, ctx) {
-        super.applyUniformValues(bindGroup, ctx);
-        if (this.needFragmentColor(ctx)) {
-            if (this.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type)) {
-                bindGroup.setValue('kkNormalScale', this._normalScale);
-                bindGroup.setTexture('kkNormalTexture', this._normalTexture, this._normalSampler);
-                if (this.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE_MATRIX, ctx.renderPass.type)) {
-                    bindGroup.setValue('kkNormalTextureMatrix', this._normalTexCoordMatrix);
-                }
-            }
-        }
-    }
-    /**
-   * Check if the environment lighting should be calculated.
-   *
-   * @param ctx - Draw context
-   * @returns true Environment lighting should be calculated, otherwise false
-   */ needCalculateEnvLight(ctx) {
-        return ctx.drawEnvLight;
-    }
-    /**
-   * Get irradiance of current environment light
-   *
-   * @param scope - Shader scope
-   * @param normal - Fragment normal vector
-   * @param ctx - The drawing context
-   *
-   * @returns Irradiance of current environment light of type vec3
-   */ getEnvLightIrradiance(scope, normal, ctx) {
-        if (!this.needCalculateEnvLight) {
-            console.warn('getEnvLightIrradiance(): No need to calculate environment lighting');
-            return scope.$builder.vec3(0);
-        }
-        return ctx.env.light.envLight.hasIrradiance() ? scope.$builder.mul(ctx.env.light.envLight.getIrradiance(scope, normal).rgb, ShaderFramework.getEnvLightStrength(scope)) : scope.$builder.vec3(0);
-    }
-    /**
-   * Get Radiance of current environment light
-   *
-   * @param scope - Shader scope
-   * @param reflectVec - The reflection vector
-   * @param roughness - Roughness value of current fragment
-   * @param ctx - The drawing context
-   *
-   * @returns Radiance of current environment light of type vec3
-   */ getEnvLightRadiance(scope, reflectVec, roughness, ctx) {
-        if (!this.needCalculateEnvLight) {
-            console.warn('getEnvLightRadiance(): No need to calculate environment lighting');
-            return scope.$builder.vec3(0);
-        }
-        return ctx.env.light.envLight.hasRadiance() ? scope.$builder.mul(ctx.env.light.envLight.getRadiance(scope, reflectVec, roughness).rgb, ShaderFramework.getEnvLightStrength(scope)) : scope.$builder.vec3(0);
-    }
-    /**
-   * Checks if shadow should be computed
-   * @param ctx - The drawing context
-   * @returns true if shadow should be computed, other wise false
-   */ needCalucateShadow(ctx) {
-        return !!ctx.currentShadowLight;
-    }
-    /**
-   * Calculates shadow of current fragment
-   *
-   * @param scope - Shader scope
-   * @param NoL - NdotL vector
-   * @param ctx - The drawing context
-   * @returns Shadow of current fragment, 1 means no shadow and 0 means full shadowed.
-   */ calculateShadow(scope, NoL, ctx) {
-        const pb = scope.$builder;
-        if (!this.needCalucateShadow(ctx)) {
-            console.warn('calculateShadow(): No need to calculate shadow');
-            return pb.float(1);
-        }
-        const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-        const funcName = 'lm_calculateCSM';
-        pb.func(funcName, [
-            pb.float('NoL')
-        ], function() {
-            if (shadowMapParams.numShadowCascades > 1) {
-                this.$l.shadowCascades = this.global.light.shadowCascades;
-                this.$l.shadowBound = pb.vec4(0, 0, 1, 1);
-                this.$l.linearDepth = nonLinearDepthToLinear(this, this.$builtins.fragCoord.z);
-                this.$l.splitDistances = ShaderFramework.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 (Application.instance.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 = ShaderFramework.calculateShadowSpaceVertex(this, this.cascade);
-                            this.$break();
-                        });
-                    });
-                } else {
-                    this.$l.shadowVertex = ShaderFramework.calculateShadowSpaceVertex(this, 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 = ShaderFramework.getShadowCameraParams(scope).w;
-                this.shadow = pb.mix(this.shadow, 1, pb.smoothStep(pb.mul(this.shadowDistance, 0.8), this.shadowDistance, pb.distance(ShaderFramework.getCameraPosition(this), ShaderFramework.getWorldPosition(this).xyz)));
-                this.$return(this.shadow);
-            } else {
-                this.$l.shadowVertex = ShaderFramework.calculateShadowSpaceVertex(this);
-                const shadowMapParams = ctx.shadowMapInfo.get(ctx.currentShadowLight);
-                this.$l.shadow = shadowMapParams.impl.computeShadow(shadowMapParams, this, this.shadowVertex, this.NoL);
-                this.$l.shadowDistance = ShaderFramework.getShadowCameraParams(scope).w;
-                this.shadow = pb.mix(this.shadow, 1, pb.smoothStep(pb.mul(this.shadowDistance, 0.8), this.shadowDistance, pb.distance(ShaderFramework.getCameraPosition(this), ShaderFramework.getWorldPosition(this).xyz)));
-                this.$return(this.shadow);
-            }
-        });
-        return pb.getGlobalScope()[funcName](NoL);
-    }
-    getClusterIndex(scope, fragCoord) {
-        const pb = scope.$builder;
-        const funcName = 'lm_getClusterIndex';
-        pb.func(funcName, [
-            pb.vec3('fragCoord')
-        ], function() {
-            const clusterParams = ShaderFramework.getClusterParams(this);
-            const countParams = ShaderFramework.getCountParams(this);
-            this.$l.zTile = pb.int(pb.max(pb.add(pb.mul(pb.log2(nonLinearDepthToLinear(this, this.fragCoord.z)), clusterParams.z), clusterParams.w), 0));
-            this.$l.f = pb.vec2(this.fragCoord.x, pb.sub(clusterParams.y, pb.add(this.fragCoord.y, 1)));
-            this.$l.xyTile = pb.ivec2(pb.div(this.f, pb.div(clusterParams.xy, pb.vec2(countParams.xy))));
-            this.$return(pb.ivec3(this.xyTile, this.zTile));
-        });
-        return pb.getGlobalScope()[funcName](fragCoord);
-    }
-    calculatePointLightAttenuation(scope, posRange) {
-        const pb = scope.$builder;
-        const funcName = 'lm_calculatePointLightAttenuation';
-        pb.func(funcName, [
-            pb.vec4('posRange')
-        ], function() {
-            this.$l.dist = pb.distance(this.posRange.xyz, ShaderFramework.getWorldPosition(this).xyz);
-            this.$l.falloff = pb.max(0, pb.sub(1, pb.div(this.dist, this.posRange.w)));
-            this.$return(pb.mul(this.falloff, this.falloff));
-        });
-        return pb.getGlobalScope()[funcName](posRange);
-    }
-    calculateSpotLightAttenuation(scope, posRange, dirCutoff) {
-        const pb = scope.$builder;
-        const funcName = 'lm_calculateSpotLightAttenuation';
-        pb.func(funcName, [
-            pb.vec4('posRange'),
-            pb.vec4('dirCutoff')
-        ], function() {
-            this.$l.dist = pb.distance(this.posRange.xyz, ShaderFramework.getWorldPosition(this).xyz);
-            this.$l.falloff = pb.max(0, pb.sub(1, pb.div(this.dist, this.posRange.w)));
-            this.$l.spotFactor = pb.dot(pb.normalize(pb.sub(ShaderFramework.getWorldPosition(this).xyz, this.posRange.xyz)), this.dirCutoff.xyz);
-            this.spotFactor = pb.smoothStep(this.dirCutoff.w, pb.mix(this.dirCutoff.w, 1, 0.5), this.spotFactor);
-            this.$return(pb.mul(this.spotFactor, this.falloff, this.falloff));
-        });
-        return pb.getGlobalScope()[funcName](posRange, dirCutoff);
-    }
-    calculateLightAttenuation(scope, type, posRange, dirCutoff) {
-        const pb = scope.$builder;
-        return scope.$choice(pb.equal(type, LIGHT_TYPE_DIRECTIONAL), pb.float(1), scope.$choice(pb.equal(type, LIGHT_TYPE_POINT), this.calculatePointLightAttenuation(scope, posRange), this.calculateSpotLightAttenuation(scope, posRange, dirCutoff)));
-    }
-    calculateLightDirection(scope, type, posRange, dirCutoff) {
-        const pb = scope.$builder;
-        return scope.$choice(pb.equal(type, LIGHT_TYPE_DIRECTIONAL), pb.neg(dirCutoff.xyz), pb.normalize(pb.sub(posRange.xyz, ShaderFramework.getWorldPosition(scope).xyz)));
-    }
-    forEachLight(scope, ctx, callback) {
-        const pb = scope.$builder;
-        const that = this;
-        if (ctx.currentShadowLight) {
-            const posRange = scope.global.light.positionAndRange;
-            const dirCutoff = scope.global.light.directionAndCutoff;
-            const colorIntensity = scope.global.light.diffuseAndIntensity;
-            scope.$scope(function() {
-                const lightType = scope.$choice(pb.lessThan(posRange.w, 0), pb.int(LIGHT_TYPE_DIRECTIONAL), scope.$choice(pb.lessThan(dirCutoff.w, 0), pb.int(LIGHT_TYPE_POINT), pb.int(LIGHT_TYPE_SPOT)));
-                callback.call(this, lightType, posRange, dirCutoff, colorIntensity, true);
-            });
-        } else {
-            scope.$scope(function() {
-                const countParams = ShaderFramework.getCountParams(this);
-                this.$l.cluster = that.getClusterIndex(this, this.$builtins.fragCoord.xyz);
-                this.$l.clusterIndex = pb.add(this.cluster.x, pb.mul(this.cluster.y, countParams.x), pb.mul(this.cluster.z, countParams.x, countParams.y));
-                this.$l.texSize = this.global.light.lightIndexTexSize;
-                if (pb.getDevice().type === 'webgl') {
-                    this.$l.texCoordX = pb.div(pb.add(pb.mod(pb.float(this.clusterIndex), pb.float(this.texSize.x)), 0.5), pb.float(this.texSize.x));
-                    this.$l.texCoordY = pb.div(pb.add(pb.float(pb.div(this.clusterIndex, this.texSize.x)), 0.5), pb.float(this.texSize.y));
-                    this.$l.samp = pb.textureSample(ShaderFramework.getClusteredLightIndexTexture(this), pb.vec2(this.texCoordX, this.texCoordY));
-                } else {
-                    this.$l.texCoordX = pb.mod(this.clusterIndex, this.texSize.x);
-                    this.$l.texCoordY = pb.div(this.clusterIndex, this.texSize.x);
-                    this.$l.samp = pb.textureLoad(ShaderFramework.getClusteredLightIndexTexture(this), pb.ivec2(this.texCoordX, this.texCoordY), 0);
-                }
-                if (pb.getDevice().type === 'webgl') {
-                    this.$for(pb.int('i'), 0, 4, function() {
-                        this.$l.k = this.samp.at(this.i);
-                        this.$l.lights = pb.int[2]();
-                        this.$l.lights[0] = pb.int(pb.mod(this.k, 256));
-                        this.$l.lights[1] = pb.int(pb.div(this.k, 256));
-                        this.$for(pb.int('k'), 0, 2, function() {
-                            this.$l.li = this.lights.at(this.k);
-                            this.$if(pb.greaterThan(this.li, 0), function() {
-                                this.$for(pb.int('j'), 1, 256, function() {
-                                    this.$if(pb.equal(this.j, this.li), function() {
-                                        this.$l.positionRange = ShaderFramework.getLightPositionAndRange(this, this.j);
-                                        this.$l.directionCutoff = ShaderFramework.getLightDirectionAndCutoff(this, this.j);
-                                        this.$l.diffuseIntensity = ShaderFramework.getLightColorAndIntensity(this, this.j);
-                                        this.$l.lightType = this.$choice(pb.lessThan(this.positionRange.w, 0), pb.int(LIGHT_TYPE_DIRECTIONAL), this.$choice(pb.lessThan(this.directionCutoff.w, 0), pb.int(LIGHT_TYPE_POINT), pb.int(LIGHT_TYPE_SPOT)));
-                                        this.$scope(function() {
-                                            callback.call(this, this.lightType, this.positionRange, this.directionCutoff, this.diffuseIntensity, false);
-                                        });
-                                        this.$break();
-                                    });
-                                });
-                            });
-                        });
-                    });
-                } else {
-                    this.$for(pb.uint('i'), 0, 4, function() {
-                        this.$for(pb.uint('k'), 0, 4, function() {
-                            this.$l.c = pb.compAnd(pb.sar(this.samp.at(this.i), pb.mul(this.k, 8)), 0xff);
-                            this.$if(pb.greaterThan(this.c, 0), function() {
-                                this.$l.positionRange = ShaderFramework.getLightPositionAndRange(this, this.c);
-                                this.$l.directionCutoff = ShaderFramework.getLightDirectionAndCutoff(this, this.c);
-                                this.$l.diffuseIntensity = ShaderFramework.getLightColorAndIntensity(this, this.c);
-                                this.$l.lightType = this.$choice(pb.lessThan(this.positionRange.w, 0), pb.int(LIGHT_TYPE_DIRECTIONAL), this.$choice(pb.lessThan(this.directionCutoff.w, 0), pb.int(LIGHT_TYPE_POINT), pb.int(LIGHT_TYPE_SPOT)));
-                                this.$scope(function() {
-                                    callback.call(this, this.lightType, this.positionRange, this.directionCutoff, this.diffuseIntensity, false);
-                                });
-                            });
-                        });
-                    });
-                }
-            });
-        }
-    }
-    /**
-   * Vertex shader implementation.
-   *
-   * @param scope - Shader scope
-   * @param ctx - The drawing context
-   */ vertexShader(scope, ctx) {
-        super.vertexShader(scope, ctx);
-        const pb = scope.$builder;
-        if (this.needFragmentColor(ctx)) {
-            if (this.vertexNormal) {
-                scope.$inputs.normal = pb.vec3().attrib('normal');
-            }
-            if (this.vertexTangent) {
-                scope.$inputs.tangent = pb.vec4().attrib('tangent');
-            }
-            if (this.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type)) {
-                const semantic = `texCoord${this.normalTexCoordIndex}`;
-                if (!scope.$getVertexAttrib(semantic)) {
-                    scope.$inputs[semantic] = pb.vec2().attrib(semantic);
-                }
-                if (this.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE_MATRIX, ctx.renderPass.type)) {
-                    scope.$g.kkNormalTextureMatrix = pb.mat4().uniform(2);
-                    scope.$outputs.kkNormalTexCoord = pb.mul(scope.kkNormalTextureMatrix, pb.vec4(scope.$inputs[semantic], 0, 1)).xy;
-                } else {
-                    scope.$outputs.kkNormalTexCoord = scope.$inputs[semantic];
-                }
-            }
-        }
-    }
-    /**
-   * Fragment shader implementation
-   *
-   * @param scope - Shader scope
-   * @param ctx - The drawing context
-   * @returns Calucated fragment color
-   */ fragmentShader(scope, ctx) {
-        super.fragmentShader(scope, ctx);
-        const pb = scope.$builder;
-        if (this.featureUsed(LitMaterial.FEATURE_NORMAL_TEXTURE, ctx.renderPass.type)) {
-            scope.$g.kkNormalTexture = pb.tex2D().uniform(2);
-            scope.$g.kkNormalScale = pb.float().uniform(2);
-        }
-    }
-    /**
-   * {@inheritDoc Material.supportLighting}
-   * @override
-   */ supportLighting() {
-        return true;
-    }
-}
-
-export { LitMaterial };
-//# sourceMappingURL=lit.js.map