Merge branch 'master' of https://github.com/BabylonJS/Babylon.js

loaders/src/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.ts

@@ -47,6 +47,8 @@ module BABYLON.GLTF2.Extensions {
                 babylonMaterial.reflectivityTexture = loader.loadTexture(properties.specularGlossinessTexture);
                 babylonMaterial.useMicroSurfaceFromReflectivityMapAlpha = true;
             }
+
+            loader.loadMaterialAlphaProperties(material, properties.diffuseFactor);
         }
     }
 

loaders/src/glTF/2.0/babylon.glTFLoader.ts

@@ -908,7 +908,6 @@ module BABYLON.GLTF2 {
 
             if (properties.baseColorTexture) {
                 babylonMaterial.albedoTexture = this.loadTexture(properties.baseColorTexture);
-                this.loadMaterialAlphaProperties(material);
             }
 
             if (properties.metallicRoughnessTexture) {
@@ -917,6 +916,8 @@ module BABYLON.GLTF2 {
                 babylonMaterial.useRoughnessFromMetallicTextureGreen = true;
                 babylonMaterial.useRoughnessFromMetallicTextureAlpha = false;
             }
+
+            this.loadMaterialAlphaProperties(material, properties.baseColorFactor);
         }
 
         public loadMaterial(index: number, assign: (material: Material) => void): void {
@@ -975,7 +976,7 @@ module BABYLON.GLTF2 {
             }
         }
 
-        public loadMaterialAlphaProperties(material: IGLTFMaterial): void {
+        public loadMaterialAlphaProperties(material: IGLTFMaterial, colorFactor?: number[]): void {
             var babylonMaterial = material.babylonMaterial as PBRMaterial;
 
             var alphaMode = material.alphaMode || "OPAQUE";
@@ -984,12 +985,15 @@ module BABYLON.GLTF2 {
                     // default is opaque
                     break;
                 case "MASK":
-                    babylonMaterial.albedoTexture.hasAlpha = true;
-                    babylonMaterial.useAlphaFromAlbedoTexture = false;
-                    break;
                 case "BLEND":
-                    babylonMaterial.albedoTexture.hasAlpha = true;
-                    babylonMaterial.useAlphaFromAlbedoTexture = true;
+                    if (colorFactor) {
+                        babylonMaterial.alpha = colorFactor[3];
+                    }
+
+                    if (babylonMaterial.albedoTexture) {
+                        babylonMaterial.albedoTexture.hasAlpha = true;
+                        babylonMaterial.useAlphaFromAlbedoTexture = (alphaMode === "BLEND");
+                    }
                     break;
                 default:
                     Tools.Warn("Invalid alpha mode '" + material.alphaMode + "'");

materialsLibrary/src/water/babylon.waterMaterial.ts

@@ -28,55 +28,55 @@ module BABYLON {
             this.rebuild();
         }
     }
-	
-	export class WaterMaterial extends PushMaterial {
+
+    export class WaterMaterial extends PushMaterial {
 		/*
 		* Public members
 		*/
         @serializeAsTexture("bumpTexture")
         private _bumpTexture: BaseTexture;
         @expandToProperty("_markAllSubMeshesAsTexturesDirty")
-        public bumpTexture: BaseTexture;        
-        
+        public bumpTexture: BaseTexture;
+
         @serializeAsColor3()
         public diffuseColor = new Color3(1, 1, 1);
-        
+
         @serializeAsColor3()
         public specularColor = new Color3(0, 0, 0);
-        
+
         @serialize()
         public specularPower = 64;
-        
+
         @serialize("disableLighting")
         private _disableLighting = false;
         @expandToProperty("_markAllSubMeshesAsLightsDirty")
         public disableLighting: boolean;
-        
+
         @serialize("maxSimultaneousLights")
         private _maxSimultaneousLights = 4;
         @expandToProperty("_markAllSubMeshesAsLightsDirty")
-        public maxSimultaneousLights: number;                   
-        
+        public maxSimultaneousLights: number;
+
         /**
         * @param {number}: Represents the wind force
         */
         @serialize()
-		public windForce: number = 6;
+        public windForce: number = 6;
         /**
         * @param {Vector2}: The direction of the wind in the plane (X, Z)
         */
         @serializeAsVector2()
-		public windDirection: Vector2 = new Vector2(0, 1);
+        public windDirection: Vector2 = new Vector2(0, 1);
         /**
         * @param {number}: Wave height, represents the height of the waves
         */
         @serialize()
-		public waveHeight: number = 0.4;
+        public waveHeight: number = 0.4;
         /**
         * @param {number}: Bump height, represents the bump height related to the bump map
         */
         @serialize()
-		public bumpHeight: number = 0.4;
+        public bumpHeight: number = 0.4;
         /**
          * @param {boolean}: Add a smaller moving bump to less steady waves.
          */
@@ -99,18 +99,18 @@ module BABYLON {
         @serialize("bumpAffectsReflection")
         private _bumpAffectsReflection = false;
         @expandToProperty("_markAllSubMeshesAsMiscDirty")
-        public bumpAffectsReflection: boolean;        
+        public bumpAffectsReflection: boolean;
 
         /**
         * @param {number}: The water color blended with the refraction (near)
         */
         @serializeAsColor3()
-		public waterColor: Color3 = new Color3(0.1, 0.1, 0.6);
+        public waterColor: Color3 = new Color3(0.1, 0.1, 0.6);
         /**
         * @param {number}: The blend factor related to the water color
         */
         @serialize()
-		public colorBlendFactor: number = 0.2;
+        public colorBlendFactor: number = 0.2;
         /**
          * @param {number}: The water color blended with the reflection (far)
          */
@@ -125,27 +125,28 @@ module BABYLON {
         * @param {number}: Represents the maximum length of a wave
         */
         @serialize()
-		public waveLength: number = 0.1;
-        
+        public waveLength: number = 0.1;
+
         /**
         * @param {number}: Defines the waves speed
         */
         @serialize()
         public waveSpeed: number = 1.0;
-		
+
 		/*
 		* Private members
 		*/
-		private _mesh: AbstractMesh = null;
-		
-		private _refractionRTT: RenderTargetTexture;
-		private _reflectionRTT: RenderTargetTexture;
-		
-		private _material: ShaderMaterial;
-		
-		private _reflectionTransform: Matrix = Matrix.Zero();
-		private _lastTime: number = 0;
-        
+        private _mesh: AbstractMesh = null;
+
+        private _refractionRTT: RenderTargetTexture;
+        private _reflectionRTT: RenderTargetTexture;
+
+        private _material: ShaderMaterial;
+
+        private _reflectionTransform: Matrix = Matrix.Zero();
+        private _lastTime: number = 0;
+        private _lastDeltaTime: number = 0;
+
         private _renderId: number;
 
         private _useLogarithmicDepth: boolean;
@@ -153,11 +154,11 @@ module BABYLON {
         /**
 		* Constructor
 		*/
-		constructor(name: string, scene: Scene, public renderTargetSize: Vector2 = new Vector2(512, 512)) {
+        constructor(name: string, scene: Scene, public renderTargetSize: Vector2 = new Vector2(512, 512)) {
             super(name, scene);
-			
-			// Create render targets
-			this._createRenderTargets(scene, renderTargetSize);
+
+            // Create render targets
+            this._createRenderTargets(scene, renderTargetSize);
         }
 
         @serialize()
@@ -174,33 +175,33 @@ module BABYLON {
         public get refractionTexture(): RenderTargetTexture {
             return this._refractionRTT;
         }
-        
+
         public get reflectionTexture(): RenderTargetTexture {
             return this._reflectionRTT;
         }
-		
+
         // Methods
         public addToRenderList(node: any): void {
             this._refractionRTT.renderList.push(node);
             this._reflectionRTT.renderList.push(node);
         }
-        
+
         public enableRenderTargets(enable: boolean): void {
             var refreshRate = enable ? 1 : 0;
-            
+
             this._refractionRTT.refreshRate = refreshRate;
             this._reflectionRTT.refreshRate = refreshRate;
         }
-        
+
         public getRenderList(): AbstractMesh[] {
             return this._refractionRTT.renderList;
         }
-        
+
         public get renderTargetsEnabled(): boolean {
             return !(this._refractionRTT.refreshRate === 0);
         }
-        
-		public needAlphaBlending(): boolean {
+
+        public needAlphaBlending(): boolean {
             return (this.alpha < 1.0);
         }
 
@@ -211,8 +212,8 @@ module BABYLON {
         public getAlphaTestTexture(): BaseTexture {
             return null;
         }
-		
-		public isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean {
+
+        public isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean {
             if (this.isFrozen) {
                 if (this._wasPreviouslyReady && subMesh.effect) {
                     return true;
@@ -246,7 +247,7 @@ module BABYLON {
                             defines.BUMP = true;
                         }
                     }
-                    
+
                     if (StandardMaterial.ReflectionTextureEnabled) {
                         defines.REFLECTION = true;
                     }
@@ -270,13 +271,13 @@ module BABYLON {
                     defines.BUMPAFFECTSREFLECTION = true;
                 }
             }
-           
+
             // Lights
             defines._needNormals = MaterialHelper.PrepareDefinesForLights(scene, mesh, defines, true, this._maxSimultaneousLights, this._disableLighting);
 
             // Attribs
             MaterialHelper.PrepareDefinesForAttributes(mesh, defines, true, true);
-            
+
             this._mesh = mesh;
 
             // Get correct effect      
@@ -285,7 +286,7 @@ module BABYLON {
                 scene.resetCachedMaterial();
 
                 // Fallbacks
-                var fallbacks = new EffectFallbacks();             
+                var fallbacks = new EffectFallbacks();
                 if (defines.FOG) {
                     fallbacks.addFallback(1, "FOG");
                 }
@@ -295,7 +296,7 @@ module BABYLON {
                 }
 
                 MaterialHelper.HandleFallbacksForShadows(defines, fallbacks, this.maxSimultaneousLights);
-             
+
                 if (defines.NUM_BONE_INFLUENCERS > 0) {
                     fallbacks.addCPUSkinningFallback(0, mesh);
                 }
@@ -327,7 +328,7 @@ module BABYLON {
                 var join = defines.toString();
                 var uniforms = ["world", "view", "viewProjection", "vEyePosition", "vLightsType", "vDiffuseColor", "vSpecularColor",
                     "vFogInfos", "vFogColor", "pointSize",
-                    "vNormalInfos", 
+                    "vNormalInfos",
                     "mBones",
                     "vClipPlane", "normalMatrix",
                     "logarithmicDepthConstant",
@@ -343,10 +344,10 @@ module BABYLON {
                 var uniformBuffers = [];
 
                 MaterialHelper.PrepareUniformsAndSamplersList(<EffectCreationOptions>{
-                    uniformsNames: uniforms, 
+                    uniformsNames: uniforms,
                     uniformBuffersNames: uniformBuffers,
-                    samplers: samplers, 
-                    defines: defines, 
+                    samplers: samplers,
+                    defines: defines,
                     maxSimultaneousLights: this.maxSimultaneousLights
                 });
                 subMesh.setEffect(scene.getEngine().createEffect(shaderName,
@@ -371,9 +372,9 @@ module BABYLON {
             this._wasPreviouslyReady = true;
 
             return true;
-		}
-        
-		public bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void {
+        }
+
+        public bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void {
             var scene = this.getScene();
 
             var defines = <WaterMaterialDefines>subMesh._materialDefines;
@@ -407,11 +408,11 @@ module BABYLON {
                     this._activeEffect.setFloat("pointSize", this.pointSize);
                 }
 
-                this._activeEffect.setVector3("vEyePosition", scene._mirroredCameraPosition ? scene._mirroredCameraPosition : scene.activeCamera.position);                
+                this._activeEffect.setVector3("vEyePosition", scene._mirroredCameraPosition ? scene._mirroredCameraPosition : scene.activeCamera.position);
             }
 
             this._activeEffect.setColor4("vDiffuseColor", this.diffuseColor, this.alpha * mesh.visibility);
-            
+
             if (defines.SPECULARTERM) {
                 this._activeEffect.setColor4("vSpecularColor", this.specularColor, this.specularPower);
             }
@@ -436,102 +437,108 @@ module BABYLON {
                 this._activeEffect.setTexture("refractionSampler", this._refractionRTT);
                 this._activeEffect.setTexture("reflectionSampler", this._reflectionRTT);
             }
-            
-			var wrvp = this._mesh.getWorldMatrix().multiply(this._reflectionTransform).multiply(scene.getProjectionMatrix());
-			this._lastTime += scene.getEngine().getDeltaTime();
-			
-			this._activeEffect.setMatrix("worldReflectionViewProjection", wrvp);
-			this._activeEffect.setVector2("windDirection", this.windDirection);
-			this._activeEffect.setFloat("waveLength", this.waveLength);
-			this._activeEffect.setFloat("time", this._lastTime / 100000);
-			this._activeEffect.setFloat("windForce", this.windForce);
-			this._activeEffect.setFloat("waveHeight", this.waveHeight);
+
+            var wrvp = this._mesh.getWorldMatrix().multiply(this._reflectionTransform).multiply(scene.getProjectionMatrix());
+
+            // Add delta time. Prevent adding delta time if it hasn't changed.
+            let deltaTime = scene.getEngine().getDeltaTime();
+            if (deltaTime !== this._lastDeltaTime) {
+                this._lastDeltaTime = deltaTime;
+                this._lastTime += this._lastDeltaTime;
+            }
+
+            this._activeEffect.setMatrix("worldReflectionViewProjection", wrvp);
+            this._activeEffect.setVector2("windDirection", this.windDirection);
+            this._activeEffect.setFloat("waveLength", this.waveLength);
+            this._activeEffect.setFloat("time", this._lastTime / 100000);
+            this._activeEffect.setFloat("windForce", this.windForce);
+            this._activeEffect.setFloat("waveHeight", this.waveHeight);
             this._activeEffect.setFloat("bumpHeight", this.bumpHeight);
-			this._activeEffect.setColor4("waterColor", this.waterColor, 1.0);
-			this._activeEffect.setFloat("colorBlendFactor", this.colorBlendFactor);
+            this._activeEffect.setColor4("waterColor", this.waterColor, 1.0);
+            this._activeEffect.setFloat("colorBlendFactor", this.colorBlendFactor);
             this._activeEffect.setColor4("waterColor2", this.waterColor2, 1.0);
             this._activeEffect.setFloat("colorBlendFactor2", this.colorBlendFactor2);
             this._activeEffect.setFloat("waveSpeed", this.waveSpeed);
 
             this._afterBind(mesh, this._activeEffect);
-		}
-		
-		private _createRenderTargets(scene: Scene, renderTargetSize: Vector2): void {
-			// Render targets
-			this._refractionRTT = new RenderTargetTexture(name + "_refraction", {width: renderTargetSize.x, height: renderTargetSize.y}, scene, false, true);
+        }
+
+        private _createRenderTargets(scene: Scene, renderTargetSize: Vector2): void {
+            // Render targets
+            this._refractionRTT = new RenderTargetTexture(name + "_refraction", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
             this._refractionRTT.wrapU = BABYLON.Texture.MIRROR_ADDRESSMODE;
             this._refractionRTT.wrapV = BABYLON.Texture.MIRROR_ADDRESSMODE;
 
-			this._reflectionRTT = new RenderTargetTexture(name + "_reflection", {width: renderTargetSize.x, height: renderTargetSize.y}, scene, false, true);
+            this._reflectionRTT = new RenderTargetTexture(name + "_reflection", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
             this._reflectionRTT.wrapU = BABYLON.Texture.MIRROR_ADDRESSMODE;
             this._reflectionRTT.wrapV = BABYLON.Texture.MIRROR_ADDRESSMODE;
 
-			scene.customRenderTargets.push(this._refractionRTT);
-			scene.customRenderTargets.push(this._reflectionRTT);
-			
-			var isVisible: boolean;
-			var clipPlane = null;
-			var savedViewMatrix;
-			var mirrorMatrix = Matrix.Zero();
-            
-			this._refractionRTT.onBeforeRender = () => {
+            scene.customRenderTargets.push(this._refractionRTT);
+            scene.customRenderTargets.push(this._reflectionRTT);
+
+            var isVisible: boolean;
+            var clipPlane = null;
+            var savedViewMatrix;
+            var mirrorMatrix = Matrix.Zero();
+
+            this._refractionRTT.onBeforeRender = () => {
                 if (this._mesh) {
                     isVisible = this._mesh.isVisible;
                     this._mesh.isVisible = false;
                 }
-				// Clip plane
-				clipPlane = scene.clipPlane;
-                
+                // Clip plane
+                clipPlane = scene.clipPlane;
+
                 var positiony = this._mesh ? this._mesh.position.y : 0.0;
-				scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony + 0.05, 0), new Vector3(0, 1, 0));
-			};
-			
-			this._refractionRTT.onAfterRender = () => {
+                scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony + 0.05, 0), new Vector3(0, 1, 0));
+            };
+
+            this._refractionRTT.onAfterRender = () => {
                 if (this._mesh) {
-				    this._mesh.isVisible = isVisible;
+                    this._mesh.isVisible = isVisible;
                 }
-                
-				// Clip plane
-				scene.clipPlane = clipPlane;
-			};
-			
-			this._reflectionRTT.onBeforeRender = () => {
+
+                // Clip plane
+                scene.clipPlane = clipPlane;
+            };
+
+            this._reflectionRTT.onBeforeRender = () => {
                 if (this._mesh) {
                     isVisible = this._mesh.isVisible;
                     this._mesh.isVisible = false;
                 }
-                
-				// Clip plane
-				clipPlane = scene.clipPlane;
-                
+
+                // Clip plane
+                clipPlane = scene.clipPlane;
+
                 var positiony = this._mesh ? this._mesh.position.y : 0.0;
-				scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony - 0.05, 0), new Vector3(0, -1, 0));
-				
-				// Transform
-				Matrix.ReflectionToRef(scene.clipPlane, mirrorMatrix);
-				savedViewMatrix = scene.getViewMatrix();
-				
-				mirrorMatrix.multiplyToRef(savedViewMatrix, this._reflectionTransform);
-				scene.setTransformMatrix(this._reflectionTransform, scene.getProjectionMatrix());
-				scene.getEngine().cullBackFaces = false;
+                scene.clipPlane = Plane.FromPositionAndNormal(new Vector3(0, positiony - 0.05, 0), new Vector3(0, -1, 0));
+
+                // Transform
+                Matrix.ReflectionToRef(scene.clipPlane, mirrorMatrix);
+                savedViewMatrix = scene.getViewMatrix();
+
+                mirrorMatrix.multiplyToRef(savedViewMatrix, this._reflectionTransform);
+                scene.setTransformMatrix(this._reflectionTransform, scene.getProjectionMatrix());
+                scene.getEngine().cullBackFaces = false;
                 scene._mirroredCameraPosition = Vector3.TransformCoordinates(scene.activeCamera.position, mirrorMatrix);
-			};
-			
-			this._reflectionRTT.onAfterRender = () => {
+            };
+
+            this._reflectionRTT.onAfterRender = () => {
                 if (this._mesh) {
-				    this._mesh.isVisible = isVisible;
+                    this._mesh.isVisible = isVisible;
                 }
-                
-				// Clip plane
-				scene.clipPlane = clipPlane;
-				
-				// Transform
-				scene.setTransformMatrix(savedViewMatrix, scene.getProjectionMatrix());
+
+                // Clip plane
+                scene.clipPlane = clipPlane;
+
+                // Transform
+                scene.setTransformMatrix(savedViewMatrix, scene.getProjectionMatrix());
                 scene.getEngine().cullBackFaces = true;
                 scene._mirroredCameraPosition = null;
-			};
-		}
-        
+            };
+        }
+
         public getAnimatables(): IAnimatable[] {
             var results = [];
 
@@ -565,9 +572,9 @@ module BABYLON {
 
             if (this._bumpTexture === texture) {
                 return true;
-            }        
+            }
 
-            return false;    
+            return false;
         }
 
         public dispose(forceDisposeEffect?: boolean): void {
@@ -576,12 +583,12 @@ module BABYLON {
             }
 
             var index = this.getScene().customRenderTargets.indexOf(this._refractionRTT);
-            if (index != -1){
+            if (index != -1) {
                 this.getScene().customRenderTargets.splice(index, 1);
             }
             index = -1;
             index = this.getScene().customRenderTargets.indexOf(this._reflectionRTT);
-            if (index != -1){
+            if (index != -1) {
                 this.getScene().customRenderTargets.splice(index, 1);
             }
 
@@ -611,10 +618,10 @@ module BABYLON {
         public static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial {
             return SerializationHelper.Parse(() => new WaterMaterial(source.name, scene), source, scene, rootUrl);
         }
-		
-		public static CreateDefaultMesh(name: string, scene: Scene): Mesh {
-			var mesh = Mesh.CreateGround(name, 512, 512, 32, scene, false);
-			return mesh;
-		}
-	}
+
+        public static CreateDefaultMesh(name: string, scene: Scene): Mesh {
+            var mesh = Mesh.CreateGround(name, 512, 512, 32, scene, false);
+            return mesh;
+        }
+    }
 }