@zephyr3d/scene 0.1.2 → 0.2.0

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

@@ -0,0 +1,132 @@
+import { applyMaterialMixins } from '../../meshmaterial.js';
+import { mixinTextureProps } from '../texture.js';
+import { mixinPBRCommon } from '../pbr/common.js';
+import { Vector4 } from '@zephyr3d/base';
+import { mixinLight } from '../lit.js';
+
+/**
+ * PBRMetallicRoughness lighting model mixin
+ * @param BaseCls - Class to mix in
+ * @returns Mixed class
+ * @public
+ */ function mixinPBRMetallicRoughness(BaseCls) {
+    if (BaseCls.pbrMetallicRoughnessMixed) {
+        return BaseCls;
+    }
+    const S = applyMaterialMixins(BaseCls, mixinPBRCommon, mixinLight, mixinTextureProps('metallicRoughness'), mixinTextureProps('occlusion'), mixinTextureProps('specular'), mixinTextureProps('specularColor'));
+    return class extends S {
+        static pbrMetallicRoughnessMixed = true;
+        _metallic;
+        _roughness;
+        _specularFactor;
+        constructor(){
+            super();
+            this._metallic = 1;
+            this._roughness = 1;
+            this._specularFactor = Vector4.one();
+        }
+        get metallic() {
+            return this._metallic;
+        }
+        set metallic(val) {
+            if (val !== this._metallic) {
+                this._metallic = val;
+                this.uniformChanged();
+            }
+        }
+        get roughness() {
+            return this._roughness;
+        }
+        set roughness(val) {
+            if (val !== this._roughness) {
+                this._roughness = val;
+                this.uniformChanged();
+            }
+        }
+        get specularFactor() {
+            return this._specularFactor;
+        }
+        set specularFactor(val) {
+            if (!val.equalsTo(this._specularFactor)) {
+                this._specularFactor.set(val);
+                this.uniformChanged();
+            }
+        }
+        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN) {
+            const pb = scope.$builder;
+            const funcName = 'Z_PBRMetallicRoughnessLight';
+            const that = this;
+            pb.func(funcName, [
+                pb.vec3('worldPos'),
+                pb.vec3('normal'),
+                pb.mat3('TBN'),
+                pb.vec3('viewVec'),
+                pb.vec4('albedo')
+            ], function() {
+                this.$l.pbrData = that.getCommonData(this, this.albedo, this.viewVec, this.TBN);
+                this.$l.lightingColor = pb.vec3(0);
+                this.$l.emissiveColor = that.calculateEmissiveColor(this);
+                that.indirectLighting(this, this.normal, this.viewVec, this.pbrData, this.lightingColor);
+                that.forEachLight(this, function(type, posRange, dirCutoff, colorIntensity, shadow) {
+                    this.$l.diffuse = pb.vec3();
+                    this.$l.specular = pb.vec3();
+                    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.NoL);
+                    if (shadow) {
+                        this.lightColor = pb.mul(this.lightColor, that.calculateShadow(this, this.worldPos, this.NoL));
+                    }
+                    that.directLighting(this, this.lightDir, this.lightColor, this.normal, this.viewVec, this.pbrData, this.lightingColor);
+                });
+                this.$return(pb.add(this.lightingColor, this.emissiveColor));
+            });
+            return pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
+        }
+        fragmentShader(scope) {
+            super.fragmentShader(scope);
+            if (this.needFragmentColor()) {
+                const pb = scope.$builder;
+                scope.zMetallic = pb.float().uniform(2);
+                scope.zRoughness = pb.float().uniform(2);
+                scope.zSpecularFactor = pb.vec4().uniform(2);
+            }
+        }
+        applyUniformValues(bindGroup, ctx, pass) {
+            super.applyUniformValues(bindGroup, ctx, pass);
+            if (this.needFragmentColor(ctx)) {
+                bindGroup.setValue('zMetallic', this._metallic);
+                bindGroup.setValue('zRoughness', this._roughness);
+                bindGroup.setValue('zSpecularFactor', this._specularFactor);
+            }
+        }
+        calculateCommonData(scope, albedo, viewVec, TBN, data) {
+            super.calculateCommonData(scope, albedo, viewVec, TBN, data);
+            const pb = scope.$builder;
+            if (this.metallicRoughnessTexture) {
+                scope.$l.metallicRoughnessSample = this.sampleMetallicRoughnessTexture(scope);
+                data.metallic = pb.mul(scope.zMetallic, scope.metallicRoughnessSample.z);
+                data.roughness = pb.mul(scope.zRoughness, scope.metallicRoughnessSample.y);
+            } else {
+                data.metallic = scope.zMetallic;
+                data.roughness = scope.zRoughness;
+            }
+            if (this.specularColorTexture) {
+                scope.$l.specularColor = pb.mul(scope.zSpecularFactor.rgb, this.sampleSpecularColorTexture(scope).rgb);
+            } else {
+                scope.$l.specularColor = scope.zSpecularFactor.rgb;
+            }
+            if (this.specularTexture) {
+                data.specularWeight = pb.mul(scope.zSpecularFactor.a, this.sampleSpecularTexture(scope).a);
+            } else {
+                data.specularWeight = scope.zSpecularFactor.a;
+            }
+            data.f0 = pb.vec4(pb.mix(pb.min(pb.mul(this.getF0(scope).rgb, scope.specularColor), pb.vec3(1)), albedo.rgb, data.metallic), this.getF0(scope).a);
+            data.f90 = pb.vec3(1);
+            data.diffuse = pb.vec4(pb.mix(albedo.rgb, pb.vec3(0), data.metallic), albedo.a);
+        }
+    };
+}
+
+export { mixinPBRMetallicRoughness };
+//# sourceMappingURL=pbrmetallicroughness.js.map

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

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

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

