Setting files up for PBRMaterial

Tools/Gulp/config.json

@@ -146,7 +146,8 @@
       "../../src/PostProcess/babylon.hdrRenderingPipeline.js",
       "../../src/Rendering/babylon.edgesRenderer.js",
       "../../src/PostProcess/babylon.tonemapPostProcess.js",
-	  "../../src/Tools/babylon.loadingScreen.js"
+	    "../../src/Tools/babylon.loadingScreen.js",
+      "../../src/Materials/babylon.pbrMaterial.js"
     ]
   },
   "shadersDirectories": [

src/Actions/babylon.action.js

@@ -67,3 +67,4 @@ var BABYLON;
     })();
     BABYLON.Action = Action;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.action.js.map

src/Actions/babylon.actionManager.js

@@ -287,3 +287,4 @@ var BABYLON;
     })();
     BABYLON.ActionManager = ActionManager;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.actionManager.js.map

src/Actions/babylon.condition.js

@@ -115,3 +115,4 @@ var BABYLON;
     })(Condition);
     BABYLON.StateCondition = StateCondition;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.condition.js.map

src/Actions/babylon.directActions.js

@@ -202,3 +202,4 @@ var BABYLON;
     })(BABYLON.Action);
     BABYLON.StopSoundAction = StopSoundAction;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.directActions.js.map

src/Actions/babylon.interpolateValueAction.js

@@ -62,3 +62,4 @@ var BABYLON;
     })(BABYLON.Action);
     BABYLON.InterpolateValueAction = InterpolateValueAction;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.interpolateValueAction.js.map

src/Animations/babylon.animatable.js

@@ -100,3 +100,4 @@ var BABYLON;
     })();
     BABYLON.Animatable = Animatable;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.animatable.js.map

src/Animations/babylon.animation.js

@@ -387,3 +387,4 @@ var BABYLON;
     })();
     BABYLON.Animation = Animation;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.animation.js.map

src/Animations/babylon.easing.js

@@ -247,3 +247,4 @@ var BABYLON;
     })(EasingFunction);
     BABYLON.BezierCurveEase = BezierCurveEase;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.easing.js.map

src/Audio/babylon.analyser.js

@@ -109,3 +109,4 @@ var BABYLON;
     })();
     BABYLON.Analyser = Analyser;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.analyser.js.map

src/Audio/babylon.audioEngine.js

@@ -77,3 +77,4 @@ var BABYLON;
     })();
     BABYLON.AudioEngine = AudioEngine;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.audioEngine.js.map

src/Audio/babylon.sound.js

@@ -379,3 +379,4 @@ var BABYLON;
     })();
     BABYLON.Sound = Sound;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.sound.js.map

src/Audio/babylon.soundtrack.js

@@ -92,3 +92,4 @@ var BABYLON;
     })();
     BABYLON.SoundTrack = SoundTrack;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.soundtrack.js.map

src/Bones/babylon.bone.js

@@ -79,3 +79,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.Bone = Bone;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.bone.js.map

src/Bones/babylon.skeleton.js

@@ -74,3 +74,4 @@ var BABYLON;
     })();
     BABYLON.Skeleton = Skeleton;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.skeleton.js.map

src/Cameras/VR/babylon.vrDeviceOrientationCamera.js

@@ -45,3 +45,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.VRDeviceOrientationFreeCamera = VRDeviceOrientationFreeCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.vrDeviceOrientationCamera.js.map

src/Cameras/VR/babylon.webVRCamera.js

@@ -71,3 +71,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.WebVRFreeCamera = WebVRFreeCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.webVRCamera.js.map

src/Cameras/babylon.arcRotateCamera.js

@@ -553,3 +553,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.ArcRotateCamera = ArcRotateCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.arcRotateCamera.js.map

src/Cameras/babylon.camera.js

@@ -525,3 +525,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.Camera = Camera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.camera.js.map

src/Cameras/babylon.deviceOrientationCamera.js

@@ -69,3 +69,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.DeviceOrientationCamera = DeviceOrientationCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.deviceOrientationCamera.js.map

src/Cameras/babylon.followCamera.js

@@ -84,3 +84,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.ArcFollowCamera = ArcFollowCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.followCamera.js.map

src/Cameras/babylon.freeCamera.js

@@ -223,3 +223,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.FreeCamera = FreeCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.freeCamera.js.map

src/Cameras/babylon.gamepadCamera.js

@@ -49,3 +49,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.GamepadCamera = GamepadCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.gamepadCamera.js.map

src/Cameras/babylon.stereoscopicCameras.js

@@ -60,3 +60,4 @@ var BABYLON;
     })(BABYLON.GamepadCamera);
     BABYLON.StereoscopicGamepadCamera = StereoscopicGamepadCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.stereoscopicCameras.js.map

src/Cameras/babylon.targetCamera.js

@@ -244,3 +244,4 @@ var BABYLON;
     })(BABYLON.Camera);
     BABYLON.TargetCamera = TargetCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.targetCamera.js.map

src/Cameras/babylon.touchCamera.js

@@ -113,3 +113,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.TouchCamera = TouchCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.touchCamera.js.map

src/Cameras/babylon.virtualJoysticksCamera.js

@@ -49,3 +49,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.VirtualJoysticksCamera = VirtualJoysticksCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.virtualJoysticksCamera.js.map

src/Collisions/babylon.collider.js

@@ -270,3 +270,4 @@ var BABYLON;
     })();
     BABYLON.Collider = Collider;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.collider.js.map

src/Collisions/babylon.collisionCoordinator.js

@@ -271,3 +271,4 @@ var BABYLON;
     })();
     BABYLON.CollisionCoordinatorLegacy = CollisionCoordinatorLegacy;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.collisionCoordinator.js.map

src/Collisions/babylon.collisionWorker.js

@@ -227,3 +227,4 @@ var BABYLON;
         console.log("single worker init");
     }
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.collisionWorker.js.map

