@zephyr3d/scene 0.4.0 → 0.6.0

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

@@ -1,5 +1,6 @@
 import { applyMaterialMixins } from '../../meshmaterial.js';
 import { mixinLight } from '../lit.js';
+import { ShaderHelper } from '../../shader/helper.js';
 
 /**
  * Blinn-phong lighting model mixin
@@ -40,7 +41,7 @@ import { mixinLight } from '../lit.js';
                 bindGroup.setValue('zShininess', this._shininess);
             }
         }
-        blinnPhongLight(scope, worldPos, normal, viewVec, albedo) {
+        blinnPhongLight(scope, worldPos, normal, viewVec, albedo, outRoughness) {
             const pb = scope.$builder;
             const funcName = 'Z_blinnPhongLight';
             const that = this;
@@ -48,12 +49,15 @@ import { mixinLight } from '../lit.js';
                 pb.vec3('worldPos'),
                 pb.vec3('normal'),
                 pb.vec3('viewVec'),
-                pb.vec4('albedo')
+                pb.vec4('albedo'),
+                ...outRoughness ? [
+                    pb.vec4('outRoughness').out()
+                ] : []
             ], function() {
                 if (!that.needFragmentColor()) {
                     this.$return(this.albedo.rgb);
                 } else {
-                    if (that.needCalculateEnvLight()) {
+                    if (that.needCalculateEnvLight() && !outRoughness) {
                         this.$l.diffuseColor = that.getEnvLightIrradiance(this, this.normal);
                     } else {
                         this.$l.diffuseColor = pb.vec3(0);
@@ -69,18 +73,24 @@ import { mixinLight } from '../lit.js';
                         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.$if(pb.greaterThan(this.NoL, 0), function() {
+                                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);
+                    if (outRoughness) {
+                        this.$l.roughness = pb.sqrt(pb.div(2, pb.add(this.zShininess, 2)));
+                        this.outRoughness = pb.vec4(pb.mul(this.albedo.rgb, pb.sub(1, this.roughness)), pb.mul(this.roughness, ShaderHelper.getCameraRoughnessFactor(this)));
+                    }
                     this.$return(this.litColor);
                 }
             });
-            return pb.getGlobalScope()[funcName](worldPos, normal, viewVec, albedo);
+            return outRoughness ? pb.getGlobalScope()[funcName](worldPos, normal, viewVec, albedo, outRoughness) : pb.getGlobalScope()[funcName](worldPos, normal, viewVec, albedo);
         }
     };
 }

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

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

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

@@ -1,11 +1,11 @@
 import { applyMaterialMixins } from '../../meshmaterial.js';
 import { mixinLight } from '../lit.js';
 
-/**
- * Lambert lighting model mixin
- * @param BaseCls - Class to mix in
- * @returns Mixed class
- * @public
+/**
+ * Lambert lighting model mixin
+ * @param BaseCls - Class to mix in
+ * @returns Mixed class
+ * @public
  */ function mixinLambert(BaseCls) {
     if (BaseCls.lambertMixed) {
         return BaseCls;

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

@@ -3,6 +3,7 @@ import { mixinTextureProps } from '../texture.js';
 import { mixinPBRCommon } from '../pbr/common.js';
 import { Vector4 } from '@zephyr3d/base';
 import { mixinLight } from '../lit.js';
+import { ShaderHelper } from '../../shader/helper.js';
 
 /**
  * PBRMetallicRoughness lighting model mixin
@@ -52,7 +53,7 @@ import { mixinLight } from '../lit.js';
                 this.uniformChanged();
             }
         }
-        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN) {
+        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN, outRoughness) {
             const pb = scope.$builder;
             const funcName = 'Z_PBRMetallicRoughnessLight';
             const that = this;
@@ -61,12 +62,19 @@ import { mixinLight } from '../lit.js';
                 pb.vec3('normal'),
                 pb.mat3('TBN'),
                 pb.vec3('viewVec'),
-                pb.vec4('albedo')
+                pb.vec4('albedo'),
+                ...outRoughness ? [
+                    pb.vec4('outRoughness').out()
+                ] : []
             ], function() {
-                this.$l.pbrData = that.getCommonData(this, this.albedo, this.viewVec, this.TBN);
+                this.$l.pbrData = that.getCommonData(this, this.albedo, this.normal, 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);
+                if (outRoughness) {
+                    that.indirectLighting(this, this.normal, this.viewVec, this.pbrData, this.lightingColor, this.outRoughness);
+                } else {
+                    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();
@@ -81,7 +89,7 @@ import { mixinLight } from '../lit.js';
                 });
                 this.$return(pb.add(this.lightingColor, this.emissiveColor));
             });
-            return pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
+            return outRoughness ? pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo, outRoughness) : pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
         }
         fragmentShader(scope) {
             super.fragmentShader(scope);
@@ -100,8 +108,7 @@ import { mixinLight } from '../lit.js';
                 bindGroup.setValue('zSpecularFactor', this._specularFactor);
             }
         }
-        calculateCommonData(scope, albedo, viewVec, TBN, data) {
-            super.calculateCommonData(scope, albedo, viewVec, TBN, data);
+        calculateCommonData(scope, albedo, normal, viewVec, TBN, data) {
             const pb = scope.$builder;
             if (this.metallicRoughnessTexture) {
                 scope.$l.metallicRoughnessSample = this.sampleMetallicRoughnessTexture(scope);
@@ -111,6 +118,7 @@ import { mixinLight } from '../lit.js';
                 data.metallic = scope.zMetallic;
                 data.roughness = scope.zRoughness;
             }
+            data.roughness = pb.mul(data.roughness, ShaderHelper.getCameraRoughnessFactor(scope));
             if (this.specularColorTexture) {
                 scope.$l.specularColor = pb.mul(scope.zSpecularFactor.rgb, this.sampleSpecularColorTexture(scope).rgb);
             } else {
@@ -124,6 +132,7 @@ import { mixinLight } from '../lit.js';
             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);
+            super.calculateCommonData(scope, albedo, normal, viewVec, TBN, data);
         }
     };
 }

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

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

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

@@ -3,6 +3,7 @@ import { mixinTextureProps } from '../texture.js';
 import { mixinPBRCommon } from '../pbr/common.js';
 import { Vector4 } from '@zephyr3d/base';
 import { mixinLight } from '../lit.js';
+import { ShaderHelper } from '../../shader/helper.js';
 
 /**
  * PBRSpecularGlossiness mixin
@@ -58,7 +59,7 @@ import { mixinLight } from '../lit.js';
                 bindGroup.setValue('zGlossinessFactor', this._glossinessFactor);
             }
         }
-        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN) {
+        PBRLight(scope, worldPos, normal, viewVec, albedo, TBN, outRoughness) {
             const pb = scope.$builder;
             const funcName = 'Z_PBRSpecularGlossinessLight';
             const that = this;
@@ -67,12 +68,19 @@ import { mixinLight } from '../lit.js';
                 pb.vec3('normal'),
                 pb.mat3('TBN'),
                 pb.vec3('viewVec'),
-                pb.vec4('albedo')
+                pb.vec4('albedo'),
+                ...outRoughness ? [
+                    pb.vec4('outRoughness').out()
+                ] : []
             ], function() {
-                this.$l.pbrData = that.getCommonData(this, this.albedo, this.viewVec, this.TBN);
+                this.$l.pbrData = that.getCommonData(this, this.albedo, this.normal, 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);
+                if (outRoughness) {
+                    that.indirectLighting(this, this.normal, this.viewVec, this.pbrData, this.lightingColor, this.outRoughness);
+                } else {
+                    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();
@@ -87,10 +95,10 @@ import { mixinLight } from '../lit.js';
                 });
                 this.$return(pb.add(this.lightingColor, this.emissiveColor));
             });
-            return pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
+            return outRoughness ? pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo, outRoughness) : pb.getGlobalScope()[funcName](worldPos, normal, TBN, viewVec, albedo);
         }
-        calculateCommonData(scope, albedo, viewVec, TBN, data) {
-            super.calculateCommonData(scope, albedo, viewVec, TBN, data);
+        calculateCommonData(scope, albedo, normal, viewVec, TBN, data) {
+            super.calculateCommonData(scope, albedo, normal, viewVec, TBN, data);
             const pb = scope.$builder;
             if (this.specularTexture) {
                 scope.$l.specularTextureSample = this.sampleSpecularTexture(scope);
@@ -100,6 +108,7 @@ import { mixinLight } from '../lit.js';
                 data.roughness = pb.sub(1, scope.zGlossinessFactor);
                 data.f0 = pb.vec4(scope.zSpecularFactor.rgb, this.getF0(scope).a);
             }
+            data.roughness = pb.mul(data.roughness, ShaderHelper.getCameraRoughnessFactor(scope));
             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;

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

@@ -292,7 +292,7 @@ import { ShaderHelper } from '../shader/helper.js';
      * Checks if shadow should be computed
      *
      * @returns true if shadow should be computed, other wise false
-     */ needCalucateShadow() {
+     */ needCalculateShadow() {
             return this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT && !!this.drawContext.currentShadowLight;
         }
         /**
@@ -303,7 +303,7 @@ import { ShaderHelper } from '../shader/helper.js';
      * @returns Shadow of current fragment, 1 means no shadow and 0 means full shadowed.
      */ calculateShadow(scope, worldPos, NoL) {
             const pb = scope.$builder;
-            if (!this.needCalucateShadow()) {
+            if (!this.needCalculateShadow()) {
                 console.warn('calculateShadow(): No need to calculate shadow');
                 return pb.float(1);
             }