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

materialsLibrary/src/cell/babylon.cellMaterial.ts

@@ -270,6 +270,16 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTexture) {
+                activeTextures.push(this._diffuseTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this._diffuseTexture) {
                 this._diffuseTexture.dispose();

materialsLibrary/src/fire/babylon.fireMaterial.ts

@@ -258,6 +258,24 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTexture) {
+                activeTextures.push(this._diffuseTexture);
+            }
+
+            if (this._distortionTexture) {
+                activeTextures.push(this._distortionTexture);
+            }
+
+            if (this._opacityTexture) {
+                activeTextures.push(this._opacityTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this._diffuseTexture) {
                 this._diffuseTexture.dispose();

materialsLibrary/src/fur/babylon.furMaterial.ts

@@ -369,6 +369,20 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTexture) {
+                activeTextures.push(this._diffuseTexture);
+            }
+
+            if (this._heightTexture) {
+                activeTextures.push(this._heightTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this.diffuseTexture) {
                 this.diffuseTexture.dispose();

materialsLibrary/src/lava/babylon.lavaMaterial.ts

@@ -339,6 +339,16 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTexture) {
+                activeTextures.push(this._diffuseTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this.diffuseTexture) {
                 this.diffuseTexture.dispose();

materialsLibrary/src/normal/babylon.normalMaterial.ts

@@ -293,6 +293,16 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTexture) {
+                activeTextures.push(this._diffuseTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this.diffuseTexture) {
                 this.diffuseTexture.dispose();

materialsLibrary/src/simple/babylon.simpleMaterial.ts

@@ -259,6 +259,16 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTexture) {
+                activeTextures.push(this._diffuseTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this._diffuseTexture) {
                 this._diffuseTexture.dispose();

materialsLibrary/src/terrain/babylon.terrainMaterial.ts

@@ -332,6 +332,40 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._mixTexture) {
+                activeTextures.push(this._mixTexture);
+            }
+
+            if (this._diffuseTexture1) {
+                activeTextures.push(this._diffuseTexture1);
+            }
+
+            if (this._diffuseTexture2) {
+                activeTextures.push(this._diffuseTexture2);
+            }
+
+            if (this._diffuseTexture3) {
+                activeTextures.push(this._diffuseTexture3);
+            }
+
+            if (this._bumpTexture1) {
+                activeTextures.push(this._bumpTexture1);
+            }
+
+            if (this._bumpTexture2) {
+                activeTextures.push(this._bumpTexture2);
+            }
+
+            if (this._bumpTexture3) {
+                activeTextures.push(this._bumpTexture3);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this.mixTexture) {
                 this.mixTexture.dispose();

materialsLibrary/src/triPlanar/babylon.triPlanarMaterial.ts

@@ -332,6 +332,36 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTextureX) {
+                activeTextures.push(this._diffuseTextureX);
+            }
+
+            if (this._diffuseTextureY) {
+                activeTextures.push(this._diffuseTextureY);
+            }
+
+            if (this._diffuseTextureZ) {
+                activeTextures.push(this._diffuseTextureZ);
+            }
+
+            if (this._normalTextureX) {
+                activeTextures.push(this._normalTextureX);
+            }
+
+            if (this._normalTextureY) {
+                activeTextures.push(this._normalTextureY);
+            }
+
+            if (this._normalTextureZ) {
+                activeTextures.push(this._normalTextureZ);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this.mixTexture) {
                 this.mixTexture.dispose();

materialsLibrary/src/water/babylon.waterMaterial.ts

@@ -548,6 +548,16 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._bumpTexture) {
+                activeTextures.push(this._bumpTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean): void {
             if (this.bumpTexture) {
                 this.bumpTexture.dispose();

src/Materials/PBR/babylon.pbrBaseMaterial.ts

@@ -105,7 +105,7 @@
      * For more information, please refer to the documentation : 
      * http://doc.babylonjs.com/extensions/Physically_Based_Rendering
      */
-    export abstract class PBRBaseMaterial extends BABYLON.PushMaterial {
+    export abstract class PBRBaseMaterial extends PushMaterial {
 
         /**
          * Intensity of the direct lights e.g. the four lights available in your scene.

src/Materials/PBR/babylon.pbrMaterial.ts

@@ -432,6 +432,56 @@
             return "PBRMaterial";
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._albedoTexture) {
+                activeTextures.push(this._albedoTexture);
+            }
+
+            if (this._ambientTexture) {
+                activeTextures.push(this._ambientTexture);
+            }
+
+            if (this._opacityTexture) {
+                activeTextures.push(this._opacityTexture);
+            }
+
+            if (this._reflectionTexture) {
+                activeTextures.push(this._reflectionTexture);
+            }
+
+            if (this._emissiveTexture) {
+                activeTextures.push(this._emissiveTexture);
+            }
+
+            if (this._reflectionTexture) {
+                activeTextures.push(this._reflectionTexture);
+            }
+
+            if (this._metallicTexture) {
+                activeTextures.push(this._metallicTexture);
+            }
+
+            if (this._microSurfaceTexture) {
+                activeTextures.push(this._microSurfaceTexture);
+            }
+
+            if (this._bumpTexture) {
+                activeTextures.push(this._bumpTexture);
+            }
+
+            if (this._lightmapTexture) {
+                activeTextures.push(this._lightmapTexture);
+            }
+
+            if (this._refractionTexture) {
+                activeTextures.push(this._refractionTexture);
+            }
+
+            return activeTextures;
+        }
+
         public clone(name: string): PBRMaterial {
             return SerializationHelper.Clone(() => new PBRMaterial(name, this.getScene()), this);
         }

src/Materials/PBR/babylon.pbrMetallicRoughnessMaterial.ts

@@ -69,6 +69,23 @@
         }
 
         /**
+         * Return the active textures of the material.
+         */
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this.baseTexture) {
+                activeTextures.push(this.baseTexture);
+            }
+
+            if (this.metallicRoughnessTexture) {
+                activeTextures.push(this.metallicRoughnessTexture);
+            }
+
+            return activeTextures;
+        }
+
+        /**
          * Serialize the material to a parsable JSON object.
          */
         public serialize(): any {

src/Materials/PBR/babylon.pbrSpecularGlossinessMaterial.ts

@@ -62,6 +62,23 @@
         }
 
         /**
+         * Return the active textures of the material.
+         */
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this.diffuseTexture) {
+                activeTextures.push(this.diffuseTexture);
+            }
+
+            if (this.specularGlossinessTexture) {
+                activeTextures.push(this.specularGlossinessTexture);
+            }
+
+            return activeTextures;
+        }
+
+        /**
          * Serialize the material to a parsable JSON object.
          */
         public serialize(): any {

src/Materials/Textures/babylon.baseTexture.ts

@@ -241,5 +241,31 @@
 
             return serializationObject;
         }
+
+        public static WhenAllReady(textures: BaseTexture[], onLoad: () => void): void {
+            var numReady = 0;
+
+            for (var i = 0; i < textures.length; i++) {
+                var texture = textures[i];
+
+                if (texture.isReady()) {
+                    if (++numReady === textures.length) {
+                        onLoad();
+                    }
+                }
+                else {
+                    var observable = (texture as any).onLoadObservable as Observable<Texture>;
+
+                    let callback = () => {
+                        observable.removeCallback(callback);
+                        if (++numReady === textures.length) {
+                            onLoad();
+                        }
+                    };
+
+                    observable.add(callback);
+                }
+            }
+        }
     }
 } 

src/Materials/Textures/babylon.texture.ts

@@ -72,7 +72,7 @@
         protected _format: number;
         private _delayedOnLoad: () => void;
         private _delayedOnError: () => void;
-        private _onLoadObservarble: Observable<boolean>;
+        private _onLoadObservable: Observable<Texture>;
 
         protected _isBlocking: boolean = true;
         public set isBlocking(value: boolean) {
@@ -98,8 +98,8 @@
             scene = this.getScene();
 
             let load = () => {
-                if (this._onLoadObservarble && this._onLoadObservarble.hasObservers()) {
-                    this.onLoadObservable.notifyObservers(true);
+                if (this._onLoadObservable && this._onLoadObservable.hasObservers()) {
+                    this.onLoadObservable.notifyObservers(this);
                 }
                 if (onLoad) {
                     onLoad();
@@ -287,11 +287,11 @@
             }, this);
         }
 
-        public get onLoadObservable(): Observable<boolean> {
-            if (!this._onLoadObservarble) {
-                this._onLoadObservarble = new Observable<boolean>();
+        public get onLoadObservable(): Observable<Texture> {
+            if (!this._onLoadObservable) {
+                this._onLoadObservable = new Observable<Texture>();
             }
-            return this._onLoadObservarble;
+            return this._onLoadObservable;
         }
 
         // Statics

src/Materials/babylon.material.ts

@@ -482,6 +482,10 @@
             }
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            return [];
+        }
+
         public clone(name: string): Material {
             return null;
         }

src/Materials/babylon.multiMaterial.ts

@@ -47,6 +47,10 @@
             return this.subMaterials[index];
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            return super.getActiveTextures().concat(...this.subMaterials.map(subMaterial => subMaterial.getActiveTextures()));
+        }
+
         // Methods
         public getClassName(): string {
             return "MultiMaterial";

src/Materials/babylon.shaderMaterial.ts

@@ -356,6 +356,23 @@
             this._afterBind(mesh);
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            for (var name in this._textures) {
+                activeTextures.push(this._textures[name]);
+            }
+
+            for (var name in this._textureArrays) {
+                var array = this._textureArrays[name];
+                for (var index = 0; index < array.length; index++) {
+                    activeTextures.push(array[index]);
+                }
+            }
+
+            return activeTextures;
+        }
+
         public clone(name: string): ShaderMaterial {
             var newShaderMaterial = new ShaderMaterial(name, this.getScene(), this._shaderPath, this._options);
 

src/Materials/babylon.standardMaterial.ts

@@ -1065,6 +1065,52 @@ module BABYLON {
             return results;
         }
 
+        public getActiveTextures(): BaseTexture[] {
+            var activeTextures = super.getActiveTextures();
+
+            if (this._diffuseTexture) {
+                activeTextures.push(this._diffuseTexture);
+            }
+
+            if (this._ambientTexture) {
+                activeTextures.push(this._ambientTexture);
+            }
+
+            if (this._opacityTexture) {
+                activeTextures.push(this._opacityTexture);
+            }
+
+            if (this._reflectionTexture) {
+                activeTextures.push(this._reflectionTexture);
+            }
+
+            if (this._emissiveTexture) {
+                activeTextures.push(this._emissiveTexture);
+            }
+
+            if (this._specularTexture) {
+                activeTextures.push(this._specularTexture);
+            }
+
+            if (this._bumpTexture) {
+                activeTextures.push(this._bumpTexture);
+            }
+
+            if (this._lightmapTexture) {
+                activeTextures.push(this._lightmapTexture);
+            }
+
+            if (this._refractionTexture) {
+                activeTextures.push(this._refractionTexture);
+            }
+
+            if (this._cameraColorGradingTexture) {
+                activeTextures.push(this._cameraColorGradingTexture);
+            }
+
+            return activeTextures;
+        }
+
         public dispose(forceDisposeEffect?: boolean, forceDisposeTextures?: boolean): void {
             if (forceDisposeTextures) {
                 if (this._diffuseTexture) {

src/Shaders/ShadersInclude/pbrFunctions.fx

@@ -95,7 +95,7 @@ vec3 computeSpecularTerm(float NdotH, float NdotL, float NdotV, float VdotH, flo
     float specTerm = max(0., visibility * distribution) * NdotL;
 
     vec3 fresnel = fresnelSchlickGGX(VdotH, reflectance0, reflectance90);
-    return vec3(specTerm, specTerm, specTerm);
+    return fresnel * specTerm;
 }
 
 float computeDiffuseTerm(float NdotL, float NdotV, float VdotH, float roughness)