src/Collisions/babylon.pickingInfo.js

@@ -73,3 +73,4 @@ var BABYLON;
     })();
     BABYLON.PickingInfo = PickingInfo;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.pickingInfo.js.map

src/Culling/Octrees/babylon.octree.js

@@ -86,3 +86,4 @@ var BABYLON;
     })();
     BABYLON.Octree = Octree;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.octree.js.map

src/Culling/Octrees/babylon.octreeBlock.js

@@ -120,3 +120,4 @@ var BABYLON;
     })();
     BABYLON.OctreeBlock = OctreeBlock;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.octreeBlock.js.map

src/Culling/babylon.boundingBox.js

@@ -137,3 +137,4 @@ var BABYLON;
     })();
     BABYLON.BoundingBox = BoundingBox;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.boundingBox.js.map

src/Culling/babylon.boundingInfo.js

@@ -103,3 +103,4 @@ var BABYLON;
     })();
     BABYLON.BoundingInfo = BoundingInfo;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.boundingInfo.js.map

src/Culling/babylon.boundingSphere.js

@@ -47,3 +47,4 @@ var BABYLON;
     })();
     BABYLON.BoundingSphere = BoundingSphere;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.boundingSphere.js.map

src/Debug/babylon.debugLayer.js

@@ -603,3 +603,4 @@ var BABYLON;
     })();
     BABYLON.DebugLayer = DebugLayer;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.debugLayer.js.map

src/Layer/babylon.layer.js

@@ -74,3 +74,4 @@ var BABYLON;
     })();
     BABYLON.Layer = Layer;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.layer.js.map

src/LensFlare/babylon.lensFlare.js

@@ -21,3 +21,4 @@ var BABYLON;
     })();
     BABYLON.LensFlare = LensFlare;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.lensFlare.js.map

src/LensFlare/babylon.lensFlareSystem.js

@@ -180,3 +180,4 @@ var BABYLON;
     })();
     BABYLON.LensFlareSystem = LensFlareSystem;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.lensFlareSystem.js.map

src/Lights/Shadows/babylon.shadowGenerator.js

@@ -333,3 +333,4 @@ var BABYLON;
     })();
     BABYLON.ShadowGenerator = ShadowGenerator;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.shadowGenerator.js.map

src/Lights/babylon.directionalLight.js

@@ -92,3 +92,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.DirectionalLight = DirectionalLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.directionalLight.js.map

src/Lights/babylon.hemisphericLight.js

@@ -34,3 +34,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.HemisphericLight = HemisphericLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.hemisphericLight.js.map

src/Lights/babylon.light.js

@@ -75,3 +75,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.Light = Light;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.light.js.map

src/Lights/babylon.pointLight.js

@@ -39,3 +39,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.PointLight = PointLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.pointLight.js.map

src/Lights/babylon.spotLight.js

@@ -69,3 +69,4 @@ var BABYLON;
     })(BABYLON.Light);
     BABYLON.SpotLight = SpotLight;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.spotLight.js.map

src/Loading/Plugins/babylon.babylonFileLoader.js

@@ -1431,3 +1431,4 @@ var BABYLON;
         });
     })(Internals = BABYLON.Internals || (BABYLON.Internals = {}));
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.babylonFileLoader.js.map

src/Loading/babylon.sceneLoader.js

@@ -174,3 +174,4 @@ var BABYLON;
     BABYLON.SceneLoader = SceneLoader;
     ;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.sceneLoader.js.map

src/Materials/Textures/Procedurals/babylon.customProceduralTexture.js

@@ -122,3 +122,4 @@ var BABYLON;
     })(BABYLON.ProceduralTexture);
     BABYLON.CustomProceduralTexture = CustomProceduralTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.customProceduralTexture.js.map

src/Materials/Textures/Procedurals/babylon.proceduralTexture.js

@@ -247,3 +247,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.ProceduralTexture = ProceduralTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.proceduralTexture.js.map

src/Materials/Textures/Procedurals/babylon.standardProceduralTexture.js

@@ -417,3 +417,4 @@ var BABYLON;
     })(BABYLON.ProceduralTexture);
     BABYLON.MarbleProceduralTexture = MarbleProceduralTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.standardProceduralTexture.js.map

src/Materials/Textures/babylon.baseTexture.js

@@ -125,3 +125,4 @@ var BABYLON;
     })();
     BABYLON.BaseTexture = BaseTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.baseTexture.js.map

src/Materials/Textures/babylon.cubeTexture.js

@@ -58,3 +58,4 @@ var BABYLON;
     })(BABYLON.BaseTexture);
     BABYLON.CubeTexture = CubeTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.cubeTexture.js.map

src/Materials/Textures/babylon.dynamicTexture.js

@@ -91,3 +91,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.DynamicTexture = DynamicTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.dynamicTexture.js.map

src/Materials/Textures/babylon.mirrorTexture.js

@@ -42,3 +42,4 @@ var BABYLON;
     })(BABYLON.RenderTargetTexture);
     BABYLON.MirrorTexture = MirrorTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.mirrorTexture.js.map

src/Materials/Textures/babylon.rawTexture.js

@@ -55,3 +55,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.RawTexture = RawTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.rawTexture.js.map

src/Materials/Textures/babylon.renderTargetTexture.js

@@ -164,3 +164,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.RenderTargetTexture = RenderTargetTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.renderTargetTexture.js.map

src/Materials/Textures/babylon.texture.js

@@ -211,3 +211,4 @@ var BABYLON;
     })(BABYLON.BaseTexture);
     BABYLON.Texture = Texture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.texture.js.map

src/Materials/Textures/babylon.videoTexture.js

@@ -56,3 +56,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.VideoTexture = VideoTexture;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.videoTexture.js.map

src/Materials/babylon.effect.js