@@ -0,0 +1,105 @@
+import { applyMaterialMixins } from '../../meshmaterial.js';
+import { mixinTextureProps } from '../texture.js';
+import { mixinPBRCommon } from '../pbr/common.js';
+import { Vector4 } from '@zephyr3d/base';
+import { mixinLight } from '../lit.js';
+
+function mixinPBRSpecularGlossness(BaseCls) {
+    if (BaseCls.pbrSpecularGlossnessMixed) {
+        return BaseCls;
+    }
+    const S = applyMaterialMixins(BaseCls, mixinPBRCommon, mixinLight, mixinTextureProps('specular'));
+    return class extends S {
+        static pbrSpecularGlossnessMixed = true;
+        _specularFactor;
+        _glossinessFactor;
+        constructor(){
+            super();
+            this._specularFactor = Vector4.one();
+            this._glossinessFactor = 1;
+        }
+        get specularFactor() {
+            return this._specularFactor;
+        }
+        set specularFactor(val) {
+            if (!val.equalsTo(this._specularFactor)) {
+                this._specularFactor.set(val);
+                this.uniformChanged();
+            }
+        }
+        get glossinessFactor() {
+            return this._glossinessFactor;
+        }
+        set glossinessFactor(val) {
+            if (val !== this._glossinessFactor) {
+                this._glossinessFactor = val;
+                this.uniformChanged();
+            }
+        }
+        fragmentShader(scope) {
+            super.fragmentShader(scope);
+            if (this.needFragmentColor()) {
+                const pb = scope.$builder;
+                scope.zSpecularFactor = pb.vec4().uniform(2);
+                scope.zGlossinessFactor = pb.float().uniform(2);
+            }
+        }
+        applyUniformValues(bindGroup, ctx, pass) {
+            super.applyUniformValues(bindGroup, ctx, pass);
+            if (this.needFragmentColor(ctx)) {
+                bindGroup.setValue('zSpecularFactor', this._specularFactor);
+                bindGroup.setValue('zGlossinessFactor', this._glossinessFactor);
+            }
+        }
+        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN) {
+            const pb = scope.$builder;
+            const funcName = 'Z_PBRSpecularGlossinessLight';
+            const that = this;
+            pb.func(funcName, [
+                pb.vec3('worldPos'),
+                pb.vec3('normal'),
+                pb.mat3('TBN'),
+                pb.vec3('viewVec'),
+                pb.vec4('albedo')
+            ], function() {
+                this.$l.pbrData = that.getCommonData(this, this.albedo, this.viewVec, this.TBN);
+                this.$l.lightingColor = pb.vec3(0);
+                this.$l.emissiveColor = that.calculateEmissiveColor(this);
+                that.indirectLighting(this, this.normal, this.viewVec, this.pbrData, this.lightingColor);
+                that.forEachLight(this, function(type, posRange, dirCutoff, colorIntensity, shadow) {
+                    this.$l.diffuse = pb.vec3();
+                    this.$l.specular = pb.vec3();
+                    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.NoL);
+                    if (shadow) {
+                        this.lightColor = pb.mul(this.lightColor, that.calculateShadow(this, this.worldPos, this.NoL));
+                    }
+                    that.directLighting(this, this.lightDir, this.lightColor, this.normal, this.viewVec, this.pbrData, this.lightingColor);
+                });
+                this.$return(pb.add(this.lightingColor, this.emissiveColor));
+            });
+            return pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
+        }
+        calculateCommonData(scope, albedo, viewVec, TBN, data) {
+            super.calculateCommonData(scope, albedo, viewVec, TBN, data);
+            const pb = scope.$builder;
+            if (this.specularTexture) {
+                scope.$l.specularTextureSample = this.sampleSpecularTexture(scope);
+                data.roughness = pb.sub(1, pb.mul(scope.zGlossinessFactor, scope.specularTextureSample.a));
+                data.f0 = pb.vec4(pb.mul(scope.specularTextureSample.rgb, scope.zSpecularFactor.rgb), this.getF0(scope).a);
+            } else {
+                data.roughness = pb.sub(1, scope.zGlossinessFactor);
+                data.f0 = pb.vec4(scope.zSpecularFactor.rgb, this.getF0(scope).a);
+            }
+            data.metallic = pb.max(pb.max(data.f0.r, data.f0.g), data.f0.b);
+            data.diffuse = pb.vec4(pb.mul(albedo.rgb, pb.sub(1, data.metallic)), albedo.a);
+            data.specularWeight = 1;
+            data.f90 = pb.vec3(1);
+        }
+    };
+}
+
+export { mixinPBRSpecularGlossness };
+//# sourceMappingURL=pbrspecularglossness.js.map

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

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