@zephyr3d/scene 0.3.0 → 0.3.1

package/dist/asset/assetmanager.js

@@ -189,7 +189,7 @@ import { TGALoader } from './loaders/image/tga_Loader.js';
    * @returns The created model node
    */ async fetchModel(scene, url, options) {
         const sharedModel = await this.fetchModelData(scene, url, options?.mimeType, options?.postProcess);
-        return this.createSceneNode(scene, sharedModel, !options?.disableInstancing);
+        return this.createSceneNode(scene, sharedModel, !!options?.enableInstancing);
     }
     /** @internal */ async loadTextData(url, postProcess) {
         let text = await this._httpRequest.requestText(url);

package/dist/index.d.ts

@@ -634,6 +634,7 @@ declare const XForm_base: (new (...args: any[]) => {
             removed: boolean;
         }[];
     }>;
+    /** Inverse of the world transformation matrix of the xform */
     _internalRemoveEventListener<K_4 extends "nodeattached" | "noderemoved" | "transformchanged">(listenerMap: Partial<{
         [type: string]: {
             handler: _zephyr3d_base.EventListener<{
@@ -1382,6 +1383,7 @@ type CachedBindGroup = {
     buffer: Float32Array;
     dirty: boolean;
 };
+/** @internal */
 declare class InstanceBindGroupAllocator {
     private static _instanceBindGroupLayout;
     _usedBindGroupList: CachedBindGroup[];
@@ -2953,6 +2955,8 @@ interface IMixinVertexColor {
  *
  * @param BaseCls - Base class to mix in
  * @returns Mixed class
+ *
+ * @public
  */
 declare function mixinVertexColor<T extends typeof MeshMaterial>(BaseCls: T): T & (new (...args: any[]) => IMixinVertexColor);
 
@@ -3177,6 +3181,8 @@ type IMixinPBRCommon = {
  * PBR common stuff mixin
  * @param BaseCls - Class to mix in
  * @returns Mixed class
+ *
+ * @public
  */
 declare function mixinPBRCommon<T extends typeof MeshMaterial>(BaseCls: T): T & (new (...args: any[]) => IMixinPBRCommon);
 
@@ -3309,7 +3315,7 @@ declare class TerrainMaterial extends TerrainMaterial_base {
 
 declare const PBRMetallicRoughnessMaterial_base: typeof MeshMaterial & (new (...args: any[]) => IMixinPBRMetallicRoughness) & (new (...args: any[]) => IMixinVertexColor);
 /**
- * PBRMetallicRoughness material class
+ * PBRMetallicRoughnessMaterial class
  * @public
  */
 declare class PBRMetallicRoughnessMaterial extends PBRMetallicRoughnessMaterial_base {
@@ -3331,18 +3337,39 @@ declare class PBRMetallicRoughnessMaterial extends PBRMetallicRoughnessMaterial_
     fragmentShader(scope: PBFunctionScope): void;
 }
 
+/**
+ * Interface for PBRSpecularGlossiness mixin
+ * @public
+ */
 type IMixinPBRSpecularGlossiness = {
     specularFactor: Vector4;
     glossinessFactor: number;
     PBRLight(scope: PBInsideFunctionScope, worldPos: PBShaderExp, normal: PBShaderExp, viewVec: PBShaderExp, albedo: PBShaderExp, TBN?: PBShaderExp): PBShaderExp;
     calculateCommonData(scope: PBInsideFunctionScope, albedo: PBShaderExp, viewVec: PBShaderExp, TBN: PBShaderExp, data: PBShaderExp): void;
 } & IMixinPBRCommon & IMixinLight & TextureMixinInstanceTypes<['specular']>;
+/**
+ * PBRSpecularGlossiness mixin
+ *
+ * @param BaseCls - Base class to mix in
+ * @returns Mixed class
+ *
+ * @public
+ */
 declare function mixinPBRSpecularGlossness<T extends typeof MeshMaterial>(BaseCls: T): T & (new (...args: any[]) => IMixinPBRSpecularGlossiness);
 
 declare const PBRSpecularGlossinessMaterial_base: typeof MeshMaterial & (new (...args: any[]) => IMixinPBRSpecularGlossiness) & (new (...args: any[]) => IMixinVertexColor);
+/**
+ * PBRSpecularGlossinessMaterial class
+ * @public
+ */
 declare class PBRSpecularGlossinessMaterial extends PBRSpecularGlossinessMaterial_base {
+    /** @internal */
     private static FEATURE_VERTEX_NORMAL;
+    /** @internal */
     private static FEATURE_VERTEX_TANGENT;
+    /**
+     * Creates an instance of PBRSpecularGlossinessMaterial class
+     */
     constructor();
     /** true if vertex normal attribute presents */
     get vertexNormal(): boolean;
@@ -3415,7 +3442,7 @@ declare class Mesh extends GraphNode implements BatchDrawable {
      */
     getInstanceId(renderPass: RenderPass): string;
     /**
-     * {@inheritDoc BatchDrawable.getInstanceUniformCount}
+     * {@inheritDoc BatchDrawable.getInstanceUniforms}
      */
     getInstanceUniforms(): Float32Array;
     /**
@@ -4796,7 +4823,7 @@ interface BatchDrawable extends Drawable {
      */
     getInstanceId(renderPass: RenderPass): string;
     /**
-     * Gets the instance uniforms count
+     * Gets the instance uniforms
      */
     getInstanceUniforms(): Float32Array;
     /**
@@ -7489,8 +7516,11 @@ type TextureFetchOptions<T extends BaseTexture> = {
  * @public
  **/
 type ModelFetchOptions = {
+    /** MIME type of the model, if not specified, model type will be determined by file extension */
     mimeType?: string;
-    disableInstancing?: boolean;
+    /** True if the model need to be rendered instanced, the default value is false */
+    enableInstancing?: boolean;
+    /** PostProcess loading function for the mesh  */
     postProcess?: (model: SharedModel) => SharedModel;
 };
 /**

package/dist/material/lightmodel.js

@@ -699,6 +699,7 @@ const TEX_NAME_CLEARCOAT_NORMAL = 'clearcoatNormal';
  * Unlit light model
  * @public
  */ class UnlitLightModel extends LightModel {
+    /** @internal */ static funcNameBRDFUnlit = 'libLM_brdfUnlit';
     /**
    * {@inheritDoc LightModel.supportLighting}
    * @override
@@ -906,10 +907,10 @@ const TEX_NAME_CLEARCOAT_NORMAL = 'clearcoatNormal';
                     ], function() {
                         this.$l.n = this.bits;
                         this.n = pb.compOr(pb.sal(this.n, 16), pb.sar(this.n, 16));
-                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x55555555), 1), pb.sar(pb.compAnd(this.n, 0xaaaaaaaa), 1));
-                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x33333333), 2), pb.sar(pb.compAnd(this.n, 0xcccccccc), 2));
-                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x0f0f0f0f), 4), pb.sar(pb.compAnd(this.n, 0xf0f0f0f0), 4));
-                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x00ff00ff), 8), pb.sar(pb.compAnd(this.n, 0xff00ff00), 8));
+                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x55555555), 1), pb.sar(pb.compAnd(this.n, 0xAAAAAAAA), 1));
+                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x33333333), 2), pb.sar(pb.compAnd(this.n, 0xCCCCCCCC), 2));
+                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x0F0F0F0F), 4), pb.sar(pb.compAnd(this.n, 0xF0F0F0F0), 4));
+                        this.n = pb.compOr(pb.sal(pb.compAnd(this.n, 0x00FF00FF), 8), pb.sar(pb.compAnd(this.n, 0xFF00FF00), 8));
                         this.$return(pb.mul(pb.float(this.n), 2.3283064365386963e-10));
                     });
                     pb.func('hammersley2d', [
@@ -1038,9 +1039,7 @@ const TEX_NAME_CLEARCOAT_NORMAL = 'clearcoatNormal';
         rs.useRasterizerState().setCullMode('none');
         rs.useDepthState().enableTest(false).enableWrite(false);
         const tex = device.createTexture2D('rgba8unorm', size, size, {
-            samplerOptions: {
-                mipFilter: 'none'
-            }
+            noMipmap: true
         });
         tex.name = 'GGXLUT';
         const fb = device.createFrameBuffer([

package/dist/material/lightmodel.js.map

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

package/dist/material/lit.js

@@ -30,10 +30,7 @@ class LitMaterial extends MeshMaterial {
         return this._normalScale;
     }
     set normalScale(val) {
-        if (val !== this._normalScale) {
-            this._normalScale = val;
-            this.optionChanged(false);
-        }
+        this._normalScale = val;
     }
     get normalMapMode() {
         return this.featureUsed(LitMaterial.FEATURE_OBJECT_SPACE_NORMALMAP, RENDER_PASS_TYPE_FORWARD);
@@ -63,15 +60,11 @@ class LitMaterial extends MeshMaterial {
         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);
+        this.useFeature(LitMaterial.FEATURE_NORMAL_TEXTURE, !!tex);
+        if (tex) {
+            this.useFeature(LitMaterial.FEATURE_NORMAL_TEXCOORD_INDEX, this._normalTexCoordIndex);
         }
+        this._normalTexture = tex ?? null;
     }
     /** Normal texture sampler */ get normalTextureSampler() {
         return this._normalSampler;
@@ -99,7 +92,6 @@ class LitMaterial extends MeshMaterial {
             if (this._normalTexture) {
                 this.useFeature(LitMaterial.FEATURE_NORMAL_TEXTURE_MATRIX, !!this._normalTexCoordMatrix);
             }
-            this.optionChanged(false);
         }
     }
     /**
@@ -205,92 +197,6 @@ class LitMaterial extends MeshMaterial {
         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) {

package/dist/material/lit.js.map

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

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

@@ -4,7 +4,14 @@ import { mixinPBRCommon } from '../pbr/common.js';
 import { Vector4 } from '@zephyr3d/base';
 import { mixinLight } from '../lit.js';
 
-function mixinPBRSpecularGlossness(BaseCls) {
+/**
+ * PBRSpecularGlossiness mixin
+ *
+ * @param BaseCls - Base class to mix in
+ * @returns Mixed class
+ *
+ * @public
+ */ function mixinPBRSpecularGlossness(BaseCls) {
     if (BaseCls.pbrSpecularGlossnessMixed) {
         return BaseCls;
     }

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

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

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

@@ -8,6 +8,8 @@ import { ShaderHelper } from '../../shader/helper.js';
  * PBR common stuff mixin
  * @param BaseCls - Class to mix in
  * @returns Mixed class
+ *
+ * @public
  */ function mixinPBRCommon(BaseCls) {
     if (BaseCls.pbrCommonMixed) {
         return BaseCls;

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

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

package/dist/material/mixins/vertexcolor.js

@@ -3,6 +3,8 @@
  *
  * @param BaseCls - Base class to mix in
  * @returns Mixed class
+ *
+ * @public
  */ function mixinVertexColor(BaseCls) {
     if (BaseCls.vertexColorMixed) {
         return BaseCls;

package/dist/material/mixins/vertexcolor.js.map

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

package/dist/material/pbrmr.js

@@ -4,7 +4,7 @@ import { mixinPBRMetallicRoughness } from './mixins/lightmodel/pbrmetallicroughn
 import { ShaderHelper } from './shader/helper.js';
 
 /**
- * PBRMetallicRoughness material class
+ * PBRMetallicRoughnessMaterial class
  * @public
  */ class PBRMetallicRoughnessMaterial extends applyMaterialMixins(MeshMaterial, mixinPBRMetallicRoughness, mixinVertexColor) {
     /** @internal */ static FEATURE_VERTEX_NORMAL = this.defineFeature();

package/dist/material/pbrsg.js

@@ -3,10 +3,15 @@ import { mixinVertexColor } from './mixins/vertexcolor.js';
 import { mixinPBRSpecularGlossness } from './mixins/lightmodel/pbrspecularglossness.js';
 import { ShaderHelper } from './shader/helper.js';
 
-class PBRSpecularGlossinessMaterial extends applyMaterialMixins(MeshMaterial, mixinPBRSpecularGlossness, mixinVertexColor) {
-    static FEATURE_VERTEX_NORMAL = this.defineFeature();
-    static FEATURE_VERTEX_TANGENT = this.defineFeature();
-    constructor(){
+/**
+ * PBRSpecularGlossinessMaterial class
+ * @public
+ */ class PBRSpecularGlossinessMaterial extends applyMaterialMixins(MeshMaterial, mixinPBRSpecularGlossness, mixinVertexColor) {
+    /** @internal */ static FEATURE_VERTEX_NORMAL = this.defineFeature();
+    /** @internal */ static FEATURE_VERTEX_TANGENT = this.defineFeature();
+    /**
+   * Creates an instance of PBRSpecularGlossinessMaterial class
+   */ constructor(){
         super();
         this.useFeature(PBRSpecularGlossinessMaterial.FEATURE_VERTEX_NORMAL, true);
     }

package/dist/material/pbrsg.js.map

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

package/dist/material/terrainlightmodel.js

@@ -187,9 +187,7 @@ class TerrainLightModel extends PBRLightModelMR {
         const device = Application.instance.device;
         if (!this._options) {
             const tex = device.createTexture2D('rgba8unorm', 1, 1, {
-                samplerOptions: {
-                    mipFilter: 'none'
-                }
+                noMipmap: true
             });
             tex.update(new Uint8Array([
                 0,

package/dist/material/terrainlightmodel.js.map

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

package/dist/render/depth_pass.js

@@ -1,8 +1,7 @@
 import { RenderPass } from './renderpass.js';
 import { RENDER_PASS_TYPE_DEPTH_ONLY } from '../values.js';
-import { ShaderFramework } from '../shaders/framework.js';
-import '@zephyr3d/device';
 import { Application } from '../app.js';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 /**
  * Depth render pass
@@ -29,7 +28,7 @@ import { Application } from '../app.js';
         const device = Application.instance.device;
         const bindGroup = this.getGlobalBindGroupInfo(ctx).bindGroup;
         device.setBindGroup(0, bindGroup);
-        ShaderFramework.setCameraUniforms(bindGroup, ctx, true);
+        ShaderHelper.setCameraUniforms(bindGroup, ctx, true);
         ctx.renderPassHash = this.getGlobalBindGroupHash(ctx);
         const reverseWinding = ctx.camera.worldMatrixDet < 0;
         for (const order of Object.keys(renderQueue.items).map((val)=>Number(val)).sort((a, b)=>a - b)){

package/dist/render/depth_pass.js.map

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

package/dist/render/forward.js

@@ -5,14 +5,17 @@ import { Vector4 } from '@zephyr3d/base';
 import { Application } from '../app.js';
 import '../shaders/framework.js';
 import '@zephyr3d/device';
+import '../material/shader/helper.js';
 import { CopyBlitter } from '../blitter/copy.js';
 import '../scene/octree.js';
-import '../material/material.js';
-import './scatteringlut.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
-import '../material/lightmodel.js';
+import '../material/material.js';
+import '../material/grassmaterial.js';
+import '../material/terrainmaterial.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
 import './sky.js';
 import './clipmap.js';
 import { TemporalCache } from './temporalcache.js';

package/dist/render/forward.js.map

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

package/dist/render/forward_pass.js

@@ -1,9 +1,8 @@
 import { RenderPass } from './renderpass.js';
 import { RENDER_PASS_TYPE_FORWARD } from '../values.js';
-import { ShaderFramework } from '../shaders/framework.js';
-import '@zephyr3d/device';
 import { Application } from '../app.js';
 import { Vector4 } from '@zephyr3d/base';
+import { ShaderHelper } from '../material/shader/helper.js';
 
 /**
  * Forward render pass
@@ -61,14 +60,14 @@ import { Vector4 } from '@zephyr3d/base';
         ctx.drawEnvLight = baseLightPass && ctx.env.light.type !== 'none' && (ctx.env.light.envLight.hasRadiance() || ctx.env.light.envLight.hasIrradiance());
         ctx.renderPassHash = this.getGlobalBindGroupHash(ctx);
         const info = this.getGlobalBindGroupInfo(ctx);
-        ShaderFramework.setCameraUniforms(info.bindGroup, ctx, !!device.getFramebuffer());
+        ShaderHelper.setCameraUniforms(info.bindGroup, ctx, !!device.getFramebuffer());
         if (ctx.currentShadowLight) {
-            ShaderFramework.setLightUniformsShadow(info.bindGroup, ctx, lights[0]);
+            ShaderHelper.setLightUniformsShadow(info.bindGroup, ctx, lights[0]);
         } else {
-            ShaderFramework.setLightUniforms(info.bindGroup, ctx, ctx.clusteredLight.clusterParam, ctx.clusteredLight.countParam, ctx.clusteredLight.lightBuffer, ctx.clusteredLight.lightIndexTexture);
+            ShaderHelper.setLightUniforms(info.bindGroup, ctx, ctx.clusteredLight.clusterParam, ctx.clusteredLight.countParam, ctx.clusteredLight.lightBuffer, ctx.clusteredLight.lightIndexTexture);
         }
         if (ctx.applyFog) {
-            ShaderFramework.setFogUniforms(info.bindGroup, ctx.env.sky.mappedFogType, baseLightPass ? ctx.env.sky.fogColor : Vector4.zero(), ctx.env.sky.fogParams, ctx.env.sky.getAerialPerspectiveLUT(ctx));
+            ShaderHelper.setFogUniforms(info.bindGroup, ctx.env.sky.mappedFogType, baseLightPass ? ctx.env.sky.fogColor : Vector4.zero(), ctx.env.sky.fogParams, ctx.env.sky.getAerialPerspectiveLUT(ctx));
         }
         device.setBindGroup(0, info.bindGroup);
         if (blend) {

package/dist/render/forward_pass.js.map

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

package/dist/render/render_queue.js

@@ -13,7 +13,7 @@ import '../material/pbrmr.js';
 import '../material/pbrsg.js';
 import '@zephyr3d/base';
 
-class InstanceBindGroupAllocator {
+/** @internal */ class InstanceBindGroupAllocator {
     static _instanceBindGroupLayout = null;
     _usedBindGroupList = [];
     _freeBindGroupList = [];

package/dist/scene/mesh.js

@@ -63,7 +63,7 @@ import { QUEUE_OPAQUE } from '../values.js';
         return `${this._instanceHash}:${this.worldMatrixDet >= 0}`;
     }
     /**
-   * {@inheritDoc BatchDrawable.getInstanceUniformCount}
+   * {@inheritDoc BatchDrawable.getInstanceUniforms}
    */ getInstanceUniforms() {
         return this.material.$instanceUniforms;
     }

package/dist/scene/octree.js

@@ -520,9 +520,9 @@ var OctreePlacement;
         }
         const dim = this._chunks[level].getDimension();
         const inv_node_size = 1 / this._chunks[level].getNodeSize();
-        let px = Math.floor((center.x + this._rootSize * 0.5) * inv_node_size);
-        let py = Math.floor((center.y + this._rootSize * 0.5) * inv_node_size);
-        let pz = Math.floor((center.z + this._rootSize * 0.5) * inv_node_size);
+        const px = Math.floor((center.x + this._rootSize * 0.5) * inv_node_size);
+        const py = Math.floor((center.y + this._rootSize * 0.5) * inv_node_size);
+        const pz = Math.floor((center.z + this._rootSize * 0.5) * inv_node_size);
         if (px >= dim || py >= dim || pz >= dim) {
             return null;
         }

package/dist/shaders/lighting.js

@@ -38,14 +38,10 @@ import { Application } from '../app.js';
             pb.vec3('attenuation')
         ], function() {
             this.$l.dist = pb.distance(this.lightPositionRange.xyz, ShaderFramework.getWorldPosition(this).xyz);
-            this.$l.a = pb.div(1, pb.add(1, pb.mul(this.dist, this.dist)));
-            this.$l.falloff = pb.mul(this.a, pb.clamp(pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)), 0, 1));
-            //this.$l.t = pb.div(pb.mul(this.dist, 16), this.lightPositionRange.w);
-            //this.$l.falloff = pb.div(1, pb.add(1, pb.mul(this.t, this.t)));
-            //this.$l.falloff = pb.div(1, )   pb.max(0, pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)));
-            //this.falloff = pb.mul(this.falloff, this.falloff);
-            this.$if(pb.greaterThan(this.falloff, 0), function() {
-                lm.directBRDF(this, this.lightDir, pb.mul(this.attenuation, this.falloff));
+            this.$l.falloff = pb.max(0, pb.sub(1, pb.div(this.dist, this.lightPositionRange.w)));
+            this.$l.falloff2 = pb.mul(this.falloff, this.falloff);
+            this.$if(pb.greaterThan(this.falloff2, 0), function() {
+                lm.directBRDF(this, this.lightDir, pb.mul(this.attenuation, this.falloff2));
             });
         });
         pb.getGlobalScope()[funcNameIllumPointLight](...args);
@@ -170,12 +166,12 @@ import { Application } from '../app.js';
             this.lightDir = this.directionCutoff.xyz;
             this.$l.nl = pb.dot(this.surfaceData.normal, this.lightDir);
             this.$l.NdotL = pb.clamp(pb.neg(this.nl), 0, 1);
-            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));
+            this.shadowBound = pb.vec4(0, 0, 1, 1);
+            this.linearDepth = nonLinearDepthToLinear(this, this.$builtins.fragCoord.z);
+            this.splitDistances = ShaderFramework.getCascadeDistances(this);
+            this.comparison = pb.vec4(pb.greaterThan(pb.vec4(this.linearDepth), this.splitDistances));
+            this.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.split = pb.int(pb.dot(this.comparison, this.cascadeFlags));
             this.$l.shadowVertex = pb.vec4();
             if (Application.instance.device.type === 'webgl') {
                 this.$for(pb.int('cascade'), 0, 4, function() {

package/dist/shaders/lighting.js.map

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