@@ -371,3 +371,4 @@ var BABYLON;
     })();
     BABYLON.Effect = Effect;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.effect.js.map

src/Materials/babylon.material.js

@@ -11,6 +11,7 @@ var BABYLON;
             this.sideOrientation = Material.CounterClockWiseSideOrientation;
             this.alphaMode = BABYLON.Engine.ALPHA_COMBINE;
             this.disableDepthWrite = false;
+            this.fogEnabled = true;
             this._wasPreviouslyReady = false;
             this._fillMode = Material.TriangleFillMode;
             this.pointSize = 1.0;
@@ -147,6 +148,22 @@ var BABYLON;
                 this.onDispose();
             }
         };
+        Material.prototype.copyTo = function (other) {
+            other.checkReadyOnlyOnce = this.checkReadyOnlyOnce;
+            other.checkReadyOnEveryCall = this.checkReadyOnEveryCall;
+            other.alpha = this.alpha;
+            other.fillMode = this.fillMode;
+            other.backFaceCulling = this.backFaceCulling;
+            other.wireframe = this.wireframe;
+            other.fogEnabled = this.fogEnabled;
+            other.wireframe = this.wireframe;
+            other.zOffset = this.zOffset;
+            other.alphaMode = this.alphaMode;
+            other.sideOrientation = this.sideOrientation;
+            other.disableDepthWrite = this.disableDepthWrite;
+            other.pointSize = this.pointSize;
+            other.pointsCloud = this.pointsCloud;
+        };
         Material._TriangleFillMode = 0;
         Material._WireFrameFillMode = 1;
         Material._PointFillMode = 2;
@@ -156,3 +173,4 @@ var BABYLON;
     })();
     BABYLON.Material = Material;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.material.js.map

src/Materials/babylon.material.ts

@@ -41,6 +41,7 @@
         public getRenderTargetTextures: () => SmartArray<RenderTargetTexture>;
         public alphaMode = Engine.ALPHA_COMBINE;
         public disableDepthWrite = false;
+        public fogEnabled = true;
 
         public _effect: Effect;
         public _wasPreviouslyReady = false;
@@ -164,5 +165,22 @@
                 this.onDispose();
             }
         }
+
+        public copyTo(other: Material): void {
+            other.checkReadyOnlyOnce = this.checkReadyOnlyOnce;
+            other.checkReadyOnEveryCall = this.checkReadyOnEveryCall;
+            other.alpha = this.alpha;
+            other.fillMode = this.fillMode;
+            other.backFaceCulling = this.backFaceCulling;
+            other.wireframe = this.wireframe;
+            other.fogEnabled = this.fogEnabled
+            other.wireframe = this.wireframe;
+            other.zOffset = this.zOffset;
+            other.alphaMode = this.alphaMode;
+            other.sideOrientation = this.sideOrientation;
+            other.disableDepthWrite = this.disableDepthWrite;
+            other.pointSize = this.pointSize;
+            other.pointsCloud = this.pointsCloud;
+        }
     }
 } 

src/Materials/babylon.multiMaterial.js

@@ -43,3 +43,4 @@ var BABYLON;
     })(BABYLON.Material);
     BABYLON.MultiMaterial = MultiMaterial;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.multiMaterial.js.map

src/Materials/babylon.pbrMaterial.js

