@zephyr3d/scene 0.1.0

package/dist/material/lightmodel.js.map

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

package/dist/material/lit.js

@@ -0,0 +1,578 @@
+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

package/dist/material/lit.js.map

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