@zephyr3d/scene 0.1.2 → 0.3.0

package/dist/material/mixins/albedocolor.js

@@ -1,126 +1,59 @@
 import { Vector4 } from '@zephyr3d/base';
+import { applyMaterialMixins } from '../meshmaterial.js';
+import { mixinTextureProps } from './texture.js';
 
-function mixinAlbedoColor(BaseCls) {
+/**
+ * Albedo color mixin
+ * @param BaseCls - Class to mix in
+ * @returns Mixed class
+ *
+ * @public
+ */ function mixinAlbedoColor(BaseCls) {
     if (BaseCls.albedoColorMixed) {
         return BaseCls;
     }
-    const FEATURE_ALBEDO_MAP = 'z-feature-albedo-map';
-    const FEATURE_ALBEDO_TEXCOORD_INDEX = 'z-feature-albedo-texcoord-index';
-    const FEATURE_ALBEDO_TEXCOORD_MATRIX = 'z-feature-albedo-texcoord-matrix';
-    return class extends BaseCls {
+    const S = applyMaterialMixins(BaseCls, mixinTextureProps('albedo'));
+    const ALBEDO_COLOR_UNIFORM = S.defineInstanceUniform('albedoColor', 'vec4');
+    return class extends S {
         static albedoColorMixed = true;
         _albedoColor;
-        _albedoTexture;
-        _albedoSampler;
-        _albedoTexCoordIndex;
-        _albedoTexCoordMatrix;
-        constructor(...args){
-            super(...args);
+        constructor(){
+            super();
             this._albedoColor = Vector4.one();
-            this._albedoTexture = null;
-            this._albedoSampler = null;
-            this._albedoTexCoordIndex = 0;
-            this._albedoTexCoordMatrix = null;
         }
         /** Albedo color */ get albedoColor() {
             return this._albedoColor;
         }
         set albedoColor(val) {
             this._albedoColor.set(val);
-            this.optionChanged(false);
+            this.uniformChanged();
         }
-        /** Albedo texture coordinate index */ get albedoTexCoordIndex() {
-            return this._albedoTexCoordIndex;
+        getUniformValueAlbedoColor(scope) {
+            return this.drawContext.instanceData ? this.getInstancedUniform(scope, ALBEDO_COLOR_UNIFORM) : scope.zAlbedo;
         }
-        set albedoTexCoordIndex(val) {
-            if (val !== this._albedoTexCoordIndex) {
-                this._albedoTexCoordIndex = val;
-                if (this._albedoTexture) {
-                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_INDEX, this._albedoTexCoordIndex);
-                }
-            }
-        }
-        /** Albedo texture */ get albedoTexture() {
-            return this._albedoTexture;
-        }
-        set albedoTexture(tex) {
-            if (this._albedoTexture !== tex) {
-                this.useFeature(FEATURE_ALBEDO_MAP, !!tex);
-                if (tex) {
-                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_INDEX, this._albedoTexCoordIndex);
-                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_MATRIX, !!this._albedoTexCoordMatrix);
-                }
-                this._albedoTexture = tex ?? null;
-                this.optionChanged(false);
-            }
-        }
-        /** Albedo texture sampler */ get albedoTextureSampler() {
-            return this._albedoSampler;
-        }
-        set albedoTextureSampler(sampler) {
-            this._albedoSampler = sampler ?? null;
-        }
-        /** Albedo texture coordinate transform matrix */ get albedoTexMatrix() {
-            return this._albedoTexCoordMatrix;
-        }
-        set albedoTexMatrix(val) {
-            if (val !== this._albedoTexCoordMatrix) {
-                this._albedoTexCoordMatrix = val;
-                if (this._albedoTexture) {
-                    this.useFeature(FEATURE_ALBEDO_TEXCOORD_MATRIX, !!this._albedoTexCoordMatrix);
-                }
-                this.optionChanged(false);
-            }
-        }
-        calculateAlbedoColor(scope, ctx) {
-            if (!this.needFragmentColor(ctx)) {
-                throw new Error('mixinAlbedoColor.calculateAlbedoColor(): No need to calculate albedo color, make sure needFragmentColor() returns true');
-            }
+        calculateAlbedoColor(scope, uv) {
             const pb = scope.$builder;
-            let color = scope.kkAlbedo;
-            if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
-                color = pb.mul(color, pb.textureSample(scope.kkAlbedoTex, scope.$inputs.kkAlbedoTexCoord));
+            if (!this.needFragmentColor()) {
+                console.warn('mixinAlbedoColor.calculateAlbedoColor(): No need to calculate albedo color, make sure needFragmentColor() returns true');
+                return pb.vec4(1);
             }
-            return color;
-        }
-        vertexShader(scope, ctx) {
-            super.vertexShader(scope, ctx);
-            if (this.needFragmentColor(ctx)) {
-                const pb = scope.$builder;
-                if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
-                    const semantic = `texCoord${this.albedoTexCoordIndex}`;
-                    if (!scope.$getVertexAttrib(semantic)) {
-                        scope.$inputs[semantic] = pb.vec2().attrib(semantic);
-                    }
-                    if (this.featureUsed(FEATURE_ALBEDO_TEXCOORD_MATRIX, ctx.renderPass.type)) {
-                        scope.$g.kkAlbedoTextureMatrix = pb.mat4().uniform(2);
-                        scope.$outputs.kkAlbedoTexCoord = pb.mul(scope.kkAlbedoTextureMatrix, pb.vec4(scope.$inputs[semantic], 0, 1)).xy;
-                    } else {
-                        scope.$outputs.kkAlbedoTexCoord = scope.$inputs[semantic];
-                    }
-                }
+            let color = this.getUniformValueAlbedoColor(scope);
+            if (this.albedoTexture) {
+                color = pb.mul(color, this.sampleAlbedoTexture(scope, uv));
             }
+            return color;
         }
-        fragmentShader(scope, ctx) {
-            super.fragmentShader(scope, ctx);
-            if (this.needFragmentColor(ctx)) {
+        fragmentShader(scope) {
+            super.fragmentShader(scope);
+            if (this.needFragmentColor()) {
                 const pb = scope.$builder;
-                scope.$g.kkAlbedo = pb.vec4().uniform(2);
-                if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
-                    scope.$g.kkAlbedoTex = pb.tex2D().uniform(2);
-                }
+                scope.zAlbedo = pb.vec4().uniform(2);
             }
         }
-        applyUniformValues(bindGroup, ctx) {
-            super.applyUniformValues(bindGroup, ctx);
+        applyUniformValues(bindGroup, ctx, pass) {
+            super.applyUniformValues(bindGroup, ctx, pass);
             if (this.needFragmentColor(ctx)) {
-                bindGroup.setValue('kkAlbedo', this._albedoColor);
-                if (this.featureUsed(FEATURE_ALBEDO_MAP, ctx.renderPass.type)) {
-                    bindGroup.setTexture('kkAlbedoTex', this._albedoTexture, this._albedoSampler);
-                    if (this.featureUsed(FEATURE_ALBEDO_TEXCOORD_MATRIX, ctx.renderPass.type)) {
-                        bindGroup.setValue('kkAlbedoTextureMatrix', this._albedoTexCoordMatrix);
-                    }
-                }
+                bindGroup.setValue('zAlbedo', this._albedoColor);
             }
         }
     };

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

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

package/dist/material/mixins/foliage.js

@@ -0,0 +1,47 @@
+/**
+ * Foliage mixin
+ *
+ * @param BaseCls - Class to mix in
+ * @returns Mixed class
+ *
+ * @public
+ */ function mixinFoliage(BaseCls) {
+    if (BaseCls.foliageMixed) {
+        return BaseCls;
+    }
+    return class extends BaseCls {
+        static foliageMixed = true;
+        constructor(...args){
+            super(...args);
+            this.cullMode = 'none';
+        }
+        calculateFoliageAlbedo(scope, albedoColor, texelCoord) {
+            const pb = scope.$builder;
+            const that = this;
+            const funcNameCalcMipLevel = 'Z_CalcFoliageMipLevel';
+            pb.func(funcNameCalcMipLevel, [
+                pb.vec2('coord')
+            ], function() {
+                this.$l.dx = pb.dpdx(this.coord);
+                this.$l.dy = pb.dpdy(this.coord);
+                this.$l.deltaMaxSqr = pb.max(pb.dot(this.dx, this.dx), pb.dot(this.dy, this.dy));
+                this.$return(pb.max(0, pb.mul(pb.log2(this.deltaMaxSqr), 0.5)));
+            });
+            const funcNameCalcFoliageAlbedo = 'Z_calcFoliageAlbedo';
+            pb.func(funcNameCalcFoliageAlbedo, [
+                pb.vec4('albedo'),
+                pb.vec2('coord')
+            ], function() {
+                this.$l.a = pb.mul(this.albedo.a, pb.add(1, pb.mul(pb.max(0, scope[funcNameCalcMipLevel](this.coord)), 0.25)));
+                if (that.alphaToCoverage) {
+                    this.a = pb.add(pb.div(pb.sub(this.a, 0.4), pb.max(pb.fwidth(this.albedo.a), 0.0001)), 0.5);
+                }
+                this.$return(pb.vec4(this.albedo.rgb, this.a));
+            });
+            return pb.getGlobalScope()[funcNameCalcFoliageAlbedo](albedoColor, texelCoord);
+        }
+    };
+}
+
+export { mixinFoliage };
+//# sourceMappingURL=foliage.js.map

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

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

package/dist/material/mixins/ggxlut.js

@@ -0,0 +1,213 @@
+import { Application } from '../../app.js';
+
+const ggxLut = new Map();
+function getGGXLUT(size) {
+    let lut = ggxLut.get(size);
+    if (!lut) {
+        lut = createGGXLUT(size);
+        ggxLut.set(size, lut);
+    }
+    return lut;
+}
+function createGGXLUT(size) {
+    const device = Application.instance.device;
+    const program = device.buildRenderProgram({
+        vertex (pb) {
+            this.$inputs.pos = pb.vec2().attrib('position');
+            this.$outputs.uv = pb.vec2();
+            pb.main(function() {
+                this.$builtins.position = pb.vec4(this.$inputs.pos, 0, 1);
+                this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                if (device.type === 'webgpu') {
+                    this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                }
+            });
+        },
+        fragment (pb) {
+            this.$outputs.color = pb.vec4();
+            const SAMPLE_COUNT = 1024;
+            if (device.type === 'webgl') {
+                pb.func('radicalInverse_VdC', [
+                    pb.int('bits')
+                ], function() {
+                    this.$l.rand = pb.float(0);
+                    this.$l.denom = pb.float(1);
+                    this.$l.invBase = pb.float(0.5);
+                    this.$l.n = this.bits;
+                    this.$for(pb.int('i'), 0, 32, function() {
+                        this.denom = pb.mul(this.denom, 2);
+                        this.rand = pb.add(this.rand, pb.div(pb.mod(pb.float(this.n), 2), this.denom));
+                        this.n = pb.div(this.n, 2);
+                        this.$if(pb.equal(this.n, 0), function() {
+                            this.$break();
+                        });
+                    });
+                    this.$return(this.rand);
+                });
+                pb.func('hammersley2d', [
+                    pb.int('i'),
+                    pb.int('N')
+                ], function() {
+                    this.$return(pb.vec2(pb.div(pb.float(this.i), pb.float(this.N)), this.radicalInverse_VdC(this.i)));
+                });
+            } else {
+                pb.func('radicalInverse_VdC', [
+                    pb.uint('bits')
+                ], 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.$return(pb.mul(pb.float(this.n), 2.3283064365386963e-10));
+                });
+                pb.func('hammersley2d', [
+                    pb.int('i'),
+                    pb.int('N')
+                ], function() {
+                    this.$return(pb.vec2(pb.div(pb.float(this.i), pb.float(this.N)), this.radicalInverse_VdC(pb.uint(this.i))));
+                });
+            }
+            pb.func('generateTBN', [
+                pb.vec3('normal')
+            ], function() {
+                this.$l.bitangent = pb.vec3(0, 1, 0);
+                this.$l.NoU = this.normal.y;
+                this.$l.epsl = 0.0000001;
+                this.$if(pb.lessThanEqual(pb.sub(1, pb.abs(this.normal.y)), this.epsl), function() {
+                    this.bitangent = this.$choice(pb.greaterThan(this.normal.y, 0), pb.vec3(0, 0, 1), pb.vec3(0, 0, -1));
+                });
+                this.$l.tangent = pb.normalize(pb.cross(this.bitangent, this.normal));
+                this.bitangent = pb.cross(this.normal, this.tangent);
+                this.$return(pb.mat3(this.tangent, this.bitangent, this.normal));
+            });
+            pb.func('D_Charlie', [
+                pb.float('sheenRoughness'),
+                pb.float('NdotH')
+            ], function() {
+                this.$l.roughness = pb.max(this.sheenRoughness, 0.000001);
+                this.$l.invR = pb.div(1, this.roughness);
+                this.$l.cos2h = pb.mul(this.NdotH, this.NdotH);
+                this.$l.sin2h = pb.sub(1, this.cos2h);
+                this.$return(pb.div(pb.mul(pb.add(this.invR, 2), pb.pow(this.sin2h, pb.mul(this.invR, 0.5))), Math.PI * 2));
+            });
+            pb.func('smithGGXCorrelated', [
+                pb.float('NoV'),
+                pb.float('NoL'),
+                pb.float('roughness')
+            ], function() {
+                this.$l.a2 = pb.mul(this.roughness, this.roughness, this.roughness, this.roughness);
+                this.$l.GGXV = pb.mul(this.NoL, pb.sqrt(pb.add(pb.mul(this.NoV, this.NoV, pb.sub(1, this.a2)), this.a2)));
+                this.$l.GGXL = pb.mul(this.NoV, pb.sqrt(pb.add(pb.mul(this.NoL, this.NoL, pb.sub(1, this.a2)), this.a2)));
+                this.$return(pb.div(0.5, pb.add(this.GGXV, this.GGXL)));
+            });
+            pb.func('V_Ashikhmin', [
+                pb.float('NdotL'),
+                pb.float('NdotV')
+            ], function() {
+                this.$return(pb.clamp(pb.div(1, pb.mul(pb.sub(pb.add(this.NdotL, this.NdotV), pb.mul(this.NdotL, this.NdotV)), 4)), 0, 1));
+            });
+            pb.func('importanceSample', [
+                pb.vec2('xi'),
+                pb.vec3('normal'),
+                pb.float('roughness'),
+                pb.vec3('ggx').out(),
+                pb.vec3('charlie').out()
+            ], function() {
+                this.$l.alphaRoughness = pb.mul(this.roughness, this.roughness);
+                this.$l.cosTheta = pb.clamp(pb.sqrt(pb.div(pb.sub(1, this.xi.y), pb.add(1, pb.mul(pb.sub(pb.mul(this.alphaRoughness, this.alphaRoughness), 1), this.xi.y)))), 0, 1);
+                this.$l.sinTheta = pb.sqrt(pb.sub(1, pb.mul(this.cosTheta, this.cosTheta)));
+                this.$l.phi = pb.mul(this.xi.x, Math.PI * 2);
+                this.$l.TBN = this.generateTBN(this.normal);
+                this.$l.localSpaceDir = pb.normalize(pb.vec3(pb.mul(this.sinTheta, pb.cos(this.phi)), pb.mul(this.sinTheta, pb.sin(this.phi)), this.cosTheta));
+                this.ggx = pb.mul(this.TBN, this.localSpaceDir);
+                this.sinTheta = pb.pow(this.xi.y, pb.div(this.alphaRoughness, pb.add(pb.mul(this.alphaRoughness, 2), 1)));
+                this.cosTheta = pb.sqrt(pb.sub(1, pb.mul(this.sinTheta, this.sinTheta)));
+                this.localSpaceDir = pb.normalize(pb.vec3(pb.mul(this.sinTheta, pb.cos(this.phi)), pb.mul(this.sinTheta, pb.sin(this.phi)), this.cosTheta));
+                this.charlie = pb.mul(this.TBN, this.localSpaceDir);
+            });
+            pb.func('integrateBRDF', [
+                pb.float('NoV'),
+                pb.float('roughness')
+            ], function() {
+                this.$l.V = pb.vec3(pb.sub(1, pb.mul(this.NoV, this.NoV)), 0, this.NoV);
+                this.$l.a = pb.float(0);
+                this.$l.b = pb.float(0);
+                this.$l.c = pb.float(0);
+                this.$l.n = pb.vec3(0, 0, 1);
+                this.$for(pb.int('i'), 0, SAMPLE_COUNT, function() {
+                    this.$l.xi = this.hammersley2d(this.i, SAMPLE_COUNT);
+                    this.$l.ggxSample = pb.vec3();
+                    this.$l.charlieSample = pb.vec3();
+                    this.importanceSample(this.xi, this.n, this.roughness, this.ggxSample, this.charlieSample);
+                    this.$l.ggxL = pb.normalize(pb.reflect(pb.neg(this.V), this.ggxSample.xyz));
+                    this.$l.ggxNoL = pb.clamp(this.ggxL.z, 0, 1);
+                    this.$l.ggxNoH = pb.clamp(this.ggxSample.z, 0, 1);
+                    this.$l.ggxVoH = pb.clamp(pb.dot(this.V, this.ggxSample.xyz), 0, 1);
+                    this.$l.charlieL = pb.normalize(pb.reflect(pb.neg(this.V), this.charlieSample.xyz));
+                    this.$l.charlieNoL = pb.clamp(this.charlieL.z, 0, 1);
+                    this.$l.charlieNoH = pb.clamp(this.charlieSample.z, 0, 1);
+                    this.$l.charlieVoH = pb.clamp(pb.dot(this.V, this.charlieSample.xyz), 0, 1);
+                    this.$if(pb.greaterThan(this.ggxNoL, 0), function() {
+                        this.$l.pdf = pb.div(pb.mul(this.smithGGXCorrelated(this.NoV, this.ggxNoL, this.roughness), this.ggxVoH, this.ggxNoL), this.ggxNoH);
+                        this.$l.Fc = pb.pow(pb.sub(1, this.ggxVoH), 5);
+                        this.a = pb.add(this.a, pb.mul(pb.sub(1, this.Fc), this.pdf));
+                        this.b = pb.add(this.b, pb.mul(this.Fc, this.pdf));
+                    });
+                    this.$if(pb.greaterThan(this.charlieNoL, 0), function() {
+                        this.$l.sheenDistribution = this.D_Charlie(this.roughness, this.charlieNoH);
+                        this.$l.sheenVis = this.V_Ashikhmin(this.charlieNoL, this.NoV);
+                        this.c = pb.add(this.c, pb.mul(this.sheenVis, this.sheenDistribution, this.charlieNoL, this.charlieVoH));
+                    });
+                });
+                this.$return(pb.div(pb.vec3(pb.mul(this.a, 4), pb.mul(this.b, 4), pb.mul(this.c, 8 * Math.PI)), SAMPLE_COUNT));
+            });
+            pb.main(function() {
+                this.$outputs.color = pb.vec4(this.integrateBRDF(this.$inputs.uv.x, this.$inputs.uv.y), 1);
+            });
+        }
+    });
+    const vertexLayout = device.createVertexLayout({
+        vertexBuffers: [
+            {
+                buffer: device.createVertexBuffer('position_f32x2', new Float32Array([
+                    -1,
+                    -1,
+                    1,
+                    -1,
+                    -1,
+                    1,
+                    1,
+                    1
+                ]))
+            }
+        ]
+    });
+    const rs = device.createRenderStateSet();
+    rs.useRasterizerState().setCullMode('none');
+    rs.useDepthState().enableTest(false).enableWrite(false);
+    const tex = device.createTexture2D('rgba8unorm', size, size, {
+        samplerOptions: {
+            mipFilter: 'none'
+        }
+    });
+    tex.name = 'GGXLUT';
+    const fb = device.createFrameBuffer([
+        tex
+    ], null);
+    device.pushDeviceStates();
+    device.setProgram(program);
+    device.setVertexLayout(vertexLayout);
+    device.setRenderStates(rs);
+    device.setFramebuffer(fb);
+    device.draw('triangle-strip', 0, 4);
+    device.popDeviceStates();
+    fb.dispose();
+    vertexLayout.dispose();
+    program.dispose();
+    return tex;
+}
+
+export { getGGXLUT };
+//# sourceMappingURL=ggxlut.js.map

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

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

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

@@ -0,0 +1,89 @@
+import { applyMaterialMixins } from '../../meshmaterial.js';
+import { mixinLight } from '../lit.js';
+
+/**
+ * Blinn-phong lighting model mixin
+ * @param BaseCls - Class to mix in
+ * @returns Mixed class
+ * @public
+ */ function mixinBlinnPhong(BaseCls) {
+    if (BaseCls.blinnPhongMixed) {
+        return BaseCls;
+    }
+    const S = applyMaterialMixins(BaseCls, mixinLight);
+    return class extends S {
+        static blinnPhongMixed = true;
+        _shininess;
+        constructor(){
+            super();
+            this._shininess = 32;
+        }
+        /** Shininess */ get shininess() {
+            return this._shininess;
+        }
+        set shininess(val) {
+            if (val !== this._shininess) {
+                this._shininess = val;
+                this.uniformChanged();
+            }
+        }
+        fragmentShader(scope) {
+            super.fragmentShader(scope);
+            const pb = scope.$builder;
+            if (this.needFragmentColor()) {
+                scope.zShininess = pb.float().uniform(2);
+            }
+        }
+        applyUniformValues(bindGroup, ctx, pass) {
+            super.applyUniformValues(bindGroup, ctx, pass);
+            if (this.needFragmentColor()) {
+                bindGroup.setValue('zShininess', this._shininess);
+            }
+        }
+        blinnPhongLight(scope, worldPos, normal, viewVec, albedo) {
+            const pb = scope.$builder;
+            const funcName = 'Z_blinnPhongLight';
+            const that = this;
+            pb.func(funcName, [
+                pb.vec3('worldPos'),
+                pb.vec3('normal'),
+                pb.vec3('viewVec'),
+                pb.vec4('albedo')
+            ], function() {
+                if (!that.needFragmentColor()) {
+                    this.$return(this.albedo.rgb);
+                } else {
+                    if (that.needCalculateEnvLight()) {
+                        this.$l.diffuseColor = that.getEnvLightIrradiance(this, this.normal);
+                    } else {
+                        this.$l.diffuseColor = pb.vec3(0);
+                    }
+                    this.$l.specularColor = pb.vec3(0);
+                    that.forEachLight(this, function(type, posRange, dirCutoff, colorIntensity, shadow) {
+                        this.$l.lightAtten = that.calculateLightAttenuation(this, type, this.worldPos, posRange, dirCutoff);
+                        this.$l.lightDir = that.calculateLightDirection(this, type, this.worldPos, posRange, dirCutoff);
+                        this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);
+                        this.$l.halfVec = pb.normalize(pb.add(this.viewVec, this.lightDir));
+                        this.$l.NoH = pb.clamp(pb.dot(this.normal, this.halfVec), 0, 1);
+                        this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);
+                        this.$l.diffuse = pb.mul(this.lightColor, this.NoL);
+                        this.$l.specular = pb.mul(this.lightColor, pb.pow(this.NoH, this.zShininess));
+                        if (shadow) {
+                            this.$l.shadow = pb.vec3(that.calculateShadow(this, this.worldPos, this.NoL));
+                            this.diffuse = pb.mul(this.diffuse, this.shadow);
+                            this.specular = pb.mul(this.specular, this.shadow);
+                        }
+                        this.diffuseColor = pb.add(this.diffuseColor, this.diffuse);
+                        this.specularColor = pb.add(this.specularColor, this.specular);
+                    });
+                    this.$l.litColor = pb.add(pb.mul(this.albedo.rgb, this.diffuseColor), this.specularColor);
+                    this.$return(this.litColor);
+                }
+            });
+            return pb.getGlobalScope()[funcName](worldPos, normal, viewVec, albedo);
+        }
+    };
+}
+
+export { mixinBlinnPhong };
+//# sourceMappingURL=blinnphong.js.map

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

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

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

@@ -0,0 +1,58 @@
+import { applyMaterialMixins } from '../../meshmaterial.js';
+import { mixinLight } from '../lit.js';
+
+/**
+ * Lambert lighting model mixin
+ * @param BaseCls - Class to mix in
+ * @returns Mixed class
+ * @public
+ */ function mixinLambert(BaseCls) {
+    if (BaseCls.lambertMixed) {
+        return BaseCls;
+    }
+    const S = applyMaterialMixins(BaseCls, mixinLight);
+    return class extends S {
+        static lambertMixed = true;
+        constructor(){
+            super();
+        }
+        lambertLight(scope, worldPos, normal, albedo) {
+            const pb = scope.$builder;
+            const funcName = 'Z_lambertLight';
+            const that = this;
+            pb.func(funcName, [
+                pb.vec3('worldPos'),
+                pb.vec3('normal'),
+                pb.vec4('albedo')
+            ], function() {
+                if (!that.needFragmentColor()) {
+                    this.$return(this.albedo.rgb);
+                } else {
+                    if (that.needCalculateEnvLight()) {
+                        this.$l.diffuseColor = that.getEnvLightIrradiance(this, this.normal);
+                    } else {
+                        this.$l.diffuseColor = pb.vec3(0);
+                    }
+                    that.forEachLight(this, function(type, posRange, dirCutoff, colorIntensity, shadow) {
+                        this.$l.lightAtten = that.calculateLightAttenuation(this, type, this.worldPos, posRange, dirCutoff);
+                        this.$l.lightDir = that.calculateLightDirection(this, type, this.worldPos, posRange, dirCutoff);
+                        this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);
+                        this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);
+                        this.$l.diffuse = pb.mul(this.lightColor, this.NoL);
+                        if (shadow) {
+                            this.$l.shadow = pb.vec3(that.calculateShadow(this, this.worldPos, this.NoL));
+                            this.diffuse = pb.mul(this.diffuse, this.shadow);
+                        }
+                        this.diffuseColor = pb.add(this.diffuseColor, this.diffuse);
+                    });
+                    this.$l.litColor = pb.mul(this.albedo.rgb, this.diffuseColor);
+                    this.$return(this.litColor);
+                }
+            });
+            return pb.getGlobalScope()[funcName](worldPos, normal, albedo);
+        }
+    };
+}
+
+export { mixinLambert };
+//# sourceMappingURL=lambert.js.map

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

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