@@ -0,0 +1,262 @@
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var BABYLON;
+(function (BABYLON) {
+    var maxSimultaneousLights = 4;
+    var PBRMaterialDefines = (function () {
+        function PBRMaterialDefines() {
+            this.ALBEDO = false;
+            this.CLIPPLANE = false;
+            this.ALPHATEST = false;
+            this.FOG = false;
+            this.NORMAL = false;
+            this.UV1 = false;
+            this.UV2 = false;
+            this.VERTEXCOLOR = false;
+            this.VERTEXALPHA = false;
+            this.BONES = false;
+            this.BONES4 = false;
+            this.BonesPerMesh = 0;
+            this.INSTANCES = false;
+            this.POINTSIZE = false;
+            this._keys = Object.keys(this);
+        }
+        PBRMaterialDefines.prototype.isEqual = function (other) {
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+                if (this[prop] !== other[prop]) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        PBRMaterialDefines.prototype.cloneTo = function (other) {
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+                other[prop] = this[prop];
+            }
+        };
+        PBRMaterialDefines.prototype.reset = function () {
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+                if (prop === "BonesPerMesh") {
+                    this[prop] = 0;
+                    continue;
+                }
+                this[prop] = false;
+            }
+        };
+        PBRMaterialDefines.prototype.toString = function () {
+            var result = "";
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+                if (prop === "BonesPerMesh" && this[prop] > 0) {
+                    result += "#define BonesPerMesh " + this[prop] + "\n";
+                    continue;
+                }
+                if (this[prop]) {
+                    result += "#define " + prop + "\n";
+                }
+            }
+            return result;
+        };
+        return PBRMaterialDefines;
+    })();
+    var PBRMaterial = (function (_super) {
+        __extends(PBRMaterial, _super);
+        function PBRMaterial(name, scene) {
+            _super.call(this, name, scene);
+            this.albedoColor = new BABYLON.Color3(1, 1, 1);
+            this._worldViewProjectionMatrix = BABYLON.Matrix.Zero();
+            this._globalAmbientColor = new BABYLON.Color3(0, 0, 0);
+            this._scaledDiffuse = new BABYLON.Color3();
+            this._scaledSpecular = new BABYLON.Color3();
+            this._defines = new PBRMaterialDefines();
+            this._cachedDefines = new PBRMaterialDefines();
+            this._cachedDefines.BonesPerMesh = -1;
+        }
+        PBRMaterial.prototype.needAlphaBlending = function () {
+            return this.alpha < 1.0;
+        };
+        PBRMaterial.prototype.needAlphaTesting = function () {
+            return false;
+        };
+        PBRMaterial.prototype.getAlphaTestTexture = function () {
+            return null;
+        };
+        // Methods   
+        PBRMaterial.prototype.isReady = function (mesh, useInstances) {
+            if (this.checkReadyOnlyOnce) {
+                if (this._wasPreviouslyReady) {
+                    return true;
+                }
+            }
+            var scene = this.getScene();
+            if (!this.checkReadyOnEveryCall) {
+                if (this._renderId === scene.getRenderId()) {
+                    return true;
+                }
+            }
+            var engine = scene.getEngine();
+            var needNormals = false;
+            var needUVs = false;
+            this._defines.reset();
+            // Textures
+            if (scene.texturesEnabled) {
+            }
+            // Effect
+            if (scene.clipPlane) {
+                this._defines.CLIPPLANE = true;
+            }
+            if (engine.getAlphaTesting()) {
+                this._defines.ALPHATEST = true;
+            }
+            // Point size
+            if (this.pointsCloud || scene.forcePointsCloud) {
+                this._defines.POINTSIZE = true;
+            }
+            // Fog
+            if (scene.fogEnabled && mesh && mesh.applyFog && scene.fogMode !== BABYLON.Scene.FOGMODE_NONE && this.fogEnabled) {
+                this._defines.FOG = true;
+            }
+            // Lights
+            // Attribs
+            if (mesh) {
+                if (needNormals && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.NormalKind)) {
+                    this._defines.NORMAL = true;
+                }
+                if (needUVs) {
+                    if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.UVKind)) {
+                        this._defines.UV1 = true;
+                    }
+                    if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.UV2Kind)) {
+                        this._defines.UV2 = true;
+                    }
+                }
+                if (mesh.useVertexColors && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.ColorKind)) {
+                    this._defines.VERTEXCOLOR = true;
+                    if (mesh.hasVertexAlpha) {
+                        this._defines.VERTEXALPHA = true;
+                    }
+                }
+                if (mesh.useBones && mesh.computeBonesUsingShaders) {
+                    this._defines.BONES = true;
+                    this._defines.BonesPerMesh = (mesh.skeleton.bones.length + 1);
+                    this._defines.BONES4 = true;
+                }
+                // Instances
+                if (useInstances) {
+                    this._defines.INSTANCES = true;
+                }
+            }
+            // Get correct effect      
+            if (!this._defines.isEqual(this._cachedDefines)) {
+                this._defines.cloneTo(this._cachedDefines);
+                scene.resetCachedMaterial();
+                // Fallbacks
+                var fallbacks = new BABYLON.EffectFallbacks();
+                if (this._defines.FOG) {
+                    fallbacks.addFallback(1, "FOG");
+                }
+                if (this._defines.BONES4) {
+                    fallbacks.addFallback(0, "BONES4");
+                }
+                //Attributes
+                var attribs = [BABYLON.VertexBuffer.PositionKind];
+                if (this._defines.NORMAL) {
+                    attribs.push(BABYLON.VertexBuffer.NormalKind);
+                }
+                if (this._defines.UV1) {
+                    attribs.push(BABYLON.VertexBuffer.UVKind);
+                }
+                if (this._defines.UV2) {
+                    attribs.push(BABYLON.VertexBuffer.UV2Kind);
+                }
+                if (this._defines.VERTEXCOLOR) {
+                    attribs.push(BABYLON.VertexBuffer.ColorKind);
+                }
+                if (this._defines.BONES) {
+                    attribs.push(BABYLON.VertexBuffer.MatricesIndicesKind);
+                    attribs.push(BABYLON.VertexBuffer.MatricesWeightsKind);
+                }
+                if (this._defines.INSTANCES) {
+                    attribs.push("world0");
+                    attribs.push("world1");
+                    attribs.push("world2");
+                    attribs.push("world3");
+                }
+                // Legacy browser patch
+                var join = this._defines.toString();
+                this._effect = scene.getEngine().createEffect("pbr", attribs, ["world", "view", "viewProjection", "vEyePosition", "vAlbedoColor",
+                    "vFogInfos", "vFogColor", "pointSize",
+                    "mBones",
+                    "vClipPlane",
+                ], [], join, fallbacks, this.onCompiled, this.onError);
+            }
+            if (!this._effect.isReady()) {
+                return false;
+            }
+            this._renderId = scene.getRenderId();
+            this._wasPreviouslyReady = true;
+            return true;
+        };
+        PBRMaterial.prototype.bindOnlyWorldMatrix = function (world) {
+            this._effect.setMatrix("world", world);
+        };
+        PBRMaterial.prototype.bind = function (world, mesh) {
+            var scene = this.getScene();
+            // Matrices        
+            this.bindOnlyWorldMatrix(world);
+            this._effect.setMatrix("viewProjection", scene.getTransformMatrix());
+            // Bones
+            if (mesh && mesh.useBones && mesh.computeBonesUsingShaders) {
+                this._effect.setMatrices("mBones", mesh.skeleton.getTransformMatrices());
+            }
+            if (scene.getCachedMaterial() !== this) {
+                // Clip plane
+                if (scene.clipPlane) {
+                    var clipPlane = scene.clipPlane;
+                    this._effect.setFloat4("vClipPlane", clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.d);
+                }
+                this._effect.setVector3("vEyePosition", scene.activeCamera.position);
+            }
+            // Point size
+            if (this.pointsCloud) {
+                this._effect.setFloat("pointSize", this.pointSize);
+            }
+            // Colors
+            this._effect.setColor4("vAlbedoColor", this.albedoColor, this.alpha * mesh.visibility);
+            // View
+            if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== BABYLON.Scene.FOGMODE_NONE) {
+                this._effect.setMatrix("view", scene.getViewMatrix());
+            }
+            // Fog
+            if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== BABYLON.Scene.FOGMODE_NONE) {
+                this._effect.setFloat4("vFogInfos", scene.fogMode, scene.fogStart, scene.fogEnd, scene.fogDensity);
+                this._effect.setColor3("vFogColor", scene.fogColor);
+            }
+            _super.prototype.bind.call(this, world, mesh);
+        };
+        PBRMaterial.prototype.getAnimatables = function () {
+            var results = [];
+            return results;
+        };
+        PBRMaterial.prototype.dispose = function (forceDisposeEffect) {
+            _super.prototype.dispose.call(this, forceDisposeEffect);
+        };
+        PBRMaterial.prototype.clone = function (name) {
+            var newPBRMaterial = new PBRMaterial(name, this.getScene());
+            // Base material
+            this.copyTo(newPBRMaterial);
+            // PBRMaterial material
+            newPBRMaterial.albedoColor = this.albedoColor.clone();
+            return newPBRMaterial;
+        };
+        return PBRMaterial;
+    })(BABYLON.Material);
+    BABYLON.PBRMaterial = PBRMaterial;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.pbrMaterial.js.map

