@zephyr3d/scene 0.2.0 → 0.3.1

package/dist/index.js

@@ -15,7 +15,7 @@ export { SceneRenderer } from './render/renderer.js';
 export { LightPass } from './render/lightpass.js';
 export { ShadowMapPass } from './render/shadowmap_pass.js';
 export { DepthPass } from './render/depthpass.js';
-export { RenderQueue } from './render/render_queue.js';
+export { InstanceBindGroupAllocator, RenderQueue } from './render/render_queue.js';
 export { SkyRenderer } from './render/sky.js';
 export { Clipmap } from './render/clipmap.js';
 export { EnvConstantAmbient, EnvHemisphericAmbient, EnvIBL, EnvironmentLighting } from './render/envlight.js';
@@ -51,6 +51,7 @@ export { Mesh } from './scene/mesh.js';
 export { Model } from './scene/model.js';
 export { Octree, OctreeNode, OctreeNodeChunk, OctreePlacement } from './scene/octree.js';
 export { SceneNode } from './scene/scene_node.js';
+export { BatchGroup } from './scene/batchgroup.js';
 export { Terrain } from './scene/terrain/terrain.js';
 export { HeightField, HeightfieldBBoxTree } from './scene/terrain/heightfield.js';
 export { TerrainPatch } from './scene/terrain/patch.js';

package/dist/index.js.map

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

package/dist/material/blinn.js

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

package/dist/material/grassmaterial.js

@@ -5,18 +5,18 @@ import { RENDER_PASS_TYPE_LIGHT } from '../values.js';
 import { ShaderHelper } from './shader/helper.js';
 import { mixinFoliage } from './mixins/foliage.js';
 
-/**
- * Terrain grass material
- * @public
+/**
+ * Terrain grass material
+ * @public
  */ class GrassMaterial extends applyMaterialMixins(MeshMaterial, mixinPBRMetallicRoughness, mixinFoliage) {
     /** @internal */ _terrainSize;
     /** @internal */ _terrainNormalMap;
     /** @internal */ _textureSize;
-    /**
-   * Creates an instance of GrassMaterial class
-   * @param terrainSize - terrain size
-   * @param normalMap - normal map
-   * @param grassTexture - grass texture
+    /**
+   * Creates an instance of GrassMaterial class
+   * @param terrainSize - terrain size
+   * @param normalMap - normal map
+   * @param grassTexture - grass texture
    */ constructor(terrainSize, normalMap, grassTexture){
         super();
         this.metallic = 0;
@@ -31,15 +31,15 @@ import { mixinFoliage } from './mixins/foliage.js';
             this._textureSize.setXY(grassTexture.width, grassTexture.height);
         }
     }
-    /**
-   * {@inheritDoc MeshMaterial.isTransparentPass}
-   * @override
+    /**
+   * {@inheritDoc MeshMaterial.isTransparentPass}
+   * @override
    */ isTransparentPass(pass) {
         return false;
     }
-    /**
-   * {@inheritDoc Material.supportLighting}
-   * @override
+    /**
+   * {@inheritDoc Material.supportLighting}
+   * @override
    */ supportLighting() {
         return true;
     }

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/material.js

@@ -4,48 +4,6 @@ import { Application } from '../app.js';
 import { QUEUE_OPAQUE, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_SHADOWMAP, RENDER_PASS_TYPE_DEPTH } from '../values.js';
 import { ShaderHelper } from './shader/helper.js';
 
-class InstanceBindGroupPool {
-    _bindGroups;
-    _frameStamp;
-    constructor(){
-        this._bindGroups = [];
-        this._frameStamp = -1;
-    }
-    apply(hash, index, worldMatrices) {
-        const device = Application.instance.device;
-        const maxSize = device.getDeviceCaps().shaderCaps.maxUniformBufferSize;
-        if (device.frameInfo.frameCounter !== this._frameStamp) {
-            this._frameStamp = device.frameInfo.frameCounter;
-            for (const bindGroup of this._bindGroups){
-                bindGroup.freeSize = maxSize;
-            }
-        }
-        let bindGroupIndex = -1;
-        for(let i = 0; i < this._bindGroups.length; i++){
-            if (this._bindGroups[i].freeSize >= worldMatrices.length * 64) {
-                bindGroupIndex = i;
-                break;
-            }
-        }
-        if (bindGroupIndex < 0) {
-            const program = Material.getProgramByHashIndex(hash, index);
-            const bindGroup = program?.bindGroupLayouts[3] ? device.createBindGroup(program.bindGroupLayouts[3]) : null;
-            this._bindGroups.push({
-                bindGroup: bindGroup,
-                freeSize: maxSize
-            });
-            bindGroupIndex = this._bindGroups.length - 1;
-        }
-        const bindGroup = this._bindGroups[bindGroupIndex];
-        const offset = (maxSize - bindGroup.freeSize) / 64;
-        for (const matrix of worldMatrices){
-            bindGroup.bindGroup.setRawData(ShaderHelper.getWorldMatricesUniformName(), maxSize - bindGroup.freeSize, matrix);
-            bindGroup.freeSize -= 64;
-        }
-        device.setBindGroup(3, bindGroup.bindGroup);
-        return offset;
-    }
-}
 /**
  * Base class for any kind of materials
  *
@@ -66,7 +24,7 @@ class InstanceBindGroupPool {
         inactiveTimeDuration: 30000
     };
     /** @internal */ static _boneMatrixTextureSampler = null;
-    /** @internal */ static _instanceBindGroupPool = new InstanceBindGroupPool();
+    /** @internal */ //private static _instanceBindGroupPool: InstanceBindGroupPool = new InstanceBindGroupPool();
     /** @internal */ static _drawableBindGroupMap = new WeakMap();
     /** @internal */ _numPasses;
     /** @internal */ _hash;
@@ -88,7 +46,7 @@ class InstanceBindGroupPool {
         this._optionTag = 0;
         this._materialBindGroup = null;
     }
-    /** Unique identifier of the material */ get id() {
+    /** Unique identifier of the material */ get instanceId() {
         return this._id;
     }
     get numPasses() {
@@ -125,7 +83,7 @@ class InstanceBindGroupPool {
         return true;
     }
     /** Returns true if this material supports geometry instancing  */ isBatchable() {
-        return true;
+        return false;
     }
     /**
    * Draws a primitive using this material
@@ -146,7 +104,6 @@ class InstanceBindGroupPool {
    * @param ctx - The context of current drawing task
    * @returns true if succeeded, otherwise false
    */ beginDraw(pass, ctx) {
-        const numInstances = ctx.instanceData?.worldMatrices?.length || 1;
         const device = Application.instance.device;
         const programInfo = this.getOrCreateProgram(ctx, pass);
         if (programInfo) {
@@ -159,7 +116,7 @@ class InstanceBindGroupPool {
             }
             this._materialBindGroup = this.applyMaterialBindGroups(ctx, hash, pass);
             if (pass === 0) {
-                if (numInstances > 1) {
+                if (ctx.instanceData) {
                     this.applyInstanceBindGroups(ctx, hash);
                 } else {
                     this.applyDrawableBindGroups(ctx, hash);
@@ -203,7 +160,7 @@ class InstanceBindGroupPool {
    */ getOrCreateProgram(ctx, pass) {
         const programMap = Material._programMap;
         const renderPassType = ctx.renderPass.type;
-        const hash = `${this.getHash(renderPassType, pass)}:${!!ctx.target.getBoneMatrices()}:${Number(!!(ctx.instanceData?.worldMatrices.length > 1))}:${ctx.renderPassHash}`;
+        const hash = `${this.getHash(renderPassType, pass)}:${!!ctx.target.getBoneMatrices()}:${Number(!!ctx.instanceData)}:${ctx.renderPassHash}`;
         let programInfo = programMap[hash];
         if (!programInfo || programInfo.programs[renderPassType] === undefined) {
             const program = this.createProgram(ctx, pass) ?? null;
@@ -363,11 +320,20 @@ class InstanceBindGroupPool {
         return drawableBindGroup;
     }
     /** @internal */ applyInstanceBindGroups(ctx, hash) {
-        const index = ctx.renderPass.type;
-        const offset = Material._instanceBindGroupPool.apply(hash, index, ctx.instanceData.worldMatrices);
-        const bindGroup = this.getDrawableBindGroup(ctx, hash).bindGroup?.[index];
+        if (ctx.instanceData) {
+            if (ctx.instanceData.bindGroup.dirty) {
+                ctx.instanceData.bindGroup.bindGroup.setRawData(ShaderHelper.getWorldMatricesUniformName(), 0, ctx.instanceData.bindGroup.buffer, 0, ctx.instanceData.currentSize * 4);
+                ctx.instanceData.bindGroup.dirty = false;
+            }
+            Application.instance.device.setBindGroup(3, ctx.instanceData.bindGroup.bindGroup ?? null);
+        } else {
+            Application.instance.device.setBindGroup(3, null);
+        }
+        const bindGroup = this.getDrawableBindGroup(ctx, hash).bindGroup?.[ctx.renderPass.type];
         if (bindGroup) {
-            bindGroup.setValue(ShaderHelper.getInstanceBufferOffsetUniformName(), offset);
+            if (ctx.instanceData) {
+                bindGroup.setValue(ShaderHelper.getInstanceBufferStrideUniformName(), ctx.instanceData.stride);
+            }
             Application.instance.device.setBindGroup(1, bindGroup);
         } else {
             Application.instance.device.setBindGroup(1, null);
@@ -460,8 +426,8 @@ class InstanceBindGroupPool {
    */ drawPrimitive(pass, primitive, ctx, numInstances) {
         if (numInstances > 0) {
             primitive.drawInstanced(numInstances);
-        } else if (ctx.instanceData?.worldMatrices.length > 1) {
-            primitive.drawInstanced(ctx.instanceData.worldMatrices.length);
+        } else if (ctx.instanceData) {
+            primitive.drawInstanced(ctx.instanceData.currentSize / ctx.instanceData.stride);
         } else {
             primitive.draw();
         }
@@ -493,6 +459,18 @@ class InstanceBindGroupPool {
    */ _createHash(renderPassType) {
         return '';
     }
+    /**
+   * True if this is a material instance
+   * @internal
+   **/ get $isInstance() {
+        return false;
+    }
+    /**
+   * Returns the instance uniforms if this is a material instance
+   * @internal
+   **/ get $instanceUniforms() {
+        return null;
+    }
 }
 
 export { Material };

package/dist/material/material.js.map

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