src/Materials/babylon.pbrMaterial.ts

@@ -0,0 +1,328 @@
+module BABYLON {
+    var maxSimultaneousLights = 4;
+
+    class PBRMaterialDefines {
+        public ALBEDO = false;
+        public CLIPPLANE = false;
+        public ALPHATEST = false;
+        public FOG = false;
+        public NORMAL = false;
+        public UV1 = false;
+        public UV2 = false;
+        public VERTEXCOLOR = false;
+        public VERTEXALPHA = false;
+        public BONES = false;
+        public BONES4 = false;
+        public BonesPerMesh = 0;
+        public INSTANCES = false;
+        public POINTSIZE = false;
+
+        _keys: string[];
+
+        constructor() {
+            this._keys = Object.keys(this);
+        }
+
+        public isEqual(other: PBRMaterialDefines): boolean {
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+
+                if (this[prop] !== other[prop]) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public cloneTo(other: PBRMaterialDefines): void {
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+
+                other[prop] = this[prop];
+            }
+        }
+
+        public reset(): void {
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+
+                if (prop === "BonesPerMesh") {
+                    this[prop] = 0;
+                    continue;
+                }
+
+                this[prop] = false;
+            }
+        }
+
+        public toString(): string {
+            var result = "";
+            for (var index = 0; index < this._keys.length; index++) {
+                var prop = this._keys[index];
+
+                if (prop === "BonesPerMesh" && this[prop] > 0) {
+                    result += "#define BonesPerMesh " + this[prop] + "\n";
+                    continue;
+                }
+
+                if (this[prop]) {
+                    result += "#define " + prop + "\n";
+                }
+            }
+
+            return result;
+        }
+    }
+
+    export class PBRMaterial extends Material {
+        public albedoColor = new Color3(1, 1, 1);
+
+        private _worldViewProjectionMatrix = Matrix.Zero();
+        private _globalAmbientColor = new Color3(0, 0, 0);
+        private _scaledDiffuse = new Color3();
+        private _scaledSpecular = new Color3();
+        private _renderId: number;
+
+        private _defines = new PBRMaterialDefines();
+        private _cachedDefines = new PBRMaterialDefines();
+
+        constructor(name: string, scene: Scene) {
+            super(name, scene);
+
+            this._cachedDefines.BonesPerMesh = -1;
+        }
+
+        public needAlphaBlending(): boolean {
+            return this.alpha < 1.0;
+        }
+
+        public needAlphaTesting(): boolean {
+            return false;
+        }
+
+        public getAlphaTestTexture(): BaseTexture {
+            return null;
+        }
+
+        // Methods   
+        public isReady(mesh?: AbstractMesh, useInstances?: boolean): boolean {
+            if (this.checkReadyOnlyOnce) {
+                if (this._wasPreviouslyReady) {
+                    return true;
+                }
+            }
+
+            var scene = this.getScene();
+
+            if (!this.checkReadyOnEveryCall) {
+                if (this._renderId === scene.getRenderId()) {
+                    return true;
+                }
+            }
+
+            var engine = scene.getEngine();
+            var needNormals = false;
+            var needUVs = false;
+
+            this._defines.reset();
+
+            // Textures
+            if (scene.texturesEnabled) {        
+            }
+
+            // Effect
+            if (scene.clipPlane) {
+                this._defines.CLIPPLANE = true;
+            }
+
+            if (engine.getAlphaTesting()) {
+                this._defines.ALPHATEST = true;
+            }
+
+            // Point size
+            if (this.pointsCloud || scene.forcePointsCloud) {
+                this._defines.POINTSIZE = true;
+            }
+
+            // Fog
+            if (scene.fogEnabled && mesh && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE && this.fogEnabled) {
+                this._defines.FOG = true;
+            }
+            
+            // Lights
+
+            // Attribs
+            if (mesh) {
+                if (needNormals && mesh.isVerticesDataPresent(VertexBuffer.NormalKind)) {
+                    this._defines.NORMAL = true;
+                }
+                if (needUVs) {
+                    if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
+                        this._defines.UV1 = true;
+                    }
+                    if (mesh.isVerticesDataPresent(VertexBuffer.UV2Kind)) {
+                        this._defines.UV2 = true;
+                    }
+                }
+                if (mesh.useVertexColors && mesh.isVerticesDataPresent(VertexBuffer.ColorKind)) {
+                    this._defines.VERTEXCOLOR = true;
+
+                    if (mesh.hasVertexAlpha) {
+                        this._defines.VERTEXALPHA = true
+                    }
+                }
+                if (mesh.useBones && mesh.computeBonesUsingShaders) {
+                    this._defines.BONES = true;
+                    this._defines.BonesPerMesh = (mesh.skeleton.bones.length + 1);
+                    this._defines.BONES4 = true;
+                }
+
+                // Instances
+                if (useInstances) {
+                    this._defines.INSTANCES = true;
+                }
+            }
+
+            // Get correct effect      
+            if (!this._defines.isEqual(this._cachedDefines)) {
+                this._defines.cloneTo(this._cachedDefines);
+
+                scene.resetCachedMaterial();
+
+                // Fallbacks
+                var fallbacks = new EffectFallbacks();              
+                if (this._defines.FOG) {
+                    fallbacks.addFallback(1, "FOG");
+                }             
+
+                if (this._defines.BONES4) {
+                    fallbacks.addFallback(0, "BONES4");
+                }
+
+                //Attributes
+                var attribs = [VertexBuffer.PositionKind];
+
+                if (this._defines.NORMAL) {
+                    attribs.push(VertexBuffer.NormalKind);
+                }
+
+                if (this._defines.UV1) {
+                    attribs.push(VertexBuffer.UVKind);
+                }
+
+                if (this._defines.UV2) {
+                    attribs.push(VertexBuffer.UV2Kind);
+                }
+
+                if (this._defines.VERTEXCOLOR) {
+                    attribs.push(VertexBuffer.ColorKind);
+                }
+
+                if (this._defines.BONES) {
+                    attribs.push(VertexBuffer.MatricesIndicesKind);
+                    attribs.push(VertexBuffer.MatricesWeightsKind);
+                }
+
+                if (this._defines.INSTANCES) {
+                    attribs.push("world0");
+                    attribs.push("world1");
+                    attribs.push("world2");
+                    attribs.push("world3");
+                }
+
+                // Legacy browser patch
+                var join = this._defines.toString();
+                this._effect = scene.getEngine().createEffect("pbr",
+                    attribs,
+                    ["world", "view", "viewProjection", "vEyePosition", "vAlbedoColor",                        
+                        "vFogInfos", "vFogColor", "pointSize",
+                        "mBones",
+                        "vClipPlane",
+                    ],
+                    [],
+                    join, fallbacks, this.onCompiled, this.onError);
+            }
+            if (!this._effect.isReady()) {
+                return false;
+            }
+
+            this._renderId = scene.getRenderId();
+            this._wasPreviouslyReady = true;
+            return true;
+        }
+
+        public bindOnlyWorldMatrix(world: Matrix): void {
+            this._effect.setMatrix("world", world);
+        }
+
+        public bind(world: Matrix, mesh?: Mesh): void {
+            var scene = this.getScene();
+
+            // Matrices        
+            this.bindOnlyWorldMatrix(world);
+            this._effect.setMatrix("viewProjection", scene.getTransformMatrix());
+
+            // Bones
+            if (mesh && mesh.useBones && mesh.computeBonesUsingShaders) {
+                this._effect.setMatrices("mBones", mesh.skeleton.getTransformMatrices());
+            }
+
+            if (scene.getCachedMaterial() !== this) {
+                // Clip plane
+                if (scene.clipPlane) {
+                    var clipPlane = scene.clipPlane;
+                    this._effect.setFloat4("vClipPlane", clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.d);
+                }
+                
+                this._effect.setVector3("vEyePosition", scene.activeCamera.position);              
+            }
+
+            // Point size
+            if (this.pointsCloud) {
+                this._effect.setFloat("pointSize", this.pointSize);
+            }
+
+            // Colors
+            this._effect.setColor4("vAlbedoColor", this.albedoColor, this.alpha * mesh.visibility);
+      
+            // View
+            if (scene.fogEnabled && mesh.applyFog &&scene.fogMode !== Scene.FOGMODE_NONE) {
+                this._effect.setMatrix("view", scene.getViewMatrix());
+            }
+
+            // Fog
+            if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
+                this._effect.setFloat4("vFogInfos", scene.fogMode, scene.fogStart, scene.fogEnd, scene.fogDensity);
+                this._effect.setColor3("vFogColor", scene.fogColor);
+            }
+
+            super.bind(world, mesh);
+        }
+
+        public getAnimatables(): IAnimatable[] {
+            var results = [];         
+
+            return results;
+        }
+
+        public dispose(forceDisposeEffect?: boolean): void {        
+            super.dispose(forceDisposeEffect);
+        }
+
+        public clone(name: string): PBRMaterial {
+            var newPBRMaterial = new PBRMaterial(name, this.getScene());
+
+            // Base material
+            this.copyTo(newPBRMaterial);
+
+            // PBRMaterial material
+            newPBRMaterial.albedoColor = this.albedoColor.clone();
+
+            return newPBRMaterial;
+        }
+
+        // Statics
+        // Flags used to enable or disable a type of texture for all PBR Materials
+    }
+} 

src/Materials/babylon.shaderMaterial.js

@@ -231,3 +231,4 @@ var BABYLON;
     })(BABYLON.Material);
     BABYLON.ShaderMaterial = ShaderMaterial;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.shaderMaterial.js.map

src/Materials/babylon.standardMaterial.js

@@ -14,6 +14,11 @@ var BABYLON;
             this.bias = 0;
             this.power = 1;
         }
+        FresnelParameters.prototype.clone = function () {
+            var newFresnelParameters = new FresnelParameters();
+            BABYLON.Tools.DeepCopy(this, newFresnelParameters);
+            return new FresnelParameters;
+        };
         return FresnelParameters;
     })();
     BABYLON.FresnelParameters = FresnelParameters;
@@ -139,7 +144,6 @@ var BABYLON;
             this.useEmissiveAsIllumination = false;
             this.useReflectionFresnelFromSpecular = false;
             this.useSpecularOverAlpha = true;
-            this.fogEnabled = true;
             this.roughness = 0;
             this.lightmapThreshold = 0;
             this.useGlossinessFromSpecularMapAlpha = false;
@@ -749,10 +753,7 @@ var BABYLON;
         StandardMaterial.prototype.clone = function (name) {
             var newStandardMaterial = new StandardMaterial(name, this.getScene());
             // Base material
-            newStandardMaterial.checkReadyOnEveryCall = this.checkReadyOnEveryCall;
-            newStandardMaterial.alpha = this.alpha;
-            newStandardMaterial.fillMode = this.fillMode;
-            newStandardMaterial.backFaceCulling = this.backFaceCulling;
+            this.copyTo(newStandardMaterial);
             // Standard material
             if (this.diffuseTexture && this.diffuseTexture.clone) {
                 newStandardMaterial.diffuseTexture = this.diffuseTexture.clone();
@@ -775,11 +776,26 @@ var BABYLON;
             if (this.bumpTexture && this.bumpTexture.clone) {
                 newStandardMaterial.bumpTexture = this.bumpTexture.clone();
             }
+            if (this.lightmapTexture && this.lightmapTexture.clone) {
+                newStandardMaterial.bumpTexture = this.bumpTexture.clone();
+                newStandardMaterial.lightmapTexture = this.lightmapTexture.clone();
+                newStandardMaterial.lightmapThreshold = this.lightmapThreshold;
+            }
             newStandardMaterial.ambientColor = this.ambientColor.clone();
             newStandardMaterial.diffuseColor = this.diffuseColor.clone();
             newStandardMaterial.specularColor = this.specularColor.clone();
             newStandardMaterial.specularPower = this.specularPower;
             newStandardMaterial.emissiveColor = this.emissiveColor.clone();
+            newStandardMaterial.useAlphaFromDiffuseTexture = this.useAlphaFromDiffuseTexture;
+            newStandardMaterial.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
+            newStandardMaterial.useGlossinessFromSpecularMapAlpha = this.useGlossinessFromSpecularMapAlpha;
+            newStandardMaterial.useReflectionFresnelFromSpecular = this.useReflectionFresnelFromSpecular;
+            newStandardMaterial.useSpecularOverAlpha = this.useSpecularOverAlpha;
+            newStandardMaterial.roughness = this.roughness;
+            newStandardMaterial.diffuseFresnelParameters = this.diffuseFresnelParameters.clone();
+            newStandardMaterial.emissiveFresnelParameters = this.emissiveFresnelParameters.clone();
+            newStandardMaterial.reflectionFresnelParameters = this.reflectionFresnelParameters.clone();
+            newStandardMaterial.opacityFresnelParameters = this.opacityFresnelParameters.clone();
             return newStandardMaterial;
         };
         // Statics
@@ -797,3 +813,4 @@ var BABYLON;
     })(BABYLON.Material);
     BABYLON.StandardMaterial = StandardMaterial;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.standardMaterial.js.map

src/Materials/babylon.standardMaterial.ts

@@ -7,6 +7,14 @@
         public rightColor = Color3.Black();
         public bias = 0;
         public power = 1;
+
+        public clone(): FresnelParameters {
+            var newFresnelParameters = new FresnelParameters();
+
+            Tools.DeepCopy(this, newFresnelParameters);
+
+            return new FresnelParameters;
+        }
     }
 
     class StandardMaterialDefines {
@@ -151,7 +159,6 @@
         public useEmissiveAsIllumination = false;
         public useReflectionFresnelFromSpecular = false;
         public useSpecularOverAlpha = true;
-        public fogEnabled = true;
 
         public roughness = 0;
 
@@ -916,10 +923,7 @@
             var newStandardMaterial = new StandardMaterial(name, this.getScene());
 
             // Base material
-            newStandardMaterial.checkReadyOnEveryCall = this.checkReadyOnEveryCall;
-            newStandardMaterial.alpha = this.alpha;
-            newStandardMaterial.fillMode = this.fillMode;
-            newStandardMaterial.backFaceCulling = this.backFaceCulling;
+            this.copyTo(newStandardMaterial);
 
             // Standard material
             if (this.diffuseTexture && this.diffuseTexture.clone) {
@@ -943,12 +947,28 @@
             if (this.bumpTexture && this.bumpTexture.clone) {
                 newStandardMaterial.bumpTexture = this.bumpTexture.clone();
             }
+            if (this.lightmapTexture && this.lightmapTexture.clone) {
+                newStandardMaterial.bumpTexture = this.bumpTexture.clone();
+                newStandardMaterial.lightmapTexture = this.lightmapTexture.clone();
+                newStandardMaterial.lightmapThreshold = this.lightmapThreshold;
+            }
 
             newStandardMaterial.ambientColor = this.ambientColor.clone();
             newStandardMaterial.diffuseColor = this.diffuseColor.clone();
             newStandardMaterial.specularColor = this.specularColor.clone();
             newStandardMaterial.specularPower = this.specularPower;
             newStandardMaterial.emissiveColor = this.emissiveColor.clone();
+            newStandardMaterial.useAlphaFromDiffuseTexture = this.useAlphaFromDiffuseTexture;
+            newStandardMaterial.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
+            newStandardMaterial.useGlossinessFromSpecularMapAlpha = this.useGlossinessFromSpecularMapAlpha;
+            newStandardMaterial.useReflectionFresnelFromSpecular = this.useReflectionFresnelFromSpecular;
+            newStandardMaterial.useSpecularOverAlpha = this.useSpecularOverAlpha;
+            newStandardMaterial.roughness = this.roughness;
+
+            newStandardMaterial.diffuseFresnelParameters = this.diffuseFresnelParameters.clone();
+            newStandardMaterial.emissiveFresnelParameters = this.emissiveFresnelParameters.clone();
+            newStandardMaterial.reflectionFresnelParameters = this.reflectionFresnelParameters.clone();
+            newStandardMaterial.opacityFresnelParameters = this.opacityFresnelParameters.clone();
 
             return newStandardMaterial;
         }

src/Math/babylon.math.js

@@ -3136,3 +3136,4 @@ var BABYLON;
     })();
     BABYLON.SIMDHelper = SIMDHelper;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.math.js.map

src/Mesh/babylon.abstractMesh.js

@@ -888,3 +888,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.AbstractMesh = AbstractMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.abstractMesh.js.map

src/Mesh/babylon.csg.js

@@ -508,3 +508,4 @@ var BABYLON;
     })();
     BABYLON.CSG = CSG;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.csg.js.map

src/Mesh/babylon.geometry.js

@@ -608,3 +608,4 @@ var BABYLON;
         })(Primitives = Geometry.Primitives || (Geometry.Primitives = {}));
     })(Geometry = BABYLON.Geometry || (BABYLON.Geometry = {}));
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.geometry.js.map

src/Mesh/babylon.groundMesh.js

@@ -39,3 +39,4 @@ var BABYLON;
     })(BABYLON.Mesh);
     BABYLON.GroundMesh = GroundMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.groundMesh.js.map

src/Mesh/babylon.instancedMesh.js

@@ -150,3 +150,4 @@ var BABYLON;
     })(BABYLON.AbstractMesh);
     BABYLON.InstancedMesh = InstancedMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.instancedMesh.js.map

src/Mesh/babylon.linesMesh.js

@@ -69,3 +69,4 @@ var BABYLON;
     })(BABYLON.Mesh);
     BABYLON.LinesMesh = LinesMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.linesMesh.js.map

src/Mesh/babylon.mesh.js

@@ -1911,3 +1911,4 @@ var BABYLON;
     })(BABYLON.AbstractMesh);
     BABYLON.Mesh = Mesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.mesh.js.map

src/Mesh/babylon.mesh.vertexData.js

@@ -1270,3 +1270,4 @@ var BABYLON;
     })();
     BABYLON.VertexData = VertexData;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.mesh.vertexData.js.map

src/Mesh/babylon.meshLODLevel.js

@@ -12,3 +12,4 @@ var BABYLON;
         Internals.MeshLODLevel = MeshLODLevel;
     })(Internals = BABYLON.Internals || (BABYLON.Internals = {}));
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.meshLODLevel.js.map

src/Mesh/babylon.meshSimplification.js

@@ -656,3 +656,4 @@ var BABYLON;
     })();
     BABYLON.QuadraticErrorSimplification = QuadraticErrorSimplification;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.meshSimplification.js.map

src/Mesh/babylon.polygonMesh.js

@@ -243,3 +243,4 @@ var BABYLON;
     })();
     BABYLON.PolygonMeshBuilder = PolygonMeshBuilder;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.polygonMesh.js.map

src/Mesh/babylon.subMesh.js

@@ -143,3 +143,4 @@ var BABYLON;
     })();
     BABYLON.SubMesh = SubMesh;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.subMesh.js.map

src/Mesh/babylon.vertexBuffer.js

@@ -190,3 +190,4 @@ var BABYLON;
     })();
     BABYLON.VertexBuffer = VertexBuffer;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.vertexBuffer.js.map

src/Particles/babylon.particle.js

@@ -27,3 +27,4 @@ var BABYLON;
     })();
     BABYLON.Particle = Particle;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.particle.js.map

src/Particles/babylon.particleSystem.js

@@ -335,3 +335,4 @@ var BABYLON;
     })();
     BABYLON.ParticleSystem = ParticleSystem;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.particleSystem.js.map

src/Physics/Plugins/babylon.cannonJSPlugin.js

@@ -251,3 +251,4 @@ var BABYLON;
     })();
     BABYLON.CannonJSPlugin = CannonJSPlugin;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.cannonJSPlugin.js.map

src/Physics/Plugins/babylon.oimoJSPlugin.js

@@ -314,3 +314,4 @@ var BABYLON;
     })();
     BABYLON.OimoJSPlugin = OimoJSPlugin;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.oimoJSPlugin.js.map

src/Physics/babylon.physicsEngine.js

@@ -60,3 +60,4 @@ var BABYLON;
     })();
     BABYLON.PhysicsEngine = PhysicsEngine;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.physicsEngine.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js

@@ -138,3 +138,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderEffect = PostProcessRenderEffect;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderEffect.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js

@@ -40,3 +40,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPass = PostProcessRenderPass;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPass.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js

@@ -110,3 +110,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPipeline = PostProcessRenderPipeline;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPipeline.js.map

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js

@@ -58,3 +58,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPipelineManager = PostProcessRenderPipelineManager;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPipelineManager.js.map

src/PostProcess/babylon.anaglyphPostProcess.js

@@ -14,3 +14,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.AnaglyphPostProcess = AnaglyphPostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.anaglyphPostProcess.js.map

src/PostProcess/babylon.blackAndWhitePostProcess.js

@@ -14,3 +14,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.BlackAndWhitePostProcess = BlackAndWhitePostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.blackAndWhitePostProcess.js.map

src/PostProcess/babylon.blurPostProcess.js

@@ -23,3 +23,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.BlurPostProcess = BlurPostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.blurPostProcess.js.map

src/PostProcess/babylon.colorCorrectionPostProcess.js

@@ -35,3 +35,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.ColorCorrectionPostProcess = ColorCorrectionPostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.colorCorrectionPostProcess.js.map

src/PostProcess/babylon.convolutionPostProcess.js

@@ -28,3 +28,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.ConvolutionPostProcess = ConvolutionPostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.convolutionPostProcess.js.map

src/PostProcess/babylon.displayPassPostProcess.js

@@ -14,3 +14,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.DisplayPassPostProcess = DisplayPassPostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.displayPassPostProcess.js.map

src/PostProcess/babylon.filterPostProcess.js

@@ -19,3 +19,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.FilterPostProcess = FilterPostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.filterPostProcess.js.map

src/PostProcess/babylon.fxaaPostProcess.js

@@ -22,3 +22,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.FxaaPostProcess = FxaaPostProcess;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.fxaaPostProcess.js.map