Fixing a bunch of bugs

Babylon/Actions/babylon.action.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Action = (function () {
         function Action(triggerOptions, condition) {
@@ -6,71 +6,59 @@
             if (triggerOptions.parameter) {
                 this.trigger = triggerOptions.trigger;
                 this._triggerParameter = triggerOptions.parameter;
-            } else {
+            }
+            else {
                 this.trigger = triggerOptions;
             }
-
             this._nextActiveAction = this;
             this._condition = condition;
         }
         // Methods
         Action.prototype._prepare = function () {
         };
-
         Action.prototype.getTriggerParameter = function () {
             return this._triggerParameter;
         };
-
         Action.prototype._executeCurrent = function (evt) {
             if (this._condition) {
                 var currentRenderId = this._actionManager.getScene().getRenderId();
-
                 // We cache the current evaluation for the current frame
                 if (this._condition._evaluationId === currentRenderId) {
                     if (!this._condition._currentResult) {
                         return;
                     }
-                } else {
+                }
+                else {
                     this._condition._evaluationId = currentRenderId;
-
                     if (!this._condition.isValid()) {
                         this._condition._currentResult = false;
                         return;
                     }
-
                     this._condition._currentResult = true;
                 }
             }
-
             this._nextActiveAction.execute(evt);
-
             if (this._nextActiveAction._child) {
                 if (!this._nextActiveAction._child._actionManager) {
                     this._nextActiveAction._child._actionManager = this._actionManager;
                 }
-
                 this._nextActiveAction = this._nextActiveAction._child;
-            } else {
+            }
+            else {
                 this._nextActiveAction = this;
             }
         };
-
         Action.prototype.execute = function (evt) {
         };
-
         Action.prototype.then = function (action) {
             this._child = action;
-
             action._actionManager = this._actionManager;
             action._prepare();
-
             return action;
         };
-
         Action.prototype._getProperty = function (propertyPath) {
             return this._actionManager._getProperty(propertyPath);
         };
-
         Action.prototype._getEffectiveTarget = function (target, propertyPath) {
             return this._actionManager._getEffectiveTarget(target, propertyPath);
         };
@@ -78,4 +66,4 @@
     })();
     BABYLON.Action = Action;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.action.js.map
+//# sourceMappingURL=babylon.action.js.map

Babylon/Actions/babylon.actionManager.js

@@ -1,17 +1,17 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     /**
-    * ActionEvent is the event beint sent when an action is triggered.
-    */
+     * ActionEvent is the event beint sent when an action is triggered.
+     */
     var ActionEvent = (function () {
         /**
-        * @constructor
-        * @param source The mesh that triggered the action.
-        * @param pointerX the X mouse cursor position at the time of the event
-        * @param pointerY the Y mouse cursor position at the time of the event
-        * @param meshUnderPointer The mesh that is currently pointed at (can be null)
-        * @param sourceEvent the original (browser) event that triggered the ActionEvent
-        */
+         * @constructor
+         * @param source The mesh that triggered the action.
+         * @param pointerX the X mouse cursor position at the time of the event
+         * @param pointerY the Y mouse cursor position at the time of the event
+         * @param meshUnderPointer The mesh that is currently pointed at (can be null)
+         * @param sourceEvent the original (browser) event that triggered the ActionEvent
+         */
         function ActionEvent(source, pointerX, pointerY, meshUnderPointer, sourceEvent) {
             this.source = source;
             this.pointerX = pointerX;
@@ -20,37 +20,34 @@
             this.sourceEvent = sourceEvent;
         }
         /**
-        * Helper function to auto-create an ActionEvent from a source mesh.
-        * @param source the source mesh that triggered the event
-        * @param evt {Event} The original (browser) event
-        */
+         * Helper function to auto-create an ActionEvent from a source mesh.
+         * @param source the source mesh that triggered the event
+         * @param evt {Event} The original (browser) event
+         */
         ActionEvent.CreateNew = function (source, evt) {
             var scene = source.getScene();
             return new ActionEvent(source, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt);
         };
-
         /**
-        * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
-        * @param scene the scene where the event occurred
-        * @param evt {Event} The original (browser) event
-        */
+         * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
+         * @param scene the scene where the event occurred
+         * @param evt {Event} The original (browser) event
+         */
         ActionEvent.CreateNewFromScene = function (scene, evt) {
             return new ActionEvent(null, scene.pointerX, scene.pointerY, scene.meshUnderPointer, evt);
         };
         return ActionEvent;
     })();
     BABYLON.ActionEvent = ActionEvent;
-
     /**
-    * Action Manager manages all events to be triggered on a given mesh or the global scene.
-    * A single scene can have many Action Managers to handle predefined actions on specific meshes.
-    */
+     * Action Manager manages all events to be triggered on a given mesh or the global scene.
+     * A single scene can have many Action Managers to handle predefined actions on specific meshes.
+     */
     var ActionManager = (function () {
         function ActionManager(scene) {
             // Members
             this.actions = new Array();
             this._scene = scene;
-
             scene._actionManagers.push(this);
         }
         Object.defineProperty(ActionManager, "NothingTrigger", {
@@ -60,7 +57,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnPickTrigger", {
             get: function () {
                 return ActionManager._OnPickTrigger;
@@ -68,7 +64,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnLeftPickTrigger", {
             get: function () {
                 return ActionManager._OnLeftPickTrigger;
@@ -76,7 +71,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnRightPickTrigger", {
             get: function () {
                 return ActionManager._OnRightPickTrigger;
@@ -84,7 +78,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnCenterPickTrigger", {
             get: function () {
                 return ActionManager._OnCenterPickTrigger;
@@ -92,7 +85,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnPointerOverTrigger", {
             get: function () {
                 return ActionManager._OnPointerOverTrigger;
@@ -100,7 +92,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnPointerOutTrigger", {
             get: function () {
                 return ActionManager._OnPointerOutTrigger;
@@ -108,7 +99,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnEveryFrameTrigger", {
             get: function () {
                 return ActionManager._OnEveryFrameTrigger;
@@ -116,7 +106,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnIntersectionEnterTrigger", {
             get: function () {
                 return ActionManager._OnIntersectionEnterTrigger;
@@ -124,7 +113,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnIntersectionExitTrigger", {
             get: function () {
                 return ActionManager._OnIntersectionExitTrigger;
@@ -132,7 +120,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnKeyDownTrigger", {
             get: function () {
                 return ActionManager._OnKeyDownTrigger;
@@ -140,7 +127,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager, "OnKeyUpTrigger", {
             get: function () {
                 return ActionManager._OnKeyUpTrigger;
@@ -148,82 +134,69 @@
             enumerable: true,
             configurable: true
         });
-
         // Methods
         ActionManager.prototype.dispose = function () {
             var index = this._scene._actionManagers.indexOf(this);
-
             if (index > -1) {
                 this._scene._actionManagers.splice(index, 1);
             }
         };
-
         ActionManager.prototype.getScene = function () {
             return this._scene;
         };
-
         /**
-        * Does this action manager handles actions of any of the given triggers
-        * @param {number[]} triggers - the triggers to be tested
-        * @return {boolean} whether one (or more) of the triggers is handeled
-        */
+         * Does this action manager handles actions of any of the given triggers
+         * @param {number[]} triggers - the triggers to be tested
+         * @return {boolean} whether one (or more) of the triggers is handeled
+         */
         ActionManager.prototype.hasSpecificTriggers = function (triggers) {
             for (var index = 0; index < this.actions.length; index++) {
                 var action = this.actions[index];
-
                 if (triggers.indexOf(action.trigger) > -1) {
                     return true;
                 }
             }
-
             return false;
         };
-
         Object.defineProperty(ActionManager.prototype, "hasPointerTriggers", {
             /**
-            * Does this action manager has pointer triggers
-            * @return {boolean} whether or not it has pointer triggers
-            */
+             * Does this action manager has pointer triggers
+             * @return {boolean} whether or not it has pointer triggers
+             */
             get: function () {
                 for (var index = 0; index < this.actions.length; index++) {
                     var action = this.actions[index];
-
                     if (action.trigger >= ActionManager._OnPickTrigger && action.trigger <= ActionManager._OnPointerOutTrigger) {
                         return true;
                     }
                 }
-
                 return false;
             },
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ActionManager.prototype, "hasPickTriggers", {
             /**
-            * Does this action manager has pick triggers
-            * @return {boolean} whether or not it has pick triggers
-            */
+             * Does this action manager has pick triggers
+             * @return {boolean} whether or not it has pick triggers
+             */
             get: function () {
                 for (var index = 0; index < this.actions.length; index++) {
                     var action = this.actions[index];
-
                     if (action.trigger >= ActionManager._OnPickTrigger && action.trigger <= ActionManager._OnCenterPickTrigger) {
                         return true;
                     }
                 }
-
                 return false;
             },
             enumerable: true,
             configurable: true
         });
-
         /**
-        * Registers an action to this action manager
-        * @param {BABYLON.Action} action - the action to be registered
-        * @return {BABYLON.Action} the action amended (prepared) after registration
-        */
+         * Registers an action to this action manager
+         * @param {BABYLON.Action} action - the action to be registered
+         * @return {BABYLON.Action} the action amended (prepared) after registration
+         */
         ActionManager.prototype.registerAction = function (action) {
             if (action.trigger === ActionManager.OnEveryFrameTrigger) {
                 if (this.getScene().actionManager !== this) {
@@ -231,55 +204,44 @@
                     return null;
                 }
             }
-
             this.actions.push(action);
-
             action._actionManager = this;
             action._prepare();
-
             return action;
         };
-
         /**
-        * Process a specific trigger
-        * @param {number} trigger - the trigger to process
-        * @param evt {BABYLON.ActionEvent} the event details to be processed
-        */
+         * Process a specific trigger
+         * @param {number} trigger - the trigger to process
+         * @param evt {BABYLON.ActionEvent} the event details to be processed
+         */
         ActionManager.prototype.processTrigger = function (trigger, evt) {
             for (var index = 0; index < this.actions.length; index++) {
                 var action = this.actions[index];
-
                 if (action.trigger === trigger) {
                     if (trigger === ActionManager.OnKeyUpTrigger || trigger === ActionManager.OnKeyDownTrigger) {
                         var parameter = action.getTriggerParameter();
-
                         if (parameter) {
                             if (evt.sourceEvent.key !== parameter) {
                                 continue;
                             }
                         }
                     }
-
                     action._executeCurrent(evt);
                 }
             }
         };
-
         ActionManager.prototype._getEffectiveTarget = function (target, propertyPath) {
             var properties = propertyPath.split(".");
-
             for (var index = 0; index < properties.length - 1; index++) {
                 target = target[properties[index]];
             }
-
             return target;
         };
-
         ActionManager.prototype._getProperty = function (propertyPath) {
             var properties = propertyPath.split(".");
-
             return properties[properties.length - 1];
         };
+        // Statics
         ActionManager._NothingTrigger = 0;
         ActionManager._OnPickTrigger = 1;
         ActionManager._OnLeftPickTrigger = 2;
@@ -296,4 +258,4 @@
     })();
     BABYLON.ActionManager = ActionManager;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.actionManager.js.map
+//# sourceMappingURL=babylon.actionManager.js.map

Babylon/Actions/babylon.condition.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -13,27 +13,23 @@ var BABYLON;
         Condition.prototype.isValid = function () {
             return true;
         };
-
         Condition.prototype._getProperty = function (propertyPath) {
             return this._actionManager._getProperty(propertyPath);
         };
-
         Condition.prototype._getEffectiveTarget = function (target, propertyPath) {
             return this._actionManager._getEffectiveTarget(target, propertyPath);
         };
         return Condition;
     })();
     BABYLON.Condition = Condition;
-
     var ValueCondition = (function (_super) {
         __extends(ValueCondition, _super);
         function ValueCondition(actionManager, target, propertyPath, value, operator) {
-            if (typeof operator === "undefined") { operator = ValueCondition.IsEqual; }
+            if (operator === void 0) { operator = ValueCondition.IsEqual; }
             _super.call(this, actionManager);
             this.propertyPath = propertyPath;
             this.value = value;
             this.operator = operator;
-
             this._target = this._getEffectiveTarget(target, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
         }
@@ -44,7 +40,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ValueCondition, "IsDifferent", {
             get: function () {
                 return ValueCondition._IsDifferent;
@@ -52,7 +47,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ValueCondition, "IsGreater", {
             get: function () {
                 return ValueCondition._IsGreater;
@@ -60,7 +54,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ValueCondition, "IsLesser", {
             get: function () {
                 return ValueCondition._IsLesser;
@@ -68,7 +61,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         // Methods
         ValueCondition.prototype.isValid = function () {
             switch (this.operator) {
@@ -79,17 +71,17 @@ var BABYLON;
                 case ValueCondition.IsEqual:
                 case ValueCondition.IsDifferent:
                     var check;
-
                     if (this.value.equals) {
                         check = this.value.equals(this._target[this._property]);
-                    } else {
+                    }
+                    else {
                         check = this.value === this._target[this._property];
                     }
                     return this.operator === ValueCondition.IsEqual ? check : !check;
             }
-
             return false;
         };
+        // Statics
         ValueCondition._IsEqual = 0;
         ValueCondition._IsDifferent = 1;
         ValueCondition._IsGreater = 2;
@@ -97,7 +89,6 @@ var BABYLON;
         return ValueCondition;
     })(Condition);
     BABYLON.ValueCondition = ValueCondition;
-
     var PredicateCondition = (function (_super) {
         __extends(PredicateCondition, _super);
         function PredicateCondition(actionManager, predicate) {
@@ -110,13 +101,11 @@ var BABYLON;
         return PredicateCondition;
     })(Condition);
     BABYLON.PredicateCondition = PredicateCondition;
-
     var StateCondition = (function (_super) {
         __extends(StateCondition, _super);
         function StateCondition(actionManager, target, value) {
             _super.call(this, actionManager);
             this.value = value;
-
             this._target = target;
         }
         // Methods
@@ -127,4 +116,4 @@ var BABYLON;
     })(Condition);
     BABYLON.StateCondition = StateCondition;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.condition.js.map
+//# sourceMappingURL=babylon.condition.js.map

Babylon/Actions/babylon.directActions.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -17,14 +17,12 @@ var BABYLON;
             this._target = this._getEffectiveTarget(this._target, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
         };
-
         SwitchBooleanAction.prototype.execute = function () {
             this._target[this._property] = !this._target[this._property];
         };
         return SwitchBooleanAction;
     })(BABYLON.Action);
     BABYLON.SwitchBooleanAction = SwitchBooleanAction;
-
     var SetStateAction = (function (_super) {
         __extends(SetStateAction, _super);
         function SetStateAction(triggerOptions, target, value, condition) {
@@ -38,7 +36,6 @@ var BABYLON;
         return SetStateAction;
     })(BABYLON.Action);
     BABYLON.SetStateAction = SetStateAction;
-
     var SetValueAction = (function (_super) {
         __extends(SetValueAction, _super);
         function SetValueAction(triggerOptions, target, propertyPath, value, condition) {
@@ -51,14 +48,12 @@ var BABYLON;
             this._target = this._getEffectiveTarget(this._target, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
         };
-
         SetValueAction.prototype.execute = function () {
             this._target[this._property] = this.value;
         };
         return SetValueAction;
     })(BABYLON.Action);
     BABYLON.SetValueAction = SetValueAction;
-
     var IncrementValueAction = (function (_super) {
         __extends(IncrementValueAction, _super);
         function IncrementValueAction(triggerOptions, target, propertyPath, value, condition) {
@@ -70,19 +65,16 @@ var BABYLON;
         IncrementValueAction.prototype._prepare = function () {
             this._target = this._getEffectiveTarget(this._target, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
-
             if (typeof this._target[this._property] !== "number") {
                 BABYLON.Tools.Warn("Warning: IncrementValueAction can only be used with number values");
             }
         };
-
         IncrementValueAction.prototype.execute = function () {
             this._target[this._property] += this.value;
         };
         return IncrementValueAction;
     })(BABYLON.Action);
     BABYLON.IncrementValueAction = IncrementValueAction;
-
     var PlayAnimationAction = (function (_super) {
         __extends(PlayAnimationAction, _super);
         function PlayAnimationAction(triggerOptions, target, from, to, loop, condition) {
@@ -94,7 +86,6 @@ var BABYLON;
         }
         PlayAnimationAction.prototype._prepare = function () {
         };
-
         PlayAnimationAction.prototype.execute = function () {
             var scene = this._actionManager.getScene();
             scene.beginAnimation(this._target, this.from, this.to, this.loop);
@@ -102,7 +93,6 @@ var BABYLON;
         return PlayAnimationAction;
     })(BABYLON.Action);
     BABYLON.PlayAnimationAction = PlayAnimationAction;
-
     var StopAnimationAction = (function (_super) {
         __extends(StopAnimationAction, _super);
         function StopAnimationAction(triggerOptions, target, condition) {
@@ -111,7 +101,6 @@ var BABYLON;
         }
         StopAnimationAction.prototype._prepare = function () {
         };
-
         StopAnimationAction.prototype.execute = function () {
             var scene = this._actionManager.getScene();
             scene.stopAnimation(this._target);
@@ -119,11 +108,10 @@ var BABYLON;
         return StopAnimationAction;
     })(BABYLON.Action);
     BABYLON.StopAnimationAction = StopAnimationAction;
-
     var DoNothingAction = (function (_super) {
         __extends(DoNothingAction, _super);
         function DoNothingAction(triggerOptions, condition) {
-            if (typeof triggerOptions === "undefined") { triggerOptions = BABYLON.ActionManager.NothingTrigger; }
+            if (triggerOptions === void 0) { triggerOptions = BABYLON.ActionManager.NothingTrigger; }
             _super.call(this, triggerOptions, condition);
         }
         DoNothingAction.prototype.execute = function () {
@@ -131,7 +119,6 @@ var BABYLON;
         return DoNothingAction;
     })(BABYLON.Action);
     BABYLON.DoNothingAction = DoNothingAction;
-
     var CombineAction = (function (_super) {
         __extends(CombineAction, _super);
         function CombineAction(triggerOptions, children, condition) {
@@ -144,7 +131,6 @@ var BABYLON;
                 this.children[index]._prepare();
             }
         };
-
         CombineAction.prototype.execute = function (evt) {
             for (var index = 0; index < this.children.length; index++) {
                 this.children[index].execute(evt);
@@ -153,7 +139,6 @@ var BABYLON;
         return CombineAction;
     })(BABYLON.Action);
     BABYLON.CombineAction = CombineAction;
-
     var ExecuteCodeAction = (function (_super) {
         __extends(ExecuteCodeAction, _super);
         function ExecuteCodeAction(triggerOptions, func, condition) {
@@ -166,7 +151,6 @@ var BABYLON;
         return ExecuteCodeAction;
     })(BABYLON.Action);
     BABYLON.ExecuteCodeAction = ExecuteCodeAction;
-
     var SetParentAction = (function (_super) {
         __extends(SetParentAction, _super);
         function SetParentAction(triggerOptions, target, parent, condition) {
@@ -176,21 +160,17 @@ var BABYLON;
         }
         SetParentAction.prototype._prepare = function () {
         };
-
         SetParentAction.prototype.execute = function () {
             if (this._target.parent === this._parent) {
                 return;
             }
-
             var invertParentWorldMatrix = this._parent.getWorldMatrix().clone();
             invertParentWorldMatrix.invert();
-
             this._target.position = BABYLON.Vector3.TransformCoordinates(this._target.position, invertParentWorldMatrix);
-
             this._target.parent = this._parent;
         };
         return SetParentAction;
     })(BABYLON.Action);
     BABYLON.SetParentAction = SetParentAction;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.directActions.js.map
+//# sourceMappingURL=babylon.directActions.js.map

Babylon/Actions/babylon.interpolateValueAction.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,61 +9,59 @@ var BABYLON;
     var InterpolateValueAction = (function (_super) {
         __extends(InterpolateValueAction, _super);
         function InterpolateValueAction(triggerOptions, target, propertyPath, value, duration, condition, stopOtherAnimations) {
-            if (typeof duration === "undefined") { duration = 1000; }
+            if (duration === void 0) { duration = 1000; }
             _super.call(this, triggerOptions, condition);
             this.propertyPath = propertyPath;
             this.value = value;
             this.duration = duration;
             this.stopOtherAnimations = stopOtherAnimations;
-
             this._target = target;
         }
         InterpolateValueAction.prototype._prepare = function () {
             this._target = this._getEffectiveTarget(this._target, this.propertyPath);
             this._property = this._getProperty(this.propertyPath);
         };
-
         InterpolateValueAction.prototype.execute = function () {
             var scene = this._actionManager.getScene();
             var keys = [
                 {
                     frame: 0,
                     value: this._target[this._property]
-                }, {
+                },
+                {
                     frame: 100,
                     value: this.value
                 }
             ];
-
             var dataType;
-
             if (typeof this.value === "number") {
                 dataType = BABYLON.Animation.ANIMATIONTYPE_FLOAT;
-            } else if (this.value instanceof BABYLON.Color3) {
+            }
+            else if (this.value instanceof BABYLON.Color3) {
                 dataType = BABYLON.Animation.ANIMATIONTYPE_COLOR3;
-            } else if (this.value instanceof BABYLON.Vector3) {
+            }
+            else if (this.value instanceof BABYLON.Vector3) {
                 dataType = BABYLON.Animation.ANIMATIONTYPE_VECTOR3;
-            } else if (this.value instanceof BABYLON.Matrix) {
+            }
+            else if (this.value instanceof BABYLON.Matrix) {
                 dataType = BABYLON.Animation.ANIMATIONTYPE_MATRIX;
-            } else if (this.value instanceof BABYLON.Quaternion) {
+            }
+            else if (this.value instanceof BABYLON.Quaternion) {
                 dataType = BABYLON.Animation.ANIMATIONTYPE_QUATERNION;
-            } else {
+            }
+            else {
                 BABYLON.Tools.Warn("InterpolateValueAction: Unsupported type (" + typeof this.value + ")");
                 return;
             }
-
             var animation = new BABYLON.Animation("InterpolateValueAction", this._property, 100 * (1000.0 / this.duration), dataType, BABYLON.Animation.ANIMATIONLOOPMODE_CONSTANT);
-
             animation.setKeys(keys);
-
             if (this.stopOtherAnimations) {
                 scene.stopAnimation(this._target);
             }
-
             scene.beginDirectAnimation(this._target, [animation], 0, 100);
         };
         return InterpolateValueAction;
     })(BABYLON.Action);
     BABYLON.InterpolateValueAction = InterpolateValueAction;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.interpolateValueAction.js.map
+//# sourceMappingURL=babylon.interpolateValueAction.js.map

Babylon/Animations/babylon.animatable.js

@@ -1,11 +1,11 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Animatable = (function () {
         function Animatable(scene, target, fromFrame, toFrame, loopAnimation, speedRatio, onAnimationEnd, animations) {
-            if (typeof fromFrame === "undefined") { fromFrame = 0; }
-            if (typeof toFrame === "undefined") { toFrame = 100; }
-            if (typeof loopAnimation === "undefined") { loopAnimation = false; }
-            if (typeof speedRatio === "undefined") { speedRatio = 1.0; }
+            if (fromFrame === void 0) { fromFrame = 0; }
+            if (toFrame === void 0) { toFrame = 100; }
+            if (loopAnimation === void 0) { loopAnimation = false; }
+            if (speedRatio === void 0) { speedRatio = 1.0; }
             this.target = target;
             this.fromFrame = fromFrame;
             this.toFrame = toFrame;
@@ -18,7 +18,6 @@
             if (animations) {
                 this.appendAnimations(target, animations);
             }
-
             this._scene = scene;
             scene._activeAnimatables.push(this);
         }
@@ -26,47 +25,37 @@
         Animatable.prototype.appendAnimations = function (target, animations) {
             for (var index = 0; index < animations.length; index++) {
                 var animation = animations[index];
-
                 animation._target = target;
                 this._animations.push(animation);
             }
         };
-
         Animatable.prototype.getAnimationByTargetProperty = function (property) {
             var animations = this._animations;
-
             for (var index = 0; index < animations.length; index++) {
                 if (animations[index].targetProperty === property) {
                     return animations[index];
                 }
             }
-
             return null;
         };
-
         Animatable.prototype.pause = function () {
             if (this._paused) {
                 return;
             }
             this._paused = true;
         };
-
         Animatable.prototype.restart = function () {
             this._paused = false;
         };
-
         Animatable.prototype.stop = function () {
             var index = this._scene._activeAnimatables.indexOf(this);
-
             if (index > -1) {
                 this._scene._activeAnimatables.splice(index, 1);
             }
-
             if (this.onAnimationEnd) {
                 this.onAnimationEnd();
             }
         };
-
         Animatable.prototype._animate = function (delay) {
             if (this._paused) {
                 if (!this._pausedDelay) {
@@ -74,32 +63,28 @@
                 }
                 return true;
             }
-
             if (!this._localDelayOffset) {
                 this._localDelayOffset = delay;
-            } else if (this._pausedDelay) {
+            }
+            else if (this._pausedDelay) {
                 this._localDelayOffset += delay - this._pausedDelay;
                 this._pausedDelay = null;
             }
-
             // Animating
             var running = false;
             var animations = this._animations;
-
             for (var index = 0; index < animations.length; index++) {
                 var animation = animations[index];
                 var isRunning = animation.animate(delay - this._localDelayOffset, this.fromFrame, this.toFrame, this.loopAnimation, this.speedRatio);
                 running = running || isRunning;
             }
-
             if (!running && this.onAnimationEnd) {
                 this.onAnimationEnd();
             }
-
             return running;
         };
         return Animatable;
     })();
     BABYLON.Animatable = Animatable;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.animatable.js.map
+//# sourceMappingURL=babylon.animatable.js.map

Babylon/Animations/babylon.animation.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Animation = (function () {
         function Animation(name, targetProperty, framePerSecond, dataType, loopMode) {
@@ -16,135 +16,107 @@
         }
         Animation.CreateAndStartAnimation = function (name, mesh, tartgetProperty, framePerSecond, totalFrame, from, to, loopMode) {
             var dataType = undefined;
-
             if (!isNaN(parseFloat(from)) && isFinite(from)) {
                 dataType = Animation.ANIMATIONTYPE_FLOAT;
-            } else if (from instanceof BABYLON.Quaternion) {
+            }
+            else if (from instanceof BABYLON.Quaternion) {
                 dataType = Animation.ANIMATIONTYPE_QUATERNION;
-            } else if (from instanceof BABYLON.Vector3) {
+            }
+            else if (from instanceof BABYLON.Vector3) {
                 dataType = Animation.ANIMATIONTYPE_VECTOR3;
-            } else if (from instanceof BABYLON.Vector2) {
+            }
+            else if (from instanceof BABYLON.Vector2) {
                 dataType = Animation.ANIMATIONTYPE_VECTOR2;
-            } else if (from instanceof BABYLON.Color3) {
+            }
+            else if (from instanceof BABYLON.Color3) {
                 dataType = Animation.ANIMATIONTYPE_COLOR3;
             }
-
             if (dataType == undefined) {
                 return;
             }
-
             var animation = new Animation(name, tartgetProperty, framePerSecond, dataType, loopMode);
-
             var keys = [];
             keys.push({ frame: 0, value: from });
             keys.push({ frame: totalFrame, value: to });
             animation.setKeys(keys);
-
             mesh.animations.push(animation);
-
             mesh.getScene().beginAnimation(mesh, 0, totalFrame, (animation.loopMode === 1));
         };
-
-        // Methods
+        // Methods   
         Animation.prototype.isStopped = function () {
             return this._stopped;
         };
-
         Animation.prototype.getKeys = function () {
             return this._keys;
         };
-
         Animation.prototype.getEasingFunction = function () {
             return this._easingFunction;
         };
-
         Animation.prototype.setEasingFunction = function (easingFunction) {
             this._easingFunction = easingFunction;
         };
-
         Animation.prototype.floatInterpolateFunction = function (startValue, endValue, gradient) {
             return startValue + (endValue - startValue) * gradient;
         };
-
         Animation.prototype.quaternionInterpolateFunction = function (startValue, endValue, gradient) {
             return BABYLON.Quaternion.Slerp(startValue, endValue, gradient);
         };
-
         Animation.prototype.vector3InterpolateFunction = function (startValue, endValue, gradient) {
             return BABYLON.Vector3.Lerp(startValue, endValue, gradient);
         };
-
         Animation.prototype.vector2InterpolateFunction = function (startValue, endValue, gradient) {
             return BABYLON.Vector2.Lerp(startValue, endValue, gradient);
         };
-
         Animation.prototype.color3InterpolateFunction = function (startValue, endValue, gradient) {
             return BABYLON.Color3.Lerp(startValue, endValue, gradient);
         };
-
         Animation.prototype.matrixInterpolateFunction = function (startValue, endValue, gradient) {
             var startScale = new BABYLON.Vector3(0, 0, 0);
             var startRotation = new BABYLON.Quaternion();
             var startTranslation = new BABYLON.Vector3(0, 0, 0);
             startValue.decompose(startScale, startRotation, startTranslation);
-
             var endScale = new BABYLON.Vector3(0, 0, 0);
             var endRotation = new BABYLON.Quaternion();
             var endTranslation = new BABYLON.Vector3(0, 0, 0);
             endValue.decompose(endScale, endRotation, endTranslation);
-
             var resultScale = this.vector3InterpolateFunction(startScale, endScale, gradient);
             var resultRotation = this.quaternionInterpolateFunction(startRotation, endRotation, gradient);
             var resultTranslation = this.vector3InterpolateFunction(startTranslation, endTranslation, gradient);
-
             var result = BABYLON.Matrix.Compose(resultScale, resultRotation, resultTranslation);
-
             return result;
         };
-
         Animation.prototype.clone = function () {
             var clone = new Animation(this.name, this.targetPropertyPath.join("."), this.framePerSecond, this.dataType, this.loopMode);
-
             clone.setKeys(this._keys);
-
             return clone;
         };
-
         Animation.prototype.setKeys = function (values) {
             this._keys = values.slice(0);
             this._offsetsCache = {};
             this._highLimitsCache = {};
         };
-
         Animation.prototype._getKeyValue = function (value) {
             if (typeof value === "function") {
                 return value();
             }
-
             return value;
         };
-
         Animation.prototype._interpolate = function (currentFrame, repeatCount, loopMode, offsetValue, highLimitValue) {
             if (loopMode === Animation.ANIMATIONLOOPMODE_CONSTANT && repeatCount > 0) {
                 return highLimitValue.clone ? highLimitValue.clone() : highLimitValue;
             }
-
             this.currentFrame = currentFrame;
-
             for (var key = 0; key < this._keys.length; key++) {
                 // for each frame, we need the key just before the frame superior
                 if (this._keys[key + 1].frame >= currentFrame) {
                     var startValue = this._getKeyValue(this._keys[key].value);
                     var endValue = this._getKeyValue(this._keys[key + 1].value);
-
                     // gradient : percent of currentFrame between the frame inf and the frame sup
                     var gradient = (currentFrame - this._keys[key].frame) / (this._keys[key + 1].frame - this._keys[key].frame);
-
                     // check for easingFunction and correction of gradient
                     if (this._easingFunction != null) {
                         gradient = this._easingFunction.ease(gradient);
                     }
-
                     switch (this.dataType) {
                         case Animation.ANIMATIONTYPE_FLOAT:
                             switch (loopMode) {
@@ -155,7 +127,6 @@
                                     return offsetValue * repeatCount + this.floatInterpolateFunction(startValue, endValue, gradient);
                             }
                             break;
-
                         case Animation.ANIMATIONTYPE_QUATERNION:
                             var quaternion = null;
                             switch (loopMode) {
@@ -167,9 +138,7 @@
                                     quaternion = this.quaternionInterpolateFunction(startValue, endValue, gradient).add(offsetValue.scale(repeatCount));
                                     break;
                             }
-
                             return quaternion;
-
                         case Animation.ANIMATIONTYPE_VECTOR3:
                             switch (loopMode) {
                                 case Animation.ANIMATIONLOOPMODE_CYCLE:
@@ -178,7 +147,6 @@
                                 case Animation.ANIMATIONLOOPMODE_RELATIVE:
                                     return this.vector3InterpolateFunction(startValue, endValue, gradient).add(offsetValue.scale(repeatCount));
                             }
-
                         case Animation.ANIMATIONTYPE_VECTOR2:
                             switch (loopMode) {
                                 case Animation.ANIMATIONLOOPMODE_CYCLE:
@@ -187,7 +155,6 @@
                                 case Animation.ANIMATIONLOOPMODE_RELATIVE:
                                     return this.vector2InterpolateFunction(startValue, endValue, gradient).add(offsetValue.scale(repeatCount));
                             }
-
                         case Animation.ANIMATIONTYPE_COLOR3:
                             switch (loopMode) {
                                 case Animation.ANIMATIONLOOPMODE_CYCLE:
@@ -196,12 +163,10 @@
                                 case Animation.ANIMATIONLOOPMODE_RELATIVE:
                                     return this.color3InterpolateFunction(startValue, endValue, gradient).add(offsetValue.scale(repeatCount));
                             }
-
                         case Animation.ANIMATIONTYPE_MATRIX:
                             switch (loopMode) {
                                 case Animation.ANIMATIONLOOPMODE_CYCLE:
                                 case Animation.ANIMATIONLOOPMODE_CONSTANT:
-                                    return this.matrixInterpolateFunction(startValue, endValue, gradient);
                                 case Animation.ANIMATIONLOOPMODE_RELATIVE:
                                     return startValue;
                             }
@@ -213,20 +178,17 @@
             }
             return this._getKeyValue(this._keys[this._keys.length - 1].value);
         };
-
         Animation.prototype.animate = function (delay, from, to, loop, speedRatio) {
             if (!this.targetPropertyPath || this.targetPropertyPath.length < 1) {
                 this._stopped = true;
                 return false;
             }
             var returnValue = true;
-
             // Adding a start key at frame 0 if missing
             if (this._keys[0].frame !== 0) {
                 var newKey = { frame: 0, value: this._keys[0].value };
                 this._keys.splice(0, 0, newKey);
             }
-
             // Check limits
             if (from < this._keys[0].frame || from > this._keys[this._keys.length - 1].frame) {
                 from = this._keys[0].frame;
@@ -234,19 +196,17 @@
             if (to < this._keys[0].frame || to > this._keys[this._keys.length - 1].frame) {
                 to = this._keys[this._keys.length - 1].frame;
             }
-
             // Compute ratio
             var range = to - from;
             var offsetValue;
-
             // ratio represents the frame delta between from and to
             var ratio = delay * (this.framePerSecond * speedRatio) / 1000.0;
             var highLimitValue = 0;
-
             if (ratio > range && !loop) {
                 returnValue = false;
                 highLimitValue = this._getKeyValue(this._keys[this._keys.length - 1].value);
-            } else {
+            }
+            else {
                 // Get max value if required
                 if (this.loopMode !== Animation.ANIMATIONLOOPMODE_CYCLE) {
                     var keyOffset = to.toString() + from.toString();
@@ -257,83 +217,65 @@
                             case Animation.ANIMATIONTYPE_FLOAT:
                                 this._offsetsCache[keyOffset] = toValue - fromValue;
                                 break;
-
                             case Animation.ANIMATIONTYPE_QUATERNION:
                                 this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
                                 break;
-
                             case Animation.ANIMATIONTYPE_VECTOR3:
                                 this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
-
                             case Animation.ANIMATIONTYPE_VECTOR2:
                                 this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
-
                             case Animation.ANIMATIONTYPE_COLOR3:
                                 this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
                             default:
                                 break;
                         }
-
                         this._highLimitsCache[keyOffset] = toValue;
                     }
-
                     highLimitValue = this._highLimitsCache[keyOffset];
                     offsetValue = this._offsetsCache[keyOffset];
                 }
             }
-
             if (offsetValue === undefined) {
                 switch (this.dataType) {
                     case Animation.ANIMATIONTYPE_FLOAT:
                         offsetValue = 0;
                         break;
-
                     case Animation.ANIMATIONTYPE_QUATERNION:
                         offsetValue = new BABYLON.Quaternion(0, 0, 0, 0);
                         break;
-
                     case Animation.ANIMATIONTYPE_VECTOR3:
                         offsetValue = BABYLON.Vector3.Zero();
                         break;
-
                     case Animation.ANIMATIONTYPE_VECTOR2:
                         offsetValue = BABYLON.Vector2.Zero();
                         break;
-
                     case Animation.ANIMATIONTYPE_COLOR3:
                         offsetValue = BABYLON.Color3.Black();
                 }
             }
-
             // Compute value
             var repeatCount = (ratio / range) >> 0;
             var currentFrame = returnValue ? from + ratio % range : to;
             var currentValue = this._interpolate(currentFrame, repeatCount, this.loopMode, offsetValue, highLimitValue);
-
             // Set value
             if (this.targetPropertyPath.length > 1) {
                 var property = this._target[this.targetPropertyPath[0]];
-
                 for (var index = 1; index < this.targetPropertyPath.length - 1; index++) {
                     property = property[this.targetPropertyPath[index]];
                 }
-
                 property[this.targetPropertyPath[this.targetPropertyPath.length - 1]] = currentValue;
-            } else {
+            }
+            else {
                 this._target[this.targetPropertyPath[0]] = currentValue;
             }
-
             if (this._target.markAsDirty) {
                 this._target.markAsDirty(this.targetProperty);
             }
-
             if (!returnValue) {
                 this._stopped = true;
             }
-
             return returnValue;
         };
-
         Object.defineProperty(Animation, "ANIMATIONTYPE_FLOAT", {
             get: function () {
                 return Animation._ANIMATIONTYPE_FLOAT;
@@ -341,7 +283,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONTYPE_VECTOR3", {
             get: function () {
                 return Animation._ANIMATIONTYPE_VECTOR3;
@@ -349,7 +290,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONTYPE_VECTOR2", {
             get: function () {
                 return Animation._ANIMATIONTYPE_VECTOR2;
@@ -357,7 +297,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONTYPE_QUATERNION", {
             get: function () {
                 return Animation._ANIMATIONTYPE_QUATERNION;
@@ -365,7 +304,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONTYPE_MATRIX", {
             get: function () {
                 return Animation._ANIMATIONTYPE_MATRIX;
@@ -373,7 +311,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONTYPE_COLOR3", {
             get: function () {
                 return Animation._ANIMATIONTYPE_COLOR3;
@@ -381,7 +318,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONLOOPMODE_RELATIVE", {
             get: function () {
                 return Animation._ANIMATIONLOOPMODE_RELATIVE;
@@ -389,7 +325,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONLOOPMODE_CYCLE", {
             get: function () {
                 return Animation._ANIMATIONLOOPMODE_CYCLE;
@@ -397,7 +332,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Animation, "ANIMATIONLOOPMODE_CONSTANT", {
             get: function () {
                 return Animation._ANIMATIONLOOPMODE_CONSTANT;
@@ -405,6 +339,7 @@
             enumerable: true,
             configurable: true
         });
+        // Statics
         Animation._ANIMATIONTYPE_FLOAT = 0;
         Animation._ANIMATIONTYPE_VECTOR3 = 1;
         Animation._ANIMATIONTYPE_QUATERNION = 2;
@@ -418,4 +353,4 @@
     })();
     BABYLON.Animation = Animation;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.animation.js.map
+//# sourceMappingURL=babylon.animation.js.map

Babylon/Animations/babylon.animation.ts

@@ -209,7 +209,7 @@
                             switch (loopMode) {
                                 case Animation.ANIMATIONLOOPMODE_CYCLE:
                                 case Animation.ANIMATIONLOOPMODE_CONSTANT:
-                                    return this.matrixInterpolateFunction(startValue, endValue, gradient);
+                                   // return this.matrixInterpolateFunction(startValue, endValue, gradient);
                                 case Animation.ANIMATIONLOOPMODE_RELATIVE:
                                     return startValue;
                             }

Babylon/Animations/babylon.easing.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -18,7 +18,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(EasingFunction, "EASINGMODE_EASEOUT", {
             get: function () {
                 return EasingFunction._EASINGMODE_EASEOUT;
@@ -26,7 +25,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(EasingFunction, "EASINGMODE_EASEINOUT", {
             get: function () {
                 return EasingFunction._EASINGMODE_EASEINOUT;
@@ -34,7 +32,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         EasingFunction.prototype.setEasingMode = function (easingMode) {
             var n = Math.min(Math.max(easingMode, 0), 2);
             this._easingMode = n;
@@ -42,11 +39,9 @@ var BABYLON;
         EasingFunction.prototype.getEasingMode = function () {
             return this._easingMode;
         };
-
         EasingFunction.prototype.easeInCore = function (gradient) {
             throw new Error('You must implement this method');
         };
-
         EasingFunction.prototype.ease = function (gradient) {
             switch (this._easingMode) {
                 case EasingFunction.EASINGMODE_EASEIN:
@@ -54,20 +49,18 @@ var BABYLON;
                 case EasingFunction.EASINGMODE_EASEOUT:
                     return (1 - this.easeInCore(1 - gradient));
             }
-
             if (gradient >= 0.5) {
                 return (((1 - this.easeInCore((1 - gradient) * 2)) * 0.5) + 0.5);
             }
-
             return (this.easeInCore(gradient * 2) * 0.5);
         };
+        //Statics
         EasingFunction._EASINGMODE_EASEIN = 0;
         EasingFunction._EASINGMODE_EASEOUT = 1;
         EasingFunction._EASINGMODE_EASEINOUT = 2;
         return EasingFunction;
     })();
     BABYLON.EasingFunction = EasingFunction;
-
     var CircleEase = (function (_super) {
         __extends(CircleEase, _super);
         function CircleEase() {
@@ -80,11 +73,10 @@ var BABYLON;
         return CircleEase;
     })(EasingFunction);
     BABYLON.CircleEase = CircleEase;
-
     var BackEase = (function (_super) {
         __extends(BackEase, _super);
         function BackEase(amplitude) {
-            if (typeof amplitude === "undefined") { amplitude = 1; }
+            if (amplitude === void 0) { amplitude = 1; }
             _super.call(this);
             this.amplitude = amplitude;
         }
@@ -95,12 +87,11 @@ var BABYLON;
         return BackEase;
     })(EasingFunction);
     BABYLON.BackEase = BackEase;
-
     var BounceEase = (function (_super) {
         __extends(BounceEase, _super);
         function BounceEase(bounces, bounciness) {
-            if (typeof bounces === "undefined") { bounces = 3; }
-            if (typeof bounciness === "undefined") { bounciness = 2; }
+            if (bounces === void 0) { bounces = 3; }
+            if (bounciness === void 0) { bounciness = 2; }
             _super.call(this);
             this.bounces = bounces;
             this.bounciness = bounciness;
@@ -128,7 +119,6 @@ var BABYLON;
         return BounceEase;
     })(EasingFunction);
     BABYLON.BounceEase = BounceEase;
-
     var CubicEase = (function (_super) {
         __extends(CubicEase, _super);
         function CubicEase() {
@@ -140,12 +130,11 @@ var BABYLON;
         return CubicEase;
     })(EasingFunction);
     BABYLON.CubicEase = CubicEase;
-
     var ElasticEase = (function (_super) {
         __extends(ElasticEase, _super);
         function ElasticEase(oscillations, springiness) {
-            if (typeof oscillations === "undefined") { oscillations = 3; }
-            if (typeof springiness === "undefined") { springiness = 3; }
+            if (oscillations === void 0) { oscillations = 3; }
+            if (springiness === void 0) { springiness = 3; }
             _super.call(this);
             this.oscillations = oscillations;
             this.springiness = springiness;
@@ -154,10 +143,10 @@ var BABYLON;
             var num2;
             var num3 = Math.max(0.0, this.oscillations);
             var num = Math.max(0.0, this.springiness);
-
             if (num == 0) {
                 num2 = gradient;
-            } else {
+            }
+            else {
                 num2 = (Math.exp(num * gradient) - 1.0) / (Math.exp(num) - 1.0);
             }
             return (num2 * Math.sin(((6.2831853071795862 * num3) + 1.5707963267948966) * gradient));
@@ -165,11 +154,10 @@ var BABYLON;
         return ElasticEase;
     })(EasingFunction);
     BABYLON.ElasticEase = ElasticEase;
-
     var ExponentialEase = (function (_super) {
         __extends(ExponentialEase, _super);
         function ExponentialEase(exponent) {
-            if (typeof exponent === "undefined") { exponent = 2; }
+            if (exponent === void 0) { exponent = 2; }
             _super.call(this);
             this.exponent = exponent;
         }
@@ -177,17 +165,15 @@ var BABYLON;
             if (this.exponent <= 0) {
                 return gradient;
             }
-
             return ((Math.exp(this.exponent * gradient) - 1.0) / (Math.exp(this.exponent) - 1.0));
         };
         return ExponentialEase;
     })(EasingFunction);
     BABYLON.ExponentialEase = ExponentialEase;
-
     var PowerEase = (function (_super) {
         __extends(PowerEase, _super);
         function PowerEase(power) {
-            if (typeof power === "undefined") { power = 2; }
+            if (power === void 0) { power = 2; }
             _super.call(this);
             this.power = power;
         }
@@ -198,7 +184,6 @@ var BABYLON;
         return PowerEase;
     })(EasingFunction);
     BABYLON.PowerEase = PowerEase;
-
     var QuadraticEase = (function (_super) {
         __extends(QuadraticEase, _super);
         function QuadraticEase() {
@@ -210,7 +195,6 @@ var BABYLON;
         return QuadraticEase;
     })(EasingFunction);
     BABYLON.QuadraticEase = QuadraticEase;
-
     var QuarticEase = (function (_super) {
         __extends(QuarticEase, _super);
         function QuarticEase() {
@@ -222,7 +206,6 @@ var BABYLON;
         return QuarticEase;
     })(EasingFunction);
     BABYLON.QuarticEase = QuarticEase;
-
     var QuinticEase = (function (_super) {
         __extends(QuinticEase, _super);
         function QuinticEase() {
@@ -234,7 +217,6 @@ var BABYLON;
         return QuinticEase;
     })(EasingFunction);
     BABYLON.QuinticEase = QuinticEase;
-
     var SineEase = (function (_super) {
         __extends(SineEase, _super);
         function SineEase() {
@@ -246,14 +228,13 @@ var BABYLON;
         return SineEase;
     })(EasingFunction);
     BABYLON.SineEase = SineEase;
-
     var BezierCurveEase = (function (_super) {
         __extends(BezierCurveEase, _super);
         function BezierCurveEase(x1, y1, x2, y2) {
-            if (typeof x1 === "undefined") { x1 = 0; }
-            if (typeof y1 === "undefined") { y1 = 0; }
-            if (typeof x2 === "undefined") { x2 = 1; }
-            if (typeof y2 === "undefined") { y2 = 1; }
+            if (x1 === void 0) { x1 = 0; }
+            if (y1 === void 0) { y1 = 0; }
+            if (x2 === void 0) { x2 = 1; }
+            if (y2 === void 0) { y2 = 1; }
             _super.call(this);
             this.x1 = x1;
             this.y1 = y1;
@@ -267,4 +248,4 @@ var BABYLON;
     })(EasingFunction);
     BABYLON.BezierCurveEase = BezierCurveEase;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.easing.js.map
+//# sourceMappingURL=babylon.easing.js.map

Babylon/Bones/babylon.bone.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Bone = (function () {
         function Bone(name, skeleton, parentBone, matrix) {
@@ -11,73 +11,59 @@
             this._skeleton = skeleton;
             this._matrix = matrix;
             this._baseMatrix = matrix;
-
             skeleton.bones.push(this);
-
             if (parentBone) {
                 this._parent = parentBone;
                 parentBone.children.push(this);
-            } else {
+            }
+            else {
                 this._parent = null;
             }
-
             this._updateDifferenceMatrix();
         }
         // Members
         Bone.prototype.getParent = function () {
             return this._parent;
         };
-
         Bone.prototype.getLocalMatrix = function () {
             return this._matrix;
         };
-
         Bone.prototype.getBaseMatrix = function () {
             return this._baseMatrix;
         };
-
         Bone.prototype.getWorldMatrix = function () {
             return this._worldTransform;
         };
-
         Bone.prototype.getInvertedAbsoluteTransform = function () {
             return this._invertedAbsoluteTransform;
         };
-
         Bone.prototype.getAbsoluteMatrix = function () {
             var matrix = this._matrix.clone();
             var parent = this._parent;
-
             while (parent) {
                 matrix = matrix.multiply(parent.getLocalMatrix());
                 parent = parent.getParent();
             }
-
             return matrix;
         };
-
         // Methods
         Bone.prototype.updateMatrix = function (matrix) {
             this._matrix = matrix;
             this._skeleton._markAsDirty();
-
             this._updateDifferenceMatrix();
         };
-
         Bone.prototype._updateDifferenceMatrix = function () {
             if (this._parent) {
                 this._matrix.multiplyToRef(this._parent._absoluteTransform, this._absoluteTransform);
-            } else {
+            }
+            else {
                 this._absoluteTransform.copyFrom(this._matrix);
             }
-
             this._absoluteTransform.invertToRef(this._invertedAbsoluteTransform);
-
             for (var index = 0; index < this.children.length; index++) {
                 this.children[index]._updateDifferenceMatrix();
             }
         };
-
         Bone.prototype.markAsDirty = function () {
             this._skeleton._markAsDirty();
         };
@@ -85,4 +71,4 @@
     })();
     BABYLON.Bone = Bone;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.bone.js.map
+//# sourceMappingURL=babylon.bone.js.map

Babylon/Bones/babylon.skeleton.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Skeleton = (function () {
         function Skeleton(name, id, scene) {
@@ -8,80 +8,63 @@
             this._isDirty = true;
             this._identity = BABYLON.Matrix.Identity();
             this.bones = [];
-
             this._scene = scene;
-
             scene.skeletons.push(this);
         }
         // Members
         Skeleton.prototype.getTransformMatrices = function () {
             return this._transformMatrices;
         };
-
         // Methods
         Skeleton.prototype._markAsDirty = function () {
             this._isDirty = true;
         };
-
         Skeleton.prototype.prepare = function () {
             if (!this._isDirty) {
                 return;
             }
-
             if (!this._transformMatrices || this._transformMatrices.length !== 16 * (this.bones.length + 1)) {
                 this._transformMatrices = new Float32Array(16 * (this.bones.length + 1));
             }
-
             for (var index = 0; index < this.bones.length; index++) {
                 var bone = this.bones[index];
                 var parentBone = bone.getParent();
-
                 if (parentBone) {
                     bone.getLocalMatrix().multiplyToRef(parentBone.getWorldMatrix(), bone.getWorldMatrix());
-                } else {
+                }
+                else {
                     bone.getWorldMatrix().copyFrom(bone.getLocalMatrix());
                 }
-
                 bone.getInvertedAbsoluteTransform().multiplyToArray(bone.getWorldMatrix(), this._transformMatrices, index * 16);
             }
-
             this._identity.copyToArray(this._transformMatrices, this.bones.length * 16);
-
             this._isDirty = false;
         };
-
         Skeleton.prototype.getAnimatables = function () {
             if (!this._animatables || this._animatables.length != this.bones.length) {
                 this._animatables = [];
-
                 for (var index = 0; index < this.bones.length; index++) {
                     this._animatables.push(this.bones[index]);
                 }
             }
-
             return this._animatables;
         };
-
         Skeleton.prototype.clone = function (name, id) {
             var result = new BABYLON.Skeleton(name, id || name, this._scene);
-
             for (var index = 0; index < this.bones.length; index++) {
                 var source = this.bones[index];
                 var parentBone = null;
-
                 if (source.getParent()) {
                     var parentIndex = this.bones.indexOf(source.getParent());
                     parentBone = result.bones[parentIndex];
                 }
-
                 var bone = new BABYLON.Bone(source.name, result, parentBone, source.getBaseMatrix());
                 BABYLON.Tools.DeepCopy(source.animations, bone.animations);
             }
-
             return result;
         };
         return Skeleton;
     })();
     BABYLON.Skeleton = Skeleton;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.skeleton.js.map
+//# sourceMappingURL=babylon.skeleton.js.map

Babylon/Cameras/VR/babylon.oculusCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -20,27 +20,20 @@ var BABYLON;
         PostProcessScaleFactor: 1.714605507808412,
         LensCenterOffset: 0.151976421
     };
-
     var _OculusInnerCamera = (function (_super) {
         __extends(_OculusInnerCamera, _super);
         function _OculusInnerCamera(name, position, scene, isLeftEye) {
             _super.call(this, name, position, scene);
             this._workMatrix = new BABYLON.Matrix();
             this._actualUp = new BABYLON.Vector3(0, 0, 0);
-
             // Constants
             this._aspectRatioAspectRatio = OculusRiftDevKit2013_Metric.HResolution / (2 * OculusRiftDevKit2013_Metric.VResolution);
             this._aspectRatioFov = (2 * Math.atan((OculusRiftDevKit2013_Metric.PostProcessScaleFactor * OculusRiftDevKit2013_Metric.VScreenSize) / (2 * OculusRiftDevKit2013_Metric.EyeToScreenDistance)));
-
             var hMeters = (OculusRiftDevKit2013_Metric.HScreenSize / 4) - (OculusRiftDevKit2013_Metric.LensSeparationDistance / 2);
             var h = (4 * hMeters) / OculusRiftDevKit2013_Metric.HScreenSize;
-
             this._hMatrix = BABYLON.Matrix.Translation(isLeftEye ? h : -h, 0, 0);
-
             this.viewport = new BABYLON.Viewport(isLeftEye ? 0 : 0.5, 0, 0.5, 1.0);
-
             this._preViewMatrix = BABYLON.Matrix.Translation(isLeftEye ? .5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance : -.5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance, 0, 0);
-
             // Postprocess
             var postProcess = new BABYLON.OculusDistortionCorrectionPostProcess("Oculus Distortion", this, !isLeftEye, OculusRiftDevKit2013_Metric);
         }
@@ -49,62 +42,47 @@ var BABYLON;
             this._workMatrix.multiplyToRef(this._hMatrix, this._projectionMatrix);
             return this._projectionMatrix;
         };
-
         _OculusInnerCamera.prototype._getViewMatrix = function () {
             BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._cameraRotationMatrix);
-
             BABYLON.Vector3.TransformCoordinatesToRef(this._referencePoint, this._cameraRotationMatrix, this._transformedReferencePoint);
             BABYLON.Vector3.TransformNormalToRef(this.upVector, this._cameraRotationMatrix, this._actualUp);
-
             // Computing target and final matrix
             this.position.addToRef(this._transformedReferencePoint, this._currentTarget);
-
             BABYLON.Matrix.LookAtLHToRef(this.position, this._currentTarget, this._actualUp, this._workMatrix);
-
             this._workMatrix.multiplyToRef(this._preViewMatrix, this._viewMatrix);
             return this._viewMatrix;
         };
         return _OculusInnerCamera;
     })(BABYLON.FreeCamera);
-
     var OculusCamera = (function (_super) {
         __extends(OculusCamera, _super);
         function OculusCamera(name, position, scene) {
             _super.call(this, name, position, scene);
-
             this._leftCamera = new _OculusInnerCamera(name + "_left", position.clone(), scene, true);
             this._rightCamera = new _OculusInnerCamera(name + "_right", position.clone(), scene, false);
-
             this.subCameras.push(this._leftCamera);
             this.subCameras.push(this._rightCamera);
-
             this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
         }
         OculusCamera.prototype._update = function () {
             this._leftCamera.position.copyFrom(this.position);
             this._rightCamera.position.copyFrom(this.position);
-
             this._updateCamera(this._leftCamera);
             this._updateCamera(this._rightCamera);
-
             _super.prototype._update.call(this);
         };
-
         OculusCamera.prototype._updateCamera = function (camera) {
             camera.minZ = this.minZ;
             camera.maxZ = this.maxZ;
-
             camera.rotation.x = this.rotation.x;
             camera.rotation.y = this.rotation.y;
             camera.rotation.z = this.rotation.z;
         };
-
         // Oculus events
         OculusCamera.prototype._onOrientationEvent = function (evt) {
             var yaw = evt.alpha / 180 * Math.PI;
             var pitch = evt.beta / 180 * Math.PI;
             var roll = evt.gamma / 180 * Math.PI;
-
             if (!this._offsetOrientation) {
                 this._offsetOrientation = {
                     yaw: yaw,
@@ -112,30 +90,26 @@ var BABYLON;
                     roll: roll
                 };
                 return;
-            } else {
+            }
+            else {
                 this.rotation.y += yaw - this._offsetOrientation.yaw;
                 this.rotation.x += pitch - this._offsetOrientation.pitch;
                 this.rotation.z += this._offsetOrientation.roll - roll;
-
                 this._offsetOrientation.yaw = yaw;
                 this._offsetOrientation.pitch = pitch;
                 this._offsetOrientation.roll = roll;
             }
         };
-
         OculusCamera.prototype.attachControl = function (element, noPreventDefault) {
             _super.prototype.attachControl.call(this, element, noPreventDefault);
-
             window.addEventListener("deviceorientation", this._deviceOrientationHandler);
         };
-
         OculusCamera.prototype.detachControl = function (element) {
             _super.prototype.detachControl.call(this, element);
-
             window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
         };
         return OculusCamera;
     })(BABYLON.FreeCamera);
     BABYLON.OculusCamera = OculusCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.oculusCamera.js.map
+//# sourceMappingURL=babylon.oculusCamera.js.map

Babylon/Cameras/VR/babylon.oculusGamepadCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -20,27 +20,20 @@ var BABYLON;
         PostProcessScaleFactor: 1.714605507808412,
         LensCenterOffset: 0.151976421
     };
-
     var _OculusInnerGamepadCamera = (function (_super) {
         __extends(_OculusInnerGamepadCamera, _super);
         function _OculusInnerGamepadCamera(name, position, scene, isLeftEye) {
             _super.call(this, name, position, scene);
             this._workMatrix = new BABYLON.Matrix();
             this._actualUp = new BABYLON.Vector3(0, 0, 0);
-
             // Constants
             this._aspectRatioAspectRatio = OculusRiftDevKit2013_Metric.HResolution / (2 * OculusRiftDevKit2013_Metric.VResolution);
             this._aspectRatioFov = (2 * Math.atan((OculusRiftDevKit2013_Metric.PostProcessScaleFactor * OculusRiftDevKit2013_Metric.VScreenSize) / (2 * OculusRiftDevKit2013_Metric.EyeToScreenDistance)));
-
             var hMeters = (OculusRiftDevKit2013_Metric.HScreenSize / 4) - (OculusRiftDevKit2013_Metric.LensSeparationDistance / 2);
             var h = (4 * hMeters) / OculusRiftDevKit2013_Metric.HScreenSize;
-
             this._hMatrix = BABYLON.Matrix.Translation(isLeftEye ? h : -h, 0, 0);
-
             this.viewport = new BABYLON.Viewport(isLeftEye ? 0 : 0.5, 0, 0.5, 1.0);
-
             this._preViewMatrix = BABYLON.Matrix.Translation(isLeftEye ? .5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance : -.5 * OculusRiftDevKit2013_Metric.InterpupillaryDistance, 0, 0);
-
             // Postprocess
             var postProcess = new BABYLON.OculusDistortionCorrectionPostProcess("Oculus Distortion", this, !isLeftEye, OculusRiftDevKit2013_Metric);
         }
@@ -49,24 +42,18 @@ var BABYLON;
             this._workMatrix.multiplyToRef(this._hMatrix, this._projectionMatrix);
             return this._projectionMatrix;
         };
-
         _OculusInnerGamepadCamera.prototype._getViewMatrix = function () {
             BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._cameraRotationMatrix);
-
             BABYLON.Vector3.TransformCoordinatesToRef(this._referencePoint, this._cameraRotationMatrix, this._transformedReferencePoint);
             BABYLON.Vector3.TransformNormalToRef(this.upVector, this._cameraRotationMatrix, this._actualUp);
-
             // Computing target and final matrix
             this.position.addToRef(this._transformedReferencePoint, this._currentTarget);
-
             BABYLON.Matrix.LookAtLHToRef(this.position, this._currentTarget, this._actualUp, this._workMatrix);
-
             this._workMatrix.multiplyToRef(this._preViewMatrix, this._viewMatrix);
             return this._viewMatrix;
         };
         return _OculusInnerGamepadCamera;
     })(BABYLON.FreeCamera);
-
     var OculusGamepadCamera = (function (_super) {
         __extends(OculusGamepadCamera, _super);
         function OculusGamepadCamera(name, position, scene) {
@@ -74,13 +61,10 @@ var BABYLON;
             _super.call(this, name, position, scene);
             this.angularSensibility = 200;
             this.moveSensibility = 75;
-
             this._leftCamera = new _OculusInnerGamepadCamera(name + "_left", position.clone(), scene, true);
             this._rightCamera = new _OculusInnerGamepadCamera(name + "_right", position.clone(), scene, false);
-
             this.subCameras.push(this._leftCamera);
             this.subCameras.push(this._rightCamera);
-
             this._deviceOrientationHandler = this._onOrientationEvent.bind(this);
             this._gamepads = new BABYLON.Gamepads(function (gamepad) {
                 _this._onNewGameConnected(gamepad);
@@ -92,48 +76,38 @@ var BABYLON;
                 this._gamepad = gamepad;
             }
         };
-
         OculusGamepadCamera.prototype._update = function () {
             this._leftCamera.position.copyFrom(this.position);
             this._rightCamera.position.copyFrom(this.position);
-
             this._updateCamera(this._leftCamera);
             this._updateCamera(this._rightCamera);
-
             _super.prototype._update.call(this);
         };
-
         OculusGamepadCamera.prototype._checkInputs = function () {
             if (!this._gamepad) {
                 return;
             }
-
             var LSValues = this._gamepad.leftStick;
             var normalizedLX = LSValues.x / this.moveSensibility;
             var normalizedLY = LSValues.y / this.moveSensibility;
             LSValues.x = Math.abs(normalizedLX) > 0.005 ? 0 + normalizedLX : 0;
             LSValues.y = Math.abs(normalizedLY) > 0.005 ? 0 + normalizedLY : 0;
-
             var cameraTransform = BABYLON.Matrix.RotationYawPitchRoll(this.rotation.y, this.rotation.x, 0);
             var deltaTransform = BABYLON.Vector3.TransformCoordinates(new BABYLON.Vector3(LSValues.x, 0, -LSValues.y), cameraTransform);
             this.cameraDirection = this.cameraDirection.add(deltaTransform);
         };
-
         OculusGamepadCamera.prototype._updateCamera = function (camera) {
             camera.minZ = this.minZ;
             camera.maxZ = this.maxZ;
-
             camera.rotation.x = this.rotation.x;
             camera.rotation.y = this.rotation.y;
             camera.rotation.z = this.rotation.z;
         };
-
         // Oculus events
         OculusGamepadCamera.prototype._onOrientationEvent = function (evt) {
             var yaw = evt.alpha / 180 * Math.PI;
             var pitch = evt.beta / 180 * Math.PI;
             var roll = evt.gamma / 180 * Math.PI;
-
             if (!this._offsetOrientation) {
                 this._offsetOrientation = {
                     yaw: yaw,
@@ -141,29 +115,24 @@ var BABYLON;
                     roll: roll
                 };
                 return;
-            } else {
+            }
+            else {
                 this.rotation.y += yaw - this._offsetOrientation.yaw;
                 this.rotation.x += pitch - this._offsetOrientation.pitch;
                 this.rotation.z += this._offsetOrientation.roll - roll;
-
                 this._offsetOrientation.yaw = yaw;
                 this._offsetOrientation.pitch = pitch;
                 this._offsetOrientation.roll = roll;
             }
         };
-
         OculusGamepadCamera.prototype.attachControl = function (element, noPreventDefault) {
             _super.prototype.attachControl.call(this, element, noPreventDefault);
-
             window.addEventListener("deviceorientation", this._deviceOrientationHandler);
         };
-
         OculusGamepadCamera.prototype.detachControl = function (element) {
             _super.prototype.detachControl.call(this, element);
-
             window.removeEventListener("deviceorientation", this._deviceOrientationHandler);
         };
-
         OculusGamepadCamera.prototype.dispose = function () {
             this._gamepads.dispose();
             _super.prototype.dispose.call(this);
@@ -172,4 +141,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.OculusGamepadCamera = OculusGamepadCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.oculusGamepadCamera.js.map
+//# sourceMappingURL=babylon.oculusGamepadCamera.js.map

Babylon/Cameras/VR/babylon.vrDeviceOrientationCamera.js

@@ -18,14 +18,13 @@ var BABYLON;
             this._alpha = +evt.alpha | 0;
             this._beta = +evt.beta | 0;
             this._gamma = +evt.gamma | 0;
-
             if (this._gamma < 0) {
                 this._gamma = 90 + this._gamma;
-            } else {
+            }
+            else {
                 // Incline it in the correct angle.
                 this._gamma = 270 - this._gamma;
             }
-
             this.rotation.x = this._gamma / 180.0 * Math.PI;
             this.rotation.y = -this._alpha / 180.0 * Math.PI;
             this.rotation.z = this._beta / 180.0 * Math.PI;
@@ -34,4 +33,4 @@ var BABYLON;
     })(BABYLON.OculusCamera);
     BABYLON.VRDeviceOrientationCamera = VRDeviceOrientationCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.vrDeviceOrientationCamera.js.map
+//# sourceMappingURL=babylon.vrDeviceOrientationCamera.js.map

Babylon/Cameras/VR/babylon.webVRCamera.js

@@ -21,54 +21,44 @@ var BABYLON;
         WebVRCamera.prototype._getWebVRDevices = function (devices) {
             var size = devices.length;
             var i = 0;
-
             // Reset devices.
             this._sensorDevice = null;
             this._hmdDevice = null;
-
             while (i < size && this._hmdDevice === null) {
                 if (devices[i] instanceof HMDVRDevice) {
                     this._hmdDevice = devices[i];
                 }
                 i++;
             }
-
             i = 0;
-
             while (i < size && this._sensorDevice === null) {
                 if (devices[i] instanceof PositionSensorVRDevice && (!this._hmdDevice || devices[i].hardwareUnitId === this._hmdDevice.hardwareUnitId)) {
                     this._sensorDevice = devices[i];
                 }
                 i++;
             }
-
             this._vrEnabled = this._sensorDevice && this._hmdDevice ? true : false;
         };
-
         WebVRCamera.prototype._update = function () {
             if (this._vrEnabled) {
                 this._cacheState = this._sensorDevice.getState();
                 this._cacheQuaternion.copyFromFloats(this._cacheState.orientation.x, this._cacheState.orientation.y, this._cacheState.orientation.z, this._cacheState.orientation.w);
                 this._cacheQuaternion.toEulerAnglesToRef(this._cacheRotation);
-
                 this.rotation.x = -this._cacheRotation.z;
                 this.rotation.y = -this._cacheRotation.y;
                 this.rotation.z = this._cacheRotation.x;
             }
-
             _super.prototype._update.call(this);
         };
-
         WebVRCamera.prototype.attachControl = function (element, noPreventDefault) {
             _super.prototype.attachControl.call(this, element, noPreventDefault);
-
             if (navigator.getVRDevices) {
                 navigator.getVRDevices().then(this._getWebVRDevices);
-            } else if (navigator.mozGetVRDevices) {
+            }
+            else if (navigator.mozGetVRDevices) {
                 navigator.mozGetVRDevices(this._getWebVRDevices);
             }
         };
-
         WebVRCamera.prototype.detachControl = function (element) {
             _super.prototype.detachControl.call(this, element);
             this._vrEnabled = false;
@@ -77,4 +67,4 @@ var BABYLON;
     })(BABYLON.OculusCamera);
     BABYLON.WebVRCamera = WebVRCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.webVRCamera.js.map
+//# sourceMappingURL=babylon.webVRCamera.js.map

Babylon/Cameras/babylon.anaglyphCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -8,102 +8,75 @@ var BABYLON;
 (function (BABYLON) {
     var buildCamera = function (that, name) {
         that._leftCamera.isIntermediate = true;
-
         that.subCameras.push(that._leftCamera);
         that.subCameras.push(that._rightCamera);
-
         that._leftTexture = new BABYLON.PassPostProcess(name + "_leftTexture", 1.0, that._leftCamera);
         that._anaglyphPostProcess = new BABYLON.AnaglyphPostProcess(name + "_anaglyph", 1.0, that._rightCamera);
-
         that._anaglyphPostProcess.onApply = function (effect) {
             effect.setTextureFromPostProcess("leftSampler", that._leftTexture);
         };
-
         that._update();
     };
-
     var AnaglyphArcRotateCamera = (function (_super) {
         __extends(AnaglyphArcRotateCamera, _super);
         // ANY
         function AnaglyphArcRotateCamera(name, alpha, beta, radius, target, eyeSpace, scene) {
             _super.call(this, name, alpha, beta, radius, target, scene);
-
             this._eyeSpace = BABYLON.Tools.ToRadians(eyeSpace);
-
             this._leftCamera = new BABYLON.ArcRotateCamera(name + "_left", alpha - this._eyeSpace, beta, radius, target, scene);
             this._rightCamera = new BABYLON.ArcRotateCamera(name + "_right", alpha + this._eyeSpace, beta, radius, target, scene);
-
             buildCamera(this, name);
         }
         AnaglyphArcRotateCamera.prototype._update = function () {
             this._updateCamera(this._leftCamera);
             this._updateCamera(this._rightCamera);
-
             this._leftCamera.alpha = this.alpha - this._eyeSpace;
             this._rightCamera.alpha = this.alpha + this._eyeSpace;
-
             _super.prototype._update.call(this);
         };
-
         AnaglyphArcRotateCamera.prototype._updateCamera = function (camera) {
             camera.beta = this.beta;
             camera.radius = this.radius;
-
             camera.minZ = this.minZ;
             camera.maxZ = this.maxZ;
-
             camera.fov = this.fov;
-
             camera.target = this.target;
         };
         return AnaglyphArcRotateCamera;
     })(BABYLON.ArcRotateCamera);
     BABYLON.AnaglyphArcRotateCamera = AnaglyphArcRotateCamera;
-
     var AnaglyphFreeCamera = (function (_super) {
         __extends(AnaglyphFreeCamera, _super);
         function AnaglyphFreeCamera(name, position, eyeSpace, scene) {
             _super.call(this, name, position, scene);
-
             this._eyeSpace = BABYLON.Tools.ToRadians(eyeSpace);
             this._transformMatrix = new BABYLON.Matrix();
-
             this._leftCamera = new BABYLON.FreeCamera(name + "_left", position.clone(), scene);
             this._rightCamera = new BABYLON.FreeCamera(name + "_right", position.clone(), scene);
-
             buildCamera(this, name);
         }
         AnaglyphFreeCamera.prototype._getSubCameraPosition = function (eyeSpace, result) {
             var target = this.getTarget();
             BABYLON.Matrix.Translation(-target.x, -target.y, -target.z).multiplyToRef(BABYLON.Matrix.RotationY(eyeSpace), this._transformMatrix);
-
             this._transformMatrix = this._transformMatrix.multiply(BABYLON.Matrix.Translation(target.x, target.y, target.z));
-
             BABYLON.Vector3.TransformCoordinatesToRef(this.position, this._transformMatrix, result);
         };
-
         AnaglyphFreeCamera.prototype._update = function () {
             this._getSubCameraPosition(-this._eyeSpace, this._leftCamera.position);
             this._getSubCameraPosition(this._eyeSpace, this._rightCamera.position);
-
             this._updateCamera(this._leftCamera);
             this._updateCamera(this._rightCamera);
-
             _super.prototype._update.call(this);
         };
-
         AnaglyphFreeCamera.prototype._updateCamera = function (camera) {
             camera.minZ = this.minZ;
             camera.maxZ = this.maxZ;
-
             camera.fov = this.fov;
-
             camera.viewport = this.viewport;
-
             camera.setTarget(this.getTarget());
         };
         return AnaglyphFreeCamera;
     })(BABYLON.FreeCamera);
     BABYLON.AnaglyphFreeCamera = AnaglyphFreeCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.anaglyphCamera.js.map
+//# sourceMappingURL=babylon.anaglyphCamera.js.map

Babylon/Cameras/babylon.arcRotateCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -7,7 +7,6 @@
 var BABYLON;
 (function (BABYLON) {
     var eventPrefix = BABYLON.Tools.GetPointerPrefix();
-
     var ArcRotateCamera = (function (_super) {
         __extends(ArcRotateCamera, _super);
         function ArcRotateCamera(name, alpha, beta, radius, target, scene) {
@@ -45,13 +44,11 @@ var BABYLON;
             // value for pinch step scaling
             // set to 20 by default
             this.pinchPrecision = 20;
-
             this.getViewMatrix();
         }
         ArcRotateCamera.prototype._getTargetPosition = function () {
             return this.target.position || this.target;
         };
-
         // Cache
         ArcRotateCamera.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
@@ -61,65 +58,51 @@ var BABYLON;
             this._cache.radius = undefined;
             this._cache.targetScreenOffset = undefined;
         };
-
         ArcRotateCamera.prototype._updateCache = function (ignoreParentClass) {
             if (!ignoreParentClass) {
                 _super.prototype._updateCache.call(this);
             }
-
             this._cache.target.copyFrom(this._getTargetPosition());
             this._cache.alpha = this.alpha;
             this._cache.beta = this.beta;
             this._cache.radius = this.radius;
             this._cache.targetScreenOffset = this.targetScreenOffset.clone();
         };
-
         // Synchronized
         ArcRotateCamera.prototype._isSynchronizedViewMatrix = function () {
             if (!_super.prototype._isSynchronizedViewMatrix.call(this))
                 return false;
-
             return this._cache.target.equals(this._getTargetPosition()) && this._cache.alpha === this.alpha && this._cache.beta === this.beta && this._cache.radius === this.radius && this._cache.targetScreenOffset.equals(this.targetScreenOffset);
         };
-
         // Methods
         ArcRotateCamera.prototype.attachControl = function (element, noPreventDefault) {
             var _this = this;
             var previousPosition;
             var pointerId;
-
             // to know if pinch started
             var pinchStarted = false;
-
             // two pinch point on X
             // that will use for find if user action is pinch open or pinch close
             var pinchPointX1, pinchPointX2;
-
             if (this._attachedElement) {
                 return;
             }
             this._attachedElement = element;
-
             var engine = this.getEngine();
-
             if (this._onPointerDown === undefined) {
                 this._onPointerDown = function (evt) {
                     if (pointerId) {
                         return;
                     }
-
                     pointerId = evt.pointerId;
-
                     previousPosition = {
                         x: evt.clientX,
                         y: evt.clientY
                     };
-
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
                 };
-
                 this._onPointerUp = function (evt) {
                     previousPosition = null;
                     pointerId = null;
@@ -127,84 +110,67 @@ var BABYLON;
                         evt.preventDefault();
                     }
                 };
-
                 this._onPointerMove = function (evt) {
                     if (!previousPosition) {
                         return;
                     }
-
                     if (pointerId !== evt.pointerId) {
                         return;
                     }
-
                     // return pinch is started
                     if (pinchStarted) {
                         return;
                     }
-
                     var offsetX = evt.clientX - previousPosition.x;
                     var offsetY = evt.clientY - previousPosition.y;
-
                     _this.inertialAlphaOffset -= offsetX / _this.angularSensibility;
                     _this.inertialBetaOffset -= offsetY / _this.angularSensibility;
-
                     previousPosition = {
                         x: evt.clientX,
                         y: evt.clientY
                     };
-
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
                 };
-
                 this._onMouseMove = function (evt) {
                     if (!engine.isPointerLock) {
                         return;
                     }
-
                     // return pinch is started
                     if (pinchStarted) {
                         return;
                     }
-
                     var offsetX = evt.movementX || evt.mozMovementX || evt.webkitMovementX || evt.msMovementX || 0;
                     var offsetY = evt.movementY || evt.mozMovementY || evt.webkitMovementY || evt.msMovementY || 0;
-
                     _this.inertialAlphaOffset -= offsetX / _this.angularSensibility;
                     _this.inertialBetaOffset -= offsetY / _this.angularSensibility;
-
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
                 };
-
                 this._wheel = function (event) {
                     var delta = 0;
                     if (event.wheelDelta) {
                         delta = event.wheelDelta / (_this.wheelPrecision * 40);
-                    } else if (event.detail) {
+                    }
+                    else if (event.detail) {
                         delta = -event.detail / _this.wheelPrecision;
                     }
-
                     if (delta)
                         _this.inertialRadiusOffset += delta;
-
                     if (event.preventDefault) {
                         if (!noPreventDefault) {
                             event.preventDefault();
                         }
                     }
                 };
-
                 this._onKeyDown = function (evt) {
                     if (_this.keysUp.indexOf(evt.keyCode) !== -1 || _this.keysDown.indexOf(evt.keyCode) !== -1 || _this.keysLeft.indexOf(evt.keyCode) !== -1 || _this.keysRight.indexOf(evt.keyCode) !== -1) {
                         var index = _this._keys.indexOf(evt.keyCode);
-
                         if (index === -1) {
                             _this._keys.push(evt.keyCode);
                         }
-
                         if (evt.preventDefault) {
                             if (!noPreventDefault) {
                                 evt.preventDefault();
@@ -212,15 +178,12 @@ var BABYLON;
                         }
                     }
                 };
-
                 this._onKeyUp = function (evt) {
                     if (_this.keysUp.indexOf(evt.keyCode) !== -1 || _this.keysDown.indexOf(evt.keyCode) !== -1 || _this.keysLeft.indexOf(evt.keyCode) !== -1 || _this.keysRight.indexOf(evt.keyCode) !== -1) {
                         var index = _this._keys.indexOf(evt.keyCode);
-
                         if (index >= 0) {
                             _this._keys.splice(index, 1);
                         }
-
                         if (evt.preventDefault) {
                             if (!noPreventDefault) {
                                 evt.preventDefault();
@@ -228,28 +191,22 @@ var BABYLON;
                         }
                     }
                 };
-
                 this._onLostFocus = function () {
                     _this._keys = [];
                     pointerId = null;
                 };
-
                 this._onGestureStart = function (e) {
                     if (window.MSGesture === undefined) {
                         return;
                     }
-
                     if (!_this._MSGestureHandler) {
                         _this._MSGestureHandler = new MSGesture();
                         _this._MSGestureHandler.target = element;
                     }
-
                     _this._MSGestureHandler.addPointer(e.pointerId);
                 };
-
                 this._onGesture = function (e) {
                     _this.radius *= e.scale;
-
                     if (e.preventDefault) {
                         if (!noPreventDefault) {
                             e.stopPropagation();
@@ -257,7 +214,6 @@ var BABYLON;
                         }
                     }
                 };
-
                 this._reset = function () {
                     _this._keys = [];
                     _this.inertialAlphaOffset = 0;
@@ -266,7 +222,6 @@ var BABYLON;
                     previousPosition = null;
                     pointerId = null;
                 };
-
                 this._touchStart = function (event) {
                     if (event.touches.length === 2) {
                         //-- start pinch if two fingers on the screen
@@ -286,42 +241,33 @@ var BABYLON;
                         _this._pinchEnd(event);
                     }
                 };
-
                 this._pinchStart = function (event) {
                     // save origin touch point
                     pinchPointX1 = event.touches[0].clientX;
                     pinchPointX2 = event.touches[1].clientX;
-
-                    // block the camera
+                    // block the camera 
                     // if not it rotate around target during pinch
                     pinchStarted = true;
                 };
                 this._pinchMove = function (event) {
                     // variable for new camera's radius
                     var delta = 0;
-
                     // variables to know if pinch open or pinch close
                     var direction = 1;
                     var distanceXOrigine, distanceXNow;
-
                     if (event.touches.length !== 2)
                         return;
-
                     // calculate absolute distances of the two fingers
                     distanceXOrigine = Math.abs(pinchPointX1 - pinchPointX2);
                     distanceXNow = Math.abs(event.touches[0].clientX - event.touches[1].clientX);
-
                     // if distanceXNow < distanceXOrigine -> pinch close so direction = -1
                     if (distanceXNow < distanceXOrigine) {
                         direction = -1;
                     }
-
                     // calculate new radius
                     delta = (_this.pinchPrecision / (_this.wheelPrecision * 40)) * direction;
-
                     // set new radius
                     _this.inertialRadiusOffset -= delta;
-
                     // save origin touch point
                     pinchPointX1 = event.touches[0].clientX;
                     pinchPointX2 = event.touches[1].clientX;
@@ -331,7 +277,6 @@ var BABYLON;
                     pinchStarted = false;
                 };
             }
-
             element.addEventListener(eventPrefix + "down", this._onPointerDown, false);
             element.addEventListener(eventPrefix + "up", this._onPointerUp, false);
             element.addEventListener(eventPrefix + "out", this._onPointerUp, false);
@@ -341,24 +286,20 @@ var BABYLON;
             element.addEventListener("MSGestureChange", this._onGesture, false);
             element.addEventListener('mousewheel', this._wheel, false);
             element.addEventListener('DOMMouseScroll', this._wheel, false);
-
             // pinch
             element.addEventListener('touchstart', this._touchStart, false);
             element.addEventListener('touchmove', this._touchMove, false);
             element.addEventListener('touchend', this._touchEnd, false);
-
             BABYLON.Tools.RegisterTopRootEvents([
                 { name: "keydown", handler: this._onKeyDown },
                 { name: "keyup", handler: this._onKeyUp },
                 { name: "blur", handler: this._onLostFocus }
             ]);
         };
-
         ArcRotateCamera.prototype.detachControl = function (element) {
             if (this._attachedElement != element) {
                 return;
             }
-
             element.removeEventListener(eventPrefix + "down", this._onPointerDown);
             element.removeEventListener(eventPrefix + "up", this._onPointerUp);
             element.removeEventListener(eventPrefix + "out", this._onPointerUp);
@@ -368,61 +309,52 @@ var BABYLON;
             element.removeEventListener("MSGestureChange", this._onGesture);
             element.removeEventListener('mousewheel', this._wheel);
             element.removeEventListener('DOMMouseScroll', this._wheel);
-
             // pinch
             element.removeEventListener('touchstart', this._touchStart);
             element.removeEventListener('touchmove', this._touchMove);
             element.removeEventListener('touchend', this._touchEnd);
-
             BABYLON.Tools.UnregisterTopRootEvents([
                 { name: "keydown", handler: this._onKeyDown },
                 { name: "keyup", handler: this._onKeyUp },
                 { name: "blur", handler: this._onLostFocus }
             ]);
-
             this._MSGestureHandler = null;
             this._attachedElement = null;
-
             if (this._reset) {
                 this._reset();
             }
         };
-
         ArcRotateCamera.prototype._update = function () {
             for (var index = 0; index < this._keys.length; index++) {
                 var keyCode = this._keys[index];
-
                 if (this.keysLeft.indexOf(keyCode) !== -1) {
                     this.inertialAlphaOffset -= 0.01;
-                } else if (this.keysUp.indexOf(keyCode) !== -1) {
+                }
+                else if (this.keysUp.indexOf(keyCode) !== -1) {
                     this.inertialBetaOffset -= 0.01;
-                } else if (this.keysRight.indexOf(keyCode) !== -1) {
+                }
+                else if (this.keysRight.indexOf(keyCode) !== -1) {
                     this.inertialAlphaOffset += 0.01;
-                } else if (this.keysDown.indexOf(keyCode) !== -1) {
+                }
+                else if (this.keysDown.indexOf(keyCode) !== -1) {
                     this.inertialBetaOffset += 0.01;
                 }
             }
-
             // Inertia
             if (this.inertialAlphaOffset != 0 || this.inertialBetaOffset != 0 || this.inertialRadiusOffset != 0) {
                 this.alpha += this.inertialAlphaOffset;
                 this.beta += this.inertialBetaOffset;
                 this.radius -= this.inertialRadiusOffset;
-
                 this.inertialAlphaOffset *= this.inertia;
                 this.inertialBetaOffset *= this.inertia;
                 this.inertialRadiusOffset *= this.inertia;
-
                 if (Math.abs(this.inertialAlphaOffset) < BABYLON.Engine.Epsilon)
                     this.inertialAlphaOffset = 0;
-
                 if (Math.abs(this.inertialBetaOffset) < BABYLON.Engine.Epsilon)
                     this.inertialBetaOffset = 0;
-
                 if (Math.abs(this.inertialRadiusOffset) < BABYLON.Engine.Epsilon)
                     this.inertialRadiusOffset = 0;
             }
-
             // Limits
             if (this.lowerAlphaLimit && this.alpha < this.lowerAlphaLimit) {
                 this.alpha = this.lowerAlphaLimit;
@@ -443,95 +375,72 @@ var BABYLON;
                 this.radius = this.upperRadiusLimit;
             }
         };
-
         ArcRotateCamera.prototype.setPosition = function (position) {
             var radiusv3 = position.subtract(this._getTargetPosition());
             this.radius = radiusv3.length();
-
             // Alpha
             this.alpha = Math.acos(radiusv3.x / Math.sqrt(Math.pow(radiusv3.x, 2) + Math.pow(radiusv3.z, 2)));
-
             if (radiusv3.z < 0) {
                 this.alpha = 2 * Math.PI - this.alpha;
             }
-
             // Beta
             this.beta = Math.acos(radiusv3.y / this.radius);
         };
-
         ArcRotateCamera.prototype._getViewMatrix = function () {
             // Compute
             var cosa = Math.cos(this.alpha);
             var sina = Math.sin(this.alpha);
             var cosb = Math.cos(this.beta);
             var sinb = Math.sin(this.beta);
-
             var target = this._getTargetPosition();
-
             target.addToRef(new BABYLON.Vector3(this.radius * cosa * sinb, this.radius * cosb, this.radius * sina * sinb), this.position);
-
             if (this.checkCollisions) {
                 this._collider.radius = this.collisionRadius;
                 this.position.subtractToRef(this._previousPosition, this._collisionVelocity);
-
                 this.getScene()._getNewPosition(this._previousPosition, this._collisionVelocity, this._collider, 3, this._newPosition);
-
                 if (!this._newPosition.equalsWithEpsilon(this.position)) {
                     this.position.copyFrom(this._previousPosition);
-
                     this.alpha = this._previousAlpha;
                     this.beta = this._previousBeta;
                     this.radius = this._previousRadius;
-
                     if (this.onCollide) {
                         this.onCollide(this._collider.collidedMesh);
                     }
                 }
             }
-
             BABYLON.Matrix.LookAtLHToRef(this.position, target, this.upVector, this._viewMatrix);
-
             this._previousAlpha = this.alpha;
             this._previousBeta = this.beta;
             this._previousRadius = this.radius;
             this._previousPosition.copyFrom(this.position);
-
             this._viewMatrix.m[12] += this.targetScreenOffset.x;
             this._viewMatrix.m[13] += this.targetScreenOffset.y;
-
             return this._viewMatrix;
         };
-
         ArcRotateCamera.prototype.zoomOn = function (meshes) {
             meshes = meshes || this.getScene().meshes;
-
             var minMaxVector = BABYLON.Mesh.MinMax(meshes);
             var distance = BABYLON.Vector3.Distance(minMaxVector.min, minMaxVector.max);
-
             this.radius = distance * this.zoomOnFactor;
-
             this.focusOn({ min: minMaxVector.min, max: minMaxVector.max, distance: distance });
         };
-
         ArcRotateCamera.prototype.focusOn = function (meshesOrMinMaxVectorAndDistance) {
             var meshesOrMinMaxVector;
             var distance;
-
             if (meshesOrMinMaxVectorAndDistance.min === undefined) {
                 meshesOrMinMaxVector = meshesOrMinMaxVectorAndDistance || this.getScene().meshes;
                 meshesOrMinMaxVector = BABYLON.Mesh.MinMax(meshesOrMinMaxVector);
                 distance = BABYLON.Vector3.Distance(meshesOrMinMaxVector.min, meshesOrMinMaxVector.max);
-            } else {
+            }
+            else {
                 meshesOrMinMaxVector = meshesOrMinMaxVectorAndDistance;
                 distance = meshesOrMinMaxVectorAndDistance.distance;
             }
-
             this.target = BABYLON.Mesh.Center(meshesOrMinMaxVector);
-
             this.maxZ = distance * 2;
         };
         return ArcRotateCamera;
     })(BABYLON.Camera);
     BABYLON.ArcRotateCamera = ArcRotateCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.arcRotateCamera.js.map
+//# sourceMappingURL=babylon.arcRotateCamera.js.map

Babylon/Cameras/babylon.camera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -30,9 +30,7 @@ var BABYLON;
             this._projectionMatrix = new BABYLON.Matrix();
             this._postProcesses = new Array();
             this._postProcessesTakenIndices = [];
-
             scene.cameras.push(this);
-
             if (!scene.activeCamera) {
                 scene.activeCamera = this;
             }
@@ -40,17 +38,13 @@ var BABYLON;
         //Cache
         Camera.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
-
             this._cache.position = new BABYLON.Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
             this._cache.upVector = new BABYLON.Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-
             this._cache.mode = undefined;
             this._cache.minZ = undefined;
             this._cache.maxZ = undefined;
-
             this._cache.fov = undefined;
             this._cache.aspectRatio = undefined;
-
             this._cache.orthoLeft = undefined;
             this._cache.orthoRight = undefined;
             this._cache.orthoBottom = undefined;
@@ -58,24 +52,18 @@ var BABYLON;
             this._cache.renderWidth = undefined;
             this._cache.renderHeight = undefined;
         };
-
         Camera.prototype._updateCache = function (ignoreParentClass) {
             if (!ignoreParentClass) {
                 _super.prototype._updateCache.call(this);
             }
-
             var engine = this.getEngine();
-
             this._cache.position.copyFrom(this.position);
             this._cache.upVector.copyFrom(this.upVector);
-
             this._cache.mode = this.mode;
             this._cache.minZ = this.minZ;
             this._cache.maxZ = this.maxZ;
-
             this._cache.fov = this.fov;
             this._cache.aspectRatio = engine.getAspectRatio(this);
-
             this._cache.orthoLeft = this.orthoLeft;
             this._cache.orthoRight = this.orthoRight;
             this._cache.orthoBottom = this.orthoBottom;
@@ -83,83 +71,63 @@ var BABYLON;
             this._cache.renderWidth = engine.getRenderWidth();
             this._cache.renderHeight = engine.getRenderHeight();
         };
-
         Camera.prototype._updateFromScene = function () {
             this.updateCache();
             this._update();
         };
-
         // Synchronized
         Camera.prototype._isSynchronized = function () {
             return this._isSynchronizedViewMatrix() && this._isSynchronizedProjectionMatrix();
         };
-
         Camera.prototype._isSynchronizedViewMatrix = function () {
             if (!_super.prototype._isSynchronized.call(this))
                 return false;
-
             return this._cache.position.equals(this.position) && this._cache.upVector.equals(this.upVector) && this.isSynchronizedWithParent();
         };
-
         Camera.prototype._isSynchronizedProjectionMatrix = function () {
             var check = this._cache.mode === this.mode && this._cache.minZ === this.minZ && this._cache.maxZ === this.maxZ;
-
             if (!check) {
                 return false;
             }
-
             var engine = this.getEngine();
-
             if (this.mode === BABYLON.Camera.PERSPECTIVE_CAMERA) {
                 check = this._cache.fov === this.fov && this._cache.aspectRatio === engine.getAspectRatio(this);
-            } else {
+            }
+            else {
                 check = this._cache.orthoLeft === this.orthoLeft && this._cache.orthoRight === this.orthoRight && this._cache.orthoBottom === this.orthoBottom && this._cache.orthoTop === this.orthoTop && this._cache.renderWidth === engine.getRenderWidth() && this._cache.renderHeight === engine.getRenderHeight();
             }
-
             return check;
         };
-
         // Controls
         Camera.prototype.attachControl = function (element) {
         };
-
         Camera.prototype.detachControl = function (element) {
         };
-
         Camera.prototype._update = function () {
         };
-
         Camera.prototype.attachPostProcess = function (postProcess, insertAt) {
-            if (typeof insertAt === "undefined") { insertAt = null; }
+            if (insertAt === void 0) { insertAt = null; }
             if (!postProcess.isReusable() && this._postProcesses.indexOf(postProcess) > -1) {
                 BABYLON.Tools.Error("You're trying to reuse a post process not defined as reusable.");
                 return 0;
             }
-
             if (insertAt == null || insertAt < 0) {
                 this._postProcesses.push(postProcess);
                 this._postProcessesTakenIndices.push(this._postProcesses.length - 1);
-
                 return this._postProcesses.length - 1;
             }
-
             var add = 0;
-
             if (this._postProcesses[insertAt]) {
                 var start = this._postProcesses.length - 1;
-
                 for (var i = start; i >= insertAt + 1; --i) {
                     this._postProcesses[i + 1] = this._postProcesses[i];
                 }
-
                 add = 1;
             }
-
             for (i = 0; i < this._postProcessesTakenIndices.length; ++i) {
                 if (this._postProcessesTakenIndices[i] < insertAt) {
                     continue;
                 }
-
                 start = this._postProcessesTakenIndices.length - 1;
                 for (var j = start; j >= i; --j) {
                     this._postProcessesTakenIndices[j + 1] = this._postProcessesTakenIndices[j] + add;
@@ -167,137 +135,107 @@ var BABYLON;
                 this._postProcessesTakenIndices[i] = insertAt;
                 break;
             }
-
             if (!add && this._postProcessesTakenIndices.indexOf(insertAt) == -1) {
                 this._postProcessesTakenIndices.push(insertAt);
             }
-
             var result = insertAt + add;
-
             this._postProcesses[result] = postProcess;
-
             return result;
         };
-
         Camera.prototype.detachPostProcess = function (postProcess, atIndices) {
-            if (typeof atIndices === "undefined") { atIndices = null; }
+            if (atIndices === void 0) { atIndices = null; }
             var result = [];
-
             if (!atIndices) {
                 var length = this._postProcesses.length;
-
                 for (var i = 0; i < length; i++) {
                     if (this._postProcesses[i] !== postProcess) {
                         continue;
                     }
-
                     delete this._postProcesses[i];
-
                     var index = this._postProcessesTakenIndices.indexOf(i);
                     this._postProcessesTakenIndices.splice(index, 1);
                 }
-            } else {
+            }
+            else {
                 atIndices = (atIndices instanceof Array) ? atIndices : [atIndices];
                 for (i = 0; i < atIndices.length; i++) {
                     var foundPostProcess = this._postProcesses[atIndices[i]];
-
                     if (foundPostProcess !== postProcess) {
                         result.push(i);
                         continue;
                     }
-
                     delete this._postProcesses[atIndices[i]];
-
                     index = this._postProcessesTakenIndices.indexOf(atIndices[i]);
                     this._postProcessesTakenIndices.splice(index, 1);
                 }
             }
             return result;
         };
-
         Camera.prototype.getWorldMatrix = function () {
             if (!this._worldMatrix) {
                 this._worldMatrix = BABYLON.Matrix.Identity();
             }
-
             var viewMatrix = this.getViewMatrix();
-
             viewMatrix.invertToRef(this._worldMatrix);
-
             return this._worldMatrix;
         };
-
         Camera.prototype._getViewMatrix = function () {
             return BABYLON.Matrix.Identity();
         };
-
         Camera.prototype.getViewMatrix = function () {
             this._computedViewMatrix = this._computeViewMatrix();
-
             if (!this.parent || !this.parent.getWorldMatrix || this.isSynchronized()) {
                 return this._computedViewMatrix;
             }
-
             if (!this._worldMatrix) {
                 this._worldMatrix = BABYLON.Matrix.Identity();
             }
-
             this._computedViewMatrix.invertToRef(this._worldMatrix);
-
             this._worldMatrix.multiplyToRef(this.parent.getWorldMatrix(), this._computedViewMatrix);
-
             this._computedViewMatrix.invert();
-
             this._currentRenderId = this.getScene().getRenderId();
             return this._computedViewMatrix;
         };
-
         Camera.prototype._computeViewMatrix = function (force) {
             if (!force && this._isSynchronizedViewMatrix()) {
                 return this._computedViewMatrix;
             }
-
             this._computedViewMatrix = this._getViewMatrix();
             if (!this.parent || !this.parent.getWorldMatrix) {
                 this._currentRenderId = this.getScene().getRenderId();
             }
             return this._computedViewMatrix;
         };
-
         Camera.prototype.getProjectionMatrix = function (force) {
             if (!force && this._isSynchronizedProjectionMatrix()) {
                 return this._projectionMatrix;
             }
-
             var engine = this.getEngine();
             if (this.mode === BABYLON.Camera.PERSPECTIVE_CAMERA) {
                 if (this.minZ <= 0) {
                     this.minZ = 0.1;
                 }
-
                 BABYLON.Matrix.PerspectiveFovLHToRef(this.fov, engine.getAspectRatio(this), this.minZ, this.maxZ, this._projectionMatrix);
                 return this._projectionMatrix;
             }
-
             var halfWidth = engine.getRenderWidth() / 2.0;
             var halfHeight = engine.getRenderHeight() / 2.0;
             BABYLON.Matrix.OrthoOffCenterLHToRef(this.orthoLeft || -halfWidth, this.orthoRight || halfWidth, this.orthoBottom || -halfHeight, this.orthoTop || halfHeight, this.minZ, this.maxZ, this._projectionMatrix);
             return this._projectionMatrix;
         };
-
         Camera.prototype.dispose = function () {
             // Remove from scene
             var index = this.getScene().cameras.indexOf(this);
             this.getScene().cameras.splice(index, 1);
-
             for (var i = 0; i < this._postProcessesTakenIndices.length; ++i) {
                 this._postProcesses[this._postProcessesTakenIndices[i]].dispose(this);
             }
         };
+        // Statics
         Camera.PERSPECTIVE_CAMERA = 0;
         Camera.ORTHOGRAPHIC_CAMERA = 1;
         return Camera;
     })(BABYLON.Node);
     BABYLON.Camera = Camera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.camera.js.map
+//# sourceMappingURL=babylon.camera.js.map

Babylon/Cameras/babylon.deviceOrientationCamera.js

@@ -20,7 +20,6 @@ var BABYLON;
             this._initialOrientationBeta = 0;
             this.angularSensibility = 10000.0;
             this.moveSensibility = 50.0;
-
             window.addEventListener("resize", function () {
                 _this._initialOrientationGamma = null;
             }, false);
@@ -31,48 +30,38 @@ var BABYLON;
                 return;
             }
             this._attachedCanvas = canvas;
-
             if (!this._orientationChanged) {
                 this._orientationChanged = function (evt) {
                     if (!_this._initialOrientationGamma) {
                         _this._initialOrientationGamma = evt.gamma;
                         _this._initialOrientationBeta = evt.beta;
                     }
-
                     _this._orientationGamma = evt.gamma;
                     _this._orientationBeta = evt.beta;
-
                     _this._offsetY = (_this._initialOrientationBeta - _this._orientationBeta);
                     _this._offsetX = (_this._initialOrientationGamma - _this._orientationGamma);
                 };
             }
-
             window.addEventListener("deviceorientation", this._orientationChanged);
         };
-
         DeviceOrientationCamera.prototype.detachControl = function (canvas) {
             if (this._attachedCanvas != canvas) {
                 return;
             }
-
             window.removeEventListener("deviceorientation", this._orientationChanged);
-
             this._attachedCanvas = null;
             this._orientationGamma = 0;
             this._orientationBeta = 0;
             this._initialOrientationGamma = 0;
             this._initialOrientationBeta = 0;
         };
-
         DeviceOrientationCamera.prototype._checkInputs = function () {
             if (!this._offsetX) {
                 return;
             }
             this.cameraRotation.y -= this._offsetX / this.angularSensibility;
-
             var speed = this._computeLocalCameraSpeed();
             var direction = new BABYLON.Vector3(0, 0, speed * this._offsetY / this.moveSensibility);
-
             BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, 0, this._cameraRotationMatrix);
             this.cameraDirection.addInPlace(BABYLON.Vector3.TransformCoordinates(direction, this._cameraRotationMatrix));
         };
@@ -80,4 +69,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.DeviceOrientationCamera = DeviceOrientationCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.deviceOrientationCamera.js.map
+//# sourceMappingURL=babylon.deviceOrientationCamera.js.map

Babylon/Cameras/babylon.followCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -19,38 +19,30 @@ var BABYLON;
         FollowCamera.prototype.getRadians = function (degrees) {
             return degrees * Math.PI / 180;
         };
-
         FollowCamera.prototype.follow = function (cameraTarget) {
             if (!cameraTarget)
                 return;
-
             var radians = this.getRadians(this.rotationOffset) + cameraTarget.rotation.y;
             var targetX = cameraTarget.position.x + Math.sin(radians) * this.radius;
-
             var targetZ = cameraTarget.position.z + Math.cos(radians) * this.radius;
             var dx = targetX - this.position.x;
             var dy = (cameraTarget.position.y + this.heightOffset) - this.position.y;
             var dz = (targetZ) - this.position.z;
-            var vx = dx * this.cameraAcceleration * 2;
+            var vx = dx * this.cameraAcceleration * 2; //this is set to .05
             var vy = dy * this.cameraAcceleration;
             var vz = dz * this.cameraAcceleration * 2;
-
             if (vx > this.maxCameraSpeed || vx < -this.maxCameraSpeed) {
                 vx = vx < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
             }
-
             if (vy > this.maxCameraSpeed || vy < -this.maxCameraSpeed) {
                 vy = vy < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
             }
-
             if (vz > this.maxCameraSpeed || vz < -this.maxCameraSpeed) {
                 vz = vz < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
             }
-
             this.position = new BABYLON.Vector3(this.position.x + vx, this.position.y + vy, this.position.z + vz);
             this.setTarget(cameraTarget.position);
         };
-
         FollowCamera.prototype._update = function () {
             _super.prototype._update.call(this);
             this.follow(this.target);
@@ -59,4 +51,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.FollowCamera = FollowCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.followCamera.js.map
+//# sourceMappingURL=babylon.followCamera.js.map

Babylon/Cameras/babylon.freeCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -30,31 +30,26 @@ var BABYLON;
             var _this = this;
             var previousPosition;
             var engine = this.getEngine();
-
             if (this._attachedElement) {
                 return;
             }
             this._attachedElement = element;
-
             if (this._onMouseDown === undefined) {
                 this._onMouseDown = function (evt) {
                     previousPosition = {
                         x: evt.clientX,
                         y: evt.clientY
                     };
-
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
                 };
-
                 this._onMouseUp = function (evt) {
                     previousPosition = null;
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
                 };
-
                 this._onMouseOut = function (evt) {
                     previousPosition = null;
                     _this._keys = [];
@@ -62,26 +57,22 @@ var BABYLON;
                         evt.preventDefault();
                     }
                 };
-
                 this._onMouseMove = function (evt) {
                     if (!previousPosition && !engine.isPointerLock) {
                         return;
                     }
-
                     var offsetX;
                     var offsetY;
-
                     if (!engine.isPointerLock) {
                         offsetX = evt.clientX - previousPosition.x;
                         offsetY = evt.clientY - previousPosition.y;
-                    } else {
+                    }
+                    else {
                         offsetX = evt.movementX || evt.mozMovementX || evt.webkitMovementX || evt.msMovementX || 0;
                         offsetY = evt.movementY || evt.mozMovementY || evt.webkitMovementY || evt.msMovementY || 0;
                     }
-
                     _this.cameraRotation.y += offsetX / _this.angularSensibility;
                     _this.cameraRotation.x += offsetY / _this.angularSensibility;
-
                     previousPosition = {
                         x: evt.clientX,
                         y: evt.clientY
@@ -90,11 +81,9 @@ var BABYLON;
                         evt.preventDefault();
                     }
                 };
-
                 this._onKeyDown = function (evt) {
                     if (_this.keysUp.indexOf(evt.keyCode) !== -1 || _this.keysDown.indexOf(evt.keyCode) !== -1 || _this.keysLeft.indexOf(evt.keyCode) !== -1 || _this.keysRight.indexOf(evt.keyCode) !== -1) {
                         var index = _this._keys.indexOf(evt.keyCode);
-
                         if (index === -1) {
                             _this._keys.push(evt.keyCode);
                         }
@@ -103,11 +92,9 @@ var BABYLON;
                         }
                     }
                 };
-
                 this._onKeyUp = function (evt) {
                     if (_this.keysUp.indexOf(evt.keyCode) !== -1 || _this.keysDown.indexOf(evt.keyCode) !== -1 || _this.keysLeft.indexOf(evt.keyCode) !== -1 || _this.keysRight.indexOf(evt.keyCode) !== -1) {
                         var index = _this._keys.indexOf(evt.keyCode);
-
                         if (index >= 0) {
                             _this._keys.splice(index, 1);
                         }
@@ -116,11 +103,9 @@ var BABYLON;
                         }
                     }
                 };
-
                 this._onLostFocus = function () {
                     _this._keys = [];
                 };
-
                 this._reset = function () {
                     _this._keys = [];
                     previousPosition = null;
@@ -128,56 +113,46 @@ var BABYLON;
                     _this.cameraRotation = new BABYLON.Vector2(0, 0);
                 };
             }
-
             element.addEventListener("mousedown", this._onMouseDown, false);
             element.addEventListener("mouseup", this._onMouseUp, false);
             element.addEventListener("mouseout", this._onMouseOut, false);
             element.addEventListener("mousemove", this._onMouseMove, false);
-
             BABYLON.Tools.RegisterTopRootEvents([
                 { name: "keydown", handler: this._onKeyDown },
                 { name: "keyup", handler: this._onKeyUp },
                 { name: "blur", handler: this._onLostFocus }
             ]);
         };
-
         FreeCamera.prototype.detachControl = function (element) {
             if (this._attachedElement != element) {
                 return;
             }
-
             element.removeEventListener("mousedown", this._onMouseDown);
             element.removeEventListener("mouseup", this._onMouseUp);
             element.removeEventListener("mouseout", this._onMouseOut);
             element.removeEventListener("mousemove", this._onMouseMove);
-
             BABYLON.Tools.UnregisterTopRootEvents([
                 { name: "keydown", handler: this._onKeyDown },
                 { name: "keyup", handler: this._onKeyUp },
                 { name: "blur", handler: this._onLostFocus }
             ]);
-
             this._attachedElement = null;
             if (this._reset) {
                 this._reset();
             }
         };
-
         FreeCamera.prototype._collideWithWorld = function (velocity) {
             var globalPosition;
-
             if (this.parent) {
                 globalPosition = BABYLON.Vector3.TransformCoordinates(this.position, this.parent.getWorldMatrix());
-            } else {
+            }
+            else {
                 globalPosition = this.position;
             }
-
             globalPosition.subtractFromFloatsToRef(0, this.ellipsoid.y, 0, this._oldPosition);
             this._collider.radius = this.ellipsoid;
-
             this.getScene()._getNewPosition(this._oldPosition, velocity, this._collider, 3, this._newPosition);
             this._newPosition.subtractToRef(this._oldPosition, this._diffPosition);
-
             if (this._diffPosition.length() > BABYLON.Engine.CollisionsEpsilon) {
                 this.position.addInPlace(this._diffPosition);
                 if (this.onCollide) {
@@ -185,37 +160,34 @@ var BABYLON;
                 }
             }
         };
-
         FreeCamera.prototype._checkInputs = function () {
             if (!this._localDirection) {
                 this._localDirection = BABYLON.Vector3.Zero();
                 this._transformedDirection = BABYLON.Vector3.Zero();
             }
-
             for (var index = 0; index < this._keys.length; index++) {
                 var keyCode = this._keys[index];
                 var speed = this._computeLocalCameraSpeed();
-
                 if (this.keysLeft.indexOf(keyCode) !== -1) {
                     this._localDirection.copyFromFloats(-speed, 0, 0);
-                } else if (this.keysUp.indexOf(keyCode) !== -1) {
+                }
+                else if (this.keysUp.indexOf(keyCode) !== -1) {
                     this._localDirection.copyFromFloats(0, 0, speed);
-                } else if (this.keysRight.indexOf(keyCode) !== -1) {
+                }
+                else if (this.keysRight.indexOf(keyCode) !== -1) {
                     this._localDirection.copyFromFloats(speed, 0, 0);
-                } else if (this.keysDown.indexOf(keyCode) !== -1) {
+                }
+                else if (this.keysDown.indexOf(keyCode) !== -1) {
                     this._localDirection.copyFromFloats(0, 0, -speed);
                 }
-
                 this.getViewMatrix().invertToRef(this._cameraTransformMatrix);
                 BABYLON.Vector3.TransformNormalToRef(this._localDirection, this._cameraTransformMatrix, this._transformedDirection);
                 this.cameraDirection.addInPlace(this._transformedDirection);
             }
         };
-
         FreeCamera.prototype._decideIfNeedsToMove = function () {
             return this._needMoveForGravity || Math.abs(this.cameraDirection.x) > 0 || Math.abs(this.cameraDirection.y) > 0 || Math.abs(this.cameraDirection.z) > 0;
         };
-
         FreeCamera.prototype._updatePosition = function () {
             if (this.checkCollisions && this.getScene().collisionsEnabled) {
                 this._collideWithWorld(this.cameraDirection);
@@ -224,11 +196,11 @@ var BABYLON;
                     this._collideWithWorld(this.getScene().gravity);
                     this._needMoveForGravity = (BABYLON.Vector3.DistanceSquared(oldPosition, this.position) != 0);
                 }
-            } else {
+            }
+            else {
                 this.position.addInPlace(this.cameraDirection);
             }
         };
-
         FreeCamera.prototype._update = function () {
             this._checkInputs();
             _super.prototype._update.call(this);
@@ -237,4 +209,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.FreeCamera = FreeCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.freeCamera.js.map
+//# sourceMappingURL=babylon.freeCamera.js.map

Babylon/Cameras/babylon.gamepadCamera.js

@@ -24,31 +24,26 @@ var BABYLON;
                 this._gamepad = gamepad;
             }
         };
-
         GamepadCamera.prototype._checkInputs = function () {
             if (!this._gamepad) {
                 return;
             }
-
             var LSValues = this._gamepad.leftStick;
             var normalizedLX = LSValues.x / this.moveSensibility;
             var normalizedLY = LSValues.y / this.moveSensibility;
             LSValues.x = Math.abs(normalizedLX) > 0.005 ? 0 + normalizedLX : 0;
             LSValues.y = Math.abs(normalizedLY) > 0.005 ? 0 + normalizedLY : 0;
-
             var RSValues = this._gamepad.rightStick;
             var normalizedRX = RSValues.x / this.angularSensibility;
             var normalizedRY = RSValues.y / this.angularSensibility;
             RSValues.x = Math.abs(normalizedRX) > 0.001 ? 0 + normalizedRX : 0;
             RSValues.y = Math.abs(normalizedRY) > 0.001 ? 0 + normalizedRY : 0;
             ;
-
             var cameraTransform = BABYLON.Matrix.RotationYawPitchRoll(this.rotation.y, this.rotation.x, 0);
             var deltaTransform = BABYLON.Vector3.TransformCoordinates(new BABYLON.Vector3(LSValues.x, 0, -LSValues.y), cameraTransform);
             this.cameraDirection = this.cameraDirection.add(deltaTransform);
             this.cameraRotation = this.cameraRotation.add(new BABYLON.Vector2(RSValues.y, RSValues.x));
         };
-
         GamepadCamera.prototype.dispose = function () {
             this._gamepads.dispose();
             _super.prototype.dispose.call(this);
@@ -57,4 +52,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.GamepadCamera = GamepadCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.gamepadCamera.js.map
+//# sourceMappingURL=babylon.gamepadCamera.js.map

Babylon/Cameras/babylon.targetCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -30,170 +30,140 @@ var BABYLON;
             if (!this.lockedTarget) {
                 return null;
             }
-
             return this.lockedTarget.position || this.lockedTarget;
         };
-
         // Cache
         TargetCamera.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
             this._cache.lockedTarget = new BABYLON.Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
             this._cache.rotation = new BABYLON.Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
         };
-
         TargetCamera.prototype._updateCache = function (ignoreParentClass) {
             if (!ignoreParentClass) {
                 _super.prototype._updateCache.call(this);
             }
-
             var lockedTargetPosition = this._getLockedTargetPosition();
             if (!lockedTargetPosition) {
                 this._cache.lockedTarget = null;
-            } else {
+            }
+            else {
                 if (!this._cache.lockedTarget) {
                     this._cache.lockedTarget = lockedTargetPosition.clone();
-                } else {
+                }
+                else {
                     this._cache.lockedTarget.copyFrom(lockedTargetPosition);
                 }
             }
-
             this._cache.rotation.copyFrom(this.rotation);
         };
-
         // Synchronized
         TargetCamera.prototype._isSynchronizedViewMatrix = function () {
             if (!_super.prototype._isSynchronizedViewMatrix.call(this)) {
                 return false;
             }
-
             var lockedTargetPosition = this._getLockedTargetPosition();
-
             return (this._cache.lockedTarget ? this._cache.lockedTarget.equals(lockedTargetPosition) : !lockedTargetPosition) && this._cache.rotation.equals(this.rotation);
         };
-
         // Methods
         TargetCamera.prototype._computeLocalCameraSpeed = function () {
             var engine = this.getEngine();
             return this.speed * ((engine.getDeltaTime() / (engine.getFps() * 10.0)));
         };
-
         // Target
         TargetCamera.prototype.setTarget = function (target) {
             this.upVector.normalize();
-
             BABYLON.Matrix.LookAtLHToRef(this.position, target, this.upVector, this._camMatrix);
             this._camMatrix.invert();
-
             this.rotation.x = Math.atan(this._camMatrix.m[6] / this._camMatrix.m[10]);
-
             var vDir = target.subtract(this.position);
-
             if (vDir.x >= 0.0) {
                 this.rotation.y = (-Math.atan(vDir.z / vDir.x) + Math.PI / 2.0);
-            } else {
+            }
+            else {
                 this.rotation.y = (-Math.atan(vDir.z / vDir.x) - Math.PI / 2.0);
             }
-
             this.rotation.z = -Math.acos(BABYLON.Vector3.Dot(new BABYLON.Vector3(0, 1.0, 0), this.upVector));
-
             if (isNaN(this.rotation.x)) {
                 this.rotation.x = 0;
             }
-
             if (isNaN(this.rotation.y)) {
                 this.rotation.y = 0;
             }
-
             if (isNaN(this.rotation.z)) {
                 this.rotation.z = 0;
             }
         };
-
         TargetCamera.prototype.getTarget = function () {
             return this._currentTarget;
         };
-
         TargetCamera.prototype._decideIfNeedsToMove = function () {
             return Math.abs(this.cameraDirection.x) > 0 || Math.abs(this.cameraDirection.y) > 0 || Math.abs(this.cameraDirection.z) > 0;
         };
-
         TargetCamera.prototype._updatePosition = function () {
             this.position.addInPlace(this.cameraDirection);
         };
         TargetCamera.prototype._update = function () {
             var needToMove = this._decideIfNeedsToMove();
             var needToRotate = Math.abs(this.cameraRotation.x) > 0 || Math.abs(this.cameraRotation.y) > 0;
-
             // Move
             if (needToMove) {
                 this._updatePosition();
             }
-
             // Rotate
             if (needToRotate) {
                 this.rotation.x += this.cameraRotation.x;
                 this.rotation.y += this.cameraRotation.y;
-
                 if (!this.noRotationConstraint) {
                     var limit = (Math.PI / 2) * 0.95;
-
                     if (this.rotation.x > limit)
                         this.rotation.x = limit;
                     if (this.rotation.x < -limit)
                         this.rotation.x = -limit;
                 }
             }
-
             // Inertia
             if (needToMove) {
                 if (Math.abs(this.cameraDirection.x) < BABYLON.Engine.Epsilon) {
                     this.cameraDirection.x = 0;
                 }
-
                 if (Math.abs(this.cameraDirection.y) < BABYLON.Engine.Epsilon) {
                     this.cameraDirection.y = 0;
                 }
-
                 if (Math.abs(this.cameraDirection.z) < BABYLON.Engine.Epsilon) {
                     this.cameraDirection.z = 0;
                 }
-
                 this.cameraDirection.scaleInPlace(this.inertia);
             }
             if (needToRotate) {
                 if (Math.abs(this.cameraRotation.x) < BABYLON.Engine.Epsilon) {
                     this.cameraRotation.x = 0;
                 }
-
                 if (Math.abs(this.cameraRotation.y) < BABYLON.Engine.Epsilon) {
                     this.cameraRotation.y = 0;
                 }
                 this.cameraRotation.scaleInPlace(this.inertia);
             }
         };
-
         TargetCamera.prototype._getViewMatrix = function () {
             if (!this.lockedTarget) {
                 // Compute
                 if (this.upVector.x != 0 || this.upVector.y != 1.0 || this.upVector.z != 0) {
                     BABYLON.Matrix.LookAtLHToRef(BABYLON.Vector3.Zero(), this._referencePoint, this.upVector, this._lookAtTemp);
                     BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._cameraRotationMatrix);
-
                     this._lookAtTemp.multiplyToRef(this._cameraRotationMatrix, this._tempMatrix);
                     this._lookAtTemp.invert();
                     this._tempMatrix.multiplyToRef(this._lookAtTemp, this._cameraRotationMatrix);
-                } else {
+                }
+                else {
                     BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._cameraRotationMatrix);
                 }
-
                 BABYLON.Vector3.TransformCoordinatesToRef(this._referencePoint, this._cameraRotationMatrix, this._transformedReferencePoint);
-
                 // Computing target and final matrix
                 this.position.addToRef(this._transformedReferencePoint, this._currentTarget);
-            } else {
+            }
+            else {
                 this._currentTarget.copyFrom(this._getLockedTargetPosition());
             }
-
             BABYLON.Matrix.LookAtLHToRef(this.position, this._currentTarget, this.upVector, this._viewMatrix);
             return this._viewMatrix;
         };
@@ -201,4 +171,4 @@ var BABYLON;
     })(BABYLON.Camera);
     BABYLON.TargetCamera = TargetCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.targetCamera.js.map
+//# sourceMappingURL=babylon.targetCamera.js.map

Babylon/Cameras/babylon.touchCamera.js

@@ -21,42 +21,33 @@ var BABYLON;
         TouchCamera.prototype.attachControl = function (canvas, noPreventDefault) {
             var _this = this;
             var previousPosition;
-
             if (this._attachedCanvas) {
                 return;
             }
             this._attachedCanvas = canvas;
-
             if (this._onPointerDown === undefined) {
                 this._onPointerDown = function (evt) {
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
-
                     _this._pointerPressed.push(evt.pointerId);
-
                     if (_this._pointerPressed.length !== 1) {
                         return;
                     }
-
                     previousPosition = {
                         x: evt.clientX,
                         y: evt.clientY
                     };
                 };
-
                 this._onPointerUp = function (evt) {
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
-
                     var index = _this._pointerPressed.indexOf(evt.pointerId);
-
                     if (index === -1) {
                         return;
                     }
                     _this._pointerPressed.splice(index, 1);
-
                     if (index != 0) {
                         return;
                     }
@@ -64,71 +55,57 @@ var BABYLON;
                     _this._offsetX = null;
                     _this._offsetY = null;
                 };
-
                 this._onPointerMove = function (evt) {
                     if (!noPreventDefault) {
                         evt.preventDefault();
                     }
-
                     if (!previousPosition) {
                         return;
                     }
-
                     var index = _this._pointerPressed.indexOf(evt.pointerId);
-
                     if (index != 0) {
                         return;
                     }
-
                     _this._offsetX = evt.clientX - previousPosition.x;
                     _this._offsetY = -(evt.clientY - previousPosition.y);
                 };
-
                 this._onLostFocus = function () {
                     _this._offsetX = null;
                     _this._offsetY = null;
                 };
             }
-
             canvas.addEventListener("pointerdown", this._onPointerDown);
             canvas.addEventListener("pointerup", this._onPointerUp);
             canvas.addEventListener("pointerout", this._onPointerUp);
             canvas.addEventListener("pointermove", this._onPointerMove);
-
             BABYLON.Tools.RegisterTopRootEvents([
                 { name: "blur", handler: this._onLostFocus }
             ]);
         };
-
         TouchCamera.prototype.detachControl = function (canvas) {
             if (this._attachedCanvas != canvas) {
                 return;
             }
-
             canvas.removeEventListener("pointerdown", this._onPointerDown);
             canvas.removeEventListener("pointerup", this._onPointerUp);
             canvas.removeEventListener("pointerout", this._onPointerUp);
             canvas.removeEventListener("pointermove", this._onPointerMove);
-
             BABYLON.Tools.UnregisterTopRootEvents([
                 { name: "blur", handler: this._onLostFocus }
             ]);
-
             this._attachedCanvas = null;
         };
-
         TouchCamera.prototype._checkInputs = function () {
             if (!this._offsetX) {
                 return;
             }
             this.cameraRotation.y += this._offsetX / this.angularSensibility;
-
             if (this._pointerPressed.length > 1) {
                 this.cameraRotation.x += -this._offsetY / this.angularSensibility;
-            } else {
+            }
+            else {
                 var speed = this._computeLocalCameraSpeed();
                 var direction = new BABYLON.Vector3(0, 0, speed * this._offsetY / this.moveSensibility);
-
                 BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, 0, this._cameraRotationMatrix);
                 this.cameraDirection.addInPlace(BABYLON.Vector3.TransformCoordinates(direction, this._cameraRotationMatrix));
             }
@@ -137,4 +114,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.TouchCamera = TouchCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.touchCamera.js.map
+//# sourceMappingURL=babylon.touchCamera.js.map

Babylon/Cameras/babylon.virtualJoysticksCamera.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -34,7 +34,6 @@ var BABYLON;
                 this._rightjoystick.deltaPosition = this._rightjoystick.deltaPosition.scale(0.9);
             }
         };
-
         VirtualJoysticksCamera.prototype.dispose = function () {
             this._leftjoystick.releaseCanvas();
             _super.prototype.dispose.call(this);
@@ -43,4 +42,4 @@ var BABYLON;
     })(BABYLON.FreeCamera);
     BABYLON.VirtualJoysticksCamera = VirtualJoysticksCamera;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.virtualJoysticksCamera.js.map
+//# sourceMappingURL=babylon.virtualJoysticksCamera.js.map

Babylon/Collisions/babylon.collider.js

@@ -1,59 +1,45 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var intersectBoxAASphere = function (boxMin, boxMax, sphereCenter, sphereRadius) {
         if (boxMin.x > sphereCenter.x + sphereRadius)
             return false;
-
         if (sphereCenter.x - sphereRadius > boxMax.x)
             return false;
-
         if (boxMin.y > sphereCenter.y + sphereRadius)
             return false;
-
         if (sphereCenter.y - sphereRadius > boxMax.y)
             return false;
-
         if (boxMin.z > sphereCenter.z + sphereRadius)
             return false;
-
         if (sphereCenter.z - sphereRadius > boxMax.z)
             return false;
-
         return true;
     };
-
     var getLowestRoot = function (a, b, c, maxR) {
         var determinant = b * b - 4.0 * a * c;
         var result = { root: 0, found: false };
-
         if (determinant < 0)
             return result;
-
         var sqrtD = Math.sqrt(determinant);
         var r1 = (-b - sqrtD) / (2.0 * a);
         var r2 = (-b + sqrtD) / (2.0 * a);
-
         if (r1 > r2) {
             var temp = r2;
             r2 = r1;
             r1 = temp;
         }
-
         if (r1 > 0 && r1 < maxR) {
             result.root = r1;
             result.found = true;
             return result;
         }
-
         if (r2 > 0 && r2 < maxR) {
             result.root = r2;
             result.found = true;
             return result;
         }
-
         return result;
     };
-
     var Collider = (function () {
         function Collider() {
             this.radius = new BABYLON.Vector3(1, 1, 1);
@@ -78,165 +64,128 @@
             this.velocity = dir;
             BABYLON.Vector3.NormalizeToRef(dir, this.normalizedVelocity);
             this.basePoint = source;
-
             source.multiplyToRef(this.radius, this.basePointWorld);
             dir.multiplyToRef(this.radius, this.velocityWorld);
-
             this.velocityWorldLength = this.velocityWorld.length();
-
             this.epsilon = e;
             this.collisionFound = false;
         };
-
         Collider.prototype._checkPointInTriangle = function (point, pa, pb, pc, n) {
             pa.subtractToRef(point, this._tempVector);
             pb.subtractToRef(point, this._tempVector2);
-
             BABYLON.Vector3.CrossToRef(this._tempVector, this._tempVector2, this._tempVector4);
             var d = BABYLON.Vector3.Dot(this._tempVector4, n);
             if (d < 0)
                 return false;
-
             pc.subtractToRef(point, this._tempVector3);
             BABYLON.Vector3.CrossToRef(this._tempVector2, this._tempVector3, this._tempVector4);
             d = BABYLON.Vector3.Dot(this._tempVector4, n);
             if (d < 0)
                 return false;
-
             BABYLON.Vector3.CrossToRef(this._tempVector3, this._tempVector, this._tempVector4);
             d = BABYLON.Vector3.Dot(this._tempVector4, n);
             return d >= 0;
         };
-
         Collider.prototype._canDoCollision = function (sphereCenter, sphereRadius, vecMin, vecMax) {
             var distance = BABYLON.Vector3.Distance(this.basePointWorld, sphereCenter);
-
             var max = Math.max(this.radius.x, this.radius.y, this.radius.z);
-
             if (distance > this.velocityWorldLength + max + sphereRadius) {
                 return false;
             }
-
             if (!intersectBoxAASphere(vecMin, vecMax, this.basePointWorld, this.velocityWorldLength + max))
                 return false;
-
             return true;
         };
-
         Collider.prototype._testTriangle = function (faceIndex, subMesh, p1, p2, p3) {
             var t0;
             var embeddedInPlane = false;
-
             if (!subMesh._trianglePlanes) {
                 subMesh._trianglePlanes = [];
             }
-
             if (!subMesh._trianglePlanes[faceIndex]) {
                 subMesh._trianglePlanes[faceIndex] = new BABYLON.Plane(0, 0, 0, 0);
                 subMesh._trianglePlanes[faceIndex].copyFromPoints(p1, p2, p3);
             }
-
             var trianglePlane = subMesh._trianglePlanes[faceIndex];
-
             if ((!subMesh.getMaterial()) && !trianglePlane.isFrontFacingTo(this.normalizedVelocity, 0))
                 return;
-
             var signedDistToTrianglePlane = trianglePlane.signedDistanceTo(this.basePoint);
             var normalDotVelocity = BABYLON.Vector3.Dot(trianglePlane.normal, this.velocity);
-
             if (normalDotVelocity == 0) {
                 if (Math.abs(signedDistToTrianglePlane) >= 1.0)
                     return;
                 embeddedInPlane = true;
                 t0 = 0;
-            } else {
+            }
+            else {
                 t0 = (-1.0 - signedDistToTrianglePlane) / normalDotVelocity;
                 var t1 = (1.0 - signedDistToTrianglePlane) / normalDotVelocity;
-
                 if (t0 > t1) {
                     var temp = t1;
                     t1 = t0;
                     t0 = temp;
                 }
-
                 if (t0 > 1.0 || t1 < 0.0)
                     return;
-
                 if (t0 < 0)
                     t0 = 0;
                 if (t0 > 1.0)
                     t0 = 1.0;
             }
-
             this._collisionPoint.copyFromFloats(0, 0, 0);
-
             var found = false;
             var t = 1.0;
-
             if (!embeddedInPlane) {
                 this.basePoint.subtractToRef(trianglePlane.normal, this._planeIntersectionPoint);
                 this.velocity.scaleToRef(t0, this._tempVector);
                 this._planeIntersectionPoint.addInPlace(this._tempVector);
-
                 if (this._checkPointInTriangle(this._planeIntersectionPoint, p1, p2, p3, trianglePlane.normal)) {
                     found = true;
                     t = t0;
                     this._collisionPoint.copyFrom(this._planeIntersectionPoint);
                 }
             }
-
             if (!found) {
                 var velocitySquaredLength = this.velocity.lengthSquared();
-
                 var a = velocitySquaredLength;
-
                 this.basePoint.subtractToRef(p1, this._tempVector);
                 var b = 2.0 * (BABYLON.Vector3.Dot(this.velocity, this._tempVector));
                 var c = this._tempVector.lengthSquared() - 1.0;
-
                 var lowestRoot = getLowestRoot(a, b, c, t);
                 if (lowestRoot.found) {
                     t = lowestRoot.root;
                     found = true;
                     this._collisionPoint.copyFrom(p1);
                 }
-
                 this.basePoint.subtractToRef(p2, this._tempVector);
                 b = 2.0 * (BABYLON.Vector3.Dot(this.velocity, this._tempVector));
                 c = this._tempVector.lengthSquared() - 1.0;
-
                 lowestRoot = getLowestRoot(a, b, c, t);
                 if (lowestRoot.found) {
                     t = lowestRoot.root;
                     found = true;
                     this._collisionPoint.copyFrom(p2);
                 }
-
                 this.basePoint.subtractToRef(p3, this._tempVector);
                 b = 2.0 * (BABYLON.Vector3.Dot(this.velocity, this._tempVector));
                 c = this._tempVector.lengthSquared() - 1.0;
-
                 lowestRoot = getLowestRoot(a, b, c, t);
                 if (lowestRoot.found) {
                     t = lowestRoot.root;
                     found = true;
                     this._collisionPoint.copyFrom(p3);
                 }
-
                 p2.subtractToRef(p1, this._edge);
                 p1.subtractToRef(this.basePoint, this._baseToVertex);
                 var edgeSquaredLength = this._edge.lengthSquared();
                 var edgeDotVelocity = BABYLON.Vector3.Dot(this._edge, this.velocity);
                 var edgeDotBaseToVertex = BABYLON.Vector3.Dot(this._edge, this._baseToVertex);
-
                 a = edgeSquaredLength * (-velocitySquaredLength) + edgeDotVelocity * edgeDotVelocity;
                 b = edgeSquaredLength * (2.0 * BABYLON.Vector3.Dot(this.velocity, this._baseToVertex)) - 2.0 * edgeDotVelocity * edgeDotBaseToVertex;
                 c = edgeSquaredLength * (1.0 - this._baseToVertex.lengthSquared()) + edgeDotBaseToVertex * edgeDotBaseToVertex;
-
                 lowestRoot = getLowestRoot(a, b, c, t);
                 if (lowestRoot.found) {
                     var f = (edgeDotVelocity * lowestRoot.root - edgeDotBaseToVertex) / edgeSquaredLength;
-
                     if (f >= 0.0 && f <= 1.0) {
                         t = lowestRoot.root;
                         found = true;
@@ -244,20 +193,17 @@
                         p1.addToRef(this._edge, this._collisionPoint);
                     }
                 }
-
                 p3.subtractToRef(p2, this._edge);
                 p2.subtractToRef(this.basePoint, this._baseToVertex);
                 edgeSquaredLength = this._edge.lengthSquared();
                 edgeDotVelocity = BABYLON.Vector3.Dot(this._edge, this.velocity);
                 edgeDotBaseToVertex = BABYLON.Vector3.Dot(this._edge, this._baseToVertex);
-
                 a = edgeSquaredLength * (-velocitySquaredLength) + edgeDotVelocity * edgeDotVelocity;
                 b = edgeSquaredLength * (2.0 * BABYLON.Vector3.Dot(this.velocity, this._baseToVertex)) - 2.0 * edgeDotVelocity * edgeDotBaseToVertex;
                 c = edgeSquaredLength * (1.0 - this._baseToVertex.lengthSquared()) + edgeDotBaseToVertex * edgeDotBaseToVertex;
                 lowestRoot = getLowestRoot(a, b, c, t);
                 if (lowestRoot.found) {
                     f = (edgeDotVelocity * lowestRoot.root - edgeDotBaseToVertex) / edgeSquaredLength;
-
                     if (f >= 0.0 && f <= 1.0) {
                         t = lowestRoot.root;
                         found = true;
@@ -265,21 +211,17 @@
                         p2.addToRef(this._edge, this._collisionPoint);
                     }
                 }
-
                 p1.subtractToRef(p3, this._edge);
                 p3.subtractToRef(this.basePoint, this._baseToVertex);
                 edgeSquaredLength = this._edge.lengthSquared();
                 edgeDotVelocity = BABYLON.Vector3.Dot(this._edge, this.velocity);
                 edgeDotBaseToVertex = BABYLON.Vector3.Dot(this._edge, this._baseToVertex);
-
                 a = edgeSquaredLength * (-velocitySquaredLength) + edgeDotVelocity * edgeDotVelocity;
                 b = edgeSquaredLength * (2.0 * BABYLON.Vector3.Dot(this.velocity, this._baseToVertex)) - 2.0 * edgeDotVelocity * edgeDotBaseToVertex;
                 c = edgeSquaredLength * (1.0 - this._baseToVertex.lengthSquared()) + edgeDotBaseToVertex * edgeDotBaseToVertex;
-
                 lowestRoot = getLowestRoot(a, b, c, t);
                 if (lowestRoot.found) {
                     f = (edgeDotVelocity * lowestRoot.root - edgeDotBaseToVertex) / edgeSquaredLength;
-
                     if (f >= 0.0 && f <= 1.0) {
                         t = lowestRoot.root;
                         found = true;
@@ -288,14 +230,13 @@
                     }
                 }
             }
-
             if (found) {
                 var distToCollision = t * this.velocity.length();
-
                 if (!this.collisionFound || distToCollision < this.nearestDistance) {
                     if (!this.intersectionPoint) {
                         this.intersectionPoint = this._collisionPoint.clone();
-                    } else {
+                    }
+                    else {
                         this.intersectionPoint.copyFrom(this._collisionPoint);
                     }
                     this.nearestDistance = distToCollision;
@@ -304,36 +245,29 @@
                 }
             }
         };
-
         Collider.prototype._collide = function (subMesh, pts, indices, indexStart, indexEnd, decal) {
             for (var i = indexStart; i < indexEnd; i += 3) {
                 var p1 = pts[indices[i] - decal];
                 var p2 = pts[indices[i + 1] - decal];
                 var p3 = pts[indices[i + 2] - decal];
-
                 this._testTriangle(i, subMesh, p3, p2, p1);
             }
         };
-
         Collider.prototype._getResponse = function (pos, vel) {
             pos.addToRef(vel, this._destinationPoint);
             vel.scaleInPlace((this.nearestDistance / vel.length()));
-
             this.basePoint.addToRef(vel, pos);
             pos.subtractToRef(this.intersectionPoint, this._slidePlaneNormal);
             this._slidePlaneNormal.normalize();
             this._slidePlaneNormal.scaleToRef(this.epsilon, this._displacementVector);
-
             pos.addInPlace(this._displacementVector);
             this.intersectionPoint.addInPlace(this._displacementVector);
-
             this._slidePlaneNormal.scaleInPlace(BABYLON.Plane.SignedDistanceToPlaneFromPositionAndNormal(this.intersectionPoint, this._slidePlaneNormal, this._destinationPoint));
             this._destinationPoint.subtractInPlace(this._slidePlaneNormal);
-
             this._destinationPoint.subtractToRef(this.intersectionPoint, vel);
         };
         return Collider;
     })();
     BABYLON.Collider = Collider;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.collider.js.map
+//# sourceMappingURL=babylon.collider.js.map

Babylon/Collisions/babylon.pickingInfo.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var IntersectionInfo = (function () {
         function IntersectionInfo(bu, bv, distance) {
@@ -10,7 +10,6 @@
         return IntersectionInfo;
     })();
     BABYLON.IntersectionInfo = IntersectionInfo;
-
     var PickingInfo = (function () {
         function PickingInfo() {
             this.hit = false;
@@ -26,41 +25,32 @@
             if (!this.pickedMesh || !this.pickedMesh.isVerticesDataPresent(BABYLON.VertexBuffer.NormalKind)) {
                 return null;
             }
-
             var indices = this.pickedMesh.getIndices();
             var normals = this.pickedMesh.getVerticesData(BABYLON.VertexBuffer.NormalKind);
-
             var normal0 = BABYLON.Vector3.FromArray(normals, indices[this.faceId * 3] * 3);
             var normal1 = BABYLON.Vector3.FromArray(normals, indices[this.faceId * 3 + 1] * 3);
             var normal2 = BABYLON.Vector3.FromArray(normals, indices[this.faceId * 3 + 2] * 3);
-
             normal0 = normal0.scale(this.bu);
             normal1 = normal1.scale(this.bv);
             normal2 = normal2.scale(1.0 - this.bu - this.bv);
-
             return new BABYLON.Vector3(normal0.x + normal1.x + normal2.x, normal0.y + normal1.y + normal2.y, normal0.z + normal1.z + normal2.z);
         };
-
         PickingInfo.prototype.getTextureCoordinates = function () {
             if (!this.pickedMesh || !this.pickedMesh.isVerticesDataPresent(BABYLON.VertexBuffer.UVKind)) {
                 return null;
             }
-
             var indices = this.pickedMesh.getIndices();
             var uvs = this.pickedMesh.getVerticesData(BABYLON.VertexBuffer.UVKind);
-
             var uv0 = BABYLON.Vector2.FromArray(uvs, indices[this.faceId * 3] * 2);
             var uv1 = BABYLON.Vector2.FromArray(uvs, indices[this.faceId * 3 + 1] * 2);
             var uv2 = BABYLON.Vector2.FromArray(uvs, indices[this.faceId * 3 + 2] * 2);
-
             uv0 = uv0.scale(this.bu);
             uv1 = uv1.scale(this.bv);
             uv2 = uv2.scale(1.0 - this.bu - this.bv);
-
             return new BABYLON.Vector2(uv0.x + uv1.x + uv2.x, uv0.y + uv1.y + uv2.y);
         };
         return PickingInfo;
     })();
     BABYLON.PickingInfo = PickingInfo;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.pickingInfo.js.map
+//# sourceMappingURL=babylon.pickingInfo.js.map

Babylon/Culling/Octrees/babylon.octree.js

@@ -1,8 +1,8 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Octree = (function () {
         function Octree(creationFunc, maxBlockCapacity, maxDepth) {
-            if (typeof maxDepth === "undefined") { maxDepth = 2; }
+            if (maxDepth === void 0) { maxDepth = 2; }
             this.maxDepth = maxDepth;
             this.dynamicContent = new Array();
             this._maxBlockCapacity = maxBlockCapacity || 64;
@@ -13,71 +13,57 @@
         Octree.prototype.update = function (worldMin, worldMax, entries) {
             Octree._CreateBlocks(worldMin, worldMax, entries, this._maxBlockCapacity, 0, this.maxDepth, this, this._creationFunc);
         };
-
         Octree.prototype.addMesh = function (entry) {
             for (var index = 0; index < this.blocks.length; index++) {
                 var block = this.blocks[index];
                 block.addEntry(entry);
             }
         };
-
         Octree.prototype.select = function (frustumPlanes, allowDuplicate) {
             this._selectionContent.reset();
-
             for (var index = 0; index < this.blocks.length; index++) {
                 var block = this.blocks[index];
                 block.select(frustumPlanes, this._selectionContent, allowDuplicate);
             }
-
             if (allowDuplicate) {
                 this._selectionContent.concat(this.dynamicContent);
-            } else {
+            }
+            else {
                 this._selectionContent.concatWithNoDuplicate(this.dynamicContent);
             }
-
             return this._selectionContent;
         };
-
         Octree.prototype.intersects = function (sphereCenter, sphereRadius, allowDuplicate) {
             this._selectionContent.reset();
-
             for (var index = 0; index < this.blocks.length; index++) {
                 var block = this.blocks[index];
                 block.intersects(sphereCenter, sphereRadius, this._selectionContent, allowDuplicate);
             }
-
             if (allowDuplicate) {
                 this._selectionContent.concat(this.dynamicContent);
-            } else {
+            }
+            else {
                 this._selectionContent.concatWithNoDuplicate(this.dynamicContent);
             }
-
             return this._selectionContent;
         };
-
         Octree.prototype.intersectsRay = function (ray) {
             this._selectionContent.reset();
-
             for (var index = 0; index < this.blocks.length; index++) {
                 var block = this.blocks[index];
                 block.intersectsRay(ray, this._selectionContent);
             }
-
             this._selectionContent.concatWithNoDuplicate(this.dynamicContent);
-
             return this._selectionContent;
         };
-
         Octree._CreateBlocks = function (worldMin, worldMax, entries, maxBlockCapacity, currentDepth, maxDepth, target, creationFunc) {
             target.blocks = new Array();
             var blockSize = new BABYLON.Vector3((worldMax.x - worldMin.x) / 2, (worldMax.y - worldMin.y) / 2, (worldMax.z - worldMin.z) / 2);
-
             for (var x = 0; x < 2; x++) {
                 for (var y = 0; y < 2; y++) {
                     for (var z = 0; z < 2; z++) {
                         var localMin = worldMin.add(blockSize.multiplyByFloats(x, y, z));
                         var localMax = worldMin.add(blockSize.multiplyByFloats(x + 1, y + 1, z + 1));
-
                         var block = new BABYLON.OctreeBlock(localMin, localMax, maxBlockCapacity, currentDepth + 1, maxDepth, creationFunc);
                         block.addEntries(entries);
                         target.blocks.push(block);
@@ -85,13 +71,11 @@
                 }
             }
         };
-
         Octree.CreationFuncForMeshes = function (entry, block) {
             if (!entry.isBlocked && entry.getBoundingInfo().boundingBox.intersectsMinMax(block.minPoint, block.maxPoint)) {
                 block.entries.push(entry);
             }
         };
-
         Octree.CreationFuncForSubMeshes = function (entry, block) {
             if (entry.getBoundingInfo().boundingBox.intersectsMinMax(block.minPoint, block.maxPoint)) {
                 block.entries.push(entry);
@@ -101,4 +85,4 @@
     })();
     BABYLON.Octree = Octree;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.octree.js.map
+//# sourceMappingURL=babylon.octree.js.map

Babylon/Culling/Octrees/babylon.octreeBlock.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var OctreeBlock = (function () {
         function OctreeBlock(minPoint, maxPoint, capacity, depth, maxDepth, creationFunc) {
@@ -8,28 +8,20 @@
             this._depth = depth;
             this._maxDepth = maxDepth;
             this._creationFunc = creationFunc;
-
             this._minPoint = minPoint;
             this._maxPoint = maxPoint;
-
             this._boundingVectors.push(minPoint.clone());
             this._boundingVectors.push(maxPoint.clone());
-
             this._boundingVectors.push(minPoint.clone());
             this._boundingVectors[2].x = maxPoint.x;
-
             this._boundingVectors.push(minPoint.clone());
             this._boundingVectors[3].y = maxPoint.y;
-
             this._boundingVectors.push(minPoint.clone());
             this._boundingVectors[4].z = maxPoint.z;
-
             this._boundingVectors.push(maxPoint.clone());
             this._boundingVectors[5].z = minPoint.z;
-
             this._boundingVectors.push(maxPoint.clone());
             this._boundingVectors[6].x = minPoint.x;
-
             this._boundingVectors.push(maxPoint.clone());
             this._boundingVectors[7].y = minPoint.y;
         }
@@ -41,7 +33,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(OctreeBlock.prototype, "minPoint", {
             get: function () {
                 return this._minPoint;
@@ -49,7 +40,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(OctreeBlock.prototype, "maxPoint", {
             get: function () {
                 return this._maxPoint;
@@ -57,7 +47,6 @@
             enumerable: true,
             configurable: true
         });
-
         // Methods
         OctreeBlock.prototype.addEntry = function (entry) {
             if (this.blocks) {
@@ -67,21 +56,17 @@
                 }
                 return;
             }
-
             this._creationFunc(entry, this);
-
             if (this.entries.length > this.capacity && this._depth < this._maxDepth) {
                 this.createInnerBlocks();
             }
         };
-
         OctreeBlock.prototype.addEntries = function (entries) {
             for (var index = 0; index < entries.length; index++) {
                 var mesh = entries[index];
                 this.addEntry(mesh);
             }
         };
-
         OctreeBlock.prototype.select = function (frustumPlanes, selection, allowDuplicate) {
             if (BABYLON.BoundingBox.IsInFrustum(this._boundingVectors, frustumPlanes)) {
                 if (this.blocks) {
@@ -91,15 +76,14 @@
                     }
                     return;
                 }
-
                 if (allowDuplicate) {
                     selection.concat(this.entries);
-                } else {
+                }
+                else {
                     selection.concatWithNoDuplicate(this.entries);
                 }
             }
         };
-
         OctreeBlock.prototype.intersects = function (sphereCenter, sphereRadius, selection, allowDuplicate) {
             if (BABYLON.BoundingBox.IntersectsSphere(this._minPoint, this._maxPoint, sphereCenter, sphereRadius)) {
                 if (this.blocks) {
@@ -109,15 +93,14 @@
                     }
                     return;
                 }
-
                 if (allowDuplicate) {
                     selection.concat(this.entries);
-                } else {
+                }
+                else {
                     selection.concatWithNoDuplicate(this.entries);
                 }
             }
         };
-
         OctreeBlock.prototype.intersectsRay = function (ray, selection) {
             if (ray.intersectsBoxMinMax(this._minPoint, this._maxPoint)) {
                 if (this.blocks) {
@@ -130,7 +113,6 @@
                 selection.concatWithNoDuplicate(this.entries);
             }
         };
-
         OctreeBlock.prototype.createInnerBlocks = function () {
             BABYLON.Octree._CreateBlocks(this._minPoint, this._maxPoint, this.entries, this._capacity, this._depth, this._maxDepth, this, this._creationFunc);
         };
@@ -138,4 +120,4 @@
     })();
     BABYLON.OctreeBlock = OctreeBlock;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.octreeBlock.js.map
+//# sourceMappingURL=babylon.octreeBlock.js.map

Babylon/Culling/babylon.boundingBox.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var BoundingBox = (function () {
         function BoundingBox(minimum, maximum) {
@@ -6,61 +6,48 @@
             this.maximum = maximum;
             this.vectors = new Array();
             this.vectorsWorld = new Array();
-            // Bounding vectors
+            // Bounding vectors            
             this.vectors.push(this.minimum.clone());
             this.vectors.push(this.maximum.clone());
-
             this.vectors.push(this.minimum.clone());
             this.vectors[2].x = this.maximum.x;
-
             this.vectors.push(this.minimum.clone());
             this.vectors[3].y = this.maximum.y;
-
             this.vectors.push(this.minimum.clone());
             this.vectors[4].z = this.maximum.z;
-
             this.vectors.push(this.maximum.clone());
             this.vectors[5].z = this.minimum.z;
-
             this.vectors.push(this.maximum.clone());
             this.vectors[6].x = this.minimum.x;
-
             this.vectors.push(this.maximum.clone());
             this.vectors[7].y = this.minimum.y;
-
             // OBB
             this.center = this.maximum.add(this.minimum).scale(0.5);
             this.extendSize = this.maximum.subtract(this.minimum).scale(0.5);
             this.directions = [BABYLON.Vector3.Zero(), BABYLON.Vector3.Zero(), BABYLON.Vector3.Zero()];
-
             for (var index = 0; index < this.vectors.length; index++) {
                 this.vectorsWorld[index] = BABYLON.Vector3.Zero();
             }
             this.minimumWorld = BABYLON.Vector3.Zero();
             this.maximumWorld = BABYLON.Vector3.Zero();
-
             this._update(BABYLON.Matrix.Identity());
         }
         // Methods
         BoundingBox.prototype.getWorldMatrix = function () {
             return this._worldMatrix;
         };
-
         BoundingBox.prototype._update = function (world) {
             BABYLON.Vector3.FromFloatsToRef(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, this.minimumWorld);
             BABYLON.Vector3.FromFloatsToRef(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, this.maximumWorld);
-
             for (var index = 0; index < this.vectors.length; index++) {
                 var v = this.vectorsWorld[index];
                 BABYLON.Vector3.TransformCoordinatesToRef(this.vectors[index], world, v);
-
                 if (v.x < this.minimumWorld.x)
                     this.minimumWorld.x = v.x;
                 if (v.y < this.minimumWorld.y)
                     this.minimumWorld.y = v.y;
                 if (v.z < this.minimumWorld.z)
                     this.minimumWorld.z = v.z;
-
                 if (v.x > this.maximumWorld.x)
                     this.maximumWorld.x = v.x;
                 if (v.y > this.maximumWorld.y)
@@ -68,78 +55,57 @@
                 if (v.z > this.maximumWorld.z)
                     this.maximumWorld.z = v.z;
             }
-
             // OBB
             this.maximumWorld.addToRef(this.minimumWorld, this.center);
             this.center.scaleInPlace(0.5);
-
             BABYLON.Vector3.FromFloatArrayToRef(world.m, 0, this.directions[0]);
             BABYLON.Vector3.FromFloatArrayToRef(world.m, 4, this.directions[1]);
             BABYLON.Vector3.FromFloatArrayToRef(world.m, 8, this.directions[2]);
-
             this._worldMatrix = world;
         };
-
         BoundingBox.prototype.isInFrustum = function (frustumPlanes) {
             return BoundingBox.IsInFrustum(this.vectorsWorld, frustumPlanes);
         };
-
         BoundingBox.prototype.isCompletelyInFrustum = function (frustumPlanes) {
             return BoundingBox.IsCompletelyInFrustum(this.vectorsWorld, frustumPlanes);
         };
-
         BoundingBox.prototype.intersectsPoint = function (point) {
             var delta = BABYLON.Engine.Epsilon;
-
             if (this.maximumWorld.x - point.x < delta || delta > point.x - this.minimumWorld.x)
                 return false;
-
             if (this.maximumWorld.y - point.y < delta || delta > point.y - this.minimumWorld.y)
                 return false;
-
             if (this.maximumWorld.z - point.z < delta || delta > point.z - this.minimumWorld.z)
                 return false;
-
             return true;
         };
-
         BoundingBox.prototype.intersectsSphere = function (sphere) {
             return BoundingBox.IntersectsSphere(this.minimumWorld, this.maximumWorld, sphere.centerWorld, sphere.radiusWorld);
         };
-
         BoundingBox.prototype.intersectsMinMax = function (min, max) {
             if (this.maximumWorld.x < min.x || this.minimumWorld.x > max.x)
                 return false;
-
             if (this.maximumWorld.y < min.y || this.minimumWorld.y > max.y)
                 return false;
-
             if (this.maximumWorld.z < min.z || this.minimumWorld.z > max.z)
                 return false;
-
             return true;
         };
-
         // Statics
         BoundingBox.Intersects = function (box0, box1) {
             if (box0.maximumWorld.x < box1.minimumWorld.x || box0.minimumWorld.x > box1.maximumWorld.x)
                 return false;
-
             if (box0.maximumWorld.y < box1.minimumWorld.y || box0.minimumWorld.y > box1.maximumWorld.y)
                 return false;
-
             if (box0.maximumWorld.z < box1.minimumWorld.z || box0.minimumWorld.z > box1.maximumWorld.z)
                 return false;
-
             return true;
         };
-
         BoundingBox.IntersectsSphere = function (minPoint, maxPoint, sphereCenter, sphereRadius) {
             var vector = BABYLON.Vector3.Clamp(sphereCenter, minPoint, maxPoint);
             var num = BABYLON.Vector3.DistanceSquared(sphereCenter, vector);
             return (num <= (sphereRadius * sphereRadius));
         };
-
         BoundingBox.IsCompletelyInFrustum = function (boundingVectors, frustumPlanes) {
             for (var p = 0; p < 6; p++) {
                 for (var i = 0; i < 8; i++) {
@@ -150,15 +116,14 @@
             }
             return true;
         };
-
         BoundingBox.IsInFrustum = function (boundingVectors, frustumPlanes) {
             for (var p = 0; p < 6; p++) {
                 var inCount = 8;
-
                 for (var i = 0; i < 8; i++) {
                     if (frustumPlanes[p].dotCoordinate(boundingVectors[i]) < 0) {
                         --inCount;
-                    } else {
+                    }
+                    else {
                         break;
                     }
                 }
@@ -171,4 +136,4 @@
     })();
     BABYLON.BoundingBox = BoundingBox;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.boundingBox.js.map
+//# sourceMappingURL=babylon.boundingBox.js.map

Babylon/Culling/babylon.boundingInfo.js

@@ -1,30 +1,22 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var computeBoxExtents = function (axis, box) {
         var p = BABYLON.Vector3.Dot(box.center, axis);
-
         var r0 = Math.abs(BABYLON.Vector3.Dot(box.directions[0], axis)) * box.extendSize.x;
         var r1 = Math.abs(BABYLON.Vector3.Dot(box.directions[1], axis)) * box.extendSize.y;
         var r2 = Math.abs(BABYLON.Vector3.Dot(box.directions[2], axis)) * box.extendSize.z;
-
         var r = r0 + r1 + r2;
         return {
             min: p - r,
             max: p + r
         };
     };
-
-    var extentsOverlap = function (min0, max0, min1, max1) {
-        return !(min0 > max1 || min1 > max0);
-    };
-
+    var extentsOverlap = function (min0, max0, min1, max1) { return !(min0 > max1 || min1 > max0); };
     var axisOverlap = function (axis, box0, box1) {
         var result0 = computeBoxExtents(axis, box0);
         var result1 = computeBoxExtents(axis, box1);
-
         return extentsOverlap(result0.min, result0.max, result1.min, result1.max);
     };
-
     var BoundingInfo = (function () {
         function BoundingInfo(minimum, maximum) {
             this.minimum = minimum;
@@ -37,58 +29,44 @@
             this.boundingBox._update(world);
             this.boundingSphere._update(world);
         };
-
         BoundingInfo.prototype.isInFrustum = function (frustumPlanes) {
             if (!this.boundingSphere.isInFrustum(frustumPlanes))
                 return false;
-
             return this.boundingBox.isInFrustum(frustumPlanes);
         };
-
         BoundingInfo.prototype.isCompletelyInFrustum = function (frustumPlanes) {
             return this.boundingBox.isCompletelyInFrustum(frustumPlanes);
         };
-
         BoundingInfo.prototype._checkCollision = function (collider) {
             return collider._canDoCollision(this.boundingSphere.centerWorld, this.boundingSphere.radiusWorld, this.boundingBox.minimumWorld, this.boundingBox.maximumWorld);
         };
-
         BoundingInfo.prototype.intersectsPoint = function (point) {
             if (!this.boundingSphere.centerWorld) {
                 return false;
             }
-
             if (!this.boundingSphere.intersectsPoint(point)) {
                 return false;
             }
-
             if (!this.boundingBox.intersectsPoint(point)) {
                 return false;
             }
-
             return true;
         };
-
         BoundingInfo.prototype.intersects = function (boundingInfo, precise) {
             if (!this.boundingSphere.centerWorld || !boundingInfo.boundingSphere.centerWorld) {
                 return false;
             }
-
             if (!BABYLON.BoundingSphere.Intersects(this.boundingSphere, boundingInfo.boundingSphere)) {
                 return false;
             }
-
             if (!BABYLON.BoundingBox.Intersects(this.boundingBox, boundingInfo.boundingBox)) {
                 return false;
             }
-
             if (!precise) {
                 return true;
             }
-
             var box0 = this.boundingBox;
             var box1 = boundingInfo.boundingBox;
-
             if (!axisOverlap(box0.directions[0], box0, box1))
                 return false;
             if (!axisOverlap(box0.directions[1], box0, box1))
@@ -119,11 +97,10 @@
                 return false;
             if (!axisOverlap(BABYLON.Vector3.Cross(box0.directions[2], box1.directions[2]), box0, box1))
                 return false;
-
             return true;
         };
         return BoundingInfo;
     })();
     BABYLON.BoundingInfo = BoundingInfo;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.boundingInfo.js.map
+//# sourceMappingURL=babylon.boundingInfo.js.map

Babylon/Culling/babylon.boundingSphere.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var BoundingSphere = (function () {
         function BoundingSphere(minimum, maximum) {
@@ -6,10 +6,8 @@
             this.maximum = maximum;
             this._tempRadiusVector = BABYLON.Vector3.Zero();
             var distance = BABYLON.Vector3.Distance(minimum, maximum);
-
             this.center = BABYLON.Vector3.Lerp(minimum, maximum, 0.5);
             this.radius = distance * 0.5;
-
             this.centerWorld = BABYLON.Vector3.Zero();
             this._update(BABYLON.Matrix.Identity());
         }
@@ -19,44 +17,34 @@
             BABYLON.Vector3.TransformNormalFromFloatsToRef(1.0, 1.0, 1.0, world, this._tempRadiusVector);
             this.radiusWorld = Math.max(Math.abs(this._tempRadiusVector.x), Math.abs(this._tempRadiusVector.y), Math.abs(this._tempRadiusVector.z)) * this.radius;
         };
-
         BoundingSphere.prototype.isInFrustum = function (frustumPlanes) {
             for (var i = 0; i < 6; i++) {
                 if (frustumPlanes[i].dotCoordinate(this.centerWorld) <= -this.radiusWorld)
                     return false;
             }
-
             return true;
         };
-
         BoundingSphere.prototype.intersectsPoint = function (point) {
             var x = this.centerWorld.x - point.x;
             var y = this.centerWorld.y - point.y;
             var z = this.centerWorld.z - point.z;
-
             var distance = Math.sqrt((x * x) + (y * y) + (z * z));
-
             if (Math.abs(this.radiusWorld - distance) < BABYLON.Engine.Epsilon)
                 return false;
-
             return true;
         };
-
         // Statics
         BoundingSphere.Intersects = function (sphere0, sphere1) {
             var x = sphere0.centerWorld.x - sphere1.centerWorld.x;
             var y = sphere0.centerWorld.y - sphere1.centerWorld.y;
             var z = sphere0.centerWorld.z - sphere1.centerWorld.z;
-
             var distance = Math.sqrt((x * x) + (y * y) + (z * z));
-
             if (sphere0.radiusWorld + sphere1.radiusWorld < distance)
                 return false;
-
             return true;
         };
         return BoundingSphere;
     })();
     BABYLON.BoundingSphere = BoundingSphere;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.boundingSphere.js.map
+//# sourceMappingURL=babylon.boundingSphere.js.map

Babylon/Layer/babylon.layer.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Layer = (function () {
         function Layer(name, imgUrl, scene, isBackground, color) {
@@ -8,31 +8,24 @@
             this.texture = imgUrl ? new BABYLON.Texture(imgUrl, scene, true) : null;
             this.isBackground = isBackground === undefined ? true : isBackground;
             this.color = color === undefined ? new BABYLON.Color4(1, 1, 1, 1) : color;
-
             this._scene = scene;
             this._scene.layers.push(this);
-
             // VBO
             var vertices = [];
             vertices.push(1, 1);
             vertices.push(-1, 1);
             vertices.push(-1, -1);
             vertices.push(1, -1);
-
             this._vertexBuffer = scene.getEngine().createVertexBuffer(vertices);
-
             // Indices
             var indices = [];
             indices.push(0);
             indices.push(1);
             indices.push(2);
-
             indices.push(0);
             indices.push(2);
             indices.push(3);
-
             this._indexBuffer = scene.getEngine().createIndexBuffer(indices);
-
             // Effects
             this._effect = this._scene.getEngine().createEffect("layer", ["position"], ["textureMatrix", "color"], ["textureSampler"], "");
         }
@@ -40,49 +33,38 @@
             // Check
             if (!this._effect.isReady() || !this.texture || !this.texture.isReady())
                 return;
-
             var engine = this._scene.getEngine();
-
             // Render
             engine.enableEffect(this._effect);
             engine.setState(false);
-
             // Texture
             this._effect.setTexture("textureSampler", this.texture);
             this._effect.setMatrix("textureMatrix", this.texture.getTextureMatrix());
-
             // Color
             this._effect.setFloat4("color", this.color.r, this.color.g, this.color.b, this.color.a);
-
             // VBOs
             engine.bindBuffers(this._vertexBuffer, this._indexBuffer, this._vertexDeclaration, this._vertexStrideSize, this._effect);
-
             // Draw order
             engine.setAlphaMode(BABYLON.Engine.ALPHA_COMBINE);
             engine.draw(true, 0, 6);
             engine.setAlphaMode(BABYLON.Engine.ALPHA_DISABLE);
         };
-
         Layer.prototype.dispose = function () {
             if (this._vertexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._vertexBuffer);
                 this._vertexBuffer = null;
             }
-
             if (this._indexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._indexBuffer);
                 this._indexBuffer = null;
             }
-
             if (this.texture) {
                 this.texture.dispose();
                 this.texture = null;
             }
-
             // Remove from scene
             var index = this._scene.layers.indexOf(this);
             this._scene.layers.splice(index, 1);
-
             // Callback
             if (this.onDispose) {
                 this.onDispose();
@@ -92,4 +74,4 @@
     })();
     BABYLON.Layer = Layer;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.layer.js.map
+//# sourceMappingURL=babylon.layer.js.map

Babylon/LensFlare/babylon.lensFlare.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var LensFlare = (function () {
         function LensFlare(size, position, color, imgUrl, system) {
@@ -8,7 +8,6 @@
                 if (this.texture) {
                     this.texture.dispose();
                 }
-
                 // Remove from scene
                 var index = this._system.lensFlares.indexOf(this);
                 this._system.lensFlares.splice(index, 1);
@@ -16,11 +15,10 @@
             this.color = color || new BABYLON.Color3(1, 1, 1);
             this.texture = imgUrl ? new BABYLON.Texture(imgUrl, system.getScene(), true) : null;
             this._system = system;
-
             system.lensFlares.push(this);
         }
         return LensFlare;
     })();
     BABYLON.LensFlare = LensFlare;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.lensFlare.js.map
+//# sourceMappingURL=babylon.lensFlare.js.map

Babylon/LensFlare/babylon.lensFlareSystem.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var LensFlareSystem = (function () {
         function LensFlareSystem(name, emitter, scene) {
@@ -11,32 +11,23 @@
             this._scene = scene;
             this._emitter = emitter;
             scene.lensFlareSystems.push(this);
-
-            this.meshesSelectionPredicate = function (m) {
-                return m.material && m.isVisible && m.isEnabled() && m.isBlocker && ((m.layerMask & scene.activeCamera.layerMask) != 0);
-            };
-
+            this.meshesSelectionPredicate = function (m) { return m.material && m.isVisible && m.isEnabled() && m.isBlocker && ((m.layerMask & scene.activeCamera.layerMask) != 0); };
             // VBO
             var vertices = [];
             vertices.push(1, 1);
             vertices.push(-1, 1);
             vertices.push(-1, -1);
             vertices.push(1, -1);
-
             this._vertexBuffer = scene.getEngine().createVertexBuffer(vertices);
-
             // Indices
             var indices = [];
             indices.push(0);
             indices.push(1);
             indices.push(2);
-
             indices.push(0);
             indices.push(2);
             indices.push(3);
-
             this._indexBuffer = scene.getEngine().createIndexBuffer(indices);
-
             // Effects
             this._effect = this._scene.getEngine().createEffect("lensFlare", ["position"], ["color", "viewportMatrix"], ["textureSampler"], "");
         }
@@ -50,168 +41,132 @@
             enumerable: true,
             configurable: true
         });
-
-
         LensFlareSystem.prototype.getScene = function () {
             return this._scene;
         };
-
         LensFlareSystem.prototype.getEmitter = function () {
             return this._emitter;
         };
-
         LensFlareSystem.prototype.getEmitterPosition = function () {
             return this._emitter.getAbsolutePosition ? this._emitter.getAbsolutePosition() : this._emitter.position;
         };
-
         LensFlareSystem.prototype.computeEffectivePosition = function (globalViewport) {
             var position = this.getEmitterPosition();
-
             position = BABYLON.Vector3.Project(position, BABYLON.Matrix.Identity(), this._scene.getTransformMatrix(), globalViewport);
-
             this._positionX = position.x;
             this._positionY = position.y;
-
             position = BABYLON.Vector3.TransformCoordinates(this.getEmitterPosition(), this._scene.getViewMatrix());
-
             if (position.z > 0) {
                 if ((this._positionX > globalViewport.x) && (this._positionX < globalViewport.x + globalViewport.width)) {
                     if ((this._positionY > globalViewport.y) && (this._positionY < globalViewport.y + globalViewport.height))
                         return true;
                 }
             }
-
             return false;
         };
-
         LensFlareSystem.prototype._isVisible = function () {
             if (!this._isEnabled) {
                 return false;
             }
-
             var emitterPosition = this.getEmitterPosition();
             var direction = emitterPosition.subtract(this._scene.activeCamera.position);
             var distance = direction.length();
             direction.normalize();
-
             var ray = new BABYLON.Ray(this._scene.activeCamera.position, direction);
             var pickInfo = this._scene.pickWithRay(ray, this.meshesSelectionPredicate, true);
-
             return !pickInfo.hit || pickInfo.distance > distance;
         };
-
         LensFlareSystem.prototype.render = function () {
             if (!this._effect.isReady())
                 return false;
-
             var engine = this._scene.getEngine();
             var viewport = this._scene.activeCamera.viewport;
             var globalViewport = viewport.toGlobal(engine);
-
             // Position
             if (!this.computeEffectivePosition(globalViewport)) {
                 return false;
             }
-
             // Visibility
             if (!this._isVisible()) {
                 return false;
             }
-
             // Intensity
             var awayX;
             var awayY;
-
             if (this._positionX < this.borderLimit + globalViewport.x) {
                 awayX = this.borderLimit + globalViewport.x - this._positionX;
-            } else if (this._positionX > globalViewport.x + globalViewport.width - this.borderLimit) {
+            }
+            else if (this._positionX > globalViewport.x + globalViewport.width - this.borderLimit) {
                 awayX = this._positionX - globalViewport.x - globalViewport.width + this.borderLimit;
-            } else {
+            }
+            else {
                 awayX = 0;
             }
-
             if (this._positionY < this.borderLimit + globalViewport.y) {
                 awayY = this.borderLimit + globalViewport.y - this._positionY;
-            } else if (this._positionY > globalViewport.y + globalViewport.height - this.borderLimit) {
+            }
+            else if (this._positionY > globalViewport.y + globalViewport.height - this.borderLimit) {
                 awayY = this._positionY - globalViewport.y - globalViewport.height + this.borderLimit;
-            } else {
+            }
+            else {
                 awayY = 0;
             }
-
             var away = (awayX > awayY) ? awayX : awayY;
             if (away > this.borderLimit) {
                 away = this.borderLimit;
             }
-
             var intensity = 1.0 - (away / this.borderLimit);
             if (intensity < 0) {
                 return false;
             }
-
             if (intensity > 1.0) {
                 intensity = 1.0;
             }
-
             // Position
             var centerX = globalViewport.x + globalViewport.width / 2;
             var centerY = globalViewport.y + globalViewport.height / 2;
             var distX = centerX - this._positionX;
             var distY = centerY - this._positionY;
-
             // Effects
             engine.enableEffect(this._effect);
             engine.setState(false);
             engine.setDepthBuffer(false);
             engine.setAlphaMode(BABYLON.Engine.ALPHA_ADD);
-
             // VBOs
             engine.bindBuffers(this._vertexBuffer, this._indexBuffer, this._vertexDeclaration, this._vertexStrideSize, this._effect);
-
             for (var index = 0; index < this.lensFlares.length; index++) {
                 var flare = this.lensFlares[index];
-
                 var x = centerX - (distX * flare.position);
                 var y = centerY - (distY * flare.position);
-
                 var cw = flare.size;
                 var ch = flare.size * engine.getAspectRatio(this._scene.activeCamera);
                 var cx = 2 * (x / globalViewport.width) - 1.0;
                 var cy = 1.0 - 2 * (y / globalViewport.height);
-
                 var viewportMatrix = BABYLON.Matrix.FromValues(cw / 2, 0, 0, 0, 0, ch / 2, 0, 0, 0, 0, 1, 0, cx, cy, 0, 1);
-
                 this._effect.setMatrix("viewportMatrix", viewportMatrix);
-
                 // Texture
                 this._effect.setTexture("textureSampler", flare.texture);
-
                 // Color
                 this._effect.setFloat4("color", flare.color.r * intensity, flare.color.g * intensity, flare.color.b * intensity, 1.0);
-
                 // Draw order
                 engine.draw(true, 0, 6);
             }
-
             engine.setDepthBuffer(true);
             engine.setAlphaMode(BABYLON.Engine.ALPHA_DISABLE);
             return true;
         };
-
         LensFlareSystem.prototype.dispose = function () {
             if (this._vertexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._vertexBuffer);
                 this._vertexBuffer = null;
             }
-
             if (this._indexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._indexBuffer);
                 this._indexBuffer = null;
             }
-
             while (this.lensFlares.length) {
                 this.lensFlares[0].dispose();
             }
-
             // Remove from scene
             var index = this._scene.lensFlareSystems.indexOf(this);
             this._scene.lensFlareSystems.splice(index, 1);
@@ -220,4 +175,4 @@
     })();
     BABYLON.LensFlareSystem = LensFlareSystem;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.lensFlareSystem.js.map
+//# sourceMappingURL=babylon.lensFlareSystem.js.map

Babylon/Lights/Shadows/babylon.shadowGenerator.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var ShadowGenerator = (function () {
         function ShadowGenerator(mapSize, light) {
@@ -13,92 +13,73 @@
             this._worldViewProjection = BABYLON.Matrix.Zero();
             this._light = light;
             this._scene = light.getScene();
-
             light._shadowGenerator = this;
-
             // Render target
             this._shadowMap = new BABYLON.RenderTargetTexture(light.name + "_shadowMap", mapSize, this._scene, false);
             this._shadowMap.wrapU = BABYLON.Texture.CLAMP_ADDRESSMODE;
             this._shadowMap.wrapV = BABYLON.Texture.CLAMP_ADDRESSMODE;
             this._shadowMap.renderParticles = false;
-
             // Custom render function
             var renderSubMesh = function (subMesh) {
                 var mesh = subMesh.getRenderingMesh();
                 var scene = _this._scene;
                 var engine = scene.getEngine();
-
                 // Culling
                 engine.setState(subMesh.getMaterial().backFaceCulling);
-
                 // Managing instances
                 var batch = mesh._getInstancesRenderList(subMesh._id);
-
                 if (batch.mustReturn) {
                     return;
                 }
-
                 var hardwareInstancedRendering = (engine.getCaps().instancedArrays !== null) && (batch.visibleInstances[subMesh._id] !== null);
-
                 if (_this.isReady(subMesh, hardwareInstancedRendering)) {
                     engine.enableEffect(_this._effect);
                     mesh._bind(subMesh, _this._effect, BABYLON.Material.TriangleFillMode);
                     var material = subMesh.getMaterial();
-
                     _this._effect.setMatrix("viewProjection", _this.getTransformMatrix());
-
                     // Alpha test
                     if (material && material.needAlphaTesting()) {
                         var alphaTexture = material.getAlphaTestTexture();
                         _this._effect.setTexture("diffuseSampler", alphaTexture);
                         _this._effect.setMatrix("diffuseMatrix", alphaTexture.getTextureMatrix());
                     }
-
                     // Bones
                     var useBones = mesh.skeleton && scene.skeletonsEnabled && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesIndicesKind) && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesWeightsKind);
-
                     if (useBones) {
                         _this._effect.setMatrices("mBones", mesh.skeleton.getTransformMatrices());
                     }
-
                     if (hardwareInstancedRendering) {
                         mesh._renderWithInstances(subMesh, BABYLON.Material.TriangleFillMode, batch, _this._effect, engine);
-                    } else {
+                    }
+                    else {
                         if (batch.renderSelf[subMesh._id]) {
                             _this._effect.setMatrix("world", mesh.getWorldMatrix());
-
                             // Draw
                             mesh._draw(subMesh, BABYLON.Material.TriangleFillMode);
                         }
-
                         if (batch.visibleInstances[subMesh._id]) {
                             for (var instanceIndex = 0; instanceIndex < batch.visibleInstances[subMesh._id].length; instanceIndex++) {
                                 var instance = batch.visibleInstances[subMesh._id][instanceIndex];
-
                                 _this._effect.setMatrix("world", instance.getWorldMatrix());
-
                                 // Draw
                                 mesh._draw(subMesh, BABYLON.Material.TriangleFillMode);
                             }
                         }
                     }
-                } else {
+                }
+                else {
                     // Need to reset refresh rate of the shadowMap
                     _this._shadowMap.resetRefreshCounter();
                 }
             };
-
             this._shadowMap.customRenderFunction = function (opaqueSubMeshes, alphaTestSubMeshes, transparentSubMeshes) {
                 var index;
-
                 for (index = 0; index < opaqueSubMeshes.length; index++) {
                     renderSubMesh(opaqueSubMeshes.data[index]);
                 }
-
                 for (index = 0; index < alphaTestSubMeshes.length; index++) {
                     renderSubMesh(alphaTestSubMeshes.data[index]);
                 }
-
                 if (_this._transparencyShadow) {
                     for (index = 0; index < transparentSubMeshes.length; index++) {
                         renderSubMesh(transparentSubMeshes.data[index]);
@@ -114,7 +95,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ShadowGenerator, "FILTER_VARIANCESHADOWMAP", {
             get: function () {
                 return ShadowGenerator._FILTER_VARIANCESHADOWMAP;
@@ -122,7 +102,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ShadowGenerator, "FILTER_POISSONSAMPLING", {
             get: function () {
                 return ShadowGenerator._FILTER_POISSONSAMPLING;
@@ -130,7 +109,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ShadowGenerator.prototype, "useVarianceShadowMap", {
             get: function () {
                 return this.filter === ShadowGenerator.FILTER_VARIANCESHADOWMAP;
@@ -141,7 +119,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(ShadowGenerator.prototype, "usePoissonSampling", {
             get: function () {
                 return this.filter === ShadowGenerator.FILTER_POISSONSAMPLING;
@@ -152,20 +129,15 @@
             enumerable: true,
             configurable: true
         });
-
         ShadowGenerator.prototype.isReady = function (subMesh, useInstances) {
             var defines = [];
-
             if (this.useVarianceShadowMap) {
                 defines.push("#define VSM");
             }
-
             var attribs = [BABYLON.VertexBuffer.PositionKind];
-
             var mesh = subMesh.getMesh();
             var scene = mesh.getScene();
             var material = subMesh.getMaterial();
-
             // Alpha test
             if (material && material.needAlphaTesting()) {
                 defines.push("#define ALPHATEST");
@@ -178,7 +150,6 @@
                     defines.push("#define UV2");
                 }
             }
-
             // Bones
             if (mesh.skeleton && scene.skeletonsEnabled && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesIndicesKind) && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesWeightsKind)) {
                 attribs.push(BABYLON.VertexBuffer.MatricesIndicesKind);
@@ -186,7 +157,6 @@
                 defines.push("#define BONES");
                 defines.push("#define BonesPerMesh " + (mesh.skeleton.bones.length + 1));
             }
-
             // Instances
             if (useInstances) {
                 defines.push("#define INSTANCES");
@@ -195,53 +165,40 @@
                 attribs.push("world2");
                 attribs.push("world3");
             }
-
-            // Get correct effect
+            // Get correct effect      
             var join = defines.join("\n");
             if (this._cachedDefines !== join) {
                 this._cachedDefines = join;
                 this._effect = this._scene.getEngine().createEffect("shadowMap", attribs, ["world", "mBones", "viewProjection", "diffuseMatrix"], ["diffuseSampler"], join);
             }
-
             return this._effect.isReady();
         };
-
         ShadowGenerator.prototype.getShadowMap = function () {
             return this._shadowMap;
         };
-
         ShadowGenerator.prototype.getLight = function () {
             return this._light;
         };
-
         // Methods
         ShadowGenerator.prototype.getTransformMatrix = function () {
             var lightPosition = this._light.position;
             var lightDirection = this._light.direction;
-
             if (this._light.computeTransformedPosition()) {
                 lightPosition = this._light.transformedPosition;
             }
-
             if (!this._cachedPosition || !this._cachedDirection || !lightPosition.equals(this._cachedPosition) || !lightDirection.equals(this._cachedDirection)) {
                 this._cachedPosition = lightPosition.clone();
                 this._cachedDirection = lightDirection.clone();
-
                 var activeCamera = this._scene.activeCamera;
-
                 BABYLON.Matrix.LookAtLHToRef(lightPosition, this._light.position.add(lightDirection), BABYLON.Vector3.Up(), this._viewMatrix);
                 BABYLON.Matrix.PerspectiveFovLHToRef(Math.PI / 2.0, 1.0, activeCamera.minZ, activeCamera.maxZ, this._projectionMatrix);
-
                 this._viewMatrix.multiplyToRef(this._projectionMatrix, this._transformMatrix);
             }
-
             return this._transformMatrix;
         };
-
         ShadowGenerator.prototype.getDarkness = function () {
             return this._darkness;
         };
-
         ShadowGenerator.prototype.setDarkness = function (darkness) {
             if (darkness >= 1.0)
                 this._darkness = 1.0;
@@ -250,11 +207,9 @@
             else
                 this._darkness = darkness;
         };
-
         ShadowGenerator.prototype.setTransparencyShadow = function (hasShadow) {
             this._transparencyShadow = hasShadow;
         };
-
         ShadowGenerator.prototype.dispose = function () {
             this._shadowMap.dispose();
         };
@@ -265,4 +220,4 @@
     })();
     BABYLON.ShadowGenerator = ShadowGenerator;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.shadowGenerator.js.map
+//# sourceMappingURL=babylon.shadowGenerator.js.map

Babylon/Lights/babylon.directionalLight.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -11,57 +11,45 @@ var BABYLON;
         function DirectionalLight(name, direction, scene) {
             _super.call(this, name, scene);
             this.direction = direction;
-
             this.position = direction.scale(-1);
         }
         DirectionalLight.prototype.getAbsolutePosition = function () {
             return this.transformedPosition ? this.transformedPosition : this.position;
         };
-
         DirectionalLight.prototype.setDirectionToTarget = function (target) {
             this.direction = BABYLON.Vector3.Normalize(target.subtract(this.position));
             return this.direction;
         };
-
         DirectionalLight.prototype.computeTransformedPosition = function () {
             if (this.parent && this.parent.getWorldMatrix) {
                 if (!this.transformedPosition) {
                     this.transformedPosition = BABYLON.Vector3.Zero();
                 }
-
                 BABYLON.Vector3.TransformCoordinatesToRef(this.position, this.parent.getWorldMatrix(), this.transformedPosition);
                 return true;
             }
-
             return false;
         };
-
         DirectionalLight.prototype.transferToEffect = function (effect, directionUniformName) {
             if (this.parent && this.parent.getWorldMatrix) {
                 if (!this._transformedDirection) {
                     this._transformedDirection = BABYLON.Vector3.Zero();
                 }
-
                 BABYLON.Vector3.TransformNormalToRef(this.direction, this.parent.getWorldMatrix(), this._transformedDirection);
                 effect.setFloat4(directionUniformName, this._transformedDirection.x, this._transformedDirection.y, this._transformedDirection.z, 1);
-
                 return;
             }
-
             effect.setFloat4(directionUniformName, this.direction.x, this.direction.y, this.direction.z, 1);
         };
-
         DirectionalLight.prototype._getWorldMatrix = function () {
             if (!this._worldMatrix) {
                 this._worldMatrix = BABYLON.Matrix.Identity();
             }
-
             BABYLON.Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._worldMatrix);
-
             return this._worldMatrix;
         };
         return DirectionalLight;
     })(BABYLON.Light);
     BABYLON.DirectionalLight = DirectionalLight;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.directionalLight.js.map
+//# sourceMappingURL=babylon.directionalLight.js.map

Babylon/Lights/babylon.hemisphericLight.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -17,26 +17,22 @@ var BABYLON;
             this.direction = BABYLON.Vector3.Normalize(target.subtract(BABYLON.Vector3.Zero()));
             return this.direction;
         };
-
         HemisphericLight.prototype.getShadowGenerator = function () {
             return null;
         };
-
         HemisphericLight.prototype.transferToEffect = function (effect, directionUniformName, groundColorUniformName) {
             var normalizeDirection = BABYLON.Vector3.Normalize(this.direction);
             effect.setFloat4(directionUniformName, normalizeDirection.x, normalizeDirection.y, normalizeDirection.z, 0);
             effect.setColor3(groundColorUniformName, this.groundColor.scale(this.intensity));
         };
-
         HemisphericLight.prototype._getWorldMatrix = function () {
             if (!this._worldMatrix) {
                 this._worldMatrix = BABYLON.Matrix.Identity();
             }
-
             return this._worldMatrix;
         };
         return HemisphericLight;
     })(BABYLON.Light);
     BABYLON.HemisphericLight = HemisphericLight;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.hemisphericLight.js.map
+//# sourceMappingURL=babylon.hemisphericLight.js.map

Babylon/Lights/babylon.light.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -18,64 +18,48 @@ var BABYLON;
             this.excludedMeshes = new Array();
             this._excludedMeshesIds = new Array();
             this._includedOnlyMeshesIds = new Array();
-
             scene.lights.push(this);
         }
         Light.prototype.getShadowGenerator = function () {
             return this._shadowGenerator;
         };
-
         Light.prototype.getAbsolutePosition = function () {
             return BABYLON.Vector3.Zero();
         };
-
         Light.prototype.transferToEffect = function (effect, uniformName0, uniformName1) {
         };
-
         Light.prototype._getWorldMatrix = function () {
             return BABYLON.Matrix.Identity();
         };
-
         Light.prototype.canAffectMesh = function (mesh) {
             if (!mesh) {
                 return true;
             }
-
             if (this.includedOnlyMeshes.length > 0 && this.includedOnlyMeshes.indexOf(mesh) === -1) {
                 return false;
             }
-
             if (this.excludedMeshes.length > 0 && this.excludedMeshes.indexOf(mesh) !== -1) {
                 return false;
             }
-
             return true;
         };
-
         Light.prototype.getWorldMatrix = function () {
             this._currentRenderId = this.getScene().getRenderId();
-
             var worldMatrix = this._getWorldMatrix();
-
             if (this.parent && this.parent.getWorldMatrix) {
                 if (!this._parentedWorldMatrix) {
                     this._parentedWorldMatrix = BABYLON.Matrix.Identity();
                 }
-
                 worldMatrix.multiplyToRef(this.parent.getWorldMatrix(), this._parentedWorldMatrix);
-
                 return this._parentedWorldMatrix;
             }
-
             return worldMatrix;
         };
-
         Light.prototype.dispose = function () {
             if (this._shadowGenerator) {
                 this._shadowGenerator.dispose();
                 this._shadowGenerator = null;
             }
-
             // Remove from scene
             var index = this.getScene().lights.indexOf(this);
             this.getScene().lights.splice(index, 1);
@@ -84,4 +68,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.Light = Light;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.light.js.map
+//# sourceMappingURL=babylon.light.js.map

Babylon/Lights/babylon.pointLight.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -15,37 +15,29 @@ var BABYLON;
         PointLight.prototype.getAbsolutePosition = function () {
             return this._transformedPosition ? this._transformedPosition : this.position;
         };
-
         PointLight.prototype.transferToEffect = function (effect, positionUniformName) {
             if (this.parent && this.parent.getWorldMatrix) {
                 if (!this._transformedPosition) {
                     this._transformedPosition = BABYLON.Vector3.Zero();
                 }
-
                 BABYLON.Vector3.TransformCoordinatesToRef(this.position, this.parent.getWorldMatrix(), this._transformedPosition);
                 effect.setFloat4(positionUniformName, this._transformedPosition.x, this._transformedPosition.y, this._transformedPosition.z, 0);
-
                 return;
             }
-
             effect.setFloat4(positionUniformName, this.position.x, this.position.y, this.position.z, 0);
         };
-
         PointLight.prototype.getShadowGenerator = function () {
             return null;
         };
-
         PointLight.prototype._getWorldMatrix = function () {
             if (!this._worldMatrix) {
                 this._worldMatrix = BABYLON.Matrix.Identity();
             }
-
             BABYLON.Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._worldMatrix);
-
             return this._worldMatrix;
         };
         return PointLight;
     })(BABYLON.Light);
     BABYLON.PointLight = PointLight;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.pointLight.js.map
+//# sourceMappingURL=babylon.pointLight.js.map

Babylon/Lights/babylon.spotLight.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -18,58 +18,46 @@ var BABYLON;
         SpotLight.prototype.getAbsolutePosition = function () {
             return this.transformedPosition ? this.transformedPosition : this.position;
         };
-
         SpotLight.prototype.setDirectionToTarget = function (target) {
             this.direction = BABYLON.Vector3.Normalize(target.subtract(this.position));
             return this.direction;
         };
-
         SpotLight.prototype.computeTransformedPosition = function () {
             if (this.parent && this.parent.getWorldMatrix) {
                 if (!this.transformedPosition) {
                     this.transformedPosition = BABYLON.Vector3.Zero();
                 }
-
                 BABYLON.Vector3.TransformCoordinatesToRef(this.position, this.parent.getWorldMatrix(), this.transformedPosition);
                 return true;
             }
-
             return false;
         };
-
         SpotLight.prototype.transferToEffect = function (effect, positionUniformName, directionUniformName) {
             var normalizeDirection;
-
             if (this.parent && this.parent.getWorldMatrix) {
                 if (!this._transformedDirection) {
                     this._transformedDirection = BABYLON.Vector3.Zero();
                 }
-
                 this.computeTransformedPosition();
-
                 BABYLON.Vector3.TransformNormalToRef(this.direction, this.parent.getWorldMatrix(), this._transformedDirection);
-
                 effect.setFloat4(positionUniformName, this.transformedPosition.x, this.transformedPosition.y, this.transformedPosition.z, this.exponent);
                 normalizeDirection = BABYLON.Vector3.Normalize(this._transformedDirection);
-            } else {
+            }
+            else {
                 effect.setFloat4(positionUniformName, this.position.x, this.position.y, this.position.z, this.exponent);
                 normalizeDirection = BABYLON.Vector3.Normalize(this.direction);
             }
-
             effect.setFloat4(directionUniformName, normalizeDirection.x, normalizeDirection.y, normalizeDirection.z, Math.cos(this.angle * 0.5));
         };
-
         SpotLight.prototype._getWorldMatrix = function () {
             if (!this._worldMatrix) {
                 this._worldMatrix = BABYLON.Matrix.Identity();
             }
-
             BABYLON.Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._worldMatrix);
-
             return this._worldMatrix;
         };
         return SpotLight;
     })(BABYLON.Light);
     BABYLON.SpotLight = SpotLight;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.spotLight.js.map
+//# sourceMappingURL=babylon.spotLight.js.map

Babylon/Loading/babylon.sceneLoader.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var SceneLoader = (function () {
         function SceneLoader() {
@@ -13,8 +13,6 @@
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(SceneLoader, "ShowLoadingScreen", {
             get: function () {
                 return SceneLoader._ShowLoadingScreen;
@@ -25,79 +23,62 @@
             enumerable: true,
             configurable: true
         });
-
-
         SceneLoader._getPluginForFilename = function (sceneFilename) {
             var dotPosition = sceneFilename.lastIndexOf(".");
-
             var queryStringPosition = sceneFilename.indexOf("?");
             var extension = sceneFilename.substring(dotPosition, queryStringPosition).toLowerCase();
-
             for (var index = 0; index < this._registeredPlugins.length; index++) {
                 var plugin = this._registeredPlugins[index];
-
                 if (plugin.extensions.indexOf(extension) !== -1) {
                     return plugin;
                 }
             }
-
             return this._registeredPlugins[this._registeredPlugins.length - 1];
         };
-
         // Public functions
         SceneLoader.RegisterPlugin = function (plugin) {
             plugin.extensions = plugin.extensions.toLowerCase();
             SceneLoader._registeredPlugins.push(plugin);
         };
-
         SceneLoader.ImportMesh = function (meshesNames, rootUrl, sceneFilename, scene, onsuccess, progressCallBack, onerror) {
             var manifestChecked = function (success) {
                 scene.database = database;
-
                 var plugin = SceneLoader._getPluginForFilename(sceneFilename);
-
                 var importMeshFromData = function (data) {
                     var meshes = [];
                     var particleSystems = [];
                     var skeletons = [];
-
-                    try  {
+                    try {
                         if (!plugin.importMesh(meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons)) {
                             if (onerror) {
                                 onerror(scene, 'unable to load the scene');
                             }
-
                             return;
                         }
-                    } catch (e) {
+                    }
+                    catch (e) {
                         if (onerror) {
                             onerror(scene, e);
                         }
-
                         return;
                     }
-
                     if (onsuccess) {
                         scene.importedMeshesFiles.push(rootUrl + sceneFilename);
                         onsuccess(meshes, particleSystems, skeletons);
                     }
                 };
-
                 if (sceneFilename.substr && sceneFilename.substr(0, 5) === "data:") {
                     // Direct load
                     importMeshFromData(sceneFilename.substr(5));
                     return;
                 }
-
                 BABYLON.Tools.LoadFile(rootUrl + sceneFilename, function (data) {
                     importMeshFromData(data);
                 }, progressCallBack, database);
             };
-
             // Checking if a manifest file has been set for this scene and if offline mode has been requested
             var database = new BABYLON.Database(rootUrl + sceneFilename, manifestChecked);
         };
-
         /**
         * Load a scene
         * @param rootUrl a string that defines the root url for scene and resources
@@ -107,7 +88,6 @@
         SceneLoader.Load = function (rootUrl, sceneFilename, engine, onsuccess, progressCallBack, onerror) {
             SceneLoader.Append(rootUrl, sceneFilename, new BABYLON.Scene(engine), onsuccess, progressCallBack, onerror);
         };
-
         /**
         * Append a scene
         * @param rootUrl a string that defines the root url for scene and resources
@@ -117,58 +97,51 @@
         SceneLoader.Append = function (rootUrl, sceneFilename, scene, onsuccess, progressCallBack, onerror) {
             var plugin = this._getPluginForFilename(sceneFilename.name || sceneFilename);
             var database;
-
             if (SceneLoader.ShowLoadingScreen) {
                 scene.getEngine().displayLoadingUI();
             }
-
             var loadSceneFromData = function (data) {
                 scene.database = database;
-
                 if (!plugin.load(scene, data, rootUrl)) {
                     if (onerror) {
                         onerror(scene);
                     }
-
                     scene.getEngine().hideLoadingUI();
                     return;
                 }
-
                 if (onsuccess) {
                     onsuccess(scene);
                 }
-
                 if (SceneLoader.ShowLoadingScreen) {
                     scene.executeWhenReady(function () {
                         scene.getEngine().hideLoadingUI();
                     });
                 }
             };
-
             var manifestChecked = function (success) {
                 BABYLON.Tools.LoadFile(rootUrl + sceneFilename, loadSceneFromData, progressCallBack, database);
             };
-
             if (sceneFilename.substr && sceneFilename.substr(0, 5) === "data:") {
                 // Direct load
                 loadSceneFromData(sceneFilename.substr(5));
                 return;
             }
-
             if (rootUrl.indexOf("file:") === -1) {
                 // Checking if a manifest file has been set for this scene and if offline mode has been requested
                 database = new BABYLON.Database(rootUrl + sceneFilename, manifestChecked);
-            } else {
+            }
+            else {
                 BABYLON.Tools.ReadFile(sceneFilename, loadSceneFromData, progressCallBack);
             }
         };
+        // Flags
         SceneLoader._ForceFullSceneLoadingForIncremental = false;
         SceneLoader._ShowLoadingScreen = true;
-
+        // Members
         SceneLoader._registeredPlugins = new Array();
         return SceneLoader;
     })();
     BABYLON.SceneLoader = SceneLoader;
     ;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.sceneLoader.js.map
+//# sourceMappingURL=babylon.sceneLoader.js.map

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

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -13,7 +13,6 @@ var BABYLON;
             this._animate = true;
             this._time = 0;
             this._texturePath = texturePath;
-
             //Try to load json
             this.loadJson(texturePath);
             this.refreshRate = 1;
@@ -21,86 +20,74 @@ var BABYLON;
         CustomProceduralTexture.prototype.loadJson = function (jsonUrl) {
             var _this = this;
             var that = this;
-
             function noConfigFile() {
                 BABYLON.Tools.Log("No config file found in " + jsonUrl + " trying to use ShaderStore or DOM element");
-                try  {
+                try {
                     that.setFragment(that._texturePath);
-                } catch (ex) {
+                }
+                catch (ex) {
                     BABYLON.Tools.Error("No json or ShaderStore or DOM element found for CustomProceduralTexture");
                 }
             }
-
             var configFileUrl = jsonUrl + "/config.json";
             var xhr = new XMLHttpRequest();
-
             xhr.open("GET", configFileUrl, true);
             xhr.addEventListener("load", function () {
                 if (xhr.status === 200 || BABYLON.Tools.ValidateXHRData(xhr, 1)) {
-                    try  {
+                    try {
                         _this._config = JSON.parse(xhr.response);
-
                         _this.updateShaderUniforms();
                         _this.updateTextures();
                         _this.setFragment(_this._texturePath + "/custom");
-
                         _this._animate = _this._config.animate;
                         _this.refreshRate = _this._config.refreshrate;
-                    } catch (ex) {
+                    }
+                    catch (ex) {
                         noConfigFile();
                     }
-                } else {
+                }
+                else {
                     noConfigFile();
                 }
             }, false);
-
             xhr.addEventListener("error", function (event) {
                 noConfigFile();
             }, false);
-
-            try  {
+            try {
                 xhr.send();
-            } catch (ex) {
+            }
+            catch (ex) {
                 BABYLON.Tools.Error("CustomProceduralTexture: Error on XHR send request.");
             }
         };
-
         CustomProceduralTexture.prototype.isReady = function () {
             if (!_super.prototype.isReady.call(this)) {
                 return false;
             }
-
             for (var name in this._textures) {
                 var texture = this._textures[name];
-
                 if (!texture.isReady()) {
                     return false;
                 }
             }
-
             return true;
         };
-
         CustomProceduralTexture.prototype.render = function (useCameraPostProcess) {
             if (this._animate) {
                 this._time += this.getScene().getAnimationRatio() * 0.03;
                 this.updateShaderUniforms();
             }
-
             _super.prototype.render.call(this, useCameraPostProcess);
         };
-
         CustomProceduralTexture.prototype.updateTextures = function () {
             for (var i = 0; i < this._config.sampler2Ds.length; i++) {
                 this.setTexture(this._config.sampler2Ds[i].sample2Dname, new BABYLON.Texture(this._texturePath + "/" + this._config.sampler2Ds[i].textureRelativeUrl, this.getScene()));
             }
         };
-
         CustomProceduralTexture.prototype.updateShaderUniforms = function () {
             if (this._config) {
                 for (var j = 0; j < this._config.uniforms.length; j++) {
                     var uniform = this._config.uniforms[j];
-
                     switch (uniform.type) {
                         case "float":
                             this.setFloat(uniform.name, uniform.value);
@@ -120,10 +107,8 @@ var BABYLON;
                     }
                 }
             }
-
             this.setFloat("time", this._time);
         };
-
         Object.defineProperty(CustomProceduralTexture.prototype, "animate", {
             get: function () {
                 return this._animate;
@@ -134,9 +119,8 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return CustomProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.CustomProceduralTexture = CustomProceduralTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.customProceduralTexture.js.map
+//# sourceMappingURL=babylon.customProceduralTexture.js.map

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

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,7 +9,7 @@ var BABYLON;
     var ProceduralTexture = (function (_super) {
         __extends(ProceduralTexture, _super);
         function ProceduralTexture(name, size, fragment, scene, fallbackTexture, generateMipMaps) {
-            if (typeof generateMipMaps === "undefined") { generateMipMaps = true; }
+            if (generateMipMaps === void 0) { generateMipMaps = true; }
             _super.call(this, null, scene, !generateMipMaps);
             this._currentRefreshId = -1;
             this._refreshRate = 1;
@@ -26,39 +26,29 @@ var BABYLON;
             this._vectors3 = new Array();
             this._matrices = new Array();
             this._fallbackTextureUsed = false;
-
             scene._proceduralTextures.push(this);
-
             this.name = name;
             this.isRenderTarget = true;
             this._size = size;
             this._generateMipMaps = generateMipMaps;
-
             this.setFragment(fragment);
-
             this._fallbackTexture = fallbackTexture;
-
             this._texture = scene.getEngine().createRenderTargetTexture(size, generateMipMaps);
-
             // VBO
             var vertices = [];
             vertices.push(1, 1);
             vertices.push(-1, 1);
             vertices.push(-1, -1);
             vertices.push(1, -1);
-
             this._vertexBuffer = scene.getEngine().createVertexBuffer(vertices);
-
             // Indices
             var indices = [];
             indices.push(0);
             indices.push(1);
             indices.push(2);
-
             indices.push(0);
             indices.push(2);
             indices.push(3);
-
             this._indexBuffer = scene.getEngine().createIndexBuffer(indices);
         }
         ProceduralTexture.prototype.reset = function () {
@@ -68,48 +58,38 @@ var BABYLON;
             var engine = this.getScene().getEngine();
             engine._releaseEffect(this._effect);
         };
-
         ProceduralTexture.prototype.isReady = function () {
             var _this = this;
             var engine = this.getScene().getEngine();
             var shaders;
-
             if (!this._fragment) {
                 return false;
             }
-
             if (this._fallbackTextureUsed) {
                 return true;
             }
-
             if (this._fragment.fragmentElement !== undefined) {
                 shaders = { vertex: "procedural", fragmentElement: this._fragment.fragmentElement };
-            } else {
+            }
+            else {
                 shaders = { vertex: "procedural", fragment: this._fragment };
             }
-
             this._effect = engine.createEffect(shaders, ["position"], this._uniforms, this._samplers, "", null, null, function () {
                 _this.releaseInternalTexture();
-
                 if (_this._fallbackTexture) {
                     _this._texture = _this._fallbackTexture._texture;
                     _this._texture.references++;
                 }
-
                 _this._fallbackTextureUsed = true;
             });
-
             return this._effect.isReady();
         };
-
         ProceduralTexture.prototype.resetRefreshCounter = function () {
             this._currentRefreshId = -1;
         };
-
         ProceduralTexture.prototype.setFragment = function (fragment) {
             this._fragment = fragment;
         };
-
         Object.defineProperty(ProceduralTexture.prototype, "refreshRate", {
             get: function () {
                 return this._refreshRate;
@@ -122,181 +102,134 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         ProceduralTexture.prototype._shouldRender = function () {
             if (!this.isReady() || !this._texture) {
                 return false;
             }
-
             if (this._fallbackTextureUsed) {
                 return false;
             }
-
             if (this._currentRefreshId === -1) {
                 this._currentRefreshId = 1;
                 return true;
             }
-
             if (this.refreshRate === this._currentRefreshId) {
                 this._currentRefreshId = 1;
                 return true;
             }
-
             this._currentRefreshId++;
             return false;
         };
-
         ProceduralTexture.prototype.getRenderSize = function () {
             return this._size;
         };
-
         ProceduralTexture.prototype.resize = function (size, generateMipMaps) {
             if (this._fallbackTextureUsed) {
                 return;
             }
-
             this.releaseInternalTexture();
             this._texture = this.getScene().getEngine().createRenderTargetTexture(size, generateMipMaps);
         };
-
         ProceduralTexture.prototype._checkUniform = function (uniformName) {
             if (this._uniforms.indexOf(uniformName) === -1) {
                 this._uniforms.push(uniformName);
             }
         };
-
         ProceduralTexture.prototype.setTexture = function (name, texture) {
             if (this._samplers.indexOf(name) === -1) {
                 this._samplers.push(name);
             }
             this._textures[name] = texture;
-
             return this;
         };
-
         ProceduralTexture.prototype.setFloat = function (name, value) {
             this._checkUniform(name);
             this._floats[name] = value;
-
             return this;
         };
-
         ProceduralTexture.prototype.setFloats = function (name, value) {
             this._checkUniform(name);
             this._floatsArrays[name] = value;
-
             return this;
         };
-
         ProceduralTexture.prototype.setColor3 = function (name, value) {
             this._checkUniform(name);
             this._colors3[name] = value;
-
             return this;
         };
-
         ProceduralTexture.prototype.setColor4 = function (name, value) {
             this._checkUniform(name);
             this._colors4[name] = value;
-
             return this;
         };
-
         ProceduralTexture.prototype.setVector2 = function (name, value) {
             this._checkUniform(name);
             this._vectors2[name] = value;
-
             return this;
         };
-
         ProceduralTexture.prototype.setVector3 = function (name, value) {
             this._checkUniform(name);
             this._vectors3[name] = value;
-
             return this;
         };
-
         ProceduralTexture.prototype.setMatrix = function (name, value) {
             this._checkUniform(name);
             this._matrices[name] = value;
-
             return this;
         };
-
         ProceduralTexture.prototype.render = function (useCameraPostProcess) {
             var scene = this.getScene();
             var engine = scene.getEngine();
-
             engine.bindFramebuffer(this._texture);
-
             // Clear
             engine.clear(scene.clearColor, true, true);
-
             // Render
             engine.enableEffect(this._effect);
             engine.setState(false);
-
             for (var name in this._textures) {
                 this._effect.setTexture(name, this._textures[name]);
             }
-
             for (name in this._floats) {
                 this._effect.setFloat(name, this._floats[name]);
             }
-
             for (name in this._floatsArrays) {
                 this._effect.setArray(name, this._floatsArrays[name]);
             }
-
             for (name in this._colors3) {
                 this._effect.setColor3(name, this._colors3[name]);
             }
-
             for (name in this._colors4) {
                 var color = this._colors4[name];
                 this._effect.setFloat4(name, color.r, color.g, color.b, color.a);
             }
-
             for (name in this._vectors2) {
                 this._effect.setVector2(name, this._vectors2[name]);
             }
-
             for (name in this._vectors3) {
                 this._effect.setVector3(name, this._vectors3[name]);
             }
-
             for (name in this._matrices) {
                 this._effect.setMatrix(name, this._matrices[name]);
             }
-
             // VBOs
             engine.bindBuffers(this._vertexBuffer, this._indexBuffer, this._vertexDeclaration, this._vertexStrideSize, this._effect);
-
             // Draw order
             engine.draw(true, 0, 6);
-
             // Unbind
             engine.unBindFramebuffer(this._texture);
         };
-
         ProceduralTexture.prototype.clone = function () {
             var textureSize = this.getSize();
             var newTexture = new ProceduralTexture(this.name, textureSize.width, this._fragment, this.getScene(), this._fallbackTexture, this._generateMipMaps);
-
             // Base texture
             newTexture.hasAlpha = this.hasAlpha;
             newTexture.level = this.level;
-
             // RenderTarget Texture
             newTexture.coordinatesMode = this.coordinatesMode;
-
             return newTexture;
         };
-
         ProceduralTexture.prototype.dispose = function () {
             var index = this.getScene()._proceduralTextures.indexOf(this);
-
             if (index >= 0) {
                 this.getScene()._proceduralTextures.splice(index, 1);
             }
@@ -306,4 +239,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.ProceduralTexture = ProceduralTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.proceduralTexture.js.map
+//# sourceMappingURL=babylon.proceduralTexture.js.map

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

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -19,7 +19,6 @@ var BABYLON;
             this.setFloat("ampScale", this._ampScale);
             this.setColor3("woodColor", this._woodColor);
         };
-
         Object.defineProperty(WoodProceduralTexture.prototype, "ampScale", {
             get: function () {
                 return this._ampScale;
@@ -31,8 +30,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(WoodProceduralTexture.prototype, "woodColor", {
             get: function () {
                 return this._woodColor;
@@ -44,11 +41,9 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return WoodProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.WoodProceduralTexture = WoodProceduralTexture;
-
     var FireProceduralTexture = (function (_super) {
         __extends(FireProceduralTexture, _super);
         function FireProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
@@ -74,7 +69,6 @@ var BABYLON;
             this.setColor3("c6", this._fireColors[5]);
             this.setFloat("alphaThreshold", this._alphaThreshold);
         };
-
         FireProceduralTexture.prototype.render = function (useCameraPostProcess) {
             if (this._autoGenerateTime) {
                 this._time += this.getScene().getAnimationRatio() * 0.03;
@@ -82,7 +76,6 @@ var BABYLON;
             }
             _super.prototype.render.call(this, useCameraPostProcess);
         };
-
         Object.defineProperty(FireProceduralTexture, "PurpleFireColors", {
             get: function () {
                 return [
@@ -97,7 +90,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(FireProceduralTexture, "GreenFireColors", {
             get: function () {
                 return [
@@ -112,7 +104,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(FireProceduralTexture, "RedFireColors", {
             get: function () {
                 return [
@@ -127,7 +118,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(FireProceduralTexture, "BlueFireColors", {
             get: function () {
                 return [
@@ -142,7 +132,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(FireProceduralTexture.prototype, "fireColors", {
             get: function () {
                 return this._fireColors;
@@ -154,8 +143,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(FireProceduralTexture.prototype, "time", {
             get: function () {
                 return this._time;
@@ -167,8 +154,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(FireProceduralTexture.prototype, "speed", {
             get: function () {
                 return this._speed;
@@ -180,8 +165,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(FireProceduralTexture.prototype, "shift", {
             get: function () {
                 return this._shift;
@@ -193,8 +176,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(FireProceduralTexture.prototype, "alphaThreshold", {
             get: function () {
                 return this._alphaThreshold;
@@ -206,11 +187,9 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return FireProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.FireProceduralTexture = FireProceduralTexture;
-
     var CloudProceduralTexture = (function (_super) {
         __extends(CloudProceduralTexture, _super);
         function CloudProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
@@ -224,7 +203,6 @@ var BABYLON;
             this.setColor3("skyColor", this._skyColor);
             this.setColor3("cloudColor", this._cloudColor);
         };
-
         Object.defineProperty(CloudProceduralTexture.prototype, "skyColor", {
             get: function () {
                 return this._skyColor;
@@ -236,8 +214,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(CloudProceduralTexture.prototype, "cloudColor", {
             get: function () {
                 return this._cloudColor;
@@ -249,11 +225,9 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return CloudProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.CloudProceduralTexture = CloudProceduralTexture;
-
     var GrassProceduralTexture = (function (_super) {
         __extends(GrassProceduralTexture, _super);
         function GrassProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
@@ -262,13 +236,11 @@ var BABYLON;
             this._herb2 = new BABYLON.Color3(0.36, 0.49, 0.09);
             this._herb3 = new BABYLON.Color3(0.51, 0.6, 0.28);
             this._groundColor = new BABYLON.Color3(1, 1, 1);
-
             this._grassColors = [
                 new BABYLON.Color3(0.29, 0.38, 0.02),
                 new BABYLON.Color3(0.36, 0.49, 0.09),
                 new BABYLON.Color3(0.51, 0.6, 0.28)
             ];
-
             this.updateShaderUniforms();
             this.refreshRate = 0;
         }
@@ -278,7 +250,6 @@ var BABYLON;
             this.setColor3("herb3Color", this._grassColors[2]);
             this.setColor3("groundColor", this._groundColor);
         };
-
         Object.defineProperty(GrassProceduralTexture.prototype, "grassColors", {
             get: function () {
                 return this._grassColors;
@@ -290,8 +261,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(GrassProceduralTexture.prototype, "groundColor", {
             get: function () {
                 return this._groundColor;
@@ -303,11 +272,9 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return GrassProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.GrassProceduralTexture = GrassProceduralTexture;
-
     var RoadProceduralTexture = (function (_super) {
         __extends(RoadProceduralTexture, _super);
         function RoadProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
@@ -319,7 +286,6 @@ var BABYLON;
         RoadProceduralTexture.prototype.updateShaderUniforms = function () {
             this.setColor3("roadColor", this._roadColor);
         };
-
         Object.defineProperty(RoadProceduralTexture.prototype, "roadColor", {
             get: function () {
                 return this._roadColor;
@@ -331,11 +297,9 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return RoadProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.RoadProceduralTexture = RoadProceduralTexture;
-
     var BrickProceduralTexture = (function (_super) {
         __extends(BrickProceduralTexture, _super);
         function BrickProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
@@ -353,7 +317,6 @@ var BABYLON;
             this.setColor3("brickColor", this._brickColor);
             this.setColor3("jointColor", this._jointColor);
         };
-
         Object.defineProperty(BrickProceduralTexture.prototype, "numberOfBricksHeight", {
             get: function () {
                 return this._numberOfBricksHeight;
@@ -361,7 +324,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(BrickProceduralTexture.prototype, "cloudColor", {
             set: function (value) {
                 this._numberOfBricksHeight = value;
@@ -370,7 +332,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(BrickProceduralTexture.prototype, "numberOfBricksWidth", {
             get: function () {
                 return this._numberOfBricksWidth;
@@ -382,8 +343,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(BrickProceduralTexture.prototype, "jointColor", {
             get: function () {
                 return this._jointColor;
@@ -395,8 +354,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(BrickProceduralTexture.prototype, "brickColor", {
             get: function () {
                 return this._brickColor;
@@ -408,11 +365,9 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return BrickProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.BrickProceduralTexture = BrickProceduralTexture;
-
     var MarbleProceduralTexture = (function (_super) {
         __extends(MarbleProceduralTexture, _super);
         function MarbleProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
@@ -432,7 +387,6 @@ var BABYLON;
             this.setColor3("marbleColor", this._marbleColor);
             this.setColor3("jointColor", this._jointColor);
         };
-
         Object.defineProperty(MarbleProceduralTexture.prototype, "numberOfTilesHeight", {
             get: function () {
                 return this._numberOfTilesHeight;
@@ -444,8 +398,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(MarbleProceduralTexture.prototype, "numberOfTilesWidth", {
             get: function () {
                 return this._numberOfTilesWidth;
@@ -457,8 +409,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(MarbleProceduralTexture.prototype, "jointColor", {
             get: function () {
                 return this._jointColor;
@@ -470,8 +420,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(MarbleProceduralTexture.prototype, "marbleColor", {
             get: function () {
                 return this._marbleColor;
@@ -483,9 +431,8 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         return MarbleProceduralTexture;
     })(BABYLON.ProceduralTexture);
     BABYLON.MarbleProceduralTexture = MarbleProceduralTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.standardProceduralTexture.js.map
+//# sourceMappingURL=babylon.standardProceduralTexture.js.map

Babylon/Materials/Textures/babylon.baseTexture.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var BaseTexture = (function () {
         function BaseTexture(scene) {
@@ -20,57 +20,43 @@
         BaseTexture.prototype.getScene = function () {
             return this._scene;
         };
-
         BaseTexture.prototype.getTextureMatrix = function () {
             return null;
         };
-
         BaseTexture.prototype.getReflectionTextureMatrix = function () {
             return null;
         };
-
         BaseTexture.prototype.getInternalTexture = function () {
             return this._texture;
         };
-
         BaseTexture.prototype.isReady = function () {
             if (this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_NOTLOADED) {
                 return true;
             }
-
             if (this._texture) {
                 return this._texture.isReady;
             }
-
             return false;
         };
-
         BaseTexture.prototype.getSize = function () {
             if (this._texture._width) {
                 return { width: this._texture._width, height: this._texture._height };
             }
-
             if (this._texture._size) {
                 return { width: this._texture._size, height: this._texture._size };
             }
-
             return { width: 0, height: 0 };
         };
-
         BaseTexture.prototype.getBaseSize = function () {
             if (!this.isReady())
                 return { width: 0, height: 0 };
-
             if (this._texture._size) {
                 return { width: this._texture._size, height: this._texture._size };
             }
-
             return { width: this._texture._baseWidth, height: this._texture._baseHeight };
         };
-
         BaseTexture.prototype.scale = function (ratio) {
         };
-
         Object.defineProperty(BaseTexture.prototype, "canRescale", {
             get: function () {
                 return false;
@@ -78,24 +64,20 @@
             enumerable: true,
             configurable: true
         });
-
         BaseTexture.prototype._removeFromCache = function (url, noMipmap) {
             var texturesCache = this._scene.getEngine().getLoadedTexturesCache();
             for (var index = 0; index < texturesCache.length; index++) {
                 var texturesCacheEntry = texturesCache[index];
-
                 if (texturesCacheEntry.url === url && texturesCacheEntry.noMipmap === noMipmap) {
                     texturesCache.splice(index, 1);
                     return;
                 }
             }
         };
-
         BaseTexture.prototype._getFromCache = function (url, noMipmap, sampling) {
             var texturesCache = this._scene.getEngine().getLoadedTexturesCache();
             for (var index = 0; index < texturesCache.length; index++) {
                 var texturesCacheEntry = texturesCache[index];
-
                 if (texturesCacheEntry.url === url && texturesCacheEntry.noMipmap === noMipmap) {
                     if (!sampling || sampling === texturesCacheEntry.samplingMode) {
                         texturesCacheEntry.references++;
@@ -103,49 +85,37 @@
                     }
                 }
             }
-
             return null;
         };
-
         BaseTexture.prototype.delayLoad = function () {
         };
-
         BaseTexture.prototype.releaseInternalTexture = function () {
             if (!this._texture) {
                 return;
             }
             var texturesCache = this._scene.getEngine().getLoadedTexturesCache();
             this._texture.references--;
-
             // Final reference ?
             if (this._texture.references === 0) {
                 var index = texturesCache.indexOf(this._texture);
                 texturesCache.splice(index, 1);
-
                 this._scene.getEngine()._releaseTexture(this._texture);
-
                 delete this._texture;
             }
         };
-
         BaseTexture.prototype.clone = function () {
             return null;
         };
-
         BaseTexture.prototype.dispose = function () {
             // Remove from scene
             var index = this._scene.textures.indexOf(this);
-
             if (index >= 0) {
                 this._scene.textures.splice(index, 1);
             }
-
             if (this._texture === undefined) {
                 return;
             }
-
             this.releaseInternalTexture();
-
             // Callback
             if (this.onDispose) {
                 this.onDispose();
@@ -155,4 +125,4 @@
     })();
     BABYLON.BaseTexture = BaseTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.baseTexture.js.map
+//# sourceMappingURL=babylon.baseTexture.js.map

Babylon/Materials/Textures/babylon.cubeTexture.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -11,59 +11,47 @@ var BABYLON;
         function CubeTexture(rootUrl, scene, extensions, noMipmap) {
             _super.call(this, scene);
             this.coordinatesMode = BABYLON.Texture.CUBIC_MODE;
-
             this.name = rootUrl;
             this.url = rootUrl;
             this._noMipmap = noMipmap;
             this.hasAlpha = false;
-
             this._texture = this._getFromCache(rootUrl, noMipmap);
-
             if (!extensions) {
                 extensions = ["_px.jpg", "_py.jpg", "_pz.jpg", "_nx.jpg", "_ny.jpg", "_nz.jpg"];
             }
-
             this._extensions = extensions;
-
             if (!this._texture) {
                 if (!scene.useDelayedTextureLoading) {
                     this._texture = scene.getEngine().createCubeTexture(rootUrl, scene, extensions, noMipmap);
-                } else {
+                }
+                else {
                     this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
                 }
             }
-
             this.isCube = true;
-
             this._textureMatrix = BABYLON.Matrix.Identity();
         }
         CubeTexture.prototype.clone = function () {
             var newTexture = new BABYLON.CubeTexture(this.url, this.getScene(), this._extensions, this._noMipmap);
-
             // Base texture
             newTexture.level = this.level;
             newTexture.wrapU = this.wrapU;
             newTexture.wrapV = this.wrapV;
             newTexture.coordinatesIndex = this.coordinatesIndex;
             newTexture.coordinatesMode = this.coordinatesMode;
-
             return newTexture;
         };
-
         // Methods
         CubeTexture.prototype.delayLoad = function () {
             if (this.delayLoadState != BABYLON.Engine.DELAYLOADSTATE_NOTLOADED) {
                 return;
             }
-
             this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_LOADED;
             this._texture = this._getFromCache(this.url, this._noMipmap);
-
             if (!this._texture) {
                 this._texture = this.getScene().getEngine().createCubeTexture(this.url, this.getScene(), this._extensions);
             }
         };
-
         CubeTexture.prototype.getReflectionTextureMatrix = function () {
             return this._textureMatrix;
         };
@@ -71,4 +59,4 @@ var BABYLON;
     })(BABYLON.BaseTexture);
     BABYLON.CubeTexture = CubeTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.cubeTexture.js.map
+//# sourceMappingURL=babylon.cubeTexture.js.map

Babylon/Materials/Textures/babylon.dynamicTexture.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,31 +9,26 @@ var BABYLON;
     var DynamicTexture = (function (_super) {
         __extends(DynamicTexture, _super);
         function DynamicTexture(name, options, scene, generateMipMaps, samplingMode) {
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             _super.call(this, null, scene, !generateMipMaps);
-
             this.name = name;
-
             this.wrapU = BABYLON.Texture.CLAMP_ADDRESSMODE;
             this.wrapV = BABYLON.Texture.CLAMP_ADDRESSMODE;
-
             this._generateMipMaps = generateMipMaps;
-
             if (options.getContext) {
                 this._canvas = options;
                 this._texture = scene.getEngine().createDynamicTexture(options.width, options.height, generateMipMaps, samplingMode);
-            } else {
+            }
+            else {
                 this._canvas = document.createElement("canvas");
-
                 if (options.width) {
                     this._texture = scene.getEngine().createDynamicTexture(options.width, options.height, generateMipMaps, samplingMode);
-                } else {
+                }
+                else {
                     this._texture = scene.getEngine().createDynamicTexture(options, options, generateMipMaps, samplingMode);
                 }
             }
-
             var textureSize = this.getSize();
-
             this._canvas.width = textureSize.width;
             this._canvas.height = textureSize.height;
             this._context = this._canvas.getContext("2d");
@@ -45,72 +40,56 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         DynamicTexture.prototype.scale = function (ratio) {
             var textureSize = this.getSize();
-
             textureSize.width *= ratio;
             textureSize.height *= ratio;
-
             this._canvas.width = textureSize.width;
             this._canvas.height = textureSize.height;
-
             this.releaseInternalTexture();
-
             this._texture = this.getScene().getEngine().createDynamicTexture(textureSize.width, textureSize.height, this._generateMipMaps, this._samplingMode);
         };
-
         DynamicTexture.prototype.getContext = function () {
             return this._context;
         };
-
         DynamicTexture.prototype.clear = function () {
             var size = this.getSize();
             this._context.fillRect(0, 0, size.width, size.height);
         };
-
         DynamicTexture.prototype.update = function (invertY) {
             this.getScene().getEngine().updateDynamicTexture(this._texture, this._canvas, invertY === undefined ? true : invertY);
         };
-
         DynamicTexture.prototype.drawText = function (text, x, y, font, color, clearColor, invertY, update) {
-            if (typeof update === "undefined") { update = true; }
+            if (update === void 0) { update = true; }
             var size = this.getSize();
             if (clearColor) {
                 this._context.fillStyle = clearColor;
                 this._context.fillRect(0, 0, size.width, size.height);
             }
-
             this._context.font = font;
             if (x === null) {
                 var textSize = this._context.measureText(text);
                 x = (size.width - textSize.width) / 2;
             }
-
             this._context.fillStyle = color;
             this._context.fillText(text, x, y);
-
             if (update) {
                 this.update(invertY);
             }
         };
-
         DynamicTexture.prototype.clone = function () {
             var textureSize = this.getSize();
             var newTexture = new DynamicTexture(this.name, textureSize.width, this.getScene(), this._generateMipMaps);
-
             // Base texture
             newTexture.hasAlpha = this.hasAlpha;
             newTexture.level = this.level;
-
             // Dynamic Texture
             newTexture.wrapU = this.wrapU;
             newTexture.wrapV = this.wrapV;
-
             return newTexture;
         };
         return DynamicTexture;
     })(BABYLON.Texture);
     BABYLON.DynamicTexture = DynamicTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.dynamicTexture.js.map
+//# sourceMappingURL=babylon.dynamicTexture.js.map

Babylon/Materials/Textures/babylon.mirrorTexture.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -14,43 +14,33 @@ var BABYLON;
             this.mirrorPlane = new BABYLON.Plane(0, 1, 0, 1);
             this._transformMatrix = BABYLON.Matrix.Zero();
             this._mirrorMatrix = BABYLON.Matrix.Zero();
-
             this.onBeforeRender = function () {
                 BABYLON.Matrix.ReflectionToRef(_this.mirrorPlane, _this._mirrorMatrix);
                 _this._savedViewMatrix = scene.getViewMatrix();
-
                 _this._mirrorMatrix.multiplyToRef(_this._savedViewMatrix, _this._transformMatrix);
-
                 scene.setTransformMatrix(_this._transformMatrix, scene.getProjectionMatrix());
-
                 scene.clipPlane = _this.mirrorPlane;
-
                 scene.getEngine().cullBackFaces = false;
             };
-
             this.onAfterRender = function () {
                 scene.setTransformMatrix(_this._savedViewMatrix, scene.getProjectionMatrix());
                 scene.getEngine().cullBackFaces = true;
-
                 delete scene.clipPlane;
             };
         }
         MirrorTexture.prototype.clone = function () {
             var textureSize = this.getSize();
             var newTexture = new BABYLON.MirrorTexture(this.name, textureSize.width, this.getScene(), this._generateMipMaps);
-
             // Base texture
             newTexture.hasAlpha = this.hasAlpha;
             newTexture.level = this.level;
-
             // Mirror Texture
             newTexture.mirrorPlane = this.mirrorPlane.clone();
             newTexture.renderList = this.renderList.slice(0);
-
             return newTexture;
         };
         return MirrorTexture;
     })(BABYLON.RenderTargetTexture);
     BABYLON.MirrorTexture = MirrorTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.mirrorTexture.js.map
+//# sourceMappingURL=babylon.mirrorTexture.js.map

Babylon/Materials/Textures/babylon.rawTexture.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,53 +9,47 @@ var BABYLON;
     var RawTexture = (function (_super) {
         __extends(RawTexture, _super);
         function RawTexture(data, width, height, format, scene, generateMipMaps, invertY, samplingMode) {
-            if (typeof generateMipMaps === "undefined") { generateMipMaps = true; }
-            if (typeof invertY === "undefined") { invertY = false; }
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
+            if (generateMipMaps === void 0) { generateMipMaps = true; }
+            if (invertY === void 0) { invertY = false; }
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             _super.call(this, null, scene, !generateMipMaps, invertY);
-
             this._texture = scene.getEngine().createRawTexture(data, width, height, format, generateMipMaps, invertY, samplingMode);
-
             this.wrapU = BABYLON.Texture.CLAMP_ADDRESSMODE;
             this.wrapV = BABYLON.Texture.CLAMP_ADDRESSMODE;
         }
         // Statics
         RawTexture.CreateLuminanceTexture = function (data, width, height, scene, generateMipMaps, invertY, samplingMode) {
-            if (typeof generateMipMaps === "undefined") { generateMipMaps = true; }
-            if (typeof invertY === "undefined") { invertY = false; }
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
+            if (generateMipMaps === void 0) { generateMipMaps = true; }
+            if (invertY === void 0) { invertY = false; }
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             return new RawTexture(data, width, height, BABYLON.Engine.TEXTUREFORMAT_LUMINANCE, scene, generateMipMaps, invertY, samplingMode);
         };
-
         RawTexture.CreateLuminanceAlphaTexture = function (data, width, height, scene, generateMipMaps, invertY, samplingMode) {
-            if (typeof generateMipMaps === "undefined") { generateMipMaps = true; }
-            if (typeof invertY === "undefined") { invertY = false; }
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
+            if (generateMipMaps === void 0) { generateMipMaps = true; }
+            if (invertY === void 0) { invertY = false; }
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             return new RawTexture(data, width, height, BABYLON.Engine.TEXTUREFORMAT_LUMINANCE_ALPHA, scene, generateMipMaps, invertY, samplingMode);
         };
-
         RawTexture.CreateAlphaTexture = function (data, width, height, scene, generateMipMaps, invertY, samplingMode) {
-            if (typeof generateMipMaps === "undefined") { generateMipMaps = true; }
-            if (typeof invertY === "undefined") { invertY = false; }
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
+            if (generateMipMaps === void 0) { generateMipMaps = true; }
+            if (invertY === void 0) { invertY = false; }
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             return new RawTexture(data, width, height, BABYLON.Engine.TEXTUREFORMAT_ALPHA, scene, generateMipMaps, invertY, samplingMode);
         };
-
         RawTexture.CreateRGBTexture = function (data, width, height, scene, generateMipMaps, invertY, samplingMode) {
-            if (typeof generateMipMaps === "undefined") { generateMipMaps = true; }
-            if (typeof invertY === "undefined") { invertY = false; }
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
+            if (generateMipMaps === void 0) { generateMipMaps = true; }
+            if (invertY === void 0) { invertY = false; }
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             return new RawTexture(data, width, height, BABYLON.Engine.TEXTUREFORMAT_RGB, scene, generateMipMaps, invertY, samplingMode);
         };
-
         RawTexture.CreateRGBATexture = function (data, width, height, scene, generateMipMaps, invertY, samplingMode) {
-            if (typeof generateMipMaps === "undefined") { generateMipMaps = true; }
-            if (typeof invertY === "undefined") { invertY = false; }
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
+            if (generateMipMaps === void 0) { generateMipMaps = true; }
+            if (invertY === void 0) { invertY = false; }
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             return new RawTexture(data, width, height, BABYLON.Engine.TEXTUREFORMAT_RGBA, scene, generateMipMaps, invertY, samplingMode);
         };
         return RawTexture;
     })(BABYLON.Texture);
     BABYLON.RawTexture = RawTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.rawTexture.js.map
+//# sourceMappingURL=babylon.rawTexture.js.map

Babylon/Materials/Textures/babylon.renderTargetTexture.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,8 +9,8 @@ var BABYLON;
     var RenderTargetTexture = (function (_super) {
         __extends(RenderTargetTexture, _super);
         function RenderTargetTexture(name, size, scene, generateMipMaps, doNotChangeAspectRatio, type) {
-            if (typeof doNotChangeAspectRatio === "undefined") { doNotChangeAspectRatio = true; }
-            if (typeof type === "undefined") { type = BABYLON.Engine.TEXTURETYPE_UNSIGNED_INT; }
+            if (doNotChangeAspectRatio === void 0) { doNotChangeAspectRatio = true; }
+            if (type === void 0) { type = BABYLON.Engine.TEXTURETYPE_UNSIGNED_INT; }
             _super.call(this, null, scene, !generateMipMaps);
             this.renderList = new Array();
             this.renderParticles = true;
@@ -18,22 +18,18 @@ var BABYLON;
             this.coordinatesMode = BABYLON.Texture.PROJECTION_MODE;
             this._currentRefreshId = -1;
             this._refreshRate = 1;
-
             this.name = name;
             this.isRenderTarget = true;
             this._size = size;
             this._generateMipMaps = generateMipMaps;
             this._doNotChangeAspectRatio = doNotChangeAspectRatio;
-
             this._texture = scene.getEngine().createRenderTargetTexture(size, { generateMipMaps: generateMipMaps, type: type });
-
             // Rendering groups
             this._renderingManager = new BABYLON.RenderingManager(scene);
         }
         RenderTargetTexture.prototype.resetRefreshCounter = function () {
             this._currentRefreshId = -1;
         };
-
         Object.defineProperty(RenderTargetTexture.prototype, "refreshRate", {
             get: function () {
                 return this._refreshRate;
@@ -46,34 +42,27 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
-
         RenderTargetTexture.prototype._shouldRender = function () {
             if (this._currentRefreshId === -1) {
                 this._currentRefreshId = 1;
                 return true;
             }
-
-            if (this.refreshRate == this._currentRefreshId) {
+            if (this.refreshRate === this._currentRefreshId) {
                 this._currentRefreshId = 1;
                 return true;
             }
-
             this._currentRefreshId++;
             return false;
         };
-
         RenderTargetTexture.prototype.isReady = function () {
             if (!this.getScene().renderTargetsEnabled) {
                 return false;
             }
             return _super.prototype.isReady.call(this);
         };
-
         RenderTargetTexture.prototype.getRenderSize = function () {
             return this._size;
         };
-
         Object.defineProperty(RenderTargetTexture.prototype, "canRescale", {
             get: function () {
                 return true;
@@ -81,59 +70,46 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         RenderTargetTexture.prototype.scale = function (ratio) {
             var newSize = this._size * ratio;
-
             this.resize(newSize, this._generateMipMaps);
         };
-
         RenderTargetTexture.prototype.resize = function (size, generateMipMaps) {
             this.releaseInternalTexture();
             this._texture = this.getScene().getEngine().createRenderTargetTexture(size, generateMipMaps);
         };
-
         RenderTargetTexture.prototype.render = function (useCameraPostProcess) {
             var scene = this.getScene();
             var engine = scene.getEngine();
-
             if (this._waitingRenderList) {
                 this.renderList = [];
                 for (var index = 0; index < this._waitingRenderList.length; index++) {
                     var id = this._waitingRenderList[index];
                     this.renderList.push(scene.getMeshByID(id));
                 }
-
                 delete this._waitingRenderList;
             }
-
-            if (!this.renderList) {
+            if (this.renderList && this.renderList.length === 0) {
                 return;
             }
-
             // Bind
             if (!useCameraPostProcess || !scene.postProcessManager._prepareFrame(this._texture)) {
                 engine.bindFramebuffer(this._texture);
             }
-
             // Clear
             engine.clear(scene.clearColor, true, true);
-
             this._renderingManager.reset();
-
-            for (var meshIndex = 0; meshIndex < this.renderList.length; meshIndex++) {
-                var mesh = this.renderList[meshIndex];
-
+            var currentRenderList = this.renderList ? this.renderList : scene.getActiveMeshes().data;
+            for (var meshIndex = 0; meshIndex < currentRenderList.length; meshIndex++) {
+                var mesh = currentRenderList[meshIndex];
                 if (mesh) {
                     if (!mesh.isReady() || (mesh.material && !mesh.material.isReady())) {
                         // Reset _currentRefreshId
                         this.resetRefreshCounter();
                         continue;
                     }
-
-                    if (mesh.isEnabled() && mesh.isVisible && mesh.subMeshes && ((mesh.layerMask & scene.activeCamera.layerMask) != 0)) {
+                    if (mesh.isEnabled() && mesh.isVisible && mesh.subMeshes && ((mesh.layerMask & scene.activeCamera.layerMask) !== 0)) {
                         mesh._activate(scene.getRenderId());
-
                         for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
                             var subMesh = mesh.subMeshes[subIndex];
                             scene._activeVertices += subMesh.indexCount;
@@ -142,50 +118,39 @@ var BABYLON;
                     }
                 }
             }
-
             if (!this._doNotChangeAspectRatio) {
                 scene.updateTransformMatrix(true);
             }
-
             if (this.onBeforeRender) {
                 this.onBeforeRender();
             }
-
             // Render
-            this._renderingManager.render(this.customRenderFunction, this.renderList, this.renderParticles, this.renderSprites);
-
+            this._renderingManager.render(this.customRenderFunction, currentRenderList, this.renderParticles, this.renderSprites);
             if (useCameraPostProcess) {
                 scene.postProcessManager._finalizeFrame(false, this._texture);
             }
-
             if (this.onAfterRender) {
                 this.onAfterRender();
             }
-
             // Unbind
             engine.unBindFramebuffer(this._texture);
-
             if (!this._doNotChangeAspectRatio) {
                 scene.updateTransformMatrix(true);
             }
         };
-
         RenderTargetTexture.prototype.clone = function () {
             var textureSize = this.getSize();
-            var newTexture = new BABYLON.RenderTargetTexture(this.name, textureSize.width, this.getScene(), this._generateMipMaps);
-
+            var newTexture = new RenderTargetTexture(this.name, textureSize.width, this.getScene(), this._generateMipMaps);
             // Base texture
             newTexture.hasAlpha = this.hasAlpha;
             newTexture.level = this.level;
-
             // RenderTarget Texture
             newTexture.coordinatesMode = this.coordinatesMode;
             newTexture.renderList = this.renderList.slice(0);
-
             return newTexture;
         };
         return RenderTargetTexture;
     })(BABYLON.Texture);
     BABYLON.RenderTargetTexture = RenderTargetTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.renderTargetTexture.js.map
+//# sourceMappingURL=babylon.renderTargetTexture.js.map

Babylon/Materials/Textures/babylon.texture.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,11 +9,11 @@ var BABYLON;
     var Texture = (function (_super) {
         __extends(Texture, _super);
         function Texture(url, scene, noMipmap, invertY, samplingMode, onLoad, onError, buffer, deleteBuffer) {
-            if (typeof samplingMode === "undefined") { samplingMode = Texture.TRILINEAR_SAMPLINGMODE; }
-            if (typeof onLoad === "undefined") { onLoad = null; }
-            if (typeof onError === "undefined") { onError = null; }
-            if (typeof buffer === "undefined") { buffer = null; }
-            if (typeof deleteBuffer === "undefined") { deleteBuffer = false; }
+            if (samplingMode === void 0) { samplingMode = Texture.TRILINEAR_SAMPLINGMODE; }
+            if (onLoad === void 0) { onLoad = null; }
+            if (onError === void 0) { onError = null; }
+            if (buffer === void 0) { buffer = null; }
+            if (deleteBuffer === void 0) { deleteBuffer = false; }
             _super.call(this, scene);
             this.uOffset = 0;
             this.vOffset = 0;
@@ -22,7 +22,6 @@ var BABYLON;
             this.uAng = 0;
             this.vAng = 0;
             this.wAng = 0;
-
             this.name = url;
             this.url = url;
             this._noMipmap = noMipmap;
@@ -30,20 +29,18 @@ var BABYLON;
             this._samplingMode = samplingMode;
             this._buffer = buffer;
             this._deleteBuffer = deleteBuffer;
-
             if (!url) {
                 return;
             }
-
             this._texture = this._getFromCache(url, noMipmap, samplingMode);
-
             if (!this._texture) {
                 if (!scene.useDelayedTextureLoading) {
                     this._texture = scene.getEngine().createTexture(url, noMipmap, invertY, scene, this._samplingMode, onLoad, onError, this._buffer);
                     if (deleteBuffer) {
                         delete this._buffer;
                     }
-                } else {
+                }
+                else {
                     this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
                 }
             }
@@ -52,10 +49,8 @@ var BABYLON;
             if (this.delayLoadState != BABYLON.Engine.DELAYLOADSTATE_NOTLOADED) {
                 return;
             }
-
             this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_LOADED;
             this._texture = this._getFromCache(this.url, this._noMipmap, this._samplingMode);
-
             if (!this._texture) {
                 this._texture = this.getScene().getEngine().createTexture(this.url, this._noMipmap, this._invertY, this.getScene(), this._samplingMode, null, null, this._buffer);
                 if (this._deleteBuffer) {
@@ -63,27 +58,21 @@ var BABYLON;
                 }
             }
         };
-
         Texture.prototype._prepareRowForTextureGeneration = function (x, y, z, t) {
             x -= this.uOffset + 0.5;
             y -= this.vOffset + 0.5;
             z -= 0.5;
-
             BABYLON.Vector3.TransformCoordinatesFromFloatsToRef(x, y, z, this._rowGenerationMatrix, t);
-
             t.x *= this.uScale;
             t.y *= this.vScale;
-
             t.x += 0.5;
             t.y += 0.5;
             t.z += 0.5;
         };
-
         Texture.prototype.getTextureMatrix = function () {
             if (this.uOffset === this._cachedUOffset && this.vOffset === this._cachedVOffset && this.uScale === this._cachedUScale && this.vScale === this._cachedVScale && this.uAng === this._cachedUAng && this.vAng === this._cachedVAng && this.wAng === this._cachedWAng) {
                 return this._cachedTextureMatrix;
             }
-
             this._cachedUOffset = this.uOffset;
             this._cachedVOffset = this.vOffset;
             this._cachedUScale = this.uScale;
@@ -91,7 +80,6 @@ var BABYLON;
             this._cachedUAng = this.uAng;
             this._cachedVAng = this.vAng;
             this._cachedWAng = this.wAng;
-
             if (!this._cachedTextureMatrix) {
                 this._cachedTextureMatrix = BABYLON.Matrix.Zero();
                 this._rowGenerationMatrix = new BABYLON.Matrix();
@@ -99,16 +87,12 @@ var BABYLON;
                 this._t1 = BABYLON.Vector3.Zero();
                 this._t2 = BABYLON.Vector3.Zero();
             }
-
             BABYLON.Matrix.RotationYawPitchRollToRef(this.vAng, this.uAng, this.wAng, this._rowGenerationMatrix);
-
             this._prepareRowForTextureGeneration(0, 0, 0, this._t0);
             this._prepareRowForTextureGeneration(1.0, 0, 0, this._t1);
             this._prepareRowForTextureGeneration(0, 1.0, 0, this._t2);
-
             this._t1.subtractInPlace(this._t0);
             this._t2.subtractInPlace(this._t0);
-
             BABYLON.Matrix.IdentityToRef(this._cachedTextureMatrix);
             this._cachedTextureMatrix.m[0] = this._t1.x;
             this._cachedTextureMatrix.m[1] = this._t1.y;
@@ -119,22 +103,17 @@ var BABYLON;
             this._cachedTextureMatrix.m[8] = this._t0.x;
             this._cachedTextureMatrix.m[9] = this._t0.y;
             this._cachedTextureMatrix.m[10] = this._t0.z;
-
             return this._cachedTextureMatrix;
         };
-
         Texture.prototype.getReflectionTextureMatrix = function () {
             if (this.uOffset === this._cachedUOffset && this.vOffset === this._cachedVOffset && this.uScale === this._cachedUScale && this.vScale === this._cachedVScale && this.coordinatesMode === this._cachedCoordinatesMode) {
                 return this._cachedTextureMatrix;
             }
-
             if (!this._cachedTextureMatrix) {
                 this._cachedTextureMatrix = BABYLON.Matrix.Zero();
                 this._projectionModeMatrix = BABYLON.Matrix.Zero();
             }
-
             this._cachedCoordinatesMode = this.coordinatesMode;
-
             switch (this.coordinatesMode) {
                 case BABYLON.Texture.SPHERICAL_MODE:
                     BABYLON.Matrix.IdentityToRef(this._cachedTextureMatrix);
@@ -152,7 +131,6 @@ var BABYLON;
                     break;
                 case BABYLON.Texture.PROJECTION_MODE:
                     BABYLON.Matrix.IdentityToRef(this._projectionModeMatrix);
-
                     this._projectionModeMatrix.m[0] = 0.5;
                     this._projectionModeMatrix.m[5] = -0.5;
                     this._projectionModeMatrix.m[10] = 0.0;
@@ -160,7 +138,6 @@ var BABYLON;
                     this._projectionModeMatrix.m[13] = 0.5;
                     this._projectionModeMatrix.m[14] = 1.0;
                     this._projectionModeMatrix.m[15] = 1.0;
-
                     this.getScene().getProjectionMatrix().multiplyToRef(this._projectionModeMatrix, this._cachedTextureMatrix);
                     break;
                 default:
@@ -169,10 +146,8 @@ var BABYLON;
             }
             return this._cachedTextureMatrix;
         };
-
         Texture.prototype.clone = function () {
             var newTexture = new BABYLON.Texture(this._texture.url, this.getScene(), this._noMipmap, this._invertY, this._samplingMode);
-
             // Base texture
             newTexture.hasAlpha = this.hasAlpha;
             newTexture.level = this.level;
@@ -180,7 +155,6 @@ var BABYLON;
             newTexture.wrapV = this.wrapV;
             newTexture.coordinatesIndex = this.coordinatesIndex;
             newTexture.coordinatesMode = this.coordinatesMode;
-
             // Texture
             newTexture.uOffset = this.uOffset;
             newTexture.vOffset = this.vOffset;
@@ -189,28 +163,25 @@ var BABYLON;
             newTexture.uAng = this.uAng;
             newTexture.vAng = this.vAng;
             newTexture.wAng = this.wAng;
-
             return newTexture;
         };
-
         // Statics
         Texture.CreateFromBase64String = function (data, name, scene, noMipmap, invertY, samplingMode, onLoad, onError) {
-            if (typeof samplingMode === "undefined") { samplingMode = Texture.TRILINEAR_SAMPLINGMODE; }
-            if (typeof onLoad === "undefined") { onLoad = null; }
-            if (typeof onError === "undefined") { onError = null; }
+            if (samplingMode === void 0) { samplingMode = Texture.TRILINEAR_SAMPLINGMODE; }
+            if (onLoad === void 0) { onLoad = null; }
+            if (onError === void 0) { onError = null; }
             return new Texture("data:" + name, scene, noMipmap, invertY, samplingMode, onLoad, onError, data);
         };
+        // Constants
         Texture.NEAREST_SAMPLINGMODE = 1;
         Texture.BILINEAR_SAMPLINGMODE = 2;
         Texture.TRILINEAR_SAMPLINGMODE = 3;
-
         Texture.EXPLICIT_MODE = 0;
         Texture.SPHERICAL_MODE = 1;
         Texture.PLANAR_MODE = 2;
         Texture.CUBIC_MODE = 3;
         Texture.PROJECTION_MODE = 4;
         Texture.SKYBOX_MODE = 5;
-
         Texture.CLAMP_ADDRESSMODE = 0;
         Texture.WRAP_ADDRESSMODE = 1;
         Texture.MIRROR_ADDRESSMODE = 2;
@@ -218,4 +189,4 @@ var BABYLON;
     })(BABYLON.BaseTexture);
     BABYLON.Texture = Texture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.texture.js.map
+//# sourceMappingURL=babylon.texture.js.map

Babylon/Materials/Textures/babylon.videoTexture.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,40 +9,32 @@ var BABYLON;
     var VideoTexture = (function (_super) {
         __extends(VideoTexture, _super);
         function VideoTexture(name, urls, size, scene, generateMipMaps, invertY, samplingMode) {
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             var _this = this;
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
             _super.call(this, null, scene, !generateMipMaps, invertY);
             this._autoLaunch = true;
-
             this.name = name;
-
             this.wrapU = BABYLON.Texture.WRAP_ADDRESSMODE;
             this.wrapV = BABYLON.Texture.WRAP_ADDRESSMODE;
-
             var requiredWidth = size.width || size;
             var requiredHeight = size.height || size;
-
             this._texture = scene.getEngine().createDynamicTexture(requiredWidth, requiredHeight, generateMipMaps, samplingMode);
             var textureSize = this.getSize();
-
             this.video = document.createElement("video");
             this.video.width = textureSize.width;
             this.video.height = textureSize.height;
             this.video.autoplay = false;
             this.video.loop = true;
-
             this.video.addEventListener("canplaythrough", function () {
                 if (_this._texture) {
                     _this._texture.isReady = true;
                 }
             });
-
             urls.forEach(function (url) {
                 var source = document.createElement("source");
                 source.src = url;
                 _this.video.appendChild(source);
             });
-
             this._lastUpdate = BABYLON.Tools.Now;
         }
         VideoTexture.prototype.update = function () {
@@ -50,13 +42,10 @@ var BABYLON;
                 this._autoLaunch = false;
                 this.video.play();
             }
-
             var now = BABYLON.Tools.Now;
-
             if (now - this._lastUpdate < 15) {
                 return false;
             }
-
             this._lastUpdate = now;
             this.getScene().getEngine().updateVideoTexture(this._texture, this.video, this._invertY);
             return true;
@@ -65,4 +54,4 @@ var BABYLON;
     })(BABYLON.Texture);
     BABYLON.VideoTexture = VideoTexture;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.videoTexture.js.map
+//# sourceMappingURL=babylon.videoTexture.js.map

Babylon/Materials/babylon.effect.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var EffectFallbacks = (function () {
         function EffectFallbacks() {
@@ -11,17 +11,13 @@
                 if (rank < this._currentRank) {
                     this._currentRank = rank;
                 }
-
                 if (rank > this._maxRank) {
                     this._maxRank = rank;
                 }
-
                 this._defines[rank] = new Array();
             }
-
             this._defines[rank].push(define);
         };
-
         Object.defineProperty(EffectFallbacks.prototype, "isMoreFallbacks", {
             get: function () {
                 return this._currentRank <= this._maxRank;
@@ -29,22 +25,17 @@
             enumerable: true,
             configurable: true
         });
-
         EffectFallbacks.prototype.reduce = function (currentDefines) {
             var currentFallbacks = this._defines[this._currentRank];
-
             for (var index = 0; index < currentFallbacks.length; index++) {
                 currentDefines = currentDefines.replace("#define " + currentFallbacks[index], "");
             }
-
             this._currentRank++;
-
             return currentDefines;
         };
         return EffectFallbacks;
     })();
     BABYLON.EffectFallbacks = EffectFallbacks;
-
     var Effect = (function () {
         function Effect(baseName, attributesNames, uniformsNames, samplers, engine, defines, fallbacks, onCompiled, onError) {
             var _this = this;
@@ -57,33 +48,28 @@
             this._uniformsNames = uniformsNames.concat(samplers);
             this._samplers = samplers;
             this._attributesNames = attributesNames;
-
             this.onError = onError;
             this.onCompiled = onCompiled;
-
             var vertexSource;
             var fragmentSource;
-
             if (baseName.vertexElement) {
                 vertexSource = document.getElementById(baseName.vertexElement);
-
                 if (!vertexSource) {
                     vertexSource = baseName.vertexElement;
                 }
-            } else {
+            }
+            else {
                 vertexSource = baseName.vertex || baseName;
             }
-
             if (baseName.fragmentElement) {
                 fragmentSource = document.getElementById(baseName.fragmentElement);
-
                 if (!fragmentSource) {
                     fragmentSource = baseName.fragmentElement;
                 }
-            } else {
+            }
+            else {
                 fragmentSource = baseName.fragment || baseName;
             }
-
             this._loadVertexShader(vertexSource, function (vertexCode) {
                 _this._loadFragmentShader(fragmentSource, function (fragmentCode) {
                     _this._prepareEffect(vertexCode, fragmentCode, attributesNames, defines, fallbacks);
@@ -94,45 +80,34 @@
         Effect.prototype.isReady = function () {
             return this._isReady;
         };
-
         Effect.prototype.getProgram = function () {
             return this._program;
         };
-
         Effect.prototype.getAttributesNames = function () {
             return this._attributesNames;
         };
-
         Effect.prototype.getAttributeLocation = function (index) {
             return this._attributes[index];
         };
-
         Effect.prototype.getAttributeLocationByName = function (name) {
             var index = this._attributesNames.indexOf(name);
-
             return this._attributes[index];
         };
-
         Effect.prototype.getAttributesCount = function () {
             return this._attributes.length;
         };
-
         Effect.prototype.getUniformIndex = function (uniformName) {
             return this._uniformsNames.indexOf(uniformName);
         };
-
         Effect.prototype.getUniform = function (uniformName) {
             return this._uniforms[this._uniformsNames.indexOf(uniformName)];
         };
-
         Effect.prototype.getSamplers = function () {
             return this._samplers;
         };
-
         Effect.prototype.getCompilationError = function () {
             return this._compilationError;
         };
-
         // Methods
         Effect.prototype._loadVertexShader = function (vertex, callback) {
             // DOM element ?
@@ -141,25 +116,21 @@
                 callback(vertexCode);
                 return;
             }
-
             // Is in local store ?
             if (Effect.ShadersStore[vertex + "VertexShader"]) {
                 callback(Effect.ShadersStore[vertex + "VertexShader"]);
                 return;
             }
-
             var vertexShaderUrl;
-
             if (vertex[0] === ".") {
                 vertexShaderUrl = vertex;
-            } else {
+            }
+            else {
                 vertexShaderUrl = BABYLON.Engine.ShadersRepository + vertex;
             }
-
             // Vertex shader
             BABYLON.Tools.LoadFile(vertexShaderUrl + ".vertex.fx", callback);
         };
-
         Effect.prototype._loadFragmentShader = function (fragment, callback) {
             // DOM element ?
             if (fragment instanceof HTMLElement) {
@@ -167,93 +138,77 @@
                 callback(fragmentCode);
                 return;
             }
-
             // Is in local store ?
             if (Effect.ShadersStore[fragment + "PixelShader"]) {
                 callback(Effect.ShadersStore[fragment + "PixelShader"]);
                 return;
             }
-
             if (Effect.ShadersStore[fragment + "FragmentShader"]) {
                 callback(Effect.ShadersStore[fragment + "FragmentShader"]);
                 return;
             }
-
             var fragmentShaderUrl;
-
             if (fragment[0] === ".") {
                 fragmentShaderUrl = fragment;
-            } else {
+            }
+            else {
                 fragmentShaderUrl = BABYLON.Engine.ShadersRepository + fragment;
             }
-
             // Fragment shader
             BABYLON.Tools.LoadFile(fragmentShaderUrl + ".fragment.fx", callback);
         };
-
         Effect.prototype._prepareEffect = function (vertexSourceCode, fragmentSourceCode, attributesNames, defines, fallbacks) {
-            try  {
+            try {
                 var engine = this._engine;
-
                 this._program = engine.createShaderProgram(vertexSourceCode, fragmentSourceCode, defines);
-
                 this._uniforms = engine.getUniforms(this._program, this._uniformsNames);
                 this._attributes = engine.getAttributes(this._program, attributesNames);
-
                 for (var index = 0; index < this._samplers.length; index++) {
                     var sampler = this.getUniform(this._samplers[index]);
-
                     if (sampler == null) {
                         this._samplers.splice(index, 1);
                         index--;
                     }
                 }
                 engine.bindSamplers(this);
-
                 this._isReady = true;
                 if (this.onCompiled) {
                     this.onCompiled(this);
                 }
-            } catch (e) {
+            }
+            catch (e) {
                 // Is it a problem with precision?
                 if (e.message.indexOf("highp") !== -1) {
                     vertexSourceCode = vertexSourceCode.replace("precision highp float", "precision mediump float");
                     fragmentSourceCode = fragmentSourceCode.replace("precision highp float", "precision mediump float");
-
                     this._prepareEffect(vertexSourceCode, fragmentSourceCode, attributesNames, defines, fallbacks);
-
                     return;
                 }
-
                 // Let's go through fallbacks then
                 if (fallbacks && fallbacks.isMoreFallbacks) {
                     defines = fallbacks.reduce(defines);
                     this._prepareEffect(vertexSourceCode, fragmentSourceCode, attributesNames, defines, fallbacks);
-                } else {
+                }
+                else {
                     BABYLON.Tools.Error("Unable to compile effect: " + this.name);
                     BABYLON.Tools.Error("Defines: " + defines);
                     BABYLON.Tools.Error("Error: " + e.message);
                     this._compilationError = e.message;
-
                     if (this.onError) {
                         this.onError(this, this._compilationError);
                     }
                 }
             }
         };
-
         Effect.prototype._bindTexture = function (channel, texture) {
             this._engine._bindTexture(this._samplers.indexOf(channel), texture);
         };
-
         Effect.prototype.setTexture = function (channel, texture) {
             this._engine.setTexture(this._samplers.indexOf(channel), texture);
         };
-
         Effect.prototype.setTextureFromPostProcess = function (channel, postProcess) {
             this._engine.setTextureFromPostProcess(this._samplers.indexOf(channel), postProcess);
         };
-
         //public _cacheMatrix(uniformName, matrix) {
         //    if (!this._valueCache[uniformName]) {
         //        this._valueCache[uniformName] = new BABYLON.Matrix();
@@ -267,151 +222,110 @@
                 this._valueCache[uniformName] = [x, y];
                 return;
             }
-
             this._valueCache[uniformName][0] = x;
             this._valueCache[uniformName][1] = y;
         };
-
         Effect.prototype._cacheFloat3 = function (uniformName, x, y, z) {
             if (!this._valueCache[uniformName]) {
                 this._valueCache[uniformName] = [x, y, z];
                 return;
             }
-
             this._valueCache[uniformName][0] = x;
             this._valueCache[uniformName][1] = y;
             this._valueCache[uniformName][2] = z;
         };
-
         Effect.prototype._cacheFloat4 = function (uniformName, x, y, z, w) {
             if (!this._valueCache[uniformName]) {
                 this._valueCache[uniformName] = [x, y, z, w];
                 return;
             }
-
             this._valueCache[uniformName][0] = x;
             this._valueCache[uniformName][1] = y;
             this._valueCache[uniformName][2] = z;
             this._valueCache[uniformName][3] = w;
         };
-
         Effect.prototype.setArray = function (uniformName, array) {
             this._engine.setArray(this.getUniform(uniformName), array);
-
             return this;
         };
-
         Effect.prototype.setMatrices = function (uniformName, matrices) {
             this._engine.setMatrices(this.getUniform(uniformName), matrices);
-
             return this;
         };
-
         Effect.prototype.setMatrix = function (uniformName, matrix) {
             //if (this._valueCache[uniformName] && this._valueCache[uniformName].equals(matrix))
             //    return;
             //this._cacheMatrix(uniformName, matrix);
             this._engine.setMatrix(this.getUniform(uniformName), matrix);
-
             return this;
         };
-
         Effect.prototype.setFloat = function (uniformName, value) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName] === value)
                 return this;
-
             this._valueCache[uniformName] = value;
-
             this._engine.setFloat(this.getUniform(uniformName), value);
-
             return this;
         };
-
         Effect.prototype.setBool = function (uniformName, bool) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName] === bool)
                 return this;
-
             this._valueCache[uniformName] = bool;
-
             this._engine.setBool(this.getUniform(uniformName), bool ? 1 : 0);
-
             return this;
         };
-
         Effect.prototype.setVector2 = function (uniformName, vector2) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName][0] === vector2.x && this._valueCache[uniformName][1] === vector2.y)
                 return this;
-
             this._cacheFloat2(uniformName, vector2.x, vector2.y);
             this._engine.setFloat2(this.getUniform(uniformName), vector2.x, vector2.y);
-
             return this;
         };
-
         Effect.prototype.setFloat2 = function (uniformName, x, y) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName][0] === x && this._valueCache[uniformName][1] === y)
                 return this;
-
             this._cacheFloat2(uniformName, x, y);
             this._engine.setFloat2(this.getUniform(uniformName), x, y);
-
             return this;
         };
-
         Effect.prototype.setVector3 = function (uniformName, vector3) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName][0] === vector3.x && this._valueCache[uniformName][1] === vector3.y && this._valueCache[uniformName][2] === vector3.z)
                 return this;
-
             this._cacheFloat3(uniformName, vector3.x, vector3.y, vector3.z);
-
             this._engine.setFloat3(this.getUniform(uniformName), vector3.x, vector3.y, vector3.z);
-
             return this;
         };
-
         Effect.prototype.setFloat3 = function (uniformName, x, y, z) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName][0] === x && this._valueCache[uniformName][1] === y && this._valueCache[uniformName][2] === z)
                 return this;
-
             this._cacheFloat3(uniformName, x, y, z);
             this._engine.setFloat3(this.getUniform(uniformName), x, y, z);
-
             return this;
         };
-
         Effect.prototype.setFloat4 = function (uniformName, x, y, z, w) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName][0] === x && this._valueCache[uniformName][1] === y && this._valueCache[uniformName][2] === z && this._valueCache[uniformName][3] === w)
                 return this;
-
             this._cacheFloat4(uniformName, x, y, z, w);
             this._engine.setFloat4(this.getUniform(uniformName), x, y, z, w);
-
             return this;
         };
-
         Effect.prototype.setColor3 = function (uniformName, color3) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName][0] === color3.r && this._valueCache[uniformName][1] === color3.g && this._valueCache[uniformName][2] === color3.b)
                 return this;
-
             this._cacheFloat3(uniformName, color3.r, color3.g, color3.b);
             this._engine.setColor3(this.getUniform(uniformName), color3);
-
             return this;
         };
-
         Effect.prototype.setColor4 = function (uniformName, color3, alpha) {
             if (this._valueCache[uniformName] && this._valueCache[uniformName][0] === color3.r && this._valueCache[uniformName][1] === color3.g && this._valueCache[uniformName][2] === color3.b && this._valueCache[uniformName][3] === alpha)
                 return this;
-
             this._cacheFloat4(uniformName, color3.r, color3.g, color3.b, alpha);
             this._engine.setColor4(this.getUniform(uniformName), color3, alpha);
-
             return this;
         };
-
+        // Statics
         Effect.ShadersStore = {};
         return Effect;
     })();
     BABYLON.Effect = Effect;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.effect.js.map
+//# sourceMappingURL=babylon.effect.js.map

Babylon/Materials/babylon.material.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var Material = (function () {
         function Material(name, scene, doNotAdd) {
@@ -12,9 +12,7 @@
             this._fillMode = Material.TriangleFillMode;
             this.pointSize = 1.0;
             this.id = name;
-
             this._scene = scene;
-
             if (!doNotAdd) {
                 scene.materials.push(this);
             }
@@ -26,7 +24,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Material, "WireFrameFillMode", {
             get: function () {
                 return Material._WireFrameFillMode;
@@ -34,7 +31,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Material, "PointFillMode", {
             get: function () {
                 return Material._PointFillMode;
@@ -42,7 +38,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(Material.prototype, "wireframe", {
             get: function () {
                 return this._fillMode === Material.WireFrameFillMode;
@@ -53,8 +48,6 @@
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(Material.prototype, "pointsCloud", {
             get: function () {
                 return this._fillMode === Material.PointFillMode;
@@ -65,8 +58,6 @@
             enumerable: true,
             configurable: true
         });
-
-
         Object.defineProperty(Material.prototype, "fillMode", {
             get: function () {
                 return this._fillMode;
@@ -77,67 +68,50 @@
             enumerable: true,
             configurable: true
         });
-
-
         Material.prototype.isReady = function (mesh, useInstances) {
             return true;
         };
-
         Material.prototype.getEffect = function () {
             return this._effect;
         };
-
         Material.prototype.getScene = function () {
             return this._scene;
         };
-
         Material.prototype.needAlphaBlending = function () {
             return (this.alpha < 1.0);
         };
-
         Material.prototype.needAlphaTesting = function () {
             return false;
         };
-
         Material.prototype.getAlphaTestTexture = function () {
             return null;
         };
-
         Material.prototype.trackCreation = function (onCompiled, onError) {
         };
-
         Material.prototype._preBind = function () {
             var engine = this._scene.getEngine();
-
             engine.enableEffect(this._effect);
             engine.setState(this.backFaceCulling);
         };
-
         Material.prototype.bind = function (world, mesh) {
             this._scene._cachedMaterial = this;
-
             if (this.onBind) {
                 this.onBind(this);
             }
         };
-
         Material.prototype.bindOnlyWorldMatrix = function (world) {
         };
-
         Material.prototype.unbind = function () {
         };
-
         Material.prototype.dispose = function (forceDisposeEffect) {
             // Remove from scene
             var index = this._scene.materials.indexOf(this);
             this._scene.materials.splice(index, 1);
-
             // Shader are kept in cache for further use but we can get rid of this by using forceDisposeEffect
             if (forceDisposeEffect && this._effect) {
                 this._scene.getEngine()._releaseEffect(this._effect);
                 this._effect = null;
             }
-
             // Callback
             if (this.onDispose) {
                 this.onDispose();
@@ -150,4 +124,4 @@
     })();
     BABYLON.Material = Material;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.material.js.map
+//# sourceMappingURL=babylon.material.js.map

Babylon/Materials/babylon.multiMaterial.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -11,7 +11,6 @@ var BABYLON;
         function MultiMaterial(name, scene) {
             _super.call(this, name, scene, true);
             this.subMaterials = new Array();
-
             scene.multiMaterials.push(this);
         }
         // Properties
@@ -19,10 +18,8 @@ var BABYLON;
             if (index < 0 || index >= this.subMaterials.length) {
                 return this.getScene().defaultMaterial;
             }
-
             return this.subMaterials[index];
         };
-
         // Methods
         MultiMaterial.prototype.isReady = function (mesh) {
             for (var index = 0; index < this.subMaterials.length; index++) {
@@ -33,11 +30,10 @@ var BABYLON;
                     }
                 }
             }
-
             return true;
         };
         return MultiMaterial;
     })(BABYLON.Material);
     BABYLON.MultiMaterial = MultiMaterial;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.multiMaterial.js.map
+//# sourceMappingURL=babylon.multiMaterial.js.map

Babylon/Materials/babylon.shaderMaterial.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -20,195 +20,148 @@ var BABYLON;
             this._matrices = new Array();
             this._cachedWorldViewMatrix = new BABYLON.Matrix();
             this._shaderPath = shaderPath;
-
             options.needAlphaBlending = options.needAlphaBlending || false;
             options.needAlphaTesting = options.needAlphaTesting || false;
             options.attributes = options.attributes || ["position", "normal", "uv"];
             options.uniforms = options.uniforms || ["worldViewProjection"];
             options.samplers = options.samplers || [];
-
             this._options = options;
         }
         ShaderMaterial.prototype.needAlphaBlending = function () {
             return this._options.needAlphaBlending;
         };
-
         ShaderMaterial.prototype.needAlphaTesting = function () {
             return this._options.needAlphaTesting;
         };
-
         ShaderMaterial.prototype._checkUniform = function (uniformName) {
             if (this._options.uniforms.indexOf(uniformName) === -1) {
                 this._options.uniforms.push(uniformName);
             }
         };
-
         ShaderMaterial.prototype.setTexture = function (name, texture) {
             if (this._options.samplers.indexOf(name) === -1) {
                 this._options.samplers.push(name);
             }
             this._textures[name] = texture;
-
             return this;
         };
-
         ShaderMaterial.prototype.setFloat = function (name, value) {
             this._checkUniform(name);
             this._floats[name] = value;
-
             return this;
         };
-
         ShaderMaterial.prototype.setFloats = function (name, value) {
             this._checkUniform(name);
             this._floatsArrays[name] = value;
-
             return this;
         };
-
         ShaderMaterial.prototype.setColor3 = function (name, value) {
             this._checkUniform(name);
             this._colors3[name] = value;
-
             return this;
         };
-
         ShaderMaterial.prototype.setColor4 = function (name, value) {
             this._checkUniform(name);
             this._colors4[name] = value;
-
             return this;
         };
-
         ShaderMaterial.prototype.setVector2 = function (name, value) {
             this._checkUniform(name);
             this._vectors2[name] = value;
-
             return this;
         };
-
         ShaderMaterial.prototype.setVector3 = function (name, value) {
             this._checkUniform(name);
             this._vectors3[name] = value;
-
             return this;
         };
-
         ShaderMaterial.prototype.setMatrix = function (name, value) {
             this._checkUniform(name);
             this._matrices[name] = value;
-
             return this;
         };
-
         ShaderMaterial.prototype.isReady = function () {
             var scene = this.getScene();
             var engine = scene.getEngine();
-
             if (!this.checkReadyOnEveryCall) {
                 if (this._renderId === scene.getRenderId()) {
                     return true;
                 }
             }
-
             var previousEffect = this._effect;
             this._effect = engine.createEffect(this._shaderPath, this._options.attributes, this._options.uniforms, this._options.samplers, "", null, this.onCompiled, this.onError);
-
             if (!this._effect.isReady()) {
                 return false;
             }
-
             if (previousEffect !== this._effect) {
                 scene.resetCachedMaterial();
             }
-
             this._renderId = scene.getRenderId();
-
             return true;
         };
-
         ShaderMaterial.prototype.bindOnlyWorldMatrix = function (world) {
             var scene = this.getScene();
-
             if (this._options.uniforms.indexOf("world") !== -1) {
                 this._effect.setMatrix("world", world);
             }
-
             if (this._options.uniforms.indexOf("worldView") !== -1) {
                 world.multiplyToRef(scene.getViewMatrix(), this._cachedWorldViewMatrix);
                 this._effect.setMatrix("worldView", this._cachedWorldViewMatrix);
             }
-
             if (this._options.uniforms.indexOf("worldViewProjection") !== -1) {
                 this._effect.setMatrix("worldViewProjection", world.multiply(scene.getTransformMatrix()));
             }
         };
-
         ShaderMaterial.prototype.bind = function (world) {
             // Std values
             this.bindOnlyWorldMatrix(world);
-
             if (this.getScene().getCachedMaterial() !== this) {
                 if (this._options.uniforms.indexOf("view") !== -1) {
                     this._effect.setMatrix("view", this.getScene().getViewMatrix());
                 }
-
                 if (this._options.uniforms.indexOf("projection") !== -1) {
                     this._effect.setMatrix("projection", this.getScene().getProjectionMatrix());
                 }
-
                 if (this._options.uniforms.indexOf("viewProjection") !== -1) {
                     this._effect.setMatrix("viewProjection", this.getScene().getTransformMatrix());
                 }
-
                 for (var name in this._textures) {
                     this._effect.setTexture(name, this._textures[name]);
                 }
-
                 for (name in this._floats) {
                     this._effect.setFloat(name, this._floats[name]);
                 }
-
                 for (name in this._floatsArrays) {
                     this._effect.setArray(name, this._floatsArrays[name]);
                 }
-
                 for (name in this._colors3) {
                     this._effect.setColor3(name, this._colors3[name]);
                 }
-
                 for (name in this._colors4) {
                     var color = this._colors4[name];
                     this._effect.setFloat4(name, color.r, color.g, color.b, color.a);
                 }
-
                 for (name in this._vectors2) {
                     this._effect.setVector2(name, this._vectors2[name]);
                 }
-
                 for (name in this._vectors3) {
                     this._effect.setVector3(name, this._vectors3[name]);
                 }
-
                 for (name in this._matrices) {
                     this._effect.setMatrix(name, this._matrices[name]);
                 }
             }
-
             _super.prototype.bind.call(this, world, null);
         };
-
         ShaderMaterial.prototype.dispose = function (forceDisposeEffect) {
             for (var name in this._textures) {
                 this._textures[name].dispose();
             }
-
             this._textures = [];
-
             _super.prototype.dispose.call(this, forceDisposeEffect);
         };
         return ShaderMaterial;
     })(BABYLON.Material);
     BABYLON.ShaderMaterial = ShaderMaterial;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.shaderMaterial.js.map
+//# sourceMappingURL=babylon.shaderMaterial.js.map

Babylon/Mesh/babylon.InstancedMesh.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -6,27 +6,23 @@
 };
 var BABYLON;
 (function (BABYLON) {
+    /**
+     * Creates an instance based on a source mesh.
+     */
     var InstancedMesh = (function (_super) {
         __extends(InstancedMesh, _super);
         function InstancedMesh(name, source) {
             _super.call(this, name, source.getScene());
-
             source.instances.push(this);
-
             this._sourceMesh = source;
-
             this.position.copyFrom(source.position);
             this.rotation.copyFrom(source.rotation);
             this.scaling.copyFrom(source.scaling);
-
             if (source.rotationQuaternion) {
                 this.rotationQuaternion = source.rotationQuaternion.clone();
             }
-
             this.infiniteDistance = source.infiniteDistance;
-
             this.setPivotMatrix(source.getPivotMatrix());
-
             this.refreshBoundingInfo();
             this._syncSubMeshes();
         }
@@ -38,7 +34,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(InstancedMesh.prototype, "material", {
             get: function () {
                 return this._sourceMesh.material;
@@ -46,7 +41,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(InstancedMesh.prototype, "visibility", {
             get: function () {
                 return this._sourceMesh.visibility;
@@ -54,7 +48,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(InstancedMesh.prototype, "skeleton", {
             get: function () {
                 return this._sourceMesh.skeleton;
@@ -62,11 +55,9 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         InstancedMesh.prototype.getTotalVertices = function () {
             return this._sourceMesh.getTotalVertices();
         };
-
         Object.defineProperty(InstancedMesh.prototype, "sourceMesh", {
             get: function () {
                 return this._sourceMesh;
@@ -74,19 +65,15 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         InstancedMesh.prototype.getVerticesData = function (kind) {
             return this._sourceMesh.getVerticesData(kind);
         };
-
         InstancedMesh.prototype.isVerticesDataPresent = function (kind) {
             return this._sourceMesh.isVerticesDataPresent(kind);
         };
-
         InstancedMesh.prototype.getIndices = function () {
             return this._sourceMesh.getIndices();
         };
-
         Object.defineProperty(InstancedMesh.prototype, "_positions", {
             get: function () {
                 return this._sourceMesh._positions;
@@ -94,40 +81,31 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         InstancedMesh.prototype.refreshBoundingInfo = function () {
             var data = this._sourceMesh.getVerticesData(BABYLON.VertexBuffer.PositionKind);
-
             if (data) {
                 var extend = BABYLON.Tools.ExtractMinAndMax(data, 0, this._sourceMesh.getTotalVertices());
                 this._boundingInfo = new BABYLON.BoundingInfo(extend.minimum, extend.maximum);
             }
-
             this._updateBoundingInfo();
         };
-
         InstancedMesh.prototype._preActivate = function () {
             if (this._currentLOD) {
                 this._currentLOD._preActivate();
             }
         };
-
         InstancedMesh.prototype._activate = function (renderId) {
             if (this._currentLOD) {
                 this._currentLOD._registerInstanceForRenderId(this, renderId);
             }
         };
-
         InstancedMesh.prototype.getLOD = function (camera) {
             this._currentLOD = this.sourceMesh.getLOD(this.getScene().activeCamera, this.getBoundingInfo().boundingSphere);
-
             if (this._currentLOD === this.sourceMesh) {
                 return this;
             }
-
             return this._currentLOD;
         };
-
         InstancedMesh.prototype._syncSubMeshes = function () {
             this.releaseSubMeshes();
             if (this._sourceMesh.subMeshes) {
@@ -136,51 +114,40 @@ var BABYLON;
                 }
             }
         };
-
         InstancedMesh.prototype._generatePointsArray = function () {
             return this._sourceMesh._generatePointsArray();
         };
-
         // Clone
         InstancedMesh.prototype.clone = function (name, newParent, doNotCloneChildren) {
             var result = this._sourceMesh.createInstance(name);
-
             // Deep copy
             BABYLON.Tools.DeepCopy(this, result, ["name"], []);
-
             // Bounding info
             this.refreshBoundingInfo();
-
             // Parent
             if (newParent) {
                 result.parent = newParent;
             }
-
             if (!doNotCloneChildren) {
                 for (var index = 0; index < this.getScene().meshes.length; index++) {
                     var mesh = this.getScene().meshes[index];
-
-                    if (mesh.parent == this) {
+                    if (mesh.parent === this) {
                         mesh.clone(mesh.name, result);
                     }
                 }
             }
-
             result.computeWorldMatrix(true);
-
             return result;
         };
-
         // Dispoe
         InstancedMesh.prototype.dispose = function (doNotRecurse) {
             // Remove from mesh
             var index = this._sourceMesh.instances.indexOf(this);
             this._sourceMesh.instances.splice(index, 1);
-
             _super.prototype.dispose.call(this, doNotRecurse);
         };
         return InstancedMesh;
     })(BABYLON.AbstractMesh);
     BABYLON.InstancedMesh = InstancedMesh;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.instancedMesh.js.map
+//# sourceMappingURL=babylon.instancedMesh.js.map

Babylon/Mesh/babylon.abstractMesh.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -11,6 +11,7 @@ var BABYLON;
         function AbstractMesh(name, scene) {
             _super.call(this, name, scene);
             // Properties
+            this.definedFacingForward = true; // orientation for POV movement & rotation
             this.position = new BABYLON.Vector3(0, 0, 0);
             this.rotation = new BABYLON.Vector3(0, 0, 0);
             this.scaling = new BABYLON.Vector3(1, 1, 1);
@@ -68,7 +69,6 @@ var BABYLON;
             this._renderId = 0;
             this._intersectionsInProgress = new Array();
             this._onAfterWorldMatrixUpdate = new Array();
-
             scene.meshes.push(this);
         }
         Object.defineProperty(AbstractMesh, "BILLBOARDMODE_NONE", {
@@ -78,7 +78,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(AbstractMesh, "BILLBOARDMODE_X", {
             get: function () {
                 return AbstractMesh._BILLBOARDMODE_X;
@@ -86,7 +85,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(AbstractMesh, "BILLBOARDMODE_Y", {
             get: function () {
                 return AbstractMesh._BILLBOARDMODE_Y;
@@ -94,7 +92,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(AbstractMesh, "BILLBOARDMODE_Z", {
             get: function () {
                 return AbstractMesh._BILLBOARDMODE_Z;
@@ -102,7 +99,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(AbstractMesh, "BILLBOARDMODE_ALL", {
             get: function () {
                 return AbstractMesh._BILLBOARDMODE_ALL;
@@ -110,7 +106,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(AbstractMesh.prototype, "isBlocked", {
             // Methods
             get: function () {
@@ -119,56 +114,44 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         AbstractMesh.prototype.getLOD = function (camera) {
             return this;
         };
-
         AbstractMesh.prototype.getTotalVertices = function () {
             return 0;
         };
-
         AbstractMesh.prototype.getIndices = function () {
             return null;
         };
-
         AbstractMesh.prototype.getVerticesData = function (kind) {
             return null;
         };
-
         AbstractMesh.prototype.isVerticesDataPresent = function (kind) {
             return false;
         };
-
         AbstractMesh.prototype.getBoundingInfo = function () {
             if (this._masterMesh) {
                 return this._masterMesh.getBoundingInfo();
             }
-
             if (!this._boundingInfo) {
                 this._updateBoundingInfo();
             }
             return this._boundingInfo;
         };
-
         AbstractMesh.prototype._preActivate = function () {
         };
-
         AbstractMesh.prototype._activate = function (renderId) {
             this._renderId = renderId;
         };
-
         AbstractMesh.prototype.getWorldMatrix = function () {
             if (this._masterMesh) {
                 return this._masterMesh.getWorldMatrix();
             }
-
             if (this._currentRenderId !== this.getScene().getRenderId()) {
                 this.computeWorldMatrix();
             }
             return this._worldMatrix;
         };
-
         Object.defineProperty(AbstractMesh.prototype, "worldMatrixFromCache", {
             get: function () {
                 return this._worldMatrix;
@@ -176,7 +159,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(AbstractMesh.prototype, "absolutePosition", {
             get: function () {
                 return this._absolutePosition;
@@ -184,53 +166,46 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         AbstractMesh.prototype.rotate = function (axis, amount, space) {
             if (!this.rotationQuaternion) {
                 this.rotationQuaternion = BABYLON.Quaternion.RotationYawPitchRoll(this.rotation.y, this.rotation.x, this.rotation.z);
                 this.rotation = BABYLON.Vector3.Zero();
             }
-
             if (!space || space == 0 /* LOCAL */) {
                 var rotationQuaternion = BABYLON.Quaternion.RotationAxis(axis, amount);
                 this.rotationQuaternion = this.rotationQuaternion.multiply(rotationQuaternion);
-            } else {
+            }
+            else {
                 if (this.parent) {
                     var invertParentWorldMatrix = this.parent.getWorldMatrix().clone();
                     invertParentWorldMatrix.invert();
-
                     axis = BABYLON.Vector3.TransformNormal(axis, invertParentWorldMatrix);
                 }
                 rotationQuaternion = BABYLON.Quaternion.RotationAxis(axis, amount);
                 this.rotationQuaternion = rotationQuaternion.multiply(this.rotationQuaternion);
             }
         };
-
         AbstractMesh.prototype.translate = function (axis, distance, space) {
             var displacementVector = axis.scale(distance);
-
             if (!space || space == 0 /* LOCAL */) {
                 var tempV3 = this.getPositionExpressedInLocalSpace().add(displacementVector);
                 this.setPositionWithLocalVector(tempV3);
-            } else {
+            }
+            else {
                 this.setAbsolutePosition(this.getAbsolutePosition().add(displacementVector));
             }
         };
-
         AbstractMesh.prototype.getAbsolutePosition = function () {
             this.computeWorldMatrix();
             return this._absolutePosition;
         };
-
         AbstractMesh.prototype.setAbsolutePosition = function (absolutePosition) {
             if (!absolutePosition) {
                 return;
             }
-
             var absolutePositionX;
             var absolutePositionY;
             var absolutePositionZ;
-
             if (absolutePosition.x === undefined) {
                 if (arguments.length < 3) {
                     return;
@@ -238,78 +213,116 @@ var BABYLON;
                 absolutePositionX = arguments[0];
                 absolutePositionY = arguments[1];
                 absolutePositionZ = arguments[2];
-            } else {
+            }
+            else {
                 absolutePositionX = absolutePosition.x;
                 absolutePositionY = absolutePosition.y;
                 absolutePositionZ = absolutePosition.z;
             }
-
             if (this.parent) {
                 var invertParentWorldMatrix = this.parent.getWorldMatrix().clone();
                 invertParentWorldMatrix.invert();
-
                 var worldPosition = new BABYLON.Vector3(absolutePositionX, absolutePositionY, absolutePositionZ);
-
                 this.position = BABYLON.Vector3.TransformCoordinates(worldPosition, invertParentWorldMatrix);
-            } else {
+            }
+            else {
                 this.position.x = absolutePositionX;
                 this.position.y = absolutePositionY;
                 this.position.z = absolutePositionZ;
             }
         };
-
+        // ================================== Point of View Movement =================================
+        /**
+         * Perform relative position change from the point of view of behind the front of the mesh.
+         * This is performed taking into account the meshes current rotation, so you do not have to care.
+         * Supports definition of mesh facing forward or backward.
+         * @param {number} amountRight
+         * @param {number} amountUp
+         * @param {number} amountForward
+         */
+        AbstractMesh.prototype.movePOV = function (amountRight, amountUp, amountForward) {
+            this.position.addInPlace(this.calcMovePOV(amountRight, amountUp, amountForward));
+        };
+        /**
+         * Calculate relative position change from the point of view of behind the front of the mesh.
+         * This is performed taking into account the meshes current rotation, so you do not have to care.
+         * Supports definition of mesh facing forward or backward.
+         * @param {number} amountRight
+         * @param {number} amountUp
+         * @param {number} amountForward
+         */
+        AbstractMesh.prototype.calcMovePOV = function (amountRight, amountUp, amountForward) {
+            var rotMatrix = new BABYLON.Matrix();
+            var rotQuaternion = (this.rotationQuaternion) ? this.rotationQuaternion : BABYLON.Quaternion.RotationYawPitchRoll(this.rotation.y, this.rotation.x, this.rotation.z);
+            rotQuaternion.toRotationMatrix(rotMatrix);
+            var translationDelta = BABYLON.Vector3.Zero();
+            var defForwardMult = this.definedFacingForward ? -1 : 1;
+            BABYLON.Vector3.TransformCoordinatesFromFloatsToRef(amountRight * defForwardMult, amountUp, amountForward * defForwardMult, rotMatrix, translationDelta);
+            return translationDelta;
+        };
+        // ================================== Point of View Rotation =================================
+        /**
+         * Perform relative rotation change from the point of view of behind the front of the mesh.
+         * Supports definition of mesh facing forward or backward.
+         * @param {number} flipBack
+         * @param {number} twirlClockwise
+         * @param {number} tiltRight
+         */
+        AbstractMesh.prototype.rotatePOV = function (flipBack, twirlClockwise, tiltRight) {
+            this.rotation.addInPlace(this.calcRotatePOV(flipBack, twirlClockwise, tiltRight));
+        };
+        /**
+         * Calculate relative rotation change from the point of view of behind the front of the mesh.
+         * Supports definition of mesh facing forward or backward.
+         * @param {number} flipBack
+         * @param {number} twirlClockwise
+         * @param {number} tiltRight
+         */
+        AbstractMesh.prototype.calcRotatePOV = function (flipBack, twirlClockwise, tiltRight) {
+            var defForwardMult = this.definedFacingForward ? 1 : -1;
+            return new BABYLON.Vector3(flipBack * defForwardMult, twirlClockwise, tiltRight * defForwardMult);
+        };
         AbstractMesh.prototype.setPivotMatrix = function (matrix) {
             this._pivotMatrix = matrix;
             this._cache.pivotMatrixUpdated = true;
         };
-
         AbstractMesh.prototype.getPivotMatrix = function () {
             return this._pivotMatrix;
         };
-
         AbstractMesh.prototype._isSynchronized = function () {
             if (this._isDirty) {
                 return false;
             }
-
             if (this.billboardMode !== AbstractMesh.BILLBOARDMODE_NONE)
                 return false;
-
             if (this._cache.pivotMatrixUpdated) {
                 return false;
             }
-
             if (this.infiniteDistance) {
                 return false;
             }
-
             if (!this._cache.position.equals(this.position))
                 return false;
-
             if (this.rotationQuaternion) {
                 if (!this._cache.rotationQuaternion.equals(this.rotationQuaternion))
                     return false;
-            } else {
+            }
+            else {
                 if (!this._cache.rotation.equals(this.rotation))
                     return false;
             }
-
             if (!this._cache.scaling.equals(this.scaling))
                 return false;
-
             return true;
         };
-
         AbstractMesh.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
-
             this._cache.localMatrixUpdated = false;
             this._cache.position = BABYLON.Vector3.Zero();
             this._cache.scaling = BABYLON.Vector3.Zero();
             this._cache.rotation = BABYLON.Vector3.Zero();
             this._cache.rotationQuaternion = new BABYLON.Quaternion(0, 0, 0, 0);
         };
-
         AbstractMesh.prototype.markAsDirty = function (property) {
             if (property === "rotation") {
                 this.rotationQuaternion = null;
@@ -317,79 +330,65 @@ var BABYLON;
             this._currentRenderId = Number.MAX_VALUE;
             this._isDirty = true;
         };
-
         AbstractMesh.prototype._updateBoundingInfo = function () {
             this._boundingInfo = this._boundingInfo || new BABYLON.BoundingInfo(this.absolutePosition, this.absolutePosition);
-
             this._boundingInfo._update(this.worldMatrixFromCache);
-
             this._updateSubMeshesBoundingInfo(this.worldMatrixFromCache);
         };
-
         AbstractMesh.prototype._updateSubMeshesBoundingInfo = function (matrix) {
             if (!this.subMeshes) {
                 return;
             }
-
             for (var subIndex = 0; subIndex < this.subMeshes.length; subIndex++) {
                 var subMesh = this.subMeshes[subIndex];
-
                 subMesh.updateBoundingInfo(matrix);
             }
         };
-
         AbstractMesh.prototype.computeWorldMatrix = function (force) {
             if (!force && (this._currentRenderId == this.getScene().getRenderId() || this.isSynchronized(true))) {
                 return this._worldMatrix;
             }
-
             this._cache.position.copyFrom(this.position);
             this._cache.scaling.copyFrom(this.scaling);
             this._cache.pivotMatrixUpdated = false;
             this._currentRenderId = this.getScene().getRenderId();
             this._isDirty = false;
-
             // Scaling
             BABYLON.Matrix.ScalingToRef(this.scaling.x, this.scaling.y, this.scaling.z, this._localScaling);
-
             // Rotation
             if (this.rotationQuaternion) {
                 this.rotationQuaternion.toRotationMatrix(this._localRotation);
                 this._cache.rotationQuaternion.copyFrom(this.rotationQuaternion);
-            } else {
+            }
+            else {
                 BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._localRotation);
                 this._cache.rotation.copyFrom(this.rotation);
             }
-
             // Translation
             if (this.infiniteDistance && !this.parent) {
                 var camera = this.getScene().activeCamera;
                 var cameraWorldMatrix = camera.getWorldMatrix();
-
                 var cameraGlobalPosition = new BABYLON.Vector3(cameraWorldMatrix.m[12], cameraWorldMatrix.m[13], cameraWorldMatrix.m[14]);
-
                 BABYLON.Matrix.TranslationToRef(this.position.x + cameraGlobalPosition.x, this.position.y + cameraGlobalPosition.y, this.position.z + cameraGlobalPosition.z, this._localTranslation);
-            } else {
+            }
+            else {
                 BABYLON.Matrix.TranslationToRef(this.position.x, this.position.y, this.position.z, this._localTranslation);
             }
-
             // Composing transformations
             this._pivotMatrix.multiplyToRef(this._localScaling, this._localPivotScaling);
             this._localPivotScaling.multiplyToRef(this._localRotation, this._localPivotScalingRotation);
-
             // Billboarding
             if (this.billboardMode !== AbstractMesh.BILLBOARDMODE_NONE && this.getScene().activeCamera) {
                 var localPosition = this.position.clone();
                 var zero = this.getScene().activeCamera.position.clone();
-
                 if (this.parent && this.parent.position) {
                     localPosition.addInPlace(this.parent.position);
                     BABYLON.Matrix.TranslationToRef(localPosition.x, localPosition.y, localPosition.z, this._localTranslation);
                 }
-
                 if ((this.billboardMode & AbstractMesh.BILLBOARDMODE_ALL) === AbstractMesh.BILLBOARDMODE_ALL) {
                     zero = this.getScene().activeCamera.position;
-                } else {
+                }
+                else {
                     if (this.billboardMode & BABYLON.AbstractMesh.BILLBOARDMODE_X)
                         zero.x = localPosition.x + BABYLON.Engine.Epsilon;
                     if (this.billboardMode & BABYLON.AbstractMesh.BILLBOARDMODE_Y)
@@ -397,39 +396,30 @@ var BABYLON;
                     if (this.billboardMode & BABYLON.AbstractMesh.BILLBOARDMODE_Z)
                         zero.z = localPosition.z + 0.001;
                 }
-
                 BABYLON.Matrix.LookAtLHToRef(localPosition, zero, BABYLON.Vector3.Up(), this._localBillboard);
                 this._localBillboard.m[12] = this._localBillboard.m[13] = this._localBillboard.m[14] = 0;
-
                 this._localBillboard.invert();
-
                 this._localPivotScalingRotation.multiplyToRef(this._localBillboard, this._localWorld);
                 this._rotateYByPI.multiplyToRef(this._localWorld, this._localPivotScalingRotation);
             }
-
             // Local world
             this._localPivotScalingRotation.multiplyToRef(this._localTranslation, this._localWorld);
-
             // Parent
             if (this.parent && this.parent.getWorldMatrix && this.billboardMode === BABYLON.AbstractMesh.BILLBOARDMODE_NONE) {
                 this._localWorld.multiplyToRef(this.parent.getWorldMatrix(), this._worldMatrix);
-            } else {
+            }
+            else {
                 this._worldMatrix.copyFrom(this._localWorld);
             }
-
             // Bounding info
             this._updateBoundingInfo();
-
             // Absolute position
             this._absolutePosition.copyFromFloats(this._worldMatrix.m[12], this._worldMatrix.m[13], this._worldMatrix.m[14]);
-
             for (var callbackIndex = 0; callbackIndex < this._onAfterWorldMatrixUpdate.length; callbackIndex++) {
                 this._onAfterWorldMatrixUpdate[callbackIndex](this);
             }
-
             return this._worldMatrix;
         };
-
         /**
         * If you'd like to be callbacked after the mesh position, rotation or scaling has been updated
         * @param func: callback function to add
@@ -437,35 +427,26 @@ var BABYLON;
         AbstractMesh.prototype.registerAfterWorldMatrixUpdate = function (func) {
             this._onAfterWorldMatrixUpdate.push(func);
         };
-
         AbstractMesh.prototype.unregisterAfterWorldMatrixUpdate = function (func) {
             var index = this._onAfterWorldMatrixUpdate.indexOf(func);
-
             if (index > -1) {
                 this._onAfterWorldMatrixUpdate.splice(index, 1);
             }
         };
-
         AbstractMesh.prototype.setPositionWithLocalVector = function (vector3) {
             this.computeWorldMatrix();
-
             this.position = BABYLON.Vector3.TransformNormal(vector3, this._localWorld);
         };
-
         AbstractMesh.prototype.getPositionExpressedInLocalSpace = function () {
             this.computeWorldMatrix();
             var invLocalWorldMatrix = this._localWorld.clone();
             invLocalWorldMatrix.invert();
-
             return BABYLON.Vector3.TransformNormal(this.position, invLocalWorldMatrix);
         };
-
         AbstractMesh.prototype.locallyTranslate = function (vector3) {
             this.computeWorldMatrix();
-
             this.position = BABYLON.Vector3.TransformCoordinates(vector3, this._localWorld);
         };
-
         AbstractMesh.prototype.lookAt = function (targetPoint, yawCor, pitchCor, rollCor) {
             /// <summary>Orients a mesh towards a target point. Mesh must be drawn facing user.</summary>
             /// <param name="targetPoint" type="BABYLON.Vector3">The position (must be in same space as current mesh) to look at</param>
@@ -473,200 +454,154 @@ var BABYLON;
             /// <param name="pitchCor" type="Number">optional pitch (x-axis) correction in radians</param>
             /// <param name="rollCor" type="Number">optional roll (z-axis) correction in radians</param>
             /// <returns>Mesh oriented towards targetMesh</returns>
-            yawCor = yawCor || 0; // default to zero if undefined
+            yawCor = yawCor || 0; // default to zero if undefined 
             pitchCor = pitchCor || 0;
             rollCor = rollCor || 0;
-
             var dv = targetPoint.subtract(this.position);
             var yaw = -Math.atan2(dv.z, dv.x) - Math.PI / 2;
             var len = Math.sqrt(dv.x * dv.x + dv.z * dv.z);
             var pitch = Math.atan2(dv.y, len);
             this.rotationQuaternion = BABYLON.Quaternion.RotationYawPitchRoll(yaw + yawCor, pitch + pitchCor, rollCor);
         };
-
         AbstractMesh.prototype.isInFrustum = function (frustumPlanes) {
             if (!this._boundingInfo.isInFrustum(frustumPlanes)) {
                 return false;
             }
-
             return true;
         };
-
         AbstractMesh.prototype.isCompletelyInFrustum = function (camera) {
             if (!camera) {
                 camera = this.getScene().activeCamera;
             }
-
             var transformMatrix = camera.getViewMatrix().multiply(camera.getProjectionMatrix());
-
             if (!this._boundingInfo.isCompletelyInFrustum(BABYLON.Frustum.GetPlanes(transformMatrix))) {
                 return false;
             }
-
             return true;
         };
-
         AbstractMesh.prototype.intersectsMesh = function (mesh, precise) {
             if (!this._boundingInfo || !mesh._boundingInfo) {
                 return false;
             }
-
             return this._boundingInfo.intersects(mesh._boundingInfo, precise);
         };
-
         AbstractMesh.prototype.intersectsPoint = function (point) {
             if (!this._boundingInfo) {
                 return false;
             }
-
             return this._boundingInfo.intersectsPoint(point);
         };
-
         // Physics
         AbstractMesh.prototype.setPhysicsState = function (impostor, options) {
             var physicsEngine = this.getScene().getPhysicsEngine();
-
             if (!physicsEngine) {
                 return;
             }
-
             if (impostor.impostor) {
                 // Old API
                 options = impostor;
                 impostor = impostor.impostor;
             }
-
             impostor = impostor || BABYLON.PhysicsEngine.NoImpostor;
-
             if (impostor === BABYLON.PhysicsEngine.NoImpostor) {
                 physicsEngine._unregisterMesh(this);
                 return;
             }
-
             options.mass = options.mass || 0;
             options.friction = options.friction || 0.2;
             options.restitution = options.restitution || 0.2;
-
             this._physicImpostor = impostor;
             this._physicsMass = options.mass;
             this._physicsFriction = options.friction;
             this._physicRestitution = options.restitution;
-
             return physicsEngine._registerMesh(this, impostor, options);
         };
-
         AbstractMesh.prototype.getPhysicsImpostor = function () {
             if (!this._physicImpostor) {
                 return BABYLON.PhysicsEngine.NoImpostor;
             }
-
             return this._physicImpostor;
         };
-
         AbstractMesh.prototype.getPhysicsMass = function () {
             if (!this._physicsMass) {
                 return 0;
             }
-
             return this._physicsMass;
         };
-
         AbstractMesh.prototype.getPhysicsFriction = function () {
             if (!this._physicsFriction) {
                 return 0;
             }
-
             return this._physicsFriction;
         };
-
         AbstractMesh.prototype.getPhysicsRestitution = function () {
             if (!this._physicRestitution) {
                 return 0;
             }
-
             return this._physicRestitution;
         };
-
         AbstractMesh.prototype.getPositionInCameraSpace = function (camera) {
             if (!camera) {
                 camera = this.getScene().activeCamera;
             }
-
             return BABYLON.Vector3.TransformCoordinates(this.absolutePosition, camera.getViewMatrix());
         };
-
         AbstractMesh.prototype.getDistanceToCamera = function (camera) {
             if (!camera) {
                 camera = this.getScene().activeCamera;
             }
-
             return this.absolutePosition.subtract(camera.position).length();
         };
-
         AbstractMesh.prototype.applyImpulse = function (force, contactPoint) {
             if (!this._physicImpostor) {
                 return;
             }
-
             this.getScene().getPhysicsEngine()._applyImpulse(this, force, contactPoint);
         };
-
         AbstractMesh.prototype.setPhysicsLinkWith = function (otherMesh, pivot1, pivot2, options) {
             if (!this._physicImpostor) {
                 return;
             }
-
             this.getScene().getPhysicsEngine()._createLink(this, otherMesh, pivot1, pivot2, options);
         };
-
         AbstractMesh.prototype.updatePhysicsBodyPosition = function () {
             if (!this._physicImpostor) {
                 return;
             }
             this.getScene().getPhysicsEngine()._updateBodyPosition(this);
         };
-
         // Collisions
         AbstractMesh.prototype.moveWithCollisions = function (velocity) {
             var globalPosition = this.getAbsolutePosition();
-
             globalPosition.subtractFromFloatsToRef(0, this.ellipsoid.y, 0, this._oldPositionForCollisions);
             this._oldPositionForCollisions.addInPlace(this.ellipsoidOffset);
             this._collider.radius = this.ellipsoid;
-
             this.getScene()._getNewPosition(this._oldPositionForCollisions, velocity, this._collider, 3, this._newPositionForCollisions, this);
             this._newPositionForCollisions.subtractToRef(this._oldPositionForCollisions, this._diffPositionForCollisions);
-
             if (this._diffPositionForCollisions.length() > BABYLON.Engine.CollisionsEpsilon) {
                 this.position.addInPlace(this._diffPositionForCollisions);
             }
         };
-
         // Submeshes octree
         /**
         * This function will create an octree to help select the right submeshes for rendering, picking and collisions
         * Please note that you must have a decent number of submeshes to get performance improvements when using octree
         */
         AbstractMesh.prototype.createOrUpdateSubmeshesOctree = function (maxCapacity, maxDepth) {
-            if (typeof maxCapacity === "undefined") { maxCapacity = 64; }
-            if (typeof maxDepth === "undefined") { maxDepth = 2; }
+            if (maxCapacity === void 0) { maxCapacity = 64; }
+            if (maxDepth === void 0) { maxDepth = 2; }
             if (!this._submeshesOctree) {
                 this._submeshesOctree = new BABYLON.Octree(BABYLON.Octree.CreationFuncForSubMeshes, maxCapacity, maxDepth);
             }
-
             this.computeWorldMatrix(true);
-
             // Update octree
             var bbox = this.getBoundingInfo().boundingBox;
             this._submeshesOctree.update(bbox.minimumWorld, bbox.maximumWorld, this.subMeshes);
-
             return this._submeshesOctree;
         };
-
         // Collisions
         AbstractMesh.prototype._collideForSubMesh = function (subMesh, transformMatrix, collider) {
             this._generatePointsArray();
-
             // Transformation
             if (!subMesh._lastColliderWorldVertices || !subMesh._lastColliderTransformMatrix.equals(transformMatrix)) {
                 subMesh._lastColliderTransformMatrix = transformMatrix.clone();
@@ -678,114 +613,90 @@ var BABYLON;
                     subMesh._lastColliderWorldVertices.push(BABYLON.Vector3.TransformCoordinates(this._positions[i], transformMatrix));
                 }
             }
-
             // Collide
             collider._collide(subMesh, subMesh._lastColliderWorldVertices, this.getIndices(), subMesh.indexStart, subMesh.indexStart + subMesh.indexCount, subMesh.verticesStart);
         };
-
         AbstractMesh.prototype._processCollisionsForSubMeshes = function (collider, transformMatrix) {
             var subMeshes;
             var len;
-
             // Octrees
             if (this._submeshesOctree && this.useOctreeForCollisions) {
                 var radius = collider.velocityWorldLength + Math.max(collider.radius.x, collider.radius.y, collider.radius.z);
                 var intersections = this._submeshesOctree.intersects(collider.basePointWorld, radius);
-
                 len = intersections.length;
                 subMeshes = intersections.data;
-            } else {
+            }
+            else {
                 subMeshes = this.subMeshes;
                 len = subMeshes.length;
             }
-
             for (var index = 0; index < len; index++) {
                 var subMesh = subMeshes[index];
-
                 // Bounding test
                 if (len > 1 && !subMesh._checkCollision(collider))
                     continue;
-
                 this._collideForSubMesh(subMesh, transformMatrix, collider);
             }
         };
-
         AbstractMesh.prototype._checkCollision = function (collider) {
             // Bounding box test
             if (!this._boundingInfo._checkCollision(collider))
                 return;
-
             // Transformation matrix
             BABYLON.Matrix.ScalingToRef(1.0 / collider.radius.x, 1.0 / collider.radius.y, 1.0 / collider.radius.z, this._collisionsScalingMatrix);
             this.worldMatrixFromCache.multiplyToRef(this._collisionsScalingMatrix, this._collisionsTransformMatrix);
-
             this._processCollisionsForSubMeshes(collider, this._collisionsTransformMatrix);
         };
-
         // Picking
         AbstractMesh.prototype._generatePointsArray = function () {
             return false;
         };
-
         AbstractMesh.prototype.intersects = function (ray, fastCheck) {
             var pickingInfo = new BABYLON.PickingInfo();
-
             if (!this.subMeshes || !this._boundingInfo || !ray.intersectsSphere(this._boundingInfo.boundingSphere) || !ray.intersectsBox(this._boundingInfo.boundingBox)) {
                 return pickingInfo;
             }
-
             if (!this._generatePointsArray()) {
                 return pickingInfo;
             }
-
             var intersectInfo = null;
-
             // Octrees
             var subMeshes;
             var len;
-
             if (this._submeshesOctree && this.useOctreeForPicking) {
                 var worldRay = BABYLON.Ray.Transform(ray, this.getWorldMatrix());
                 var intersections = this._submeshesOctree.intersectsRay(worldRay);
-
                 len = intersections.length;
                 subMeshes = intersections.data;
-            } else {
+            }
+            else {
                 subMeshes = this.subMeshes;
                 len = subMeshes.length;
             }
-
             for (var index = 0; index < len; index++) {
                 var subMesh = subMeshes[index];
-
                 // Bounding test
                 if (len > 1 && !subMesh.canIntersects(ray))
                     continue;
-
                 var currentIntersectInfo = subMesh.intersects(ray, this._positions, this.getIndices(), fastCheck);
-
                 if (currentIntersectInfo) {
                     if (fastCheck || !intersectInfo || currentIntersectInfo.distance < intersectInfo.distance) {
                         intersectInfo = currentIntersectInfo;
-
                         if (fastCheck) {
                             break;
                         }
                     }
                 }
             }
-
             if (intersectInfo) {
                 // Get picked point
                 var world = this.getWorldMatrix();
                 var worldOrigin = BABYLON.Vector3.TransformCoordinates(ray.origin, world);
                 var direction = ray.direction.clone();
-                direction.normalize();
+                //  direction.normalize();
                 direction = direction.scale(intersectInfo.distance);
                 var worldDirection = BABYLON.Vector3.TransformNormal(direction, world);
-
                 var pickedPoint = worldOrigin.add(worldDirection);
-
                 // Return result
                 pickingInfo.hit = true;
                 pickingInfo.distance = BABYLON.Vector3.Distance(worldOrigin, pickedPoint);
@@ -796,49 +707,40 @@ var BABYLON;
                 pickingInfo.faceId = intersectInfo.faceId;
                 return pickingInfo;
             }
-
             return pickingInfo;
         };
-
         AbstractMesh.prototype.clone = function (name, newParent, doNotCloneChildren) {
             return null;
         };
-
         AbstractMesh.prototype.releaseSubMeshes = function () {
             if (this.subMeshes) {
                 while (this.subMeshes.length) {
                     this.subMeshes[0].dispose();
                 }
-            } else {
+            }
+            else {
                 this.subMeshes = new Array();
             }
         };
-
         AbstractMesh.prototype.dispose = function (doNotRecurse) {
             // Physics
             if (this.getPhysicsImpostor() != BABYLON.PhysicsEngine.NoImpostor) {
                 this.setPhysicsState(BABYLON.PhysicsEngine.NoImpostor);
             }
-
             for (index = 0; index < this._intersectionsInProgress.length; index++) {
                 var other = this._intersectionsInProgress[index];
-
                 var pos = other._intersectionsInProgress.indexOf(this);
                 other._intersectionsInProgress.splice(pos, 1);
             }
-
             this._intersectionsInProgress = [];
-
             // SubMeshes
             this.releaseSubMeshes();
-
             // Remove from scene
             var index = this.getScene().meshes.indexOf(this);
             if (index != -1) {
-                // Remove from the scene if mesh found
+                // Remove from the scene if mesh found 
                 this.getScene().meshes.splice(index, 1);
             }
-
             if (!doNotRecurse) {
                 for (index = 0; index < this.getScene().particleSystems.length; index++) {
                     if (this.getScene().particleSystems[index].emitter == this) {
@@ -846,7 +748,6 @@ var BABYLON;
                         index--;
                     }
                 }
-
                 // Children
                 var objects = this.getScene().meshes.slice(0);
                 for (index = 0; index < objects.length; index++) {
@@ -854,7 +755,8 @@ var BABYLON;
                         objects[index].dispose();
                     }
                 }
-            } else {
+            }
+            else {
                 for (index = 0; index < this.getScene().meshes.length; index++) {
                     var obj = this.getScene().meshes[index];
                     if (obj.parent === this) {
@@ -863,16 +765,14 @@ var BABYLON;
                     }
                 }
             }
-
             this._onAfterWorldMatrixUpdate = [];
-
             this._isDisposed = true;
-
             // Callback
             if (this.onDispose) {
                 this.onDispose();
             }
         };
+        // Statics
         AbstractMesh._BILLBOARDMODE_NONE = 0;
         AbstractMesh._BILLBOARDMODE_X = 1;
         AbstractMesh._BILLBOARDMODE_Y = 2;
@@ -882,4 +782,4 @@ var BABYLON;
     })(BABYLON.Node);
     BABYLON.AbstractMesh = AbstractMesh;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.abstractMesh.js.map
+//# sourceMappingURL=babylon.abstractMesh.js.map

Babylon/Mesh/babylon.abstractMesh.ts

@@ -832,7 +832,7 @@
                 var world = this.getWorldMatrix();
                 var worldOrigin = BABYLON.Vector3.TransformCoordinates(ray.origin, world);
                 var direction = ray.direction.clone();
-                direction.normalize();
+              //  direction.normalize();
                 direction = direction.scale(intersectInfo.distance);
                 var worldDirection = BABYLON.Vector3.TransformNormal(direction, world);
 

Babylon/Mesh/babylon.csg.js

@@ -1,8 +1,7 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     // Unique ID when we import meshes from Babylon to CSG
     var currentCSGMeshId = 0;
-
     // # class Vertex
     // Represents a vertex of a polygon. Use your own vertex class instead of this
     // one to provide additional features like texture coordinates and vertex
@@ -10,7 +9,7 @@
     // `flip()`, and `interpolate()` methods that behave analogous to the ones
     // defined by `BABYLON.CSG.Vertex`. This class provides `normal` so convenience
     // functions like `BABYLON.CSG.sphere()` can return a smooth vertex normal, but `normal`
-    // is not used anywhere else.
+    // is not used anywhere else. 
     // Same goes for uv, it allows to keep the original vertex uv coordinates of the 2 meshes
     var Vertex = (function () {
         function Vertex(pos, normal, uv) {
@@ -21,13 +20,11 @@
         Vertex.prototype.clone = function () {
             return new Vertex(this.pos.clone(), this.normal.clone(), this.uv.clone());
         };
-
         // Invert all orientation-specific data (e.g. vertex normal). Called when the
         // orientation of a polygon is flipped.
         Vertex.prototype.flip = function () {
             this.normal = this.normal.scale(-1);
         };
-
         // Create a new vertex between this vertex and `other` by linearly
         // interpolating all properties using a parameter of `t`. Subclasses should
         // override this to interpolate additional properties.
@@ -36,7 +33,6 @@
         };
         return Vertex;
     })();
-
     // # class Plane
     // Represents a plane in 3D space.
     var Plane = (function () {
@@ -47,24 +43,19 @@
         Plane.FromPoints = function (a, b, c) {
             var v0 = c.subtract(a);
             var v1 = b.subtract(a);
-
             if (v0.lengthSquared() === 0 || v1.lengthSquared() === 0) {
                 return null;
             }
-
             var n = BABYLON.Vector3.Normalize(BABYLON.Vector3.Cross(v0, v1));
             return new Plane(n, BABYLON.Vector3.Dot(n, a));
         };
-
         Plane.prototype.clone = function () {
             return new Plane(this.normal.clone(), this.w);
         };
-
         Plane.prototype.flip = function () {
             this.normal.scaleInPlace(-1);
             this.w = -this.w;
         };
-
         // Split `polygon` by this plane if needed, then put the polygon or polygon
         // fragments in the appropriate lists. Coplanar polygons go into either
         // `coplanarFront` or `coplanarBack` depending on their orientation with
@@ -75,7 +66,6 @@
             var FRONT = 1;
             var BACK = 2;
             var SPANNING = 3;
-
             // Classify each point as well as the entire polygon into one of the above
             // four classes.
             var polygonType = 0;
@@ -86,7 +76,6 @@
                 polygonType |= type;
                 types.push(type);
             }
-
             switch (polygonType) {
                 case COPLANAR:
                     (BABYLON.Vector3.Dot(this.normal, polygon.plane.normal) > 0 ? coplanarFront : coplanarBack).push(polygon);
@@ -116,29 +105,26 @@
                     }
                     if (f.length >= 3) {
                         var poly = new Polygon(f, polygon.shared);
-
                         if (poly.plane)
                             front.push(poly);
                     }
-
                     if (b.length >= 3) {
                         poly = new Polygon(b, polygon.shared);
-
                         if (poly.plane)
                             back.push(poly);
                     }
-
                     break;
             }
         };
+        // `BABYLON.CSG.Plane.EPSILON` is the tolerance used by `splitPolygon()` to decide if a
+        // point is on the plane.
         Plane.EPSILON = 1e-5;
         return Plane;
     })();
-
     // # class Polygon
     // Represents a convex polygon. The vertices used to initialize a polygon must
     // be coplanar and form a convex loop.
-    //
+    // 
     // Each convex polygon has a `shared` property, which is shared between all
     // polygons that are clones of each other or were split from the same polygon.
     // This can be used to define per-polygon properties (such as surface color).
@@ -149,12 +135,9 @@
             this.plane = Plane.FromPoints(vertices[0].pos, vertices[1].pos, vertices[2].pos);
         }
         Polygon.prototype.clone = function () {
-            var vertices = this.vertices.map(function (v) {
-                return v.clone();
-            });
+            var vertices = this.vertices.map(function (v) { return v.clone(); });
             return new Polygon(vertices, this.shared);
         };
-
         Polygon.prototype.flip = function () {
             this.vertices.reverse().map(function (v) {
                 v.flip();
@@ -163,7 +146,6 @@
         };
         return Polygon;
     })();
-
     // # class Node
     // Holds a node in a BSP tree. A BSP tree is built from a collection of polygons
     // by picking a polygon to split along. That polygon (and all other coplanar
@@ -185,12 +167,9 @@
             node.plane = this.plane && this.plane.clone();
             node.front = this.front && this.front.clone();
             node.back = this.back && this.back.clone();
-            node.polygons = this.polygons.map(function (p) {
-                return p.clone();
-            });
+            node.polygons = this.polygons.map(function (p) { return p.clone(); });
             return node;
         };
-
         // Convert solid space to empty space and empty space to solid space.
         Node.prototype.invert = function () {
             for (var i = 0; i < this.polygons.length; i++) {
@@ -209,7 +188,6 @@
             this.front = this.back;
             this.back = temp;
         };
-
         // Recursively remove all polygons in `polygons` that are inside this BSP
         // tree.
         Node.prototype.clipPolygons = function (polygons) {
@@ -224,12 +202,12 @@
             }
             if (this.back) {
                 back = this.back.clipPolygons(back);
-            } else {
+            }
+            else {
                 back = [];
             }
             return front.concat(back);
         };
-
         // Remove all polygons in this BSP tree that are inside the other BSP tree
         // `bsp`.
         Node.prototype.clipTo = function (bsp) {
@@ -239,7 +217,6 @@
             if (this.back)
                 this.back.clipTo(bsp);
         };
-
         // Return a list of all polygons in this BSP tree.
         Node.prototype.allPolygons = function () {
             var polygons = this.polygons.slice();
@@ -249,7 +226,6 @@
                 polygons = polygons.concat(this.back.allPolygons());
             return polygons;
         };
-
         // Build a BSP tree out of `polygons`. When called on an existing tree, the
         // new polygons are filtered down to the bottom of the tree and become new
         // nodes there. Each set of polygons is partitioned using the first polygon
@@ -276,7 +252,6 @@
         };
         return Node;
     })();
-
     var CSG = (function () {
         function CSG() {
             this.polygons = new Array();
@@ -284,21 +259,18 @@
         // Convert BABYLON.Mesh to BABYLON.CSG
         CSG.FromMesh = function (mesh) {
             var vertex, normal, uv, position, polygon, polygons = [], vertices;
-
             if (mesh instanceof BABYLON.Mesh) {
                 mesh.computeWorldMatrix(true);
                 var matrix = mesh.getWorldMatrix();
                 var meshPosition = mesh.position.clone();
                 var meshRotation = mesh.rotation.clone();
                 var meshScaling = mesh.scaling.clone();
-            } else {
+            }
+            else {
                 throw 'BABYLON.CSG: Wrong Mesh type, must be BABYLON.Mesh';
             }
-
             var indices = mesh.getIndices(), positions = mesh.getVerticesData(BABYLON.VertexBuffer.PositionKind), normals = mesh.getVerticesData(BABYLON.VertexBuffer.NormalKind), uvs = mesh.getVerticesData(BABYLON.VertexBuffer.UVKind);
-
             var subMeshes = mesh.subMeshes;
-
             for (var sm = 0, sml = subMeshes.length; sm < sml; sm++) {
                 for (var i = subMeshes[sm].indexStart, il = subMeshes[sm].indexCount + subMeshes[sm].indexStart; i < il; i += 3) {
                     vertices = [];
@@ -308,50 +280,39 @@
                         var sourcePosition = new BABYLON.Vector3(positions[indices[i + j] * 3], positions[indices[i + j] * 3 + 1], positions[indices[i + j] * 3 + 2]);
                         position = BABYLON.Vector3.TransformCoordinates(sourcePosition, matrix);
                         normal = BABYLON.Vector3.TransformNormal(sourceNormal, matrix);
-
                         vertex = new Vertex(position, normal, uv);
                         vertices.push(vertex);
                     }
-
                     polygon = new Polygon(vertices, { subMeshId: sm, meshId: currentCSGMeshId, materialIndex: subMeshes[sm].materialIndex });
-
                     // To handle the case of degenerated triangle
                     // polygon.plane == null <=> the polygon does not represent 1 single plane <=> the triangle is degenerated
                     if (polygon.plane)
                         polygons.push(polygon);
                 }
             }
-
             var csg = CSG.FromPolygons(polygons);
             csg.matrix = matrix;
             csg.position = meshPosition;
             csg.rotation = meshRotation;
             csg.scaling = meshScaling;
             currentCSGMeshId++;
-
             return csg;
         };
-
         // Construct a BABYLON.CSG solid from a list of `BABYLON.CSG.Polygon` instances.
         CSG.FromPolygons = function (polygons) {
             var csg = new BABYLON.CSG();
             csg.polygons = polygons;
             return csg;
         };
-
         CSG.prototype.clone = function () {
             var csg = new BABYLON.CSG();
-            csg.polygons = this.polygons.map(function (p) {
-                return p.clone();
-            });
+            csg.polygons = this.polygons.map(function (p) { return p.clone(); });
             csg.copyTransformAttributes(this);
             return csg;
         };
-
         CSG.prototype.toPolygons = function () {
             return this.polygons;
         };
-
         CSG.prototype.union = function (csg) {
             var a = new Node(this.clone().polygons);
             var b = new Node(csg.clone().polygons);
@@ -363,21 +324,17 @@
             a.build(b.allPolygons());
             return CSG.FromPolygons(a.allPolygons()).copyTransformAttributes(this);
         };
-
         CSG.prototype.unionInPlace = function (csg) {
             var a = new Node(this.polygons);
             var b = new Node(csg.polygons);
-
             a.clipTo(b);
             b.clipTo(a);
             b.invert();
             b.clipTo(a);
             b.invert();
             a.build(b.allPolygons());
-
             this.polygons = a.allPolygons();
         };
-
         CSG.prototype.subtract = function (csg) {
             var a = new Node(this.clone().polygons);
             var b = new Node(csg.clone().polygons);
@@ -391,11 +348,9 @@
             a.invert();
             return CSG.FromPolygons(a.allPolygons()).copyTransformAttributes(this);
         };
-
         CSG.prototype.subtractInPlace = function (csg) {
             var a = new Node(this.polygons);
             var b = new Node(csg.polygons);
-
             a.invert();
             a.clipTo(b);
             b.clipTo(a);
@@ -404,10 +359,8 @@
             b.invert();
             a.build(b.allPolygons());
             a.invert();
-
             this.polygons = a.allPolygons();
         };
-
         CSG.prototype.intersect = function (csg) {
             var a = new Node(this.clone().polygons);
             var b = new Node(csg.clone().polygons);
@@ -420,11 +373,9 @@
             a.invert();
             return CSG.FromPolygons(a.allPolygons()).copyTransformAttributes(this);
         };
-
         CSG.prototype.intersectInPlace = function (csg) {
             var a = new Node(this.polygons);
             var b = new Node(csg.polygons);
-
             a.invert();
             b.clipTo(a);
             b.invert();
@@ -432,10 +383,8 @@
             b.clipTo(a);
             a.build(b.allPolygons());
             a.invert();
-
             this.polygons = a.allPolygons();
         };
-
         // Return a new BABYLON.CSG solid with solid and empty space switched. This solid is
         // not modified.
         CSG.prototype.inverse = function () {
@@ -443,13 +392,11 @@
             csg.inverseInPlace();
             return csg;
         };
-
         CSG.prototype.inverseInPlace = function () {
             this.polygons.map(function (p) {
                 p.flip();
             });
         };
-
         // This is used to keep meshes transformations so they can be restored
         // when we build back a Babylon Mesh
         // NB : All CSG operations are performed in world coordinates
@@ -458,32 +405,27 @@
             this.position = csg.position;
             this.rotation = csg.rotation;
             this.scaling = csg.scaling;
-
             return this;
         };
-
         // Build Raw mesh from CSG
         // Coordinates here are in world space
         CSG.prototype.buildMeshGeometry = function (name, scene, keepSubMeshes) {
             var matrix = this.matrix.clone();
             matrix.invert();
-
             var mesh = new BABYLON.Mesh(name, scene), vertices = [], indices = [], normals = [], uvs = [], vertex = BABYLON.Vector3.Zero(), normal = BABYLON.Vector3.Zero(), uv = BABYLON.Vector2.Zero(), polygons = this.polygons, polygonIndices = [0, 0, 0], polygon, vertice_dict = {}, vertex_idx, currentIndex = 0, subMesh_dict = {}, subMesh_obj;
-
             if (keepSubMeshes) {
                 // Sort Polygons, since subMeshes are indices range
                 polygons.sort(function (a, b) {
                     if (a.shared.meshId === b.shared.meshId) {
                         return a.shared.subMeshId - b.shared.subMeshId;
-                    } else {
+                    }
+                    else {
                         return a.shared.meshId - b.shared.meshId;
                     }
                 });
             }
-
             for (var i = 0, il = polygons.length; i < il; i++) {
                 polygon = polygons[i];
-
                 // Building SubMeshes
                 if (!subMesh_dict[polygon.shared.meshId]) {
                     subMesh_dict[polygon.shared.meshId] = {};
@@ -496,21 +438,17 @@
                     };
                 }
                 subMesh_obj = subMesh_dict[polygon.shared.meshId][polygon.shared.subMeshId];
-
                 for (var j = 2, jl = polygon.vertices.length; j < jl; j++) {
                     polygonIndices[0] = 0;
                     polygonIndices[1] = j - 1;
                     polygonIndices[2] = j;
-
                     for (var k = 0; k < 3; k++) {
                         vertex.copyFrom(polygon.vertices[polygonIndices[k]].pos);
                         normal.copyFrom(polygon.vertices[polygonIndices[k]].normal);
                         uv.copyFrom(polygon.vertices[polygonIndices[k]].uv);
                         var localVertex = BABYLON.Vector3.TransformCoordinates(vertex, matrix);
                         var localNormal = BABYLON.Vector3.TransformNormal(normal, matrix);
-
                         vertex_idx = vertice_dict[localVertex.x + ',' + localVertex.y + ',' + localVertex.z];
-
                         // Check if 2 points can be merged
                         if (!(typeof vertex_idx !== 'undefined' && normals[vertex_idx * 3] === localNormal.x && normals[vertex_idx * 3 + 1] === localNormal.y && normals[vertex_idx * 3 + 2] === localNormal.z && uvs[vertex_idx * 2] === uv.x && uvs[vertex_idx * 2 + 1] === uv.y)) {
                             vertices.push(localVertex.x, localVertex.y, localVertex.z);
@@ -518,27 +456,21 @@
                             normals.push(normal.x, normal.y, normal.z);
                             vertex_idx = vertice_dict[localVertex.x + ',' + localVertex.y + ',' + localVertex.z] = (vertices.length / 3) - 1;
                         }
-
                         indices.push(vertex_idx);
-
                         subMesh_obj.indexStart = Math.min(currentIndex, subMesh_obj.indexStart);
                         subMesh_obj.indexEnd = Math.max(currentIndex, subMesh_obj.indexEnd);
                         currentIndex++;
                     }
                 }
             }
-
             mesh.setVerticesData(BABYLON.VertexBuffer.PositionKind, vertices);
             mesh.setVerticesData(BABYLON.VertexBuffer.NormalKind, normals);
             mesh.setVerticesData(BABYLON.VertexBuffer.UVKind, uvs);
             mesh.setIndices(indices);
-
             if (keepSubMeshes) {
                 // We offset the materialIndex by the previous number of materials in the CSG mixed meshes
                 var materialIndexOffset = 0, materialMaxIndex;
-
                 mesh.subMeshes.length = 0;
-
                 for (var m in subMesh_dict) {
                     materialMaxIndex = -1;
                     for (var sm in subMesh_dict[m]) {
@@ -549,25 +481,20 @@
                     materialIndexOffset += ++materialMaxIndex;
                 }
             }
-
             return mesh;
         };
-
         // Build Mesh from CSG taking material and transforms into account
         CSG.prototype.toMesh = function (name, material, scene, keepSubMeshes) {
             var mesh = this.buildMeshGeometry(name, scene, keepSubMeshes);
-
             mesh.material = material;
-
             mesh.position.copyFrom(this.position);
             mesh.rotation.copyFrom(this.rotation);
             mesh.scaling.copyFrom(this.scaling);
             mesh.computeWorldMatrix(true);
-
             return mesh;
         };
         return CSG;
     })();
     BABYLON.CSG = CSG;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.csg.js.map
+//# sourceMappingURL=babylon.csg.js.map

Babylon/Mesh/babylon.geometry.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -15,15 +15,14 @@ var BABYLON;
             this._engine = scene.getEngine();
             this._meshes = [];
             this._scene = scene;
-
             // vertexData
             if (vertexData) {
                 this.setAllVerticesData(vertexData, updatable);
-            } else {
+            }
+            else {
                 this._totalVertices = 0;
                 this._indices = [];
             }
-
             // applyToMesh
             if (mesh) {
                 this.applyToMesh(mesh);
@@ -32,38 +31,27 @@ var BABYLON;
         Geometry.prototype.getScene = function () {
             return this._scene;
         };
-
         Geometry.prototype.getEngine = function () {
             return this._engine;
         };
-
         Geometry.prototype.isReady = function () {
             return this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADED || this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_NONE;
         };
-
         Geometry.prototype.setAllVerticesData = function (vertexData, updatable) {
             vertexData.applyToGeometry(this, updatable);
         };
-
         Geometry.prototype.setVerticesData = function (kind, data, updatable, stride) {
             this._vertexBuffers = this._vertexBuffers || {};
-
             if (this._vertexBuffers[kind]) {
                 this._vertexBuffers[kind].dispose();
             }
-
             this._vertexBuffers[kind] = new BABYLON.VertexBuffer(this._engine, data, kind, updatable, this._meshes.length === 0, stride);
-
             if (kind === BABYLON.VertexBuffer.PositionKind) {
                 stride = this._vertexBuffers[kind].getStrideSize();
-
                 this._totalVertices = data.length / stride;
-
                 var extend = BABYLON.Tools.ExtractMinAndMax(data, 0, this._totalVertices);
-
                 var meshes = this._meshes;
                 var numOfMeshes = meshes.length;
-
                 for (var index = 0; index < numOfMeshes; index++) {
                     var mesh = meshes[index];
                     mesh._resetPointsArrayCache();
@@ -73,39 +61,28 @@ var BABYLON;
                 }
             }
         };
-
         Geometry.prototype.updateVerticesDataDirectly = function (kind, data, offset) {
             var vertexBuffer = this.getVertexBuffer(kind);
-
             if (!vertexBuffer) {
                 return;
             }
-
             vertexBuffer.updateDirectly(data, offset);
         };
-
         Geometry.prototype.updateVerticesData = function (kind, data, updateExtends) {
             var vertexBuffer = this.getVertexBuffer(kind);
-
             if (!vertexBuffer) {
                 return;
             }
-
             vertexBuffer.update(data);
-
             if (kind === BABYLON.VertexBuffer.PositionKind) {
                 var extend;
-
                 var stride = vertexBuffer.getStrideSize();
                 this._totalVertices = data.length / stride;
-
                 if (updateExtends) {
                     extend = BABYLON.Tools.ExtractMinAndMax(data, 0, this._totalVertices);
                 }
-
                 var meshes = this._meshes;
                 var numOfMeshes = meshes.length;
-
                 for (var index = 0; index < numOfMeshes; index++) {
                     var mesh = meshes[index];
                     mesh._resetPointsArrayCache();
@@ -115,15 +92,12 @@ var BABYLON;
                 }
             }
         };
-
         Geometry.prototype.getTotalVertices = function () {
             if (!this.isReady()) {
                 return 0;
             }
-
             return this._totalVertices;
         };
-
         Geometry.prototype.getVerticesData = function (kind) {
             var vertexBuffer = this.getVertexBuffer(kind);
             if (!vertexBuffer) {
@@ -131,21 +105,18 @@ var BABYLON;
             }
             return vertexBuffer.getData();
         };
-
         Geometry.prototype.getVertexBuffer = function (kind) {
             if (!this.isReady()) {
                 return null;
             }
             return this._vertexBuffers[kind];
         };
-
         Geometry.prototype.getVertexBuffers = function () {
             if (!this.isReady()) {
                 return null;
             }
             return this._vertexBuffers;
         };
-
         Geometry.prototype.isVerticesDataPresent = function (kind) {
             if (!this._vertexBuffers) {
                 if (this._delayInfo) {
@@ -155,138 +126,109 @@ var BABYLON;
             }
             return this._vertexBuffers[kind] !== undefined;
         };
-
         Geometry.prototype.getVerticesDataKinds = function () {
             var result = [];
             if (!this._vertexBuffers && this._delayInfo) {
                 for (var kind in this._delayInfo) {
                     result.push(kind);
                 }
-            } else {
+            }
+            else {
                 for (kind in this._vertexBuffers) {
                     result.push(kind);
                 }
             }
-
             return result;
         };
-
         Geometry.prototype.setIndices = function (indices, totalVertices) {
             if (this._indexBuffer) {
                 this._engine._releaseBuffer(this._indexBuffer);
             }
-
             this._indices = indices;
             if (this._meshes.length !== 0 && this._indices) {
                 this._indexBuffer = this._engine.createIndexBuffer(this._indices);
             }
-
             if (totalVertices !== undefined) {
                 this._totalVertices = totalVertices;
             }
-
             var meshes = this._meshes;
             var numOfMeshes = meshes.length;
-
             for (var index = 0; index < numOfMeshes; index++) {
                 meshes[index]._createGlobalSubMesh();
             }
         };
-
         Geometry.prototype.getTotalIndices = function () {
             if (!this.isReady()) {
                 return 0;
             }
             return this._indices.length;
         };
-
         Geometry.prototype.getIndices = function () {
             if (!this.isReady()) {
                 return null;
             }
             return this._indices;
         };
-
         Geometry.prototype.getIndexBuffer = function () {
             if (!this.isReady()) {
                 return null;
             }
             return this._indexBuffer;
         };
-
         Geometry.prototype.releaseForMesh = function (mesh, shouldDispose) {
             var meshes = this._meshes;
             var index = meshes.indexOf(mesh);
-
             if (index === -1) {
                 return;
             }
-
             for (var kind in this._vertexBuffers) {
                 this._vertexBuffers[kind].dispose();
             }
-
             if (this._indexBuffer && this._engine._releaseBuffer(this._indexBuffer)) {
                 this._indexBuffer = null;
             }
-
             meshes.splice(index, 1);
-
             mesh._geometry = null;
-
             if (meshes.length === 0 && shouldDispose) {
                 this.dispose();
             }
         };
-
         Geometry.prototype.applyToMesh = function (mesh) {
             if (mesh._geometry === this) {
                 return;
             }
-
             var previousGeometry = mesh._geometry;
             if (previousGeometry) {
                 previousGeometry.releaseForMesh(mesh);
             }
-
             var meshes = this._meshes;
-
             // must be done before setting vertexBuffers because of mesh._createGlobalSubMesh()
             mesh._geometry = this;
-
             this._scene.pushGeometry(this);
-
             meshes.push(mesh);
-
             if (this.isReady()) {
                 this._applyToMesh(mesh);
-            } else {
+            }
+            else {
                 mesh._boundingInfo = this._boundingInfo;
             }
         };
-
         Geometry.prototype._applyToMesh = function (mesh) {
             var numOfMeshes = this._meshes.length;
-
             for (var kind in this._vertexBuffers) {
                 if (numOfMeshes === 1) {
                     this._vertexBuffers[kind].create();
                 }
                 this._vertexBuffers[kind]._buffer.references = numOfMeshes;
-
                 if (kind === BABYLON.VertexBuffer.PositionKind) {
                     mesh._resetPointsArrayCache();
-
                     var extend = BABYLON.Tools.ExtractMinAndMax(this._vertexBuffers[kind].getData(), 0, this._totalVertices);
                     mesh._boundingInfo = new BABYLON.BoundingInfo(extend.minimum, extend.maximum);
-
                     mesh._createGlobalSubMesh();
-
                     //bounding info was just created again, world matrix should be applied again.
                     mesh._updateBoundingInfo();
                 }
             }
-
             // indexBuffer
             if (numOfMeshes === 1 && this._indices) {
                 this._indexBuffer = this._engine.createIndexBuffer(this._indices);
@@ -295,44 +237,35 @@ var BABYLON;
                 this._indexBuffer.references = numOfMeshes;
             }
         };
-
         Geometry.prototype.load = function (scene, onLoaded) {
             var _this = this;
             if (this.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADING) {
                 return;
             }
-
             if (this.isReady()) {
                 if (onLoaded) {
                     onLoaded();
                 }
                 return;
             }
-
             this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_LOADING;
-
             scene._addPendingData(this);
             BABYLON.Tools.LoadFile(this.delayLoadingFile, function (data) {
                 _this._delayLoadingFunction(JSON.parse(data), _this);
-
                 _this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_LOADED;
                 _this._delayInfo = [];
-
                 scene._removePendingData(_this);
-
                 var meshes = _this._meshes;
                 var numOfMeshes = meshes.length;
                 for (var index = 0; index < numOfMeshes; index++) {
                     _this._applyToMesh(meshes[index]);
                 }
-
                 if (onLoaded) {
                     onLoaded();
                 }
             }, function () {
             }, scene.database);
         };
-
         Geometry.prototype.dispose = function () {
             var meshes = this._meshes;
             var numOfMeshes = meshes.length;
@@ -341,85 +274,64 @@ var BABYLON;
                 this.releaseForMesh(meshes[index]);
             }
             this._meshes = [];
-
             for (var kind in this._vertexBuffers) {
                 this._vertexBuffers[kind].dispose();
             }
             this._vertexBuffers = [];
             this._totalVertices = 0;
-
             if (this._indexBuffer) {
                 this._engine._releaseBuffer(this._indexBuffer);
             }
             this._indexBuffer = null;
             this._indices = [];
-
             this.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NONE;
             this.delayLoadingFile = null;
             this._delayLoadingFunction = null;
             this._delayInfo = [];
-
             this._boundingInfo = null; // todo: .dispose()
-
             var geometries = this._scene.getGeometries();
             index = geometries.indexOf(this);
-
             if (index > -1) {
                 geometries.splice(index, 1);
             }
         };
-
         Geometry.prototype.copy = function (id) {
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = [];
-
             var indices = this.getIndices();
             for (var index = 0; index < indices.length; index++) {
                 vertexData.indices.push(indices[index]);
             }
-
             var updatable = false;
             var stopChecking = false;
-
             for (var kind in this._vertexBuffers) {
                 vertexData.set(this.getVerticesData(kind), kind);
-
                 if (!stopChecking) {
                     updatable = this.getVertexBuffer(kind).isUpdatable();
                     stopChecking = !updatable;
                 }
             }
-
             var geometry = new Geometry(id, this._scene, vertexData, updatable, null);
-
             geometry.delayLoadState = this.delayLoadState;
             geometry.delayLoadingFile = this.delayLoadingFile;
             geometry._delayLoadingFunction = this._delayLoadingFunction;
-
             for (kind in this._delayInfo) {
                 geometry._delayInfo = geometry._delayInfo || [];
                 geometry._delayInfo.push(kind);
             }
-
             // Bounding info
             var extend = BABYLON.Tools.ExtractMinAndMax(this.getVerticesData(BABYLON.VertexBuffer.PositionKind), 0, this.getTotalVertices());
             geometry._boundingInfo = new BABYLON.BoundingInfo(extend.minimum, extend.maximum);
-
             return geometry;
         };
-
         // Statics
         Geometry.ExtractFromMesh = function (mesh, id) {
             var geometry = mesh._geometry;
-
             if (!geometry) {
                 return null;
             }
-
             return geometry.copy(id);
         };
-
         // from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#answer-2117523
         // be aware Math.random() could cause collisions
         Geometry.RandomId = function () {
@@ -431,9 +343,10 @@ var BABYLON;
         return Geometry;
     })();
     BABYLON.Geometry = Geometry;
-
+    /////// Primitives //////////////////////////////////////////////
+    var Geometry;
     (function (Geometry) {
-        /////// Primitives //////////////////////////////////////////////
+        var Primitives;
         (function (Primitives) {
             /// Abstract class
             var _Primitive = (function (_super) {
@@ -447,7 +360,6 @@ var BABYLON;
                 _Primitive.prototype.canBeRegenerated = function () {
                     return this._canBeRegenerated;
                 };
-
                 _Primitive.prototype.regenerate = function () {
                     if (!this._canBeRegenerated) {
                         return;
@@ -456,11 +368,9 @@ var BABYLON;
                     this.setAllVerticesData(this._regenerateVertexData(), false);
                     this._beingRegenerated = false;
                 };
-
                 _Primitive.prototype.asNewGeometry = function (id) {
                     return _super.prototype.copy.call(this, id);
                 };
-
                 // overrides
                 _Primitive.prototype.setAllVerticesData = function (vertexData, updatable) {
                     if (!this._beingRegenerated) {
@@ -468,127 +378,108 @@ var BABYLON;
                     }
                     _super.prototype.setAllVerticesData.call(this, vertexData, false);
                 };
-
                 _Primitive.prototype.setVerticesData = function (kind, data, updatable) {
                     if (!this._beingRegenerated) {
                         return;
                     }
                     _super.prototype.setVerticesData.call(this, kind, data, false);
                 };
-
                 // to override
                 // protected
                 _Primitive.prototype._regenerateVertexData = function () {
                     throw new Error("Abstract method");
                 };
-
                 _Primitive.prototype.copy = function (id) {
                     throw new Error("Must be overriden in sub-classes.");
                 };
                 return _Primitive;
             })(Geometry);
             Primitives._Primitive = _Primitive;
-
             var Box = (function (_super) {
                 __extends(Box, _super);
                 function Box(id, scene, size, canBeRegenerated, mesh) {
                     this.size = size;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 Box.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreateBox(this.size);
                 };
-
                 Box.prototype.copy = function (id) {
                     return new Box(id, this.getScene(), this.size, this.canBeRegenerated(), null);
                 };
                 return Box;
             })(_Primitive);
             Primitives.Box = Box;
-
             var Sphere = (function (_super) {
                 __extends(Sphere, _super);
                 function Sphere(id, scene, segments, diameter, canBeRegenerated, mesh) {
                     this.segments = segments;
                     this.diameter = diameter;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 Sphere.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreateSphere(this.segments, this.diameter);
                 };
-
                 Sphere.prototype.copy = function (id) {
                     return new Sphere(id, this.getScene(), this.segments, this.diameter, this.canBeRegenerated(), null);
                 };
                 return Sphere;
             })(_Primitive);
             Primitives.Sphere = Sphere;
-
             var Cylinder = (function (_super) {
                 __extends(Cylinder, _super);
                 function Cylinder(id, scene, height, diameterTop, diameterBottom, tessellation, subdivisions, canBeRegenerated, mesh) {
-                    if (typeof subdivisions === "undefined") { subdivisions = 1; }
+                    if (subdivisions === void 0) { subdivisions = 1; }
                     this.height = height;
                     this.diameterTop = diameterTop;
                     this.diameterBottom = diameterBottom;
                     this.tessellation = tessellation;
                     this.subdivisions = subdivisions;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 Cylinder.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreateCylinder(this.height, this.diameterTop, this.diameterBottom, this.tessellation, this.subdivisions);
                 };
-
                 Cylinder.prototype.copy = function (id) {
                     return new Cylinder(id, this.getScene(), this.height, this.diameterTop, this.diameterBottom, this.tessellation, this.subdivisions, this.canBeRegenerated(), null);
                 };
                 return Cylinder;
             })(_Primitive);
             Primitives.Cylinder = Cylinder;
-
             var Torus = (function (_super) {
                 __extends(Torus, _super);
                 function Torus(id, scene, diameter, thickness, tessellation, canBeRegenerated, mesh) {
                     this.diameter = diameter;
                     this.thickness = thickness;
                     this.tessellation = tessellation;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 Torus.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreateTorus(this.diameter, this.thickness, this.tessellation);
                 };
-
                 Torus.prototype.copy = function (id) {
                     return new Torus(id, this.getScene(), this.diameter, this.thickness, this.tessellation, this.canBeRegenerated(), null);
                 };
                 return Torus;
             })(_Primitive);
             Primitives.Torus = Torus;
-
             var Ground = (function (_super) {
                 __extends(Ground, _super);
                 function Ground(id, scene, width, height, subdivisions, canBeRegenerated, mesh) {
                     this.width = width;
                     this.height = height;
                     this.subdivisions = subdivisions;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 Ground.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreateGround(this.width, this.height, this.subdivisions);
                 };
-
                 Ground.prototype.copy = function (id) {
                     return new Ground(id, this.getScene(), this.width, this.height, this.subdivisions, this.canBeRegenerated(), null);
                 };
                 return Ground;
             })(_Primitive);
             Primitives.Ground = Ground;
-
             var TiledGround = (function (_super) {
                 __extends(TiledGround, _super);
                 function TiledGround(id, scene, xmin, zmin, xmax, zmax, subdivisions, precision, canBeRegenerated, mesh) {
@@ -598,38 +489,32 @@ var BABYLON;
                     this.zmax = zmax;
                     this.subdivisions = subdivisions;
                     this.precision = precision;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 TiledGround.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreateTiledGround(this.xmin, this.zmin, this.xmax, this.zmax, this.subdivisions, this.precision);
                 };
-
                 TiledGround.prototype.copy = function (id) {
                     return new TiledGround(id, this.getScene(), this.xmin, this.zmin, this.xmax, this.zmax, this.subdivisions, this.precision, this.canBeRegenerated(), null);
                 };
                 return TiledGround;
             })(_Primitive);
             Primitives.TiledGround = TiledGround;
-
             var Plane = (function (_super) {
                 __extends(Plane, _super);
                 function Plane(id, scene, size, canBeRegenerated, mesh) {
                     this.size = size;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 Plane.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreatePlane(this.size);
                 };
-
                 Plane.prototype.copy = function (id) {
                     return new Plane(id, this.getScene(), this.size, this.canBeRegenerated(), null);
                 };
                 return Plane;
             })(_Primitive);
             Primitives.Plane = Plane;
-
             var TorusKnot = (function (_super) {
                 __extends(TorusKnot, _super);
                 function TorusKnot(id, scene, radius, tube, radialSegments, tubularSegments, p, q, canBeRegenerated, mesh) {
@@ -639,22 +524,18 @@ var BABYLON;
                     this.tubularSegments = tubularSegments;
                     this.p = p;
                     this.q = q;
-
                     _super.call(this, id, scene, this._regenerateVertexData(), canBeRegenerated, mesh);
                 }
                 TorusKnot.prototype._regenerateVertexData = function () {
                     return BABYLON.VertexData.CreateTorusKnot(this.radius, this.tube, this.radialSegments, this.tubularSegments, this.p, this.q);
                 };
-
                 TorusKnot.prototype.copy = function (id) {
                     return new TorusKnot(id, this.getScene(), this.radius, this.tube, this.radialSegments, this.tubularSegments, this.p, this.q, this.canBeRegenerated(), null);
                 };
                 return TorusKnot;
             })(_Primitive);
             Primitives.TorusKnot = TorusKnot;
-        })(Geometry.Primitives || (Geometry.Primitives = {}));
-        var Primitives = Geometry.Primitives;
-    })(BABYLON.Geometry || (BABYLON.Geometry = {}));
-    var Geometry = BABYLON.Geometry;
+        })(Primitives = Geometry.Primitives || (Geometry.Primitives = {}));
+    })(Geometry = BABYLON.Geometry || (BABYLON.Geometry = {}));
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.geometry.js.map
+//# sourceMappingURL=babylon.geometry.js.map

Babylon/Mesh/babylon.groundMesh.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -20,29 +20,22 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         GroundMesh.prototype.optimize = function (chunksCount) {
             this.subdivide(this._subdivisions);
             this.createOrUpdateSubmeshesOctree(32);
         };
-
         GroundMesh.prototype.getHeightAtCoordinates = function (x, z) {
             var ray = new BABYLON.Ray(new BABYLON.Vector3(x, this.getBoundingInfo().boundingBox.maximumWorld.y + 1, z), new BABYLON.Vector3(0, -1, 0));
-
             this.getWorldMatrix().invertToRef(this._worldInverse);
-
             ray = BABYLON.Ray.Transform(ray, this._worldInverse);
-
             var pickInfo = this.intersects(ray);
-
             if (pickInfo.hit) {
                 return pickInfo.pickedPoint.y;
             }
-
             return 0;
         };
         return GroundMesh;
     })(BABYLON.Mesh);
     BABYLON.GroundMesh = GroundMesh;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.groundMesh.js.map
+//# sourceMappingURL=babylon.groundMesh.js.map

Babylon/Mesh/babylon.linesMesh.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,12 +9,11 @@ var BABYLON;
     var LinesMesh = (function (_super) {
         __extends(LinesMesh, _super);
         function LinesMesh(name, scene, updatable) {
-            if (typeof updatable === "undefined") { updatable = false; }
+            if (updatable === void 0) { updatable = false; }
             _super.call(this, name, scene);
             this.color = new BABYLON.Color3(1, 1, 1);
             this.alpha = 1;
             this._indices = new Array();
-
             this._colorShader = new BABYLON.ShaderMaterial("colorShader", scene, "color", {
                 attributes: ["position"],
                 uniforms: ["worldViewProjection", "color"],
@@ -28,7 +27,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(LinesMesh.prototype, "isPickable", {
             get: function () {
                 return false;
@@ -36,7 +34,6 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(LinesMesh.prototype, "checkCollisions", {
             get: function () {
                 return false;
@@ -44,41 +41,31 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
-
         LinesMesh.prototype._bind = function (subMesh, effect, fillMode) {
             var engine = this.getScene().getEngine();
-
             var indexToBind = this._geometry.getIndexBuffer();
-
             // VBOs
             engine.bindBuffers(this._geometry.getVertexBuffer(BABYLON.VertexBuffer.PositionKind).getBuffer(), indexToBind, [3], 3 * 4, this._colorShader.getEffect());
-
             // Color
             this._colorShader.setColor4("color", this.color.toColor4(this.alpha));
         };
-
         LinesMesh.prototype._draw = function (subMesh, fillMode, instancesCount) {
             if (!this._geometry || !this._geometry.getVertexBuffers() || !this._geometry.getIndexBuffer()) {
                 return;
             }
-
             var engine = this.getScene().getEngine();
-
             // Draw order
             engine.draw(false, subMesh.indexStart, subMesh.indexCount);
         };
-
         LinesMesh.prototype.intersects = function (ray, fastCheck) {
             return null;
         };
-
         LinesMesh.prototype.dispose = function (doNotRecurse) {
             this._colorShader.dispose();
-
             _super.prototype.dispose.call(this, doNotRecurse);
         };
         return LinesMesh;
     })(BABYLON.Mesh);
     BABYLON.LinesMesh = LinesMesh;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.linesMesh.js.map
+//# sourceMappingURL=babylon.linesMesh.js.map

Babylon/Mesh/babylon.mesh.vertexData.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var VertexData = (function () {
         function VertexData() {
@@ -28,113 +28,86 @@
                     break;
             }
         };
-
         VertexData.prototype.applyToMesh = function (mesh, updatable) {
             this._applyTo(mesh, updatable);
         };
-
         VertexData.prototype.applyToGeometry = function (geometry, updatable) {
             this._applyTo(geometry, updatable);
         };
-
         VertexData.prototype.updateMesh = function (mesh, updateExtends, makeItUnique) {
             this._update(mesh);
         };
-
         VertexData.prototype.updateGeometry = function (geometry, updateExtends, makeItUnique) {
             this._update(geometry);
         };
-
         VertexData.prototype._applyTo = function (meshOrGeometry, updatable) {
             if (this.positions) {
                 meshOrGeometry.setVerticesData(BABYLON.VertexBuffer.PositionKind, this.positions, updatable);
             }
-
             if (this.normals) {
                 meshOrGeometry.setVerticesData(BABYLON.VertexBuffer.NormalKind, this.normals, updatable);
             }
-
             if (this.uvs) {
                 meshOrGeometry.setVerticesData(BABYLON.VertexBuffer.UVKind, this.uvs, updatable);
             }
-
             if (this.uv2s) {
                 meshOrGeometry.setVerticesData(BABYLON.VertexBuffer.UV2Kind, this.uv2s, updatable);
             }
-
             if (this.colors) {
                 meshOrGeometry.setVerticesData(BABYLON.VertexBuffer.ColorKind, this.colors, updatable);
             }
-
             if (this.matricesIndices) {
                 meshOrGeometry.setVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, this.matricesIndices, updatable);
             }
-
             if (this.matricesWeights) {
                 meshOrGeometry.setVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind, this.matricesWeights, updatable);
             }
-
             if (this.indices) {
                 meshOrGeometry.setIndices(this.indices);
             }
         };
-
         VertexData.prototype._update = function (meshOrGeometry, updateExtends, makeItUnique) {
             if (this.positions) {
                 meshOrGeometry.updateVerticesData(BABYLON.VertexBuffer.PositionKind, this.positions, updateExtends, makeItUnique);
             }
-
             if (this.normals) {
                 meshOrGeometry.updateVerticesData(BABYLON.VertexBuffer.NormalKind, this.normals, updateExtends, makeItUnique);
             }
-
             if (this.uvs) {
                 meshOrGeometry.updateVerticesData(BABYLON.VertexBuffer.UVKind, this.uvs, updateExtends, makeItUnique);
             }
-
             if (this.uv2s) {
                 meshOrGeometry.updateVerticesData(BABYLON.VertexBuffer.UV2Kind, this.uv2s, updateExtends, makeItUnique);
             }
-
             if (this.colors) {
                 meshOrGeometry.updateVerticesData(BABYLON.VertexBuffer.ColorKind, this.colors, updateExtends, makeItUnique);
             }
-
             if (this.matricesIndices) {
                 meshOrGeometry.updateVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, this.matricesIndices, updateExtends, makeItUnique);
             }
-
             if (this.matricesWeights) {
                 meshOrGeometry.updateVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind, this.matricesWeights, updateExtends, makeItUnique);
             }
-
             if (this.indices) {
                 meshOrGeometry.setIndices(this.indices);
             }
         };
-
         VertexData.prototype.transform = function (matrix) {
             var transformed = BABYLON.Vector3.Zero();
-
             if (this.positions) {
                 var position = BABYLON.Vector3.Zero();
-
                 for (var index = 0; index < this.positions.length; index += 3) {
                     BABYLON.Vector3.FromArrayToRef(this.positions, index, position);
-
                     BABYLON.Vector3.TransformCoordinatesToRef(position, matrix, transformed);
                     this.positions[index] = transformed.x;
                     this.positions[index + 1] = transformed.y;
                     this.positions[index + 2] = transformed.z;
                 }
             }
-
             if (this.normals) {
                 var normal = BABYLON.Vector3.Zero();
-
                 for (index = 0; index < this.normals.length; index += 3) {
                     BABYLON.Vector3.FromArrayToRef(this.normals, index, normal);
-
                     BABYLON.Vector3.TransformNormalToRef(normal, matrix, transformed);
                     this.normals[index] = transformed.x;
                     this.normals[index + 1] = transformed.y;
@@ -142,29 +115,24 @@
                 }
             }
         };
-
         VertexData.prototype.merge = function (other) {
             if (other.indices) {
                 if (!this.indices) {
                     this.indices = [];
                 }
-
                 var offset = this.positions ? this.positions.length / 3 : 0;
                 for (var index = 0; index < other.indices.length; index++) {
                     this.indices.push(other.indices[index] + offset);
                 }
             }
-
             if (other.positions) {
                 if (!this.positions) {
                     this.positions = [];
                 }
-
                 for (index = 0; index < other.positions.length; index++) {
                     this.positions.push(other.positions[index]);
                 }
             }
-
             if (other.normals) {
                 if (!this.normals) {
                     this.normals = [];
@@ -173,7 +141,6 @@
                     this.normals.push(other.normals[index]);
                 }
             }
-
             if (other.uvs) {
                 if (!this.uvs) {
                     this.uvs = [];
@@ -182,7 +149,6 @@
                     this.uvs.push(other.uvs[index]);
                 }
             }
-
             if (other.uv2s) {
                 if (!this.uv2s) {
                     this.uv2s = [];
@@ -191,7 +157,6 @@
                     this.uv2s.push(other.uv2s[index]);
                 }
             }
-
             if (other.matricesIndices) {
                 if (!this.matricesIndices) {
                     this.matricesIndices = [];
@@ -200,7 +165,6 @@
                     this.matricesIndices.push(other.matricesIndices[index]);
                 }
             }
-
             if (other.matricesWeights) {
                 if (!this.matricesWeights) {
                     this.matricesWeights = [];
@@ -209,7 +173,6 @@
                     this.matricesWeights.push(other.matricesWeights[index]);
                 }
             }
-
             if (other.colors) {
                 if (!this.colors) {
                     this.colors = [];
@@ -219,52 +182,39 @@
                 }
             }
         };
-
         // Statics
         VertexData.ExtractFromMesh = function (mesh) {
             return VertexData._ExtractFrom(mesh);
         };
-
         VertexData.ExtractFromGeometry = function (geometry) {
             return VertexData._ExtractFrom(geometry);
         };
-
         VertexData._ExtractFrom = function (meshOrGeometry) {
             var result = new BABYLON.VertexData();
-
             if (meshOrGeometry.isVerticesDataPresent(BABYLON.VertexBuffer.PositionKind)) {
                 result.positions = meshOrGeometry.getVerticesData(BABYLON.VertexBuffer.PositionKind);
             }
-
             if (meshOrGeometry.isVerticesDataPresent(BABYLON.VertexBuffer.NormalKind)) {
                 result.normals = meshOrGeometry.getVerticesData(BABYLON.VertexBuffer.NormalKind);
             }
-
             if (meshOrGeometry.isVerticesDataPresent(BABYLON.VertexBuffer.UVKind)) {
                 result.uvs = meshOrGeometry.getVerticesData(BABYLON.VertexBuffer.UVKind);
             }
-
             if (meshOrGeometry.isVerticesDataPresent(BABYLON.VertexBuffer.UV2Kind)) {
                 result.uv2s = meshOrGeometry.getVerticesData(BABYLON.VertexBuffer.UV2Kind);
             }
-
             if (meshOrGeometry.isVerticesDataPresent(BABYLON.VertexBuffer.ColorKind)) {
                 result.colors = meshOrGeometry.getVerticesData(BABYLON.VertexBuffer.ColorKind);
             }
-
             if (meshOrGeometry.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesIndicesKind)) {
                 result.matricesIndices = meshOrGeometry.getVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind);
             }
-
             if (meshOrGeometry.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesWeightsKind)) {
                 result.matricesWeights = meshOrGeometry.getVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind);
             }
-
             result.indices = meshOrGeometry.getIndices();
-
             return result;
         };
-
         VertexData.CreateBox = function (size) {
             var normalsSource = [
                 new BABYLON.Vector3(0, 0, 1),
@@ -274,396 +224,309 @@
                 new BABYLON.Vector3(0, 1, 0),
                 new BABYLON.Vector3(0, -1, 0)
             ];
-
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
-
             size = size || 1;
-
             for (var index = 0; index < normalsSource.length; index++) {
                 var normal = normalsSource[index];
-
                 // Get two vectors perpendicular to the face normal and to each other.
                 var side1 = new BABYLON.Vector3(normal.y, normal.z, normal.x);
                 var side2 = BABYLON.Vector3.Cross(normal, side1);
-
                 // Six indices (two triangles) per face.
                 var verticesLength = positions.length / 3;
                 indices.push(verticesLength);
                 indices.push(verticesLength + 1);
                 indices.push(verticesLength + 2);
-
                 indices.push(verticesLength);
                 indices.push(verticesLength + 2);
                 indices.push(verticesLength + 3);
-
                 // Four vertices per face.
                 var vertex = normal.subtract(side1).subtract(side2).scale(size / 2);
                 positions.push(vertex.x, vertex.y, vertex.z);
                 normals.push(normal.x, normal.y, normal.z);
                 uvs.push(1.0, 1.0);
-
                 vertex = normal.subtract(side1).add(side2).scale(size / 2);
                 positions.push(vertex.x, vertex.y, vertex.z);
                 normals.push(normal.x, normal.y, normal.z);
                 uvs.push(0.0, 1.0);
-
                 vertex = normal.add(side1).add(side2).scale(size / 2);
                 positions.push(vertex.x, vertex.y, vertex.z);
                 normals.push(normal.x, normal.y, normal.z);
                 uvs.push(0.0, 0.0);
-
                 vertex = normal.add(side1).subtract(side2).scale(size / 2);
                 positions.push(vertex.x, vertex.y, vertex.z);
                 normals.push(normal.x, normal.y, normal.z);
                 uvs.push(1.0, 0.0);
             }
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         VertexData.CreateSphere = function (segments, diameter) {
             segments = segments || 32;
             diameter = diameter || 1;
-
             var radius = diameter / 2;
-
             var totalZRotationSteps = 2 + segments;
             var totalYRotationSteps = 2 * totalZRotationSteps;
-
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
-
             for (var zRotationStep = 0; zRotationStep <= totalZRotationSteps; zRotationStep++) {
                 var normalizedZ = zRotationStep / totalZRotationSteps;
                 var angleZ = (normalizedZ * Math.PI);
-
                 for (var yRotationStep = 0; yRotationStep <= totalYRotationSteps; yRotationStep++) {
                     var normalizedY = yRotationStep / totalYRotationSteps;
-
                     var angleY = normalizedY * Math.PI * 2;
-
                     var rotationZ = BABYLON.Matrix.RotationZ(-angleZ);
                     var rotationY = BABYLON.Matrix.RotationY(angleY);
                     var afterRotZ = BABYLON.Vector3.TransformCoordinates(BABYLON.Vector3.Up(), rotationZ);
                     var complete = BABYLON.Vector3.TransformCoordinates(afterRotZ, rotationY);
-
                     var vertex = complete.scale(radius);
                     var normal = BABYLON.Vector3.Normalize(vertex);
-
                     positions.push(vertex.x, vertex.y, vertex.z);
                     normals.push(normal.x, normal.y, normal.z);
                     uvs.push(normalizedZ, normalizedY);
                 }
-
                 if (zRotationStep > 0) {
                     var verticesCount = positions.length / 3;
                     for (var firstIndex = verticesCount - 2 * (totalYRotationSteps + 1); (firstIndex + totalYRotationSteps + 2) < verticesCount; firstIndex++) {
                         indices.push((firstIndex));
                         indices.push((firstIndex + 1));
                         indices.push(firstIndex + totalYRotationSteps + 1);
-
                         indices.push((firstIndex + totalYRotationSteps + 1));
                         indices.push((firstIndex + 1));
                         indices.push((firstIndex + totalYRotationSteps + 2));
                     }
                 }
             }
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         VertexData.CreateCylinder = function (height, diameterTop, diameterBottom, tessellation, subdivisions) {
-            if (typeof subdivisions === "undefined") { subdivisions = 1; }
+            if (subdivisions === void 0) { subdivisions = 1; }
             var radiusTop = diameterTop / 2;
             var radiusBottom = diameterBottom / 2;
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
-
             height = height || 1;
             diameterTop = diameterTop || 0.5;
             diameterBottom = diameterBottom || 1;
             tessellation = tessellation || 16;
             subdivisions = subdivisions || 1;
             subdivisions = (subdivisions < 1) ? 1 : subdivisions;
-
             var getCircleVector = function (i) {
                 var angle = (i * 2.0 * Math.PI / tessellation);
                 var dx = Math.cos(angle);
                 var dz = Math.sin(angle);
-
                 return new BABYLON.Vector3(dx, 0, dz);
             };
-
             var createCylinderCap = function (isTop) {
                 var radius = isTop ? radiusTop : radiusBottom;
-
                 if (radius == 0) {
                     return;
                 }
                 var vbase = positions.length / 3;
-
                 var offset = new BABYLON.Vector3(0, height / 2, 0);
                 var textureScale = new BABYLON.Vector2(0.5, 0.5);
-
                 if (!isTop) {
                     offset.scaleInPlace(-1);
                     textureScale.x = -textureScale.x;
                 }
-
                 for (i = 0; i < tessellation; i++) {
                     var circleVector = getCircleVector(i);
                     var position = circleVector.scale(radius).add(offset);
                     var textureCoordinate = new BABYLON.Vector2(circleVector.x * textureScale.x + 0.5, circleVector.z * textureScale.y + 0.5);
-
                     positions.push(position.x, position.y, position.z);
                     uvs.push(textureCoordinate.x, textureCoordinate.y);
                 }
-
                 for (var i = 0; i < tessellation - 2; i++) {
                     if (!isTop) {
                         indices.push(vbase);
                         indices.push(vbase + (i + 2) % tessellation);
                         indices.push(vbase + (i + 1) % tessellation);
-                    } else {
+                    }
+                    else {
                         indices.push(vbase);
                         indices.push(vbase + (i + 1) % tessellation);
                         indices.push(vbase + (i + 2) % tessellation);
                     }
                 }
             };
-
             var base = new BABYLON.Vector3(0, -1, 0).scale(height / 2);
             var offset = new BABYLON.Vector3(0, 1, 0).scale(height / subdivisions);
             var stride = tessellation + 1;
-
             for (var i = 0; i <= tessellation; i++) {
                 var circleVector = getCircleVector(i);
                 var textureCoordinate = new BABYLON.Vector2(i / tessellation, 0);
                 var position, radius = radiusBottom;
-
                 for (var s = 0; s <= subdivisions; s++) {
                     // Update variables
                     position = circleVector.scale(radius);
                     position.addInPlace(base.add(offset.scale(s)));
                     textureCoordinate.y += 1 / subdivisions;
                     radius += (radiusTop - radiusBottom) / subdivisions;
-
                     // Push in arrays
                     positions.push(position.x, position.y, position.z);
                     uvs.push(textureCoordinate.x, textureCoordinate.y);
                 }
             }
-
             subdivisions += 1;
-
             for (var s = 0; s < subdivisions - 1; s++) {
                 for (var i = 0; i <= tessellation; i++) {
                     indices.push(i * subdivisions + s);
                     indices.push((i * subdivisions + (s + subdivisions)) % (stride * subdivisions));
                     indices.push(i * subdivisions + (s + 1));
-
                     indices.push(i * subdivisions + (s + 1));
                     indices.push((i * subdivisions + (s + subdivisions)) % (stride * subdivisions));
                     indices.push((i * subdivisions + (s + subdivisions + 1)) % (stride * subdivisions));
                 }
             }
-
             // Create flat triangle fan caps to seal the top and bottom.
             createCylinderCap(true);
             createCylinderCap(false);
-
             // Normals
             BABYLON.VertexData.ComputeNormals(positions, indices, normals);
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         VertexData.CreateTorus = function (diameter, thickness, tessellation) {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
-
             diameter = diameter || 1;
             thickness = thickness || 0.5;
             tessellation = tessellation || 16;
-
             var stride = tessellation + 1;
-
             for (var i = 0; i <= tessellation; i++) {
                 var u = i / tessellation;
-
                 var outerAngle = i * Math.PI * 2.0 / tessellation - Math.PI / 2.0;
-
                 var transform = BABYLON.Matrix.Translation(diameter / 2.0, 0, 0).multiply(BABYLON.Matrix.RotationY(outerAngle));
-
                 for (var j = 0; j <= tessellation; j++) {
                     var v = 1 - j / tessellation;
-
                     var innerAngle = j * Math.PI * 2.0 / tessellation + Math.PI;
                     var dx = Math.cos(innerAngle);
                     var dy = Math.sin(innerAngle);
-
                     // Create a vertex.
                     var normal = new BABYLON.Vector3(dx, dy, 0);
                     var position = normal.scale(thickness / 2);
                     var textureCoordinate = new BABYLON.Vector2(u, v);
-
                     position = BABYLON.Vector3.TransformCoordinates(position, transform);
                     normal = BABYLON.Vector3.TransformNormal(normal, transform);
-
                     positions.push(position.x, position.y, position.z);
                     normals.push(normal.x, normal.y, normal.z);
                     uvs.push(textureCoordinate.x, textureCoordinate.y);
-
                     // And create indices for two triangles.
                     var nextI = (i + 1) % stride;
                     var nextJ = (j + 1) % stride;
-
                     indices.push(i * stride + j);
                     indices.push(i * stride + nextJ);
                     indices.push(nextI * stride + j);
-
                     indices.push(i * stride + nextJ);
                     indices.push(nextI * stride + nextJ);
                     indices.push(nextI * stride + j);
                 }
             }
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         VertexData.CreateLines = function (points) {
             var indices = [];
             var positions = [];
-
             for (var index = 0; index < points.length; index++) {
                 positions.push(points[index].x, points[index].y, points[index].z);
-
                 if (index > 0) {
                     indices.push(index - 1);
                     indices.push(index);
                 }
             }
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
-
             return vertexData;
         };
-
         VertexData.CreateGround = function (width, height, subdivisions) {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
             var row, col;
-
             width = width || 1;
             height = height || 1;
             subdivisions = subdivisions || 1;
-
             for (row = 0; row <= subdivisions; row++) {
                 for (col = 0; col <= subdivisions; col++) {
                     var position = new BABYLON.Vector3((col * width) / subdivisions - (width / 2.0), 0, ((subdivisions - row) * height) / subdivisions - (height / 2.0));
                     var normal = new BABYLON.Vector3(0, 1.0, 0);
-
                     positions.push(position.x, position.y, position.z);
                     normals.push(normal.x, normal.y, normal.z);
                     uvs.push(col / subdivisions, 1.0 - row / subdivisions);
                 }
             }
-
             for (row = 0; row < subdivisions; row++) {
                 for (col = 0; col < subdivisions; col++) {
                     indices.push(col + 1 + (row + 1) * (subdivisions + 1));
                     indices.push(col + 1 + row * (subdivisions + 1));
                     indices.push(col + row * (subdivisions + 1));
-
                     indices.push(col + (row + 1) * (subdivisions + 1));
                     indices.push(col + 1 + (row + 1) * (subdivisions + 1));
                     indices.push(col + row * (subdivisions + 1));
                 }
             }
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         VertexData.CreateTiledGround = function (xmin, zmin, xmax, zmax, subdivisions, precision) {
-            if (typeof subdivisions === "undefined") { subdivisions = { w: 1, h: 1 }; }
-            if (typeof precision === "undefined") { precision = { w: 1, h: 1 }; }
+            if (subdivisions === void 0) { subdivisions = { w: 1, h: 1 }; }
+            if (precision === void 0) { precision = { w: 1, h: 1 }; }
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
             var row, col, tileRow, tileCol;
-
             subdivisions.h = (subdivisions.w < 1) ? 1 : subdivisions.h;
             subdivisions.w = (subdivisions.w < 1) ? 1 : subdivisions.w;
             precision.w = (precision.w < 1) ? 1 : precision.w;
             precision.h = (precision.h < 1) ? 1 : precision.h;
-
             var tileSize = {
                 'w': (xmax - xmin) / subdivisions.w,
                 'h': (zmax - zmin) / subdivisions.h
             };
-
             for (tileRow = 0; tileRow < subdivisions.h; tileRow++) {
                 for (tileCol = 0; tileCol < subdivisions.w; tileCol++) {
                     applyTile(xmin + tileCol * tileSize.w, zmin + tileRow * tileSize.h, xmin + (tileCol + 1) * tileSize.w, zmin + (tileRow + 1) * tileSize.h);
                 }
             }
-
             function applyTile(xTileMin, zTileMin, xTileMax, zTileMax) {
                 // Indices
                 var base = positions.length / 3;
@@ -676,7 +539,6 @@
                             base + (col + 1) + (row + 1) * rowLength,
                             base + col + (row + 1) * rowLength
                         ];
-
                         indices.push(square[1]);
                         indices.push(square[2]);
                         indices.push(square[3]);
@@ -685,7 +547,6 @@
                         indices.push(square[3]);
                     }
                 }
-
                 // Position, normals and uvs
                 var position = BABYLON.Vector3.Zero();
                 var normal = new BABYLON.Vector3(0, 1.0, 0);
@@ -694,156 +555,122 @@
                     for (col = 0; col <= precision.w; col++) {
                         position.x = (col * (xTileMax - xTileMin)) / precision.w + xTileMin;
                         position.y = 0;
-
                         positions.push(position.x, position.y, position.z);
                         normals.push(normal.x, normal.y, normal.z);
                         uvs.push(col / precision.w, row / precision.h);
                     }
                 }
             }
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         VertexData.CreateGroundFromHeightMap = function (width, height, subdivisions, minHeight, maxHeight, buffer, bufferWidth, bufferHeight) {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
             var row, col;
-
             for (row = 0; row <= subdivisions; row++) {
                 for (col = 0; col <= subdivisions; col++) {
                     var position = new BABYLON.Vector3((col * width) / subdivisions - (width / 2.0), 0, ((subdivisions - row) * height) / subdivisions - (height / 2.0));
-
                     // Compute height
                     var heightMapX = (((position.x + width / 2) / width) * (bufferWidth - 1)) | 0;
                     var heightMapY = ((1.0 - (position.z + height / 2) / height) * (bufferHeight - 1)) | 0;
-
                     var pos = (heightMapX + heightMapY * bufferWidth) * 4;
                     var r = buffer[pos] / 255.0;
                     var g = buffer[pos + 1] / 255.0;
                     var b = buffer[pos + 2] / 255.0;
-
                     var gradient = r * 0.3 + g * 0.59 + b * 0.11;
-
                     position.y = minHeight + (maxHeight - minHeight) * gradient;
-
                     // Add  vertex
                     positions.push(position.x, position.y, position.z);
                     normals.push(0, 0, 0);
                     uvs.push(col / subdivisions, 1.0 - row / subdivisions);
                 }
             }
-
             for (row = 0; row < subdivisions; row++) {
                 for (col = 0; col < subdivisions; col++) {
                     indices.push(col + 1 + (row + 1) * (subdivisions + 1));
                     indices.push(col + 1 + row * (subdivisions + 1));
                     indices.push(col + row * (subdivisions + 1));
-
                     indices.push(col + (row + 1) * (subdivisions + 1));
                     indices.push(col + 1 + (row + 1) * (subdivisions + 1));
                     indices.push(col + row * (subdivisions + 1));
                 }
             }
-
             // Normals
             BABYLON.VertexData.ComputeNormals(positions, indices, normals);
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         VertexData.CreatePlane = function (size) {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
-
             size = size || 1;
-
             // Vertices
             var halfSize = size / 2.0;
             positions.push(-halfSize, -halfSize, 0);
             normals.push(0, 0, -1.0);
             uvs.push(0.0, 0.0);
-
             positions.push(halfSize, -halfSize, 0);
             normals.push(0, 0, -1.0);
             uvs.push(1.0, 0.0);
-
             positions.push(halfSize, halfSize, 0);
             normals.push(0, 0, -1.0);
             uvs.push(1.0, 1.0);
-
             positions.push(-halfSize, halfSize, 0);
             normals.push(0, 0, -1.0);
             uvs.push(0.0, 1.0);
-
             // Indices
             indices.push(0);
             indices.push(1);
             indices.push(2);
-
             indices.push(0);
             indices.push(2);
             indices.push(3);
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         // based on http://code.google.com/p/away3d/source/browse/trunk/fp10/Away3D/src/away3d/primitives/TorusKnot.as?spec=svn2473&r=2473
         VertexData.CreateTorusKnot = function (radius, tube, radialSegments, tubularSegments, p, q) {
             var indices = [];
             var positions = [];
             var normals = [];
             var uvs = [];
-
             radius = radius || 2;
             tube = tube || 0.5;
             radialSegments = radialSegments || 32;
             tubularSegments = tubularSegments || 32;
             p = p || 2;
             q = q || 3;
-
             // Helper
             var getPos = function (angle) {
                 var cu = Math.cos(angle);
                 var su = Math.sin(angle);
                 var quOverP = q / p * angle;
                 var cs = Math.cos(quOverP);
-
                 var tx = radius * (2 + cs) * 0.5 * cu;
                 var ty = radius * (2 + cs) * su * 0.5;
                 var tz = radius * Math.sin(quOverP) * 0.5;
-
                 return new BABYLON.Vector3(tx, ty, tz);
             };
-
             for (var i = 0; i <= radialSegments; i++) {
                 var modI = i % radialSegments;
                 var u = modI / radialSegments * 2 * p * Math.PI;
@@ -851,28 +678,22 @@
                 var p2 = getPos(u + 0.01);
                 var tang = p2.subtract(p1);
                 var n = p2.add(p1);
-
                 var bitan = BABYLON.Vector3.Cross(tang, n);
                 n = BABYLON.Vector3.Cross(bitan, tang);
-
                 bitan.normalize();
                 n.normalize();
-
                 for (var j = 0; j < tubularSegments; j++) {
                     var modJ = j % tubularSegments;
                     var v = modJ / tubularSegments * 2 * Math.PI;
                     var cx = -tube * Math.cos(v);
                     var cy = tube * Math.sin(v);
-
                     positions.push(p1.x + cx * n.x + cy * bitan.x);
                     positions.push(p1.y + cx * n.y + cy * bitan.y);
                     positions.push(p1.z + cx * n.z + cy * bitan.z);
-
                     uvs.push(i / radialSegments);
                     uvs.push(j / tubularSegments);
                 }
             }
-
             for (i = 0; i < radialSegments; i++) {
                 for (j = 0; j < tubularSegments; j++) {
                     var jNext = (j + 1) % tubularSegments;
@@ -880,7 +701,6 @@
                     var b = (i + 1) * tubularSegments + j;
                     var c = (i + 1) * tubularSegments + jNext;
                     var d = i * tubularSegments + jNext;
-
                     indices.push(d);
                     indices.push(b);
                     indices.push(a);
@@ -889,63 +709,49 @@
                     indices.push(b);
                 }
             }
-
             // Normals
             BABYLON.VertexData.ComputeNormals(positions, indices, normals);
-
             // Result
             var vertexData = new BABYLON.VertexData();
-
             vertexData.indices = indices;
             vertexData.positions = positions;
             vertexData.normals = normals;
             vertexData.uvs = uvs;
-
             return vertexData;
         };
-
         // Tools
         VertexData.ComputeNormals = function (positions, indices, normals) {
             var positionVectors = [];
             var facesOfVertices = [];
             var index;
-
             for (index = 0; index < positions.length; index += 3) {
                 var vector3 = new BABYLON.Vector3(positions[index], positions[index + 1], positions[index + 2]);
                 positionVectors.push(vector3);
                 facesOfVertices.push([]);
             }
-
             // Compute normals
             var facesNormals = [];
             for (index = 0; index < indices.length / 3; index++) {
                 var i1 = indices[index * 3];
                 var i2 = indices[index * 3 + 1];
                 var i3 = indices[index * 3 + 2];
-
                 var p1 = positionVectors[i1];
                 var p2 = positionVectors[i2];
                 var p3 = positionVectors[i3];
-
                 var p1p2 = p1.subtract(p2);
                 var p3p2 = p3.subtract(p2);
-
                 facesNormals[index] = BABYLON.Vector3.Normalize(BABYLON.Vector3.Cross(p1p2, p3p2));
                 facesOfVertices[i1].push(index);
                 facesOfVertices[i2].push(index);
                 facesOfVertices[i3].push(index);
             }
-
             for (index = 0; index < positionVectors.length; index++) {
                 var faces = facesOfVertices[index];
-
                 var normal = BABYLON.Vector3.Zero();
                 for (var faceIndex = 0; faceIndex < faces.length; faceIndex++) {
                     normal.addInPlace(facesNormals[faces[faceIndex]]);
                 }
-
                 normal = BABYLON.Vector3.Normalize(normal.scale(1.0 / faces.length));
-
                 normals[index * 3] = normal.x;
                 normals[index * 3 + 1] = normal.y;
                 normals[index * 3 + 2] = normal.z;
@@ -955,4 +761,4 @@
     })();
     BABYLON.VertexData = VertexData;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.mesh.vertexData.js.map
+//# sourceMappingURL=babylon.mesh.vertexData.js.map

Babylon/Mesh/babylon.meshLODLevel.js

@@ -1,5 +1,6 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
+    var Internals;
     (function (Internals) {
         var MeshLODLevel = (function () {
             function MeshLODLevel(distance, mesh) {
@@ -9,7 +10,6 @@
             return MeshLODLevel;
         })();
         Internals.MeshLODLevel = MeshLODLevel;
-    })(BABYLON.Internals || (BABYLON.Internals = {}));
-    var Internals = BABYLON.Internals;
+    })(Internals = BABYLON.Internals || (BABYLON.Internals = {}));
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.meshLODLevel.js.map
+//# sourceMappingURL=babylon.meshLODLevel.js.map

Babylon/Mesh/babylon.meshSimplification.js

@@ -1,9 +1,5 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
-    
-
-    
-
     var SimplificationSettings = (function () {
         function SimplificationSettings(quality, distance) {
             this.quality = quality;
@@ -12,16 +8,14 @@
         return SimplificationSettings;
     })();
     BABYLON.SimplificationSettings = SimplificationSettings;
-
     /**
-    * The implemented types of simplification.
-    * At the moment only Quadratic Error Decimation is implemented.
-    */
+     * The implemented types of simplification.
+     * At the moment only Quadratic Error Decimation is implemented.
+     */
     (function (SimplificationType) {
         SimplificationType[SimplificationType["QUADRATIC"] = 0] = "QUADRATIC";
     })(BABYLON.SimplificationType || (BABYLON.SimplificationType = {}));
     var SimplificationType = BABYLON.SimplificationType;
-
     var DecimationTriangle = (function () {
         function DecimationTriangle(vertices) {
             this.vertices = vertices;
@@ -33,7 +27,6 @@
         return DecimationTriangle;
     })();
     BABYLON.DecimationTriangle = DecimationTriangle;
-
     var DecimationVertex = (function () {
         function DecimationVertex(position, normal, uv, id) {
             this.position = position;
@@ -48,14 +41,14 @@
         return DecimationVertex;
     })();
     BABYLON.DecimationVertex = DecimationVertex;
-
     var QuadraticMatrix = (function () {
         function QuadraticMatrix(data) {
             this.data = new Array(10);
             for (var i = 0; i < 10; ++i) {
                 if (data && data[i]) {
                     this.data[i] = data[i];
-                } else {
+                }
+                else {
                     this.data[i] = 0;
                 }
             }
@@ -64,19 +57,16 @@
             var det = this.data[a11] * this.data[a22] * this.data[a33] + this.data[a13] * this.data[a21] * this.data[a32] + this.data[a12] * this.data[a23] * this.data[a31] - this.data[a13] * this.data[a22] * this.data[a31] - this.data[a11] * this.data[a23] * this.data[a32] - this.data[a12] * this.data[a21] * this.data[a33];
             return det;
         };
-
         QuadraticMatrix.prototype.addInPlace = function (matrix) {
             for (var i = 0; i < 10; ++i) {
                 this.data[i] += matrix.data[i];
             }
         };
-
         QuadraticMatrix.prototype.addArrayInPlace = function (data) {
             for (var i = 0; i < 10; ++i) {
                 this.data[i] += data[i];
             }
         };
-
         QuadraticMatrix.prototype.add = function (matrix) {
             var m = new QuadraticMatrix();
             for (var i = 0; i < 10; ++i) {
@@ -84,11 +74,9 @@
             }
             return m;
         };
-
         QuadraticMatrix.FromData = function (a, b, c, d) {
             return new QuadraticMatrix(QuadraticMatrix.DataFromNumbers(a, b, c, d));
         };
-
         //returning an array to avoid garbage collection
         QuadraticMatrix.DataFromNumbers = function (a, b, c, d) {
             return [a * a, a * b, a * c, a * d, b * b, b * c, b * d, c * c, c * d, d * d];
@@ -96,7 +84,6 @@
         return QuadraticMatrix;
     })();
     BABYLON.QuadraticMatrix = QuadraticMatrix;
-
     var Reference = (function () {
         function Reference(vertexId, triangleId) {
             this.vertexId = vertexId;
@@ -105,13 +92,12 @@
         return Reference;
     })();
     BABYLON.Reference = Reference;
-
     /**
-    * An implementation of the Quadratic Error simplification algorithm.
-    * Original paper : http://www1.cs.columbia.edu/~cs4162/html05s/garland97.pdf
-    * Ported mostly from QSlim and http://voxels.blogspot.de/2014/05/quadric-mesh-simplification-with-source.html to babylon JS
-    * @author RaananW
-    */
+     * An implementation of the Quadratic Error simplification algorithm.
+     * Original paper : http://www1.cs.columbia.edu/~cs4162/html05s/garland97.pdf
+     * Ported mostly from QSlim and http://voxels.blogspot.de/2014/05/quadric-mesh-simplification-with-source.html to babylon JS
+     * @author RaananW
+     */
     var QuadraticErrorSimplification = (function () {
         function QuadraticErrorSimplification(_mesh) {
             this._mesh = _mesh;
@@ -126,26 +112,20 @@
                 _this.runDecimation(settings, successCallback);
             });
         };
-
         QuadraticErrorSimplification.prototype.runDecimation = function (settings, successCallback) {
             var _this = this;
             var targetCount = ~~(this.triangles.length * settings.quality);
             var deletedTriangles = 0;
-
             var triangleCount = this.triangles.length;
-
             var iterationFunction = function (iteration, callback) {
                 setTimeout(function () {
                     if (iteration % 5 === 0) {
                         _this.updateMesh(iteration === 0);
                     }
-
                     for (var i = 0; i < _this.triangles.length; ++i) {
                         _this.triangles[i].isDirty = false;
                     }
-
                     var threshold = 0.000000001 * Math.pow((iteration + 3), _this.aggressiveness);
-
                     var trianglesIterator = function (i) {
                         var tIdx = ~~(((_this.triangles.length / 2) + i) % _this.triangles.length);
                         var t = _this.triangles[tIdx];
@@ -158,64 +138,50 @@
                             if (t.error[j] < threshold) {
                                 var deleted0 = [];
                                 var deleted1 = [];
-
                                 var i0 = t.vertices[j];
                                 var i1 = t.vertices[(j + 1) % 3];
                                 var v0 = _this.vertices[i0];
                                 var v1 = _this.vertices[i1];
-
                                 if (v0.isBorder !== v1.isBorder)
                                     continue;
-
                                 var p = BABYLON.Vector3.Zero();
                                 var n = BABYLON.Vector3.Zero();
                                 var uv = BABYLON.Vector2.Zero();
                                 var color = new BABYLON.Color4(0, 0, 0, 1);
-
                                 _this.calculateError(v0, v1, p, n, uv, color);
-
                                 var delTr = [];
-
                                 if (_this.isFlipped(v0, i1, p, deleted0, t.borderFactor, delTr))
                                     continue;
                                 if (_this.isFlipped(v1, i0, p, deleted1, t.borderFactor, delTr))
                                     continue;
-
                                 if (delTr.length == 2 || delTr[0] === delTr[1]) {
                                     continue;
                                 }
-
                                 v0.normal = n;
                                 if (v0.uv)
                                     v0.uv = uv;
                                 else if (v0.color)
                                     v0.color = color;
                                 v0.q = v1.q.add(v0.q);
-
                                 if (deleted0.indexOf(true) < 0 || deleted1.indexOf(true) < 0)
                                     continue;
-
                                 if (p.equals(v0.position))
                                     continue;
                                 v0.position = p;
-
                                 var tStart = _this.references.length;
-
                                 deletedTriangles = _this.updateTriangles(v0.id, v0, deleted0, deletedTriangles);
                                 deletedTriangles = _this.updateTriangles(v0.id, v1, deleted1, deletedTriangles);
-
                                 var tCount = _this.references.length - tStart;
-
                                 if (tCount <= v0.triangleCount) {
                                     if (tCount) {
                                         for (var c = 0; c < tCount; c++) {
                                             _this.references[v0.triangleStart + c] = _this.references[tStart + c];
                                         }
                                     }
-                                } else {
+                                }
+                                else {
                                     v0.triangleStart = tStart;
                                 }
-
                                 v0.triangleCount = tCount;
                                 break;
                             }
@@ -226,7 +192,6 @@
                     });
                 }, 0);
             };
-
             BABYLON.AsyncLoop.Run(this.decimationIterations, function (loop) {
                 if (triangleCount - deletedTriangles <= targetCount)
                     loop.breakLoop();
@@ -241,29 +206,25 @@
                 }, 0);
             });
         };
-
         QuadraticErrorSimplification.prototype.initWithMesh = function (mesh, callback) {
             var _this = this;
             if (!mesh)
                 return;
-
             this.vertices = [];
             this.triangles = [];
-
             this._mesh = mesh;
-
             //It is assumed that a mesh has positions, normals and either uvs or colors.
             var positionData = this._mesh.getVerticesData(BABYLON.VertexBuffer.PositionKind);
             var normalData = this._mesh.getVerticesData(BABYLON.VertexBuffer.NormalKind);
             var uvs = this._mesh.getVerticesData(BABYLON.VertexBuffer.UVKind);
             var colorsData = this._mesh.getVerticesData(BABYLON.VertexBuffer.ColorKind);
             var indices = mesh.getIndices();
-
             var vertexInit = function (i) {
                 var vertex = new DecimationVertex(BABYLON.Vector3.FromArray(positionData, i * 3), BABYLON.Vector3.FromArray(normalData, i * 3), null, i);
                 if (_this._mesh.isVerticesDataPresent(BABYLON.VertexBuffer.UVKind)) {
                     vertex.uv = BABYLON.Vector2.FromArray(uvs, i * 2);
-                } else if (_this._mesh.isVerticesDataPresent(BABYLON.VertexBuffer.ColorKind)) {
+                }
+                else if (_this._mesh.isVerticesDataPresent(BABYLON.VertexBuffer.ColorKind)) {
                     vertex.color = BABYLON.Color4.FromArray(colorsData, i * 4);
                 }
                 _this.vertices.push(vertex);
@@ -283,7 +244,6 @@
                 });
             });
         };
-
         QuadraticErrorSimplification.prototype.init = function (callback) {
             var _this = this;
             var triangleInit1 = function (i) {
@@ -307,7 +267,6 @@
                 });
             });
         };
-
         QuadraticErrorSimplification.prototype.reconstructMesh = function () {
             var newTriangles = [];
             var i;
@@ -325,9 +284,7 @@
                     newTriangles.push(t);
                 }
             }
-
             var newVerticesOrder = [];
-
             //compact vertices, get the IDs of the vertices used.
             var dst = 0;
             for (i = 0; i < this.vertices.length; ++i) {
@@ -341,7 +298,6 @@
                     dst++;
                 }
             }
-
             for (i = 0; i < newTriangles.length; ++i) {
                 t = newTriangles[i];
                 for (j = 0; j < 3; ++j) {
@@ -349,12 +305,10 @@
                 }
             }
             this.vertices = this.vertices.slice(0, dst);
-
             var newPositionData = [];
             var newNormalData = [];
             var newUVsData = [];
             var newColorsData = [];
-
             for (i = 0; i < newVerticesOrder.length; ++i) {
                 newPositionData.push(this.vertices[i].position.x);
                 newPositionData.push(this.vertices[i].position.y);
@@ -365,21 +319,20 @@
                 if (this.vertices[i].uv) {
                     newUVsData.push(this.vertices[i].uv.x);
                     newUVsData.push(this.vertices[i].uv.y);
-                } else if (this.vertices[i].color) {
+                }
+                else if (this.vertices[i].color) {
                     newColorsData.push(this.vertices[i].color.r);
                     newColorsData.push(this.vertices[i].color.g);
                     newColorsData.push(this.vertices[i].color.b);
                     newColorsData.push(this.vertices[i].color.a);
                 }
             }
-
             var newIndicesArray = [];
             for (i = 0; i < newTriangles.length; ++i) {
                 newIndicesArray.push(newTriangles[i].vertices[0]);
                 newIndicesArray.push(newTriangles[i].vertices[1]);
                 newIndicesArray.push(newTriangles[i].vertices[2]);
             }
-
             //not cloning, to avoid geometry problems. Creating a whole new mesh.
             var newMesh = new BABYLON.Mesh(this._mesh.name + "Decimated", this._mesh.getScene());
             newMesh.material = this._mesh.material;
@@ -391,33 +344,24 @@
                 newMesh.setVerticesData(BABYLON.VertexBuffer.UVKind, newUVsData);
             if (newColorsData.length > 0)
                 newMesh.setVerticesData(BABYLON.VertexBuffer.ColorKind, newColorsData);
-
             //preparing the skeleton support
             if (this._mesh.skeleton) {
-                //newMesh.skeleton = this._mesh.skeleton.clone("", "");
-                //newMesh.getScene().beginAnimation(newMesh.skeleton, 0, 100, true, 1.0);
             }
-
             return newMesh;
         };
-
         QuadraticErrorSimplification.prototype.isFlipped = function (vertex1, index2, point, deletedArray, borderFactor, delTr) {
             for (var i = 0; i < vertex1.triangleCount; ++i) {
                 var t = this.triangles[this.references[vertex1.triangleStart + i].triangleId];
                 if (t.deleted)
                     continue;
-
                 var s = this.references[vertex1.triangleStart + i].vertexId;
-
                 var id1 = t.vertices[(s + 1) % 3];
                 var id2 = t.vertices[(s + 2) % 3];
-
                 if ((id1 === index2 || id2 === index2) && borderFactor < 2) {
                     deletedArray[i] = true;
                     delTr.push(t);
                     continue;
                 }
-
                 var d1 = this.vertices[id1].position.subtract(point);
                 d1 = d1.normalize();
                 var d2 = this.vertices[id2].position.subtract(point);
@@ -429,10 +373,8 @@
                 if (BABYLON.Vector3.Dot(normal, t.normal) < 0.2)
                     return true;
             }
-
             return false;
         };
-
         QuadraticErrorSimplification.prototype.updateTriangles = function (vertexId, vertex, deletedArray, deletedTriangles) {
             var newDeleted = deletedTriangles;
             for (var i = 0; i < vertex.triangleCount; ++i) {
@@ -455,7 +397,6 @@
             }
             return newDeleted;
         };
-
         QuadraticErrorSimplification.prototype.identifyBorder = function () {
             for (var i = 0; i < this.vertices.length; ++i) {
                 var vCount = [];
@@ -475,24 +416,24 @@
                         if (ofs === vCount.length) {
                             vCount.push(1);
                             vId.push(id);
-                        } else {
+                        }
+                        else {
                             vCount[ofs]++;
                         }
                     }
                 }
-
                 for (j = 0; j < vCount.length; ++j) {
                     if (vCount[j] === 1) {
                         this.vertices[vId[j]].isBorder = true;
-                    } else {
+                    }
+                    else {
                         this.vertices[vId[j]].isBorder = false;
                     }
                 }
             }
         };
-
         QuadraticErrorSimplification.prototype.updateMesh = function (identifyBorders) {
-            if (typeof identifyBorders === "undefined") { identifyBorders = false; }
+            if (identifyBorders === void 0) { identifyBorders = false; }
             var i;
             if (!identifyBorders) {
                 var newTrianglesVector = [];
@@ -503,7 +444,6 @@
                 }
                 this.triangles = newTrianglesVector;
             }
-
             for (i = 0; i < this.vertices.length; ++i) {
                 this.vertices[i].triangleCount = 0;
                 this.vertices[i].triangleStart = 0;
@@ -518,15 +458,12 @@
                     v.triangleCount++;
                 }
             }
-
             var tStart = 0;
-
             for (i = 0; i < this.vertices.length; ++i) {
                 this.vertices[i].triangleStart = tStart;
                 tStart += this.vertices[i].triangleCount;
                 this.vertices[i].triangleCount = 0;
             }
-
             var newReferences = new Array(this.triangles.length * 3);
             for (i = 0; i < this.triangles.length; ++i) {
                 t = this.triangles[i];
@@ -537,25 +474,21 @@
                 }
             }
             this.references = newReferences;
-
             if (identifyBorders) {
                 this.identifyBorder();
             }
         };
-
         QuadraticErrorSimplification.prototype.vertexError = function (q, point) {
             var x = point.x;
             var y = point.y;
             var z = point.z;
             return q.data[0] * x * x + 2 * q.data[1] * x * y + 2 * q.data[2] * x * z + 2 * q.data[3] * x + q.data[4] * y * y + 2 * q.data[5] * y * z + 2 * q.data[6] * y + q.data[7] * z * z + 2 * q.data[8] * z + q.data[9];
         };
-
         QuadraticErrorSimplification.prototype.calculateError = function (vertex1, vertex2, pointResult, normalResult, uvResult, colorResult) {
             var q = vertex1.q.add(vertex2.q);
             var border = vertex1.isBorder && vertex2.isBorder;
             var error = 0;
             var qDet = q.det(0, 1, 2, 1, 4, 5, 2, 5, 7);
-
             if (qDet !== 0 && !border) {
                 if (!pointResult) {
                     pointResult = BABYLON.Vector3.Zero();
@@ -564,7 +497,6 @@
                 pointResult.y = 1 / qDet * (q.det(0, 2, 3, 1, 5, 6, 2, 7, 8));
                 pointResult.z = -1 / qDet * (q.det(0, 1, 3, 1, 4, 6, 2, 5, 8));
                 error = this.vertexError(q, pointResult);
-
                 //TODO this should be correctly calculated
                 if (normalResult) {
                     normalResult.copyFrom(vertex1.normal);
@@ -573,9 +505,9 @@
                     else if (vertex1.color)
                         colorResult.copyFrom(vertex1.color);
                 }
-            } else {
+            }
+            else {
                 var p3 = (vertex1.position.add(vertex2.position)).divide(new BABYLON.Vector3(2, 2, 2));
-
                 //var norm3 = (vertex1.normal.add(vertex2.normal)).divide(new Vector3(2, 2, 2)).normalize();
                 var error1 = this.vertexError(q, vertex1.position);
                 var error2 = this.vertexError(q, vertex2.position);
@@ -590,7 +522,8 @@
                         else if (vertex1.color)
                             colorResult.copyFrom(vertex1.color);
                     }
-                } else if (error === error2) {
+                }
+                else if (error === error2) {
                     if (pointResult) {
                         pointResult.copyFrom(vertex2.position);
                         normalResult.copyFrom(vertex2.normal);
@@ -599,7 +532,8 @@
                         else if (vertex2.color)
                             colorResult.copyFrom(vertex2.color);
                     }
-                } else {
+                }
+                else {
                     if (pointResult) {
                         pointResult.copyFrom(p3);
                         normalResult.copyFrom(vertex1.normal);
@@ -616,4 +550,4 @@
     })();
     BABYLON.QuadraticErrorSimplification = QuadraticErrorSimplification;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.meshSimplification.js.map
+//# sourceMappingURL=babylon.meshSimplification.js.map

Babylon/Mesh/babylon.polygonmesh.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -14,7 +14,6 @@ var BABYLON;
         }
         return IndexedVector2;
     })(BABYLON.Vector2);
-
     var PolygonPoints = (function () {
         function PolygonPoints() {
             this.elements = new Array();
@@ -29,30 +28,27 @@ var BABYLON;
                     _this.elements.push(newPoint);
                 }
             });
-
             return result;
         };
-
         PolygonPoints.prototype.computeBounds = function () {
             var lmin = new BABYLON.Vector2(this.elements[0].x, this.elements[0].y);
             var lmax = new BABYLON.Vector2(this.elements[0].x, this.elements[0].y);
-
             this.elements.forEach(function (point) {
                 // x
                 if (point.x < lmin.x) {
                     lmin.x = point.x;
-                } else if (point.x > lmax.x) {
+                }
+                else if (point.x > lmax.x) {
                     lmax.x = point.x;
                 }
-
                 // y
                 if (point.y < lmin.y) {
                     lmin.y = point.y;
-                } else if (point.y > lmax.y) {
+                }
+                else if (point.y > lmax.y) {
                     lmax.y = point.y;
                 }
             });
-
             return {
                 min: lmin,
                 max: lmax,
@@ -62,7 +58,6 @@ var BABYLON;
         };
         return PolygonPoints;
     })();
-
     var Polygon = (function () {
         function Polygon() {
         }
@@ -74,99 +69,81 @@ var BABYLON;
                 new BABYLON.Vector2(xmin, ymax)
             ];
         };
-
         Polygon.Circle = function (radius, cx, cy, numberOfSides) {
-            if (typeof cx === "undefined") { cx = 0; }
-            if (typeof cy === "undefined") { cy = 0; }
-            if (typeof numberOfSides === "undefined") { numberOfSides = 32; }
+            if (cx === void 0) { cx = 0; }
+            if (cy === void 0) { cy = 0; }
+            if (numberOfSides === void 0) { numberOfSides = 32; }
             var result = new Array();
-
             var angle = 0;
             var increment = (Math.PI * 2) / numberOfSides;
-
             for (var i = 0; i < numberOfSides; i++) {
                 result.push(new BABYLON.Vector2(cx + Math.cos(angle) * radius, cy + Math.sin(angle) * radius));
                 angle -= increment;
             }
-
             return result;
         };
-
         Polygon.Parse = function (input) {
-            var floats = input.split(/[^-+eE\.\d]+/).map(parseFloat).filter(function (val) {
-                return (!isNaN(val));
-            });
+            var floats = input.split(/[^-+eE\.\d]+/).map(parseFloat).filter(function (val) { return (!isNaN(val)); });
             var i, result = [];
             for (i = 0; i < (floats.length & 0x7FFFFFFE); i += 2) {
                 result.push(new poly2tri.Point(floats[i], floats[i + 1]));
             }
             return result;
         };
-
         Polygon.StartingAt = function (x, y) {
             return BABYLON.Path2.StartingAt(x, y);
         };
         return Polygon;
     })();
     BABYLON.Polygon = Polygon;
-
     var PolygonMeshBuilder = (function () {
         function PolygonMeshBuilder(name, contours, scene) {
             this._points = new PolygonPoints();
             if (!("poly2tri" in window)) {
                 throw "PolygonMeshBuilder cannot be used because poly2tri is not referenced";
             }
-
             this._name = name;
             this._scene = scene;
-
             var points;
             if (contours instanceof BABYLON.Path2) {
                 points = contours.getPoints();
-            } else {
+            }
+            else {
                 points = contours;
             }
-
             this._swctx = new poly2tri.SweepContext(this._points.add(points));
         }
         PolygonMeshBuilder.prototype.addHole = function (hole) {
             this._swctx.addHole(this._points.add(hole));
             return this;
         };
-
         PolygonMeshBuilder.prototype.build = function (updatable) {
-            if (typeof updatable === "undefined") { updatable = false; }
+            if (updatable === void 0) { updatable = false; }
             var result = new BABYLON.Mesh(this._name, this._scene);
-
             var normals = [];
             var positions = [];
             var uvs = [];
-
             var bounds = this._points.computeBounds();
             this._points.elements.forEach(function (p) {
                 normals.push(0, 1.0, 0);
                 positions.push(p.x, 0, p.y);
                 uvs.push((p.x - bounds.min.x) / bounds.width, (p.y - bounds.min.y) / bounds.height);
             });
-
             var indices = [];
-
             this._swctx.triangulate();
             this._swctx.getTriangles().forEach(function (triangle) {
                 triangle.getPoints().forEach(function (point) {
                     indices.push(point.index);
                 });
             });
-
             result.setVerticesData(positions, BABYLON.VertexBuffer.PositionKind, updatable);
             result.setVerticesData(normals, BABYLON.VertexBuffer.NormalKind, updatable);
             result.setVerticesData(uvs, BABYLON.VertexBuffer.UVKind, updatable);
             result.setIndices(indices);
-
             return result;
         };
         return PolygonMeshBuilder;
     })();
     BABYLON.PolygonMeshBuilder = PolygonMeshBuilder;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.polygonMesh.js.map
+//# sourceMappingURL=babylon.polygonMesh.js.map

Babylon/Mesh/babylon.subMesh.js

@@ -1,8 +1,8 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var SubMesh = (function () {
         function SubMesh(materialIndex, verticesStart, verticesCount, indexStart, indexCount, mesh, renderingMesh, createBoundingBox) {
-            if (typeof createBoundingBox === "undefined") { createBoundingBox = true; }
+            if (createBoundingBox === void 0) { createBoundingBox = true; }
             this.materialIndex = materialIndex;
             this.verticesStart = verticesStart;
             this.verticesCount = verticesCount;
@@ -12,9 +12,7 @@
             this._mesh = mesh;
             this._renderingMesh = renderingMesh || mesh;
             mesh.subMeshes.push(this);
-
             this._id = mesh.subMeshes.length - 1;
-
             if (createBoundingBox) {
                 this.refreshBoundingInfo();
             }
@@ -22,158 +20,124 @@
         SubMesh.prototype.getBoundingInfo = function () {
             return this._boundingInfo;
         };
-
         SubMesh.prototype.getMesh = function () {
             return this._mesh;
         };
-
         SubMesh.prototype.getRenderingMesh = function () {
             return this._renderingMesh;
         };
-
         SubMesh.prototype.getMaterial = function () {
             var rootMaterial = this._renderingMesh.material;
-
             if (rootMaterial && rootMaterial instanceof BABYLON.MultiMaterial) {
                 var multiMaterial = rootMaterial;
                 return multiMaterial.getSubMaterial(this.materialIndex);
             }
-
             if (!rootMaterial) {
                 return this._mesh.getScene().defaultMaterial;
             }
-
             return rootMaterial;
         };
-
         // Methods
         SubMesh.prototype.refreshBoundingInfo = function () {
             var data = this._renderingMesh.getVerticesData(BABYLON.VertexBuffer.PositionKind);
-
             if (!data) {
                 this._boundingInfo = this._mesh._boundingInfo;
                 return;
             }
-
             var indices = this._renderingMesh.getIndices();
             var extend;
-
             if (this.indexStart === 0 && this.indexCount === indices.length) {
                 extend = BABYLON.Tools.ExtractMinAndMax(data, this.verticesStart, this.verticesCount);
-            } else {
+            }
+            else {
                 extend = BABYLON.Tools.ExtractMinAndMaxIndexed(data, indices, this.indexStart, this.indexCount);
             }
             this._boundingInfo = new BABYLON.BoundingInfo(extend.minimum, extend.maximum);
         };
-
         SubMesh.prototype._checkCollision = function (collider) {
             return this._boundingInfo._checkCollision(collider);
         };
-
         SubMesh.prototype.updateBoundingInfo = function (world) {
             if (!this._boundingInfo) {
                 this.refreshBoundingInfo();
             }
             this._boundingInfo._update(world);
         };
-
         SubMesh.prototype.isInFrustum = function (frustumPlanes) {
             return this._boundingInfo.isInFrustum(frustumPlanes);
         };
-
         SubMesh.prototype.render = function () {
             this._renderingMesh.render(this);
         };
-
         SubMesh.prototype.getLinesIndexBuffer = function (indices, engine) {
             if (!this._linesIndexBuffer) {
                 var linesIndices = [];
-
                 for (var index = this.indexStart; index < this.indexStart + this.indexCount; index += 3) {
                     linesIndices.push(indices[index], indices[index + 1], indices[index + 1], indices[index + 2], indices[index + 2], indices[index]);
                 }
-
                 this._linesIndexBuffer = engine.createIndexBuffer(linesIndices);
                 this.linesIndexCount = linesIndices.length;
             }
             return this._linesIndexBuffer;
         };
-
         SubMesh.prototype.canIntersects = function (ray) {
             return ray.intersectsBox(this._boundingInfo.boundingBox);
         };
-
         SubMesh.prototype.intersects = function (ray, positions, indices, fastCheck) {
             var intersectInfo = null;
-
             for (var index = this.indexStart; index < this.indexStart + this.indexCount; index += 3) {
                 var p0 = positions[indices[index]];
                 var p1 = positions[indices[index + 1]];
                 var p2 = positions[indices[index + 2]];
-
                 var currentIntersectInfo = ray.intersectsTriangle(p0, p1, p2);
-
                 if (currentIntersectInfo) {
                     if (currentIntersectInfo.distance < 0) {
                         continue;
                     }
-
                     if (fastCheck || !intersectInfo || currentIntersectInfo.distance < intersectInfo.distance) {
                         intersectInfo = currentIntersectInfo;
                         intersectInfo.faceId = index / 3;
-
                         if (fastCheck) {
                             break;
                         }
                     }
                 }
             }
-
             return intersectInfo;
         };
-
-        // Clone
+        // Clone    
         SubMesh.prototype.clone = function (newMesh, newRenderingMesh) {
             var result = new SubMesh(this.materialIndex, this.verticesStart, this.verticesCount, this.indexStart, this.indexCount, newMesh, newRenderingMesh, false);
-
             result._boundingInfo = new BABYLON.BoundingInfo(this._boundingInfo.minimum, this._boundingInfo.maximum);
-
             return result;
         };
-
         // Dispose
         SubMesh.prototype.dispose = function () {
             if (this._linesIndexBuffer) {
                 this._mesh.getScene().getEngine()._releaseBuffer(this._linesIndexBuffer);
                 this._linesIndexBuffer = null;
             }
-
             // Remove from mesh
             var index = this._mesh.subMeshes.indexOf(this);
             this._mesh.subMeshes.splice(index, 1);
         };
-
         // Statics
         SubMesh.CreateFromIndices = function (materialIndex, startIndex, indexCount, mesh, renderingMesh) {
             var minVertexIndex = Number.MAX_VALUE;
             var maxVertexIndex = -Number.MAX_VALUE;
-
             renderingMesh = renderingMesh || mesh;
             var indices = renderingMesh.getIndices();
-
             for (var index = startIndex; index < startIndex + indexCount; index++) {
                 var vertexIndex = indices[index];
-
                 if (vertexIndex < minVertexIndex)
                     minVertexIndex = vertexIndex;
                 if (vertexIndex > maxVertexIndex)
                     maxVertexIndex = vertexIndex;
             }
-
             return new BABYLON.SubMesh(materialIndex, minVertexIndex, maxVertexIndex - minVertexIndex + 1, startIndex, indexCount, mesh, renderingMesh);
         };
         return SubMesh;
     })();
     BABYLON.SubMesh = SubMesh;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.subMesh.js.map
+//# sourceMappingURL=babylon.subMesh.js.map

Babylon/Mesh/babylon.vertexBuffer.js

@@ -1,28 +1,23 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var VertexBuffer = (function () {
         function VertexBuffer(engine, data, kind, updatable, postponeInternalCreation, stride) {
             if (engine instanceof BABYLON.Mesh) {
                 this._engine = engine.getScene().getEngine();
-            } else {
+            }
+            else {
                 this._engine = engine;
             }
-
             this._updatable = updatable;
-
             this._data = data;
-
             if (!postponeInternalCreation) {
                 this.create();
             }
-
             this._kind = kind;
-
             if (stride) {
                 this._strideSize = stride;
                 return;
             }
-
             switch (kind) {
                 case VertexBuffer.PositionKind:
                     this._strideSize = 3;
@@ -51,56 +46,46 @@
         VertexBuffer.prototype.isUpdatable = function () {
             return this._updatable;
         };
-
         VertexBuffer.prototype.getData = function () {
             return this._data;
         };
-
         VertexBuffer.prototype.getBuffer = function () {
             return this._buffer;
         };
-
         VertexBuffer.prototype.getStrideSize = function () {
             return this._strideSize;
         };
-
         // Methods
         VertexBuffer.prototype.create = function (data) {
             if (!data && this._buffer) {
-                return;
+                return; // nothing to do
             }
-
             data = data || this._data;
-
             if (!this._buffer) {
                 if (this._updatable) {
                     this._buffer = this._engine.createDynamicVertexBuffer(data.length * 4);
-                } else {
+                }
+                else {
                     this._buffer = this._engine.createVertexBuffer(data);
                 }
             }
-
             if (this._updatable) {
                 this._engine.updateDynamicVertexBuffer(this._buffer, data);
                 this._data = data;
             }
         };
-
         VertexBuffer.prototype.update = function (data) {
             this.create(data);
         };
-
         VertexBuffer.prototype.updateDirectly = function (data, offset) {
             if (!this._buffer) {
                 return;
             }
-
             if (this._updatable) {
                 this._engine.updateDynamicVertexBuffer(this._buffer, data, offset);
                 this._data = null;
             }
         };
-
         VertexBuffer.prototype.dispose = function () {
             if (!this._buffer) {
                 return;
@@ -109,7 +94,6 @@
                 this._buffer = null;
             }
         };
-
         Object.defineProperty(VertexBuffer, "PositionKind", {
             get: function () {
                 return VertexBuffer._PositionKind;
@@ -117,7 +101,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(VertexBuffer, "NormalKind", {
             get: function () {
                 return VertexBuffer._NormalKind;
@@ -125,7 +108,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(VertexBuffer, "UVKind", {
             get: function () {
                 return VertexBuffer._UVKind;
@@ -133,7 +115,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(VertexBuffer, "UV2Kind", {
             get: function () {
                 return VertexBuffer._UV2Kind;
@@ -141,7 +122,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(VertexBuffer, "ColorKind", {
             get: function () {
                 return VertexBuffer._ColorKind;
@@ -149,7 +129,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(VertexBuffer, "MatricesIndicesKind", {
             get: function () {
                 return VertexBuffer._MatricesIndicesKind;
@@ -157,7 +136,6 @@
             enumerable: true,
             configurable: true
         });
-
         Object.defineProperty(VertexBuffer, "MatricesWeightsKind", {
             get: function () {
                 return VertexBuffer._MatricesWeightsKind;
@@ -165,6 +143,7 @@
             enumerable: true,
             configurable: true
         });
+        // Enums
         VertexBuffer._PositionKind = "position";
         VertexBuffer._NormalKind = "normal";
         VertexBuffer._UVKind = "uv";
@@ -176,4 +155,4 @@
     })();
     BABYLON.VertexBuffer = VertexBuffer;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.vertexBuffer.js.map
+//# sourceMappingURL=babylon.vertexBuffer.js.map

Babylon/Particles/babylon.particle.js

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

Babylon/Particles/babylon.particleSystem.js

@@ -1,15 +1,12 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var randomNumber = function (min, max) {
         if (min === max) {
             return (min);
         }
-
         var random = Math.random();
-
         return ((random * (max - min)) + min);
     };
-
     var ParticleSystem = (function () {
         function ParticleSystem(name, capacity, scene, customEffect) {
             var _this = this;
@@ -42,7 +39,7 @@
             this.textureMask = new BABYLON.Color4(1.0, 1.0, 1.0, 1.0);
             this.particles = new Array();
             this._vertexDeclaration = [3, 4, 4];
-            this._vertexStrideSize = 11 * 4;
+            this._vertexStrideSize = 11 * 4; // 11 floats per particle (x, y, z, r, g, b, a, angle, size, offsetX, offsetY)
             this._stockParticles = new Array();
             this._newPartsExcess = 0;
             this._scaledColorStep = new BABYLON.Color4(0, 0, 0, 0);
@@ -55,16 +52,11 @@
             this._actualFrame = 0;
             this.id = name;
             this._capacity = capacity;
-
             this._scene = scene;
-
             this._customEffect = customEffect;
-
             scene.particleSystems.push(this);
-
             // VBO
             this._vertexBuffer = scene.getEngine().createDynamicVertexBuffer(capacity * this._vertexStrideSize * 4);
-
             var indices = [];
             var index = 0;
             for (var count = 0; count < capacity; count++) {
@@ -76,49 +68,38 @@
                 indices.push(index + 3);
                 index += 4;
             }
-
             this._indexBuffer = scene.getEngine().createIndexBuffer(indices);
-
             this._vertices = new Float32Array(capacity * this._vertexStrideSize);
-
             // Default behaviors
             this.startDirectionFunction = function (emitPower, worldMatrix, directionToUpdate) {
                 var randX = randomNumber(_this.direction1.x, _this.direction2.x);
                 var randY = randomNumber(_this.direction1.y, _this.direction2.y);
                 var randZ = randomNumber(_this.direction1.z, _this.direction2.z);
-
                 BABYLON.Vector3.TransformNormalFromFloatsToRef(randX * emitPower, randY * emitPower, randZ * emitPower, worldMatrix, directionToUpdate);
             };
-
             this.startPositionFunction = function (worldMatrix, positionToUpdate) {
                 var randX = randomNumber(_this.minEmitBox.x, _this.maxEmitBox.x);
                 var randY = randomNumber(_this.minEmitBox.y, _this.maxEmitBox.y);
                 var randZ = randomNumber(_this.minEmitBox.z, _this.maxEmitBox.z);
-
                 BABYLON.Vector3.TransformCoordinatesFromFloatsToRef(randX, randY, randZ, worldMatrix, positionToUpdate);
             };
-
             this.updateFunction = function (particles) {
                 for (var index = 0; index < particles.length; index++) {
                     var particle = particles[index];
                     particle.age += _this._scaledUpdateSpeed;
-
                     if (particle.age >= particle.lifeTime) {
                         _this.recycleParticle(particle);
                         index--;
                         continue;
-                    } else {
+                    }
+                    else {
                         particle.colorStep.scaleToRef(_this._scaledUpdateSpeed, _this._scaledColorStep);
                         particle.color.addInPlace(_this._scaledColorStep);
-
                         if (particle.color.a < 0)
                             particle.color.a = 0;
-
                         particle.angle += particle.angularSpeed * _this._scaledUpdateSpeed;
-
                         particle.direction.scaleToRef(_this._scaledUpdateSpeed, _this._scaledDirection);
                         particle.position.addInPlace(_this._scaledDirection);
-
                         _this.gravity.scaleToRef(_this._scaledUpdateSpeed, _this._scaledGravity);
                         particle.direction.addInPlace(_this._scaledGravity);
                     }
@@ -127,35 +108,28 @@
         }
         ParticleSystem.prototype.recycleParticle = function (particle) {
             var lastParticle = this.particles.pop();
-
             if (lastParticle !== particle) {
                 lastParticle.copyTo(particle);
                 this._stockParticles.push(lastParticle);
             }
         };
-
         ParticleSystem.prototype.getCapacity = function () {
             return this._capacity;
         };
-
         ParticleSystem.prototype.isAlive = function () {
             return this._alive;
         };
-
         ParticleSystem.prototype.isStarted = function () {
             return this._started;
         };
-
         ParticleSystem.prototype.start = function () {
             this._started = true;
             this._stopped = false;
             this._actualFrame = 0;
         };
-
         ParticleSystem.prototype.stop = function () {
             this._stopped = true;
         };
-
         ParticleSystem.prototype._appendParticleVertex = function (index, particle, offsetX, offsetY) {
             var offset = index * 11;
             this._vertices[offset] = particle.position.x;
@@ -170,127 +144,96 @@
             this._vertices[offset + 9] = offsetX;
             this._vertices[offset + 10] = offsetY;
         };
-
         ParticleSystem.prototype._update = function (newParticles) {
             // Update current
             this._alive = this.particles.length > 0;
-
             this.updateFunction(this.particles);
-
             // Add new ones
             var worldMatrix;
-
             if (this.emitter.position) {
                 worldMatrix = this.emitter.getWorldMatrix();
-            } else {
+            }
+            else {
                 worldMatrix = BABYLON.Matrix.Translation(this.emitter.x, this.emitter.y, this.emitter.z);
             }
-
             for (var index = 0; index < newParticles; index++) {
                 if (this.particles.length === this._capacity) {
                     break;
                 }
-
                 if (this._stockParticles.length !== 0) {
                     var particle = this._stockParticles.pop();
                     particle.age = 0;
-                } else {
+                }
+                else {
                     particle = new BABYLON.Particle();
                 }
                 this.particles.push(particle);
-
                 var emitPower = randomNumber(this.minEmitPower, this.maxEmitPower);
-
                 this.startDirectionFunction(emitPower, worldMatrix, particle.direction);
-
                 particle.lifeTime = randomNumber(this.minLifeTime, this.maxLifeTime);
-
                 particle.size = randomNumber(this.minSize, this.maxSize);
                 particle.angularSpeed = randomNumber(this.minAngularSpeed, this.maxAngularSpeed);
-
                 this.startPositionFunction(worldMatrix, particle.position);
-
                 var step = randomNumber(0, 1.0);
-
                 BABYLON.Color4.LerpToRef(this.color1, this.color2, step, particle.color);
-
                 this.colorDead.subtractToRef(particle.color, this._colorDiff);
                 this._colorDiff.scaleToRef(1.0 / particle.lifeTime, particle.colorStep);
             }
         };
-
         ParticleSystem.prototype._getEffect = function () {
             if (this._customEffect) {
                 return this._customEffect;
             }
             ;
-
             var defines = [];
-
             if (this._scene.clipPlane) {
                 defines.push("#define CLIPPLANE");
             }
-
             // Effect
             var join = defines.join("\n");
             if (this._cachedDefines !== join) {
                 this._cachedDefines = join;
-
                 this._effect = this._scene.getEngine().createEffect("particles", ["position", "color", "options"], ["invView", "view", "projection", "vClipPlane", "textureMask"], ["diffuseSampler"], join);
             }
-
             return this._effect;
         };
-
         ParticleSystem.prototype.animate = function () {
             if (!this._started)
                 return;
-
             var effect = this._getEffect();
-
             // Check
             if (!this.emitter || !effect.isReady() || !this.particleTexture || !this.particleTexture.isReady())
                 return;
-
             if (this._currentRenderId === this._scene.getRenderId()) {
                 return;
             }
-
             this._currentRenderId = this._scene.getRenderId();
-
             this._scaledUpdateSpeed = this.updateSpeed * this._scene.getAnimationRatio();
-
-            // determine the number of particles we need to create
+            // determine the number of particles we need to create   
             var emitCout;
-
             if (this.manualEmitCount > -1) {
                 emitCout = this.manualEmitCount;
                 this.manualEmitCount = 0;
-            } else {
+            }
+            else {
                 emitCout = this.emitRate;
             }
-
             var newParticles = ((emitCout * this._scaledUpdateSpeed) >> 0);
             this._newPartsExcess += emitCout * this._scaledUpdateSpeed - newParticles;
-
             if (this._newPartsExcess > 1.0) {
                 newParticles += this._newPartsExcess >> 0;
                 this._newPartsExcess -= this._newPartsExcess >> 0;
             }
-
             this._alive = false;
-
             if (!this._stopped) {
                 this._actualFrame += this._scaledUpdateSpeed;
-
                 if (this.targetStopDuration && this._actualFrame >= this.targetStopDuration)
                     this.stop();
-            } else {
+            }
+            else {
                 newParticles = 0;
             }
-
             this._update(newParticles);
-
             // Stopped?
             if (this._stopped) {
                 if (!this._alive) {
@@ -300,12 +243,10 @@
                     }
                 }
             }
-
             // Update VBO
             var offset = 0;
             for (var index = 0; index < this.particles.length; index++) {
                 var particle = this.particles[index];
-
                 this._appendParticleVertex(offset++, particle, 0, 0);
                 this._appendParticleVertex(offset++, particle, 1, 0);
                 this._appendParticleVertex(offset++, particle, 1, 1);
@@ -314,26 +255,20 @@
             var engine = this._scene.getEngine();
             engine.updateDynamicVertexBuffer(this._vertexBuffer, this._vertices);
         };
-
         ParticleSystem.prototype.render = function () {
             var effect = this._getEffect();
-
             // Check
             if (!this.emitter || !effect.isReady() || !this.particleTexture || !this.particleTexture.isReady() || !this.particles.length)
                 return 0;
-
             var engine = this._scene.getEngine();
-
             // Render
             engine.enableEffect(effect);
             engine.setState(false);
-
             var viewMatrix = this._scene.getViewMatrix();
             effect.setTexture("diffuseSampler", this.particleTexture);
             effect.setMatrix("view", viewMatrix);
             effect.setMatrix("projection", this._scene.getProjectionMatrix());
             effect.setFloat4("textureMask", this.textureMask.r, this.textureMask.g, this.textureMask.b, this.textureMask.a);
-
             if (this._scene.clipPlane) {
                 var clipPlane = this._scene.clipPlane;
                 var invView = viewMatrix.clone();
@@ -341,76 +276,62 @@
                 effect.setMatrix("invView", invView);
                 effect.setFloat4("vClipPlane", clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.d);
             }
-
             // VBOs
             engine.bindBuffers(this._vertexBuffer, this._indexBuffer, this._vertexDeclaration, this._vertexStrideSize, effect);
-
             // Draw order
             if (this.blendMode === ParticleSystem.BLENDMODE_ONEONE) {
                 engine.setAlphaMode(BABYLON.Engine.ALPHA_ADD);
-            } else {
+            }
+            else {
                 engine.setAlphaMode(BABYLON.Engine.ALPHA_COMBINE);
             }
-
             if (this.forceDepthWrite) {
                 engine.setDepthWrite(true);
             }
-
             engine.draw(true, 0, this.particles.length * 6);
             engine.setAlphaMode(BABYLON.Engine.ALPHA_DISABLE);
-
             return this.particles.length;
         };
-
         ParticleSystem.prototype.dispose = function () {
             if (this._vertexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._vertexBuffer);
                 this._vertexBuffer = null;
             }
-
             if (this._indexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._indexBuffer);
                 this._indexBuffer = null;
             }
-
             if (this.particleTexture) {
                 this.particleTexture.dispose();
                 this.particleTexture = null;
             }
-
             // Remove from scene
             var index = this._scene.particleSystems.indexOf(this);
             this._scene.particleSystems.splice(index, 1);
-
             // Callback
             if (this.onDispose) {
                 this.onDispose();
             }
         };
-
         // Clone
         ParticleSystem.prototype.clone = function (name, newEmitter) {
             var result = new ParticleSystem(name, this._capacity, this._scene);
-
             BABYLON.Tools.DeepCopy(this, result, ["particles"], ["_vertexDeclaration", "_vertexStrideSize"]);
-
             if (newEmitter === undefined) {
                 newEmitter = this.emitter;
             }
-
             result.emitter = newEmitter;
             if (this.particleTexture) {
                 result.particleTexture = new BABYLON.Texture(this.particleTexture.url, this._scene);
             }
-
             result.start();
-
             return result;
         };
+        // Statics
         ParticleSystem.BLENDMODE_ONEONE = 0;
         ParticleSystem.BLENDMODE_STANDARD = 1;
         return ParticleSystem;
     })();
     BABYLON.ParticleSystem = ParticleSystem;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.particleSystem.js.map
+//# sourceMappingURL=babylon.particleSystem.js.map

Babylon/Physics/Plugins/babylon.cannonJSPlugin.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var CannonJSPlugin = (function () {
         function CannonJSPlugin() {
@@ -9,10 +9,8 @@
                     var registeredMesh = this._registeredMeshes[index];
                     if (registeredMesh.mesh === mesh || registeredMesh.mesh === mesh.parent) {
                         var body = registeredMesh.body;
-
                         var center = mesh.getBoundingInfo().boundingBox.center;
                         body.position.set(center.x, center.z, center.y);
-
                         body.quaternion.x = mesh.rotationQuaternion.x;
                         body.quaternion.z = mesh.rotationQuaternion.y;
                         body.quaternion.y = mesh.rotationQuaternion.z;
@@ -23,67 +21,55 @@
             };
         }
         CannonJSPlugin.prototype.initialize = function (iterations) {
-            if (typeof iterations === "undefined") { iterations = 10; }
+            if (iterations === void 0) { iterations = 10; }
             this._world = new CANNON.World();
             this._world.broadphase = new CANNON.NaiveBroadphase();
             this._world.solver.iterations = iterations;
         };
-
         CannonJSPlugin.prototype._checkWithEpsilon = function (value) {
             return value < BABYLON.PhysicsEngine.Epsilon ? BABYLON.PhysicsEngine.Epsilon : value;
         };
-
         CannonJSPlugin.prototype.runOneStep = function (delta) {
             this._world.step(delta);
-
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
-
                 if (registeredMesh.isChild) {
                     continue;
                 }
-
                 // Body position
                 var bodyX = registeredMesh.body.position.x, bodyY = registeredMesh.body.position.y, bodyZ = registeredMesh.body.position.z;
-
                 var deltaPos = registeredMesh.delta;
                 if (deltaPos) {
                     registeredMesh.mesh.position.x = bodyX + deltaPos.x;
                     registeredMesh.mesh.position.y = bodyZ + deltaPos.y;
                     registeredMesh.mesh.position.z = bodyY + deltaPos.z;
-                } else {
+                }
+                else {
                     registeredMesh.mesh.position.x = bodyX;
                     registeredMesh.mesh.position.y = bodyZ;
                     registeredMesh.mesh.position.z = bodyY;
                 }
-
                 if (!registeredMesh.mesh.rotationQuaternion) {
                     registeredMesh.mesh.rotationQuaternion = new BABYLON.Quaternion(0, 0, 0, 1);
                 }
-
                 registeredMesh.mesh.rotationQuaternion.x = registeredMesh.body.quaternion.x;
                 registeredMesh.mesh.rotationQuaternion.y = registeredMesh.body.quaternion.z;
                 registeredMesh.mesh.rotationQuaternion.z = registeredMesh.body.quaternion.y;
                 registeredMesh.mesh.rotationQuaternion.w = -registeredMesh.body.quaternion.w;
             }
         };
-
         CannonJSPlugin.prototype.setGravity = function (gravity) {
             this._world.gravity.set(gravity.x, gravity.z, gravity.y);
         };
-
         CannonJSPlugin.prototype.registerMesh = function (mesh, impostor, options) {
             this.unregisterMesh(mesh);
-
             mesh.computeWorldMatrix(true);
-
             switch (impostor) {
                 case BABYLON.PhysicsEngine.SphereImpostor:
                     var bbox = mesh.getBoundingInfo().boundingBox;
                     var radiusX = bbox.maximumWorld.x - bbox.minimumWorld.x;
                     var radiusY = bbox.maximumWorld.y - bbox.minimumWorld.y;
                     var radiusZ = bbox.maximumWorld.z - bbox.minimumWorld.z;
-
                     return this._createSphere(Math.max(this._checkWithEpsilon(radiusX), this._checkWithEpsilon(radiusY), this._checkWithEpsilon(radiusZ)) / 2, mesh, options);
                 case BABYLON.PhysicsEngine.BoxImpostor:
                     bbox = mesh.getBoundingInfo().boundingBox;
@@ -96,222 +82,166 @@
                 case BABYLON.PhysicsEngine.MeshImpostor:
                     var rawVerts = mesh.getVerticesData(BABYLON.VertexBuffer.PositionKind);
                     var rawFaces = mesh.getIndices();
-
                     return this._createConvexPolyhedron(rawVerts, rawFaces, mesh, options);
             }
-
             return null;
         };
-
         CannonJSPlugin.prototype._createSphere = function (radius, mesh, options) {
             var shape = new CANNON.Sphere(radius);
-
             if (!options) {
                 return shape;
             }
-
             return this._createRigidBodyFromShape(shape, mesh, options.mass, options.friction, options.restitution);
         };
-
         CannonJSPlugin.prototype._createBox = function (x, y, z, mesh, options) {
             var shape = new CANNON.Box(new CANNON.Vec3(x, z, y));
-
             if (!options) {
                 return shape;
             }
-
             return this._createRigidBodyFromShape(shape, mesh, options.mass, options.friction, options.restitution);
         };
-
         CannonJSPlugin.prototype._createPlane = function (mesh, options) {
             var shape = new CANNON.Plane();
-
             if (!options) {
                 return shape;
             }
-
             return this._createRigidBodyFromShape(shape, mesh, options.mass, options.friction, options.restitution);
         };
-
         CannonJSPlugin.prototype._createConvexPolyhedron = function (rawVerts, rawFaces, mesh, options) {
             var verts = [], faces = [];
-
             mesh.computeWorldMatrix(true);
-
             for (var i = 0; i < rawVerts.length; i += 3) {
                 var transformed = BABYLON.Vector3.Zero();
-
                 BABYLON.Vector3.TransformNormalFromFloatsToRef(rawVerts[i], rawVerts[i + 1], rawVerts[i + 2], mesh.getWorldMatrix(), transformed);
                 verts.push(new CANNON.Vec3(transformed.x, transformed.z, transformed.y));
             }
-
             for (var j = 0; j < rawFaces.length; j += 3) {
                 faces.push([rawFaces[j], rawFaces[j + 2], rawFaces[j + 1]]);
             }
-
             var shape = new CANNON.ConvexPolyhedron(verts, faces);
-
             if (!options) {
                 return shape;
             }
-
             return this._createRigidBodyFromShape(shape, mesh, options.mass, options.friction, options.restitution);
         };
-
         CannonJSPlugin.prototype._addMaterial = function (friction, restitution) {
             var index;
             var mat;
-
             for (index = 0; index < this._physicsMaterials.length; index++) {
                 mat = this._physicsMaterials[index];
-
                 if (mat.friction === friction && mat.restitution === restitution) {
                     return mat;
                 }
             }
-
             var currentMat = new CANNON.Material();
             currentMat.friction = friction;
             currentMat.restitution = restitution;
             this._physicsMaterials.push(currentMat);
-
             for (index = 0; index < this._physicsMaterials.length; index++) {
                 mat = this._physicsMaterials[index];
-
                 var contactMaterial = new CANNON.ContactMaterial(mat, currentMat, mat.friction * currentMat.friction, mat.restitution * currentMat.restitution);
                 contactMaterial.contactEquationStiffness = 1e10;
                 contactMaterial.contactEquationRegularizationTime = 10;
-
                 this._world.addContactMaterial(contactMaterial);
             }
-
             return currentMat;
         };
-
         CannonJSPlugin.prototype._createRigidBodyFromShape = function (shape, mesh, mass, friction, restitution) {
             var initialRotation = null;
-
             if (mesh.rotationQuaternion) {
                 initialRotation = mesh.rotationQuaternion.clone();
                 mesh.rotationQuaternion = new BABYLON.Quaternion(0, 0, 0, 1);
             }
-
             // The delta between the mesh position and the mesh bounding box center
             var bbox = mesh.getBoundingInfo().boundingBox;
             var deltaPosition = mesh.position.subtract(bbox.center);
-
             var material = this._addMaterial(friction, restitution);
             var body = new CANNON.RigidBody(mass, shape, material);
-
             if (initialRotation) {
                 body.quaternion.x = initialRotation.x;
                 body.quaternion.z = initialRotation.y;
                 body.quaternion.y = initialRotation.z;
                 body.quaternion.w = -initialRotation.w;
             }
-
             body.position.set(bbox.center.x, bbox.center.z, bbox.center.y);
             this._world.add(body);
-
             this._registeredMeshes.push({ mesh: mesh, body: body, material: material, delta: deltaPosition });
-
             return body;
         };
-
         CannonJSPlugin.prototype.registerMeshesAsCompound = function (parts, options) {
             var compoundShape = new CANNON.Compound();
-
             for (var index = 0; index < parts.length; index++) {
                 var mesh = parts[index].mesh;
-
                 var shape = this.registerMesh(mesh, parts[index].impostor);
-
                 if (index == 0) {
                     compoundShape.addChild(shape, new CANNON.Vec3(0, 0, 0));
-                } else {
+                }
+                else {
                     compoundShape.addChild(shape, new CANNON.Vec3(mesh.position.x, mesh.position.z, mesh.position.y));
                 }
             }
-
             var initialMesh = parts[0].mesh;
             var body = this._createRigidBodyFromShape(compoundShape, initialMesh, options.mass, options.friction, options.restitution);
-
             body.parts = parts;
-
             return body;
         };
-
         CannonJSPlugin.prototype._unbindBody = function (body) {
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
-
                 if (registeredMesh.body === body) {
                     registeredMesh.body = null;
                     registeredMesh.delta = 0;
                 }
             }
         };
-
         CannonJSPlugin.prototype.unregisterMesh = function (mesh) {
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
-
                 if (registeredMesh.mesh === mesh) {
                     // Remove body
                     if (registeredMesh.body) {
                         this._world.remove(registeredMesh.body);
-
                         this._unbindBody(registeredMesh.body);
                     }
-
                     this._registeredMeshes.splice(index, 1);
                     return;
                 }
             }
         };
-
         CannonJSPlugin.prototype.applyImpulse = function (mesh, force, contactPoint) {
             var worldPoint = new CANNON.Vec3(contactPoint.x, contactPoint.z, contactPoint.y);
             var impulse = new CANNON.Vec3(force.x, force.z, force.y);
-
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
-
                 if (registeredMesh.mesh === mesh) {
                     registeredMesh.body.applyImpulse(impulse, worldPoint);
                     return;
                 }
             }
         };
-
         CannonJSPlugin.prototype.createLink = function (mesh1, mesh2, pivot1, pivot2) {
             var body1 = null, body2 = null;
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
-
                 if (registeredMesh.mesh === mesh1) {
                     body1 = registeredMesh.body;
-                } else if (registeredMesh.mesh === mesh2) {
+                }
+                else if (registeredMesh.mesh === mesh2) {
                     body2 = registeredMesh.body;
                 }
             }
-
             if (!body1 || !body2) {
                 return false;
             }
-
             var constraint = new CANNON.PointToPointConstraint(body1, new CANNON.Vec3(pivot1.x, pivot1.z, pivot1.y), body2, new CANNON.Vec3(pivot2.x, pivot2.z, pivot2.y));
             this._world.addConstraint(constraint);
-
             return true;
         };
-
         CannonJSPlugin.prototype.dispose = function () {
             while (this._registeredMeshes.length) {
                 this.unregisterMesh(this._registeredMeshes[0].mesh);
             }
         };
-
         CannonJSPlugin.prototype.isSupported = function () {
             return window.CANNON !== undefined;
         };
@@ -319,4 +249,4 @@
     })();
     BABYLON.CannonJSPlugin = CannonJSPlugin;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.cannonJSPlugin.js.map
+//# sourceMappingURL=babylon.cannonJSPlugin.js.map

Babylon/Physics/Plugins/babylon.oimoJSPlugin.js

@@ -4,30 +4,26 @@ var BABYLON;
         function OimoJSPlugin() {
             this._registeredMeshes = [];
             /**
-            * Update the body position according to the mesh position
-            * @param mesh
-            */
+             * Update the body position according to the mesh position
+             * @param mesh
+             */
             this.updateBodyPosition = function (mesh) {
                 for (var index = 0; index < this._registeredMeshes.length; index++) {
                     var registeredMesh = this._registeredMeshes[index];
                     if (registeredMesh.mesh === mesh || registeredMesh.mesh === mesh.parent) {
                         var body = registeredMesh.body.body;
                         mesh.computeWorldMatrix(true);
-
                         var center = mesh.getBoundingInfo().boundingBox.center;
                         body.setPosition(center.x, center.y, center.z);
                         body.setRotation(mesh.rotation.x, mesh.rotation.y, mesh.rotation.z);
                         return;
                     }
-
                     // Case where the parent has been updated
                     if (registeredMesh.mesh.parent === mesh) {
                         mesh.computeWorldMatrix(true);
                         registeredMesh.mesh.computeWorldMatrix(true);
-
                         var absolutePosition = registeredMesh.mesh.getAbsolutePosition();
                         var absoluteRotation = mesh.rotation;
-
                         body = registeredMesh.body.body;
                         body.setPosition(absolutePosition.x, absolutePosition.y, absolutePosition.z);
                         body.setRotation(absoluteRotation.x, absoluteRotation.y, absoluteRotation.z);
@@ -39,21 +35,17 @@ var BABYLON;
         OimoJSPlugin.prototype._checkWithEpsilon = function (value) {
             return value < BABYLON.PhysicsEngine.Epsilon ? BABYLON.PhysicsEngine.Epsilon : value;
         };
-
         OimoJSPlugin.prototype.initialize = function (iterations) {
             this._world = new OIMO.World();
             this._world.clear();
         };
-
         OimoJSPlugin.prototype.setGravity = function (gravity) {
             this._world.gravity = gravity;
         };
-
         OimoJSPlugin.prototype.registerMesh = function (mesh, impostor, options) {
             var body = null;
             this.unregisterMesh(mesh);
             mesh.computeWorldMatrix(true);
-
             switch (impostor) {
                 case BABYLON.PhysicsEngine.SphereImpostor:
                     var initialRotation = null;
@@ -62,24 +54,19 @@ var BABYLON;
                         mesh.rotationQuaternion = new BABYLON.Quaternion(0, 0, 0, 1);
                         mesh.computeWorldMatrix(true);
                     }
-
                     var bbox = mesh.getBoundingInfo().boundingBox;
                     var radiusX = bbox.maximumWorld.x - bbox.minimumWorld.x;
                     var radiusY = bbox.maximumWorld.y - bbox.minimumWorld.y;
                     var radiusZ = bbox.maximumWorld.z - bbox.minimumWorld.z;
-
                     var size = Math.max(this._checkWithEpsilon(radiusX), this._checkWithEpsilon(radiusY), this._checkWithEpsilon(radiusZ)) / 2;
-
                     // The delta between the mesh position and the mesh bounding box center
                     var deltaPosition = mesh.position.subtract(bbox.center);
-
                     // Transform delta position with the rotation
                     if (initialRotation) {
                         var m = new BABYLON.Matrix();
                         initialRotation.toRotationMatrix(m);
                         deltaPosition = BABYLON.Vector3.TransformCoordinates(deltaPosition, m);
                     }
-
                     body = new OIMO.Body({
                         type: 'sphere',
                         size: [size],
@@ -89,19 +76,16 @@ var BABYLON;
                         config: [options.mass, options.friction, options.restitution],
                         world: this._world
                     });
-
                     // Restore rotation
                     if (initialRotation) {
                         body.setQuaternion(initialRotation);
                     }
-
                     this._registeredMeshes.push({
                         mesh: mesh,
                         body: body,
                         delta: deltaPosition
                     });
                     break;
-
                 case BABYLON.PhysicsEngine.PlaneImpostor:
                 case BABYLON.PhysicsEngine.BoxImpostor:
                     initialRotation = null;
@@ -110,7 +94,6 @@ var BABYLON;
                         mesh.rotationQuaternion = new BABYLON.Quaternion(0, 0, 0, 1);
                         mesh.computeWorldMatrix(true);
                     }
-
                     bbox = mesh.getBoundingInfo().boundingBox;
                     var min = bbox.minimumWorld;
                     var max = bbox.maximumWorld;
@@ -118,17 +101,14 @@ var BABYLON;
                     var sizeX = this._checkWithEpsilon(box.x);
                     var sizeY = this._checkWithEpsilon(box.y);
                     var sizeZ = this._checkWithEpsilon(box.z);
-
                     // The delta between the mesh position and the mesh boudning box center
                     deltaPosition = mesh.position.subtract(bbox.center);
-
                     // Transform delta position with the rotation
                     if (initialRotation) {
                         m = new BABYLON.Matrix();
                         initialRotation.toRotationMatrix(m);
                         deltaPosition = BABYLON.Vector3.TransformCoordinates(deltaPosition, m);
                     }
-
                     body = new OIMO.Body({
                         type: 'box',
                         size: [sizeX, sizeY, sizeZ],
@@ -138,11 +118,9 @@ var BABYLON;
                         config: [options.mass, options.friction, options.restitution],
                         world: this._world
                     });
-
                     if (initialRotation) {
                         body.setQuaternion(initialRotation);
                     }
-
                     this._registeredMeshes.push({
                         mesh: mesh,
                         body: body,
@@ -152,12 +130,9 @@ var BABYLON;
             }
             return body;
         };
-
         OimoJSPlugin.prototype.registerMeshesAsCompound = function (parts, options) {
             var types = [], sizes = [], positions = [], rotations = [];
-
             var initialMesh = parts[0].mesh;
-
             for (var index = 0; index < parts.length; index++) {
                 var part = parts[index];
                 var bodyParameters = this._createBodyAsCompound(part, options, initialMesh);
@@ -166,7 +141,6 @@ var BABYLON;
                 positions.push.apply(positions, bodyParameters.pos);
                 rotations.push.apply(rotations, bodyParameters.rot);
             }
-
             var body = new OIMO.Body({
                 type: types,
                 size: sizes,
@@ -176,26 +150,23 @@ var BABYLON;
                 config: [options.mass, options.friction, options.restitution],
                 world: this._world
             });
-
             this._registeredMeshes.push({
                 mesh: initialMesh,
                 body: body
             });
-
             return body;
         };
-
         OimoJSPlugin.prototype._createBodyAsCompound = function (part, options, initialMesh) {
             var bodyParameters = null;
             var mesh = part.mesh;
-
+            // We need the bounding box/sphere info to compute the physics body
+            mesh.computeWorldMatrix();
             switch (part.impostor) {
                 case BABYLON.PhysicsEngine.SphereImpostor:
                     var bbox = mesh.getBoundingInfo().boundingBox;
                     var radiusX = bbox.maximumWorld.x - bbox.minimumWorld.x;
                     var radiusY = bbox.maximumWorld.y - bbox.minimumWorld.y;
                     var radiusZ = bbox.maximumWorld.z - bbox.minimumWorld.z;
-
                     var size = Math.max(this._checkWithEpsilon(radiusX), this._checkWithEpsilon(radiusY), this._checkWithEpsilon(radiusZ)) / 2;
                     bodyParameters = {
                         type: 'sphere',
@@ -205,7 +176,6 @@ var BABYLON;
                         rot: [mesh.rotation.x / OIMO.TO_RAD, mesh.rotation.y / OIMO.TO_RAD, mesh.rotation.z / OIMO.TO_RAD]
                     };
                     break;
-
                 case BABYLON.PhysicsEngine.PlaneImpostor:
                 case BABYLON.PhysicsEngine.BoxImpostor:
                     bbox = mesh.getBoundingInfo().boundingBox;
@@ -224,10 +194,8 @@ var BABYLON;
                     };
                     break;
             }
-
             return bodyParameters;
         };
-
         OimoJSPlugin.prototype.unregisterMesh = function (mesh) {
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
@@ -241,7 +209,6 @@ var BABYLON;
                 }
             }
         };
-
         OimoJSPlugin.prototype._unbindBody = function (body) {
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
@@ -250,28 +217,26 @@ var BABYLON;
                 }
             }
         };
-
         OimoJSPlugin.prototype.applyImpulse = function (mesh, force, contactPoint) {
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
                 if (registeredMesh.mesh === mesh || registeredMesh.mesh === mesh.parent) {
                     // Get object mass to have a behaviour similar to cannon.js
                     var mass = registeredMesh.body.body.massInfo.mass;
-
                     // The force is scaled with the mass of object
                     registeredMesh.body.body.applyImpulse(contactPoint.scale(OIMO.INV_SCALE), force.scale(OIMO.INV_SCALE * mass));
                     return;
                 }
             }
         };
-
         OimoJSPlugin.prototype.createLink = function (mesh1, mesh2, pivot1, pivot2, options) {
             var body1 = null, body2 = null;
             for (var index = 0; index < this._registeredMeshes.length; index++) {
                 var registeredMesh = this._registeredMeshes[index];
                 if (registeredMesh.mesh === mesh1) {
                     body1 = registeredMesh.body.body;
-                } else if (registeredMesh.mesh === mesh2) {
+                }
+                else if (registeredMesh.mesh === mesh2) {
                     body2 = registeredMesh.body.body;
                 }
             }
@@ -281,7 +246,6 @@ var BABYLON;
             if (!options) {
                 options = {};
             }
-
             new OIMO.Link({
                 type: options.type,
                 body1: body1,
@@ -296,21 +260,17 @@ var BABYLON;
                 spring: options.spring,
                 world: this._world
             });
-
             return true;
         };
-
         OimoJSPlugin.prototype.dispose = function () {
             this._world.clear();
             while (this._registeredMeshes.length) {
                 this.unregisterMesh(this._registeredMeshes[0].mesh);
             }
         };
-
         OimoJSPlugin.prototype.isSupported = function () {
             return OIMO !== undefined;
         };
-
         OimoJSPlugin.prototype._getLastShape = function (body) {
             var lastShape = body.shapes;
             while (lastShape.next) {
@@ -318,10 +278,8 @@ var BABYLON;
             }
             return lastShape;
         };
-
         OimoJSPlugin.prototype.runOneStep = function (time) {
             this._world.step();
-
             // Update the position of all registered meshes
             var i = this._registeredMeshes.length;
             var m;
@@ -329,7 +287,6 @@ var BABYLON;
                 var body = this._registeredMeshes[i].body.body;
                 var mesh = this._registeredMeshes[i].mesh;
                 var delta = this._registeredMeshes[i].delta;
-
                 if (!body.sleeping) {
                     if (body.shapes.next) {
                         var parentShape = this._getLastShape(body);
@@ -337,29 +294,27 @@ var BABYLON;
                         mesh.position.y = parentShape.position.y * OIMO.WORLD_SCALE;
                         mesh.position.z = parentShape.position.z * OIMO.WORLD_SCALE;
                         var mtx = BABYLON.Matrix.FromArray(body.getMatrix());
-
                         if (!mesh.rotationQuaternion) {
                             mesh.rotationQuaternion = new BABYLON.Quaternion(0, 0, 0, 1);
                         }
                         mesh.rotationQuaternion.fromRotationMatrix(mtx);
                         mesh.computeWorldMatrix();
-                    } else {
+                    }
+                    else {
                         m = body.getMatrix();
                         mtx = BABYLON.Matrix.FromArray(m);
-
                         // Body position
                         var bodyX = mtx.m[12], bodyY = mtx.m[13], bodyZ = mtx.m[14];
-
                         if (!delta) {
                             mesh.position.x = bodyX;
                             mesh.position.y = bodyY;
                             mesh.position.z = bodyZ;
-                        } else {
+                        }
+                        else {
                             mesh.position.x = bodyX + delta.x;
                             mesh.position.y = bodyY + delta.y;
                             mesh.position.z = bodyZ + delta.z;
                         }
-
                         if (!mesh.rotationQuaternion) {
                             mesh.rotationQuaternion = new BABYLON.Quaternion(0, 0, 0, 1);
                         }
@@ -373,4 +328,4 @@ var BABYLON;
     })();
     BABYLON.OimoJSPlugin = OimoJSPlugin;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.oimoJSPlugin.js.map
+//# sourceMappingURL=babylon.oimoJSPlugin.js.map

Babylon/Physics/Plugins/babylon.oimoJSPlugin.ts

@@ -393,4 +393,4 @@ module BABYLON {
             }
         }
     }
-}
+}

Babylon/Physics/babylon.physicsEngine.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var PhysicsEngine = (function () {
         function PhysicsEngine(plugin) {
@@ -8,54 +8,44 @@
             this._currentPlugin.initialize();
             this._setGravity(gravity);
         };
-
         PhysicsEngine.prototype._runOneStep = function (delta) {
             if (delta > 0.1) {
                 delta = 0.1;
-            } else if (delta <= 0) {
+            }
+            else if (delta <= 0) {
                 delta = 1.0 / 60.0;
             }
-
             this._currentPlugin.runOneStep(delta);
         };
-
         PhysicsEngine.prototype._setGravity = function (gravity) {
             this.gravity = gravity || new BABYLON.Vector3(0, -9.82, 0);
             this._currentPlugin.setGravity(this.gravity);
         };
-
         PhysicsEngine.prototype._registerMesh = function (mesh, impostor, options) {
             return this._currentPlugin.registerMesh(mesh, impostor, options);
         };
-
         PhysicsEngine.prototype._registerMeshesAsCompound = function (parts, options) {
             return this._currentPlugin.registerMeshesAsCompound(parts, options);
         };
-
         PhysicsEngine.prototype._unregisterMesh = function (mesh) {
             this._currentPlugin.unregisterMesh(mesh);
         };
-
         PhysicsEngine.prototype._applyImpulse = function (mesh, force, contactPoint) {
             this._currentPlugin.applyImpulse(mesh, force, contactPoint);
         };
-
         PhysicsEngine.prototype._createLink = function (mesh1, mesh2, pivot1, pivot2, options) {
             return this._currentPlugin.createLink(mesh1, mesh2, pivot1, pivot2, options);
         };
-
         PhysicsEngine.prototype._updateBodyPosition = function (mesh) {
             this._currentPlugin.updateBodyPosition(mesh);
         };
-
         PhysicsEngine.prototype.dispose = function () {
             this._currentPlugin.dispose();
         };
-
         PhysicsEngine.prototype.isSupported = function () {
             return this._currentPlugin.isSupported();
         };
-
+        // Statics
         PhysicsEngine.NoImpostor = 0;
         PhysicsEngine.SphereImpostor = 1;
         PhysicsEngine.BoxImpostor = 2;
@@ -70,4 +60,4 @@
     })();
     BABYLON.PhysicsEngine = PhysicsEngine;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.physicsEngine.js.map
+//# sourceMappingURL=babylon.physicsEngine.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js

@@ -5,14 +5,10 @@ var BABYLON;
             this._engine = engine;
             this._name = name;
             this._singleInstance = singleInstance || true;
-
             this._getPostProcess = getPostProcess;
-
             this._cameras = [];
             this._indicesForCamera = [];
-
             this._postProcesses = {};
-
             this._renderPasses = {};
             this._renderEffectAsPasses = {};
         }
@@ -21,25 +17,18 @@ var BABYLON;
                 this._renderPasses[renderPassName]._update();
             }
         };
-
         PostProcessRenderEffect.prototype.addPass = function (renderPass) {
             this._renderPasses[renderPass._name] = renderPass;
-
             this._linkParameters();
         };
-
         PostProcessRenderEffect.prototype.removePass = function (renderPass) {
             delete this._renderPasses[renderPass._name];
-
             this._linkParameters();
         };
-
         PostProcessRenderEffect.prototype.addRenderEffectAsPass = function (renderEffect) {
             this._renderEffectAsPasses[renderEffect._name] = renderEffect;
-
             this._linkParameters();
         };
-
         PostProcessRenderEffect.prototype.getPass = function (passName) {
             for (var renderPassName in this._renderPasses) {
                 if (renderPassName === passName) {
@@ -47,130 +36,100 @@ var BABYLON;
                 }
             }
         };
-
         PostProcessRenderEffect.prototype.emptyPasses = function () {
             this._renderPasses = {};
-
             this._linkParameters();
         };
-
         PostProcessRenderEffect.prototype._attachCameras = function (cameras) {
             var cameraKey;
-
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             for (var i = 0; i < _cam.length; i++) {
                 var camera = _cam[i];
                 var cameraName = camera.name;
-
                 if (this._singleInstance) {
                     cameraKey = 0;
-                } else {
+                }
+                else {
                     cameraKey = cameraName;
                 }
-
                 this._postProcesses[cameraKey] = this._postProcesses[cameraKey] || this._getPostProcess();
-
                 var index = camera.attachPostProcess(this._postProcesses[cameraKey]);
-
                 if (!this._indicesForCamera[cameraName]) {
                     this._indicesForCamera[cameraName] = [];
                 }
-
                 this._indicesForCamera[cameraName].push(index);
-
                 if (this._cameras.indexOf(camera) === -1) {
                     this._cameras[cameraName] = camera;
                 }
-
                 for (var passName in this._renderPasses) {
                     this._renderPasses[passName]._incRefCount();
                 }
             }
-
             this._linkParameters();
         };
-
         PostProcessRenderEffect.prototype._detachCameras = function (cameras) {
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             for (var i = 0; i < _cam.length; i++) {
                 var camera = _cam[i];
                 var cameraName = camera.name;
-
                 camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName]);
-
                 var index = this._cameras.indexOf(cameraName);
-
                 this._indicesForCamera.splice(index, 1);
                 this._cameras.splice(index, 1);
-
                 for (var passName in this._renderPasses) {
                     this._renderPasses[passName]._decRefCount();
                 }
             }
         };
-
         PostProcessRenderEffect.prototype._enable = function (cameras) {
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             for (var i = 0; i < _cam.length; i++) {
                 var camera = _cam[i];
                 var cameraName = camera.name;
-
                 for (var j = 0; j < this._indicesForCamera[cameraName].length; j++) {
                     if (camera._postProcesses[this._indicesForCamera[cameraName][j]] === undefined) {
                         cameras[i].attachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName][j]);
                     }
                 }
-
                 for (var passName in this._renderPasses) {
                     this._renderPasses[passName]._incRefCount();
                 }
             }
         };
-
         PostProcessRenderEffect.prototype._disable = function (cameras) {
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             for (var i = 0; i < _cam.length; i++) {
                 var camera = _cam[i];
                 var cameraName = camera.Name;
-
                 camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName]);
-
                 for (var passName in this._renderPasses) {
                     this._renderPasses[passName]._decRefCount();
                 }
             }
         };
-
         PostProcessRenderEffect.prototype.getPostProcess = function (camera) {
             if (this._singleInstance) {
                 return this._postProcesses[0];
-            } else {
+            }
+            else {
                 return this._postProcesses[camera.name];
             }
         };
-
         PostProcessRenderEffect.prototype._linkParameters = function () {
             var _this = this;
             for (var index in this._postProcesses) {
                 if (this.applyParameters) {
                     this.applyParameters(this._postProcesses[index]);
                 }
-
                 this._postProcesses[index].onBeforeRender = function (effect) {
                     _this._linkTextures(effect);
                 };
             }
         };
-
         PostProcessRenderEffect.prototype._linkTextures = function (effect) {
             for (var renderPassName in this._renderPasses) {
                 effect.setTexture(renderPassName, this._renderPasses[renderPassName].getRenderTexture());
             }
-
             for (var renderEffectName in this._renderEffectAsPasses) {
                 effect.setTextureFromPostProcess(renderEffectName + "Sampler", this._renderEffectAsPasses[renderEffectName].getPostProcess());
             }
@@ -179,4 +138,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderEffect = PostProcessRenderEffect;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.postProcessRenderEffect.js.map
+//# sourceMappingURL=babylon.postProcessRenderEffect.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js

@@ -1,19 +1,15 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var PostProcessRenderPass = (function () {
         function PostProcessRenderPass(scene, name, size, renderList, beforeRender, afterRender) {
             this._enabled = true;
             this._refCount = 0;
             this._name = name;
-
             this._renderTexture = new BABYLON.RenderTargetTexture(name, size, scene);
             this.setRenderList(renderList);
-
             this._renderTexture.onBeforeRender = beforeRender;
             this._renderTexture.onAfterRender = afterRender;
-
             this._scene = scene;
-
             this._renderList = renderList;
         }
         // private
@@ -21,29 +17,22 @@
             if (this._refCount === 0) {
                 this._scene.customRenderTargets.push(this._renderTexture);
             }
-
             return ++this._refCount;
         };
-
         PostProcessRenderPass.prototype._decRefCount = function () {
             this._refCount--;
-
             if (this._refCount <= 0) {
                 this._scene.customRenderTargets.splice(this._scene.customRenderTargets.indexOf(this._renderTexture), 1);
             }
-
             return this._refCount;
         };
-
         PostProcessRenderPass.prototype._update = function () {
             this.setRenderList(this._renderList);
         };
-
         // public
         PostProcessRenderPass.prototype.setRenderList = function (renderList) {
             this._renderTexture.renderList = renderList;
         };
-
         PostProcessRenderPass.prototype.getRenderTexture = function () {
             return this._renderTexture;
         };
@@ -51,4 +40,4 @@
     })();
     BABYLON.PostProcessRenderPass = PostProcessRenderPass;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.postProcessRenderPass.js.map
+//# sourceMappingURL=babylon.postProcessRenderPass.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js

@@ -4,101 +4,76 @@ var BABYLON;
         function PostProcessRenderPipeline(engine, name) {
             this._engine = engine;
             this._name = name;
-
             this._renderEffects = {};
             this._renderEffectsForIsolatedPass = {};
-
             this._cameras = [];
         }
         PostProcessRenderPipeline.prototype.addEffect = function (renderEffect) {
             this._renderEffects[renderEffect._name] = renderEffect;
         };
-
         PostProcessRenderPipeline.prototype._enableEffect = function (renderEffectName, cameras) {
             var renderEffects = this._renderEffects[renderEffectName];
-
             if (!renderEffects) {
                 return;
             }
-
             renderEffects._enable(BABYLON.Tools.MakeArray(cameras || this._cameras));
         };
-
         PostProcessRenderPipeline.prototype._disableEffect = function (renderEffectName, cameras) {
             var renderEffects = this._renderEffects[renderEffectName];
-
             if (!renderEffects) {
                 return;
             }
-
             renderEffects._disable(BABYLON.Tools.MakeArray(cameras || this._cameras));
         };
-
         PostProcessRenderPipeline.prototype._attachCameras = function (cameras, unique) {
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             var indicesToDelete = [];
-
             for (var i = 0; i < _cam.length; i++) {
                 var camera = _cam[i];
                 var cameraName = camera.name;
-
                 if (this._cameras.indexOf(camera) === -1) {
                     this._cameras[cameraName] = camera;
-                } else if (unique) {
+                }
+                else if (unique) {
                     indicesToDelete.push(i);
                 }
             }
-
             for (var i = 0; i < indicesToDelete.length; i++) {
                 cameras.splice(indicesToDelete[i], 1);
             }
-
             for (var renderEffectName in this._renderEffects) {
                 this._renderEffects[renderEffectName]._attachCameras(_cam);
             }
         };
-
         PostProcessRenderPipeline.prototype._detachCameras = function (cameras) {
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             for (var renderEffectName in this._renderEffects) {
                 this._renderEffects[renderEffectName]._detachCameras(_cam);
             }
-
             for (var i = 0; i < _cam.length; i++) {
                 this._cameras.splice(this._cameras.indexOf(_cam[i]), 1);
             }
         };
-
         PostProcessRenderPipeline.prototype._enableDisplayOnlyPass = function (passName, cameras) {
             var _this = this;
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             var pass = null;
-
             for (var renderEffectName in this._renderEffects) {
                 pass = this._renderEffects[renderEffectName].getPass(passName);
-
                 if (pass != null) {
                     break;
                 }
             }
-
             if (pass === null) {
                 return;
             }
-
             for (var renderEffectName in this._renderEffects) {
                 this._renderEffects[renderEffectName]._disable(_cam);
             }
-
             pass._name = PostProcessRenderPipeline.PASS_SAMPLER_NAME;
-
             for (var i = 0; i < _cam.length; i++) {
                 var camera = _cam[i];
                 var cameraName = camera.name;
-
                 this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new BABYLON.PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, function () {
                     return new BABYLON.DisplayPassPostProcess(PostProcessRenderPipeline.PASS_EFFECT_NAME, 1.0, null, null, _this._engine, true);
                 });
@@ -107,31 +82,25 @@ var BABYLON;
                 this._renderEffectsForIsolatedPass[cameraName]._attachCameras(camera);
             }
         };
-
         PostProcessRenderPipeline.prototype._disableDisplayOnlyPass = function (cameras) {
             var _this = this;
             var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
             for (var i = 0; i < _cam.length; i++) {
                 var camera = _cam[i];
                 var cameraName = camera.name;
-
                 this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new BABYLON.PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, function () {
                     return new BABYLON.DisplayPassPostProcess(PostProcessRenderPipeline.PASS_EFFECT_NAME, 1.0, null, null, _this._engine, true);
                 });
                 this._renderEffectsForIsolatedPass[cameraName]._disable(camera);
             }
-
             for (var renderEffectName in this._renderEffects) {
                 this._renderEffects[renderEffectName]._enable(_cam);
             }
         };
-
         PostProcessRenderPipeline.prototype._update = function () {
             for (var renderEffectName in this._renderEffects) {
                 this._renderEffects[renderEffectName]._update();
             }
-
             for (var i = 0; i < this._cameras.length; i++) {
                 var cameraName = this._cameras[i].name;
                 if (this._renderEffectsForIsolatedPass[cameraName]) {
@@ -145,4 +114,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPipeline = PostProcessRenderPipeline;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.postProcessRenderPipeline.js.map
+//# sourceMappingURL=babylon.postProcessRenderPipeline.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js

@@ -7,67 +7,48 @@ var BABYLON;
         PostProcessRenderPipelineManager.prototype.addPipeline = function (renderPipeline) {
             this._renderPipelines[renderPipeline._name] = renderPipeline;
         };
-
         PostProcessRenderPipelineManager.prototype.attachCamerasToRenderPipeline = function (renderPipelineName, cameras, unique) {
             var renderPipeline = this._renderPipelines[renderPipelineName];
-
             if (!renderPipeline) {
                 return;
             }
-
             renderPipeline._attachCameras(cameras, unique);
         };
-
         PostProcessRenderPipelineManager.prototype.detachCamerasFromRenderPipeline = function (renderPipelineName, cameras) {
             var renderPipeline = this._renderPipelines[renderPipelineName];
-
             if (!renderPipeline) {
                 return;
             }
-
             renderPipeline._detachCameras(cameras);
         };
-
         PostProcessRenderPipelineManager.prototype.enableEffectInPipeline = function (renderPipelineName, renderEffectName, cameras) {
             var renderPipeline = this._renderPipelines[renderPipelineName];
-
             if (!renderPipeline) {
                 return;
             }
-
             renderPipeline._enableEffect(renderEffectName, cameras);
         };
-
         PostProcessRenderPipelineManager.prototype.disableEffectInPipeline = function (renderPipelineName, renderEffectName, cameras) {
             var renderPipeline = this._renderPipelines[renderPipelineName];
-
             if (!renderPipeline) {
                 return;
             }
-
             renderPipeline._disableEffect(renderEffectName, cameras);
         };
-
         PostProcessRenderPipelineManager.prototype.enableDisplayOnlyPassInPipeline = function (renderPipelineName, passName, cameras) {
             var renderPipeline = this._renderPipelines[renderPipelineName];
-
             if (!renderPipeline) {
                 return;
             }
-
             renderPipeline._enableDisplayOnlyPass(passName, cameras);
         };
-
         PostProcessRenderPipelineManager.prototype.disableDisplayOnlyPassInPipeline = function (renderPipelineName, cameras) {
             var renderPipeline = this._renderPipelines[renderPipelineName];
-
             if (!renderPipeline) {
                 return;
             }
-
             renderPipeline._disableDisplayOnlyPass(cameras);
         };
-
         PostProcessRenderPipelineManager.prototype.update = function () {
             for (var renderPipelineName in this._renderPipelines) {
                 this._renderPipelines[renderPipelineName]._update();
@@ -77,4 +58,4 @@ var BABYLON;
     })();
     BABYLON.PostProcessRenderPipelineManager = PostProcessRenderPipelineManager;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.postProcessRenderPipelineManager.js.map
+//# sourceMappingURL=babylon.postProcessRenderPipelineManager.js.map

Babylon/PostProcess/babylon.anaglyphPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -15,4 +15,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.AnaglyphPostProcess = AnaglyphPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.anaglyphPostProcess.js.map
+//# sourceMappingURL=babylon.anaglyphPostProcess.js.map

Babylon/PostProcess/babylon.blackAndWhitePostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -15,4 +15,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.BlackAndWhitePostProcess = BlackAndWhitePostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.blackAndWhitePostProcess.js.map
+//# sourceMappingURL=babylon.blackAndWhitePostProcess.js.map

Babylon/PostProcess/babylon.blurPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -9,8 +9,8 @@ var BABYLON;
     var BlurPostProcess = (function (_super) {
         __extends(BlurPostProcess, _super);
         function BlurPostProcess(name, direction, blurWidth, ratio, camera, samplingMode, engine, reusable) {
-            if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.BILINEAR_SAMPLINGMODE; }
             var _this = this;
+            if (samplingMode === void 0) { samplingMode = BABYLON.Texture.BILINEAR_SAMPLINGMODE; }
             _super.call(this, name, "blur", ["screenSize", "direction", "blurWidth"], null, ratio, camera, samplingMode, engine, reusable);
             this.direction = direction;
             this.blurWidth = blurWidth;
@@ -24,4 +24,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.BlurPostProcess = BlurPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.blurPostProcess.js.map
+//# sourceMappingURL=babylon.blurPostProcess.js.map

Babylon/PostProcess/babylon.convolutionPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -12,12 +12,13 @@ var BABYLON;
             var _this = this;
             _super.call(this, name, "convolution", ["kernel", "screenSize"], null, ratio, camera, samplingMode, engine, reusable);
             this.kernel = kernel;
-
             this.onApply = function (effect) {
                 effect.setFloat2("screenSize", _this.width, _this.height);
                 effect.setArray("kernel", _this.kernel);
             };
         }
+        // Statics
+        // Based on http://en.wikipedia.org/wiki/Kernel_(image_processing)
         ConvolutionPostProcess.EdgeDetect0Kernel = [1, 0, -1, 0, 0, 0, -1, 0, 1];
         ConvolutionPostProcess.EdgeDetect1Kernel = [0, 1, 0, 1, -4, 1, 0, 1, 0];
         ConvolutionPostProcess.EdgeDetect2Kernel = [-1, -1, -1, -1, 8, -1, -1, -1, -1];
@@ -28,4 +29,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.ConvolutionPostProcess = ConvolutionPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.convolutionPostProcess.js.map
+//# sourceMappingURL=babylon.convolutionPostProcess.js.map

Babylon/PostProcess/babylon.displayPassPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -15,4 +15,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.DisplayPassPostProcess = DisplayPassPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.displayPassPostProcess.js.map
+//# sourceMappingURL=babylon.displayPassPostProcess.js.map

Babylon/PostProcess/babylon.filterPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -12,7 +12,6 @@ var BABYLON;
             var _this = this;
             _super.call(this, name, "filter", ["kernelMatrix"], null, ratio, camera, samplingMode, engine, reusable);
             this.kernelMatrix = kernelMatrix;
-
             this.onApply = function (effect) {
                 effect.setMatrix("kernelMatrix", _this.kernelMatrix);
             };
@@ -21,4 +20,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.FilterPostProcess = FilterPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.filterPostProcess.js.map
+//# sourceMappingURL=babylon.filterPostProcess.js.map

Babylon/PostProcess/babylon.fxaaPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -11,7 +11,6 @@ var BABYLON;
         function FxaaPostProcess(name, ratio, camera, samplingMode, engine, reusable) {
             var _this = this;
             _super.call(this, name, "fxaa", ["texelSize"], null, ratio, camera, samplingMode, engine, reusable);
-
             this.onSizeChanged = function () {
                 _this.texelWidth = 1.0 / _this.width;
                 _this.texelHeight = 1.0 / _this.height;
@@ -24,4 +23,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.FxaaPostProcess = FxaaPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.fxaaPostProcess.js.map
+//# sourceMappingURL=babylon.fxaaPostProcess.js.map

Babylon/PostProcess/babylon.oculusDistortionCorrectionPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -17,12 +17,10 @@ var BABYLON;
                 'ScaleIn',
                 'HmdWarpParam'
             ], null, cameraSettings.PostProcessScaleFactor, camera, BABYLON.Texture.BILINEAR_SAMPLINGMODE, null, null);
-
             this._isRightEye = isRightEye;
             this._distortionFactors = cameraSettings.DistortionK;
             this._postProcessScaleFactor = cameraSettings.PostProcessScaleFactor;
             this._lensCenterOffset = cameraSettings.LensCenterOffset;
-
             this.onSizeChanged = function () {
                 _this.aspectRatio = _this.width * .5 / _this.height;
                 _this._scaleIn = new BABYLON.Vector2(2, 2 / _this.aspectRatio);
@@ -40,4 +38,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.OculusDistortionCorrectionPostProcess = OculusDistortionCorrectionPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.oculusDistortionCorrectionPostProcess.js.map
+//# sourceMappingURL=babylon.oculusDistortionCorrectionPostProcess.js.map

Babylon/PostProcess/babylon.passPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -15,4 +15,4 @@ var BABYLON;
     })(BABYLON.PostProcess);
     BABYLON.PassPostProcess = PassPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.passPostProcess.js.map
+//# sourceMappingURL=babylon.passPostProcess.js.map

Babylon/PostProcess/babylon.postProcess.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var PostProcess = (function () {
         function PostProcess(name, fragmentUrl, parameters, samplers, ratio, camera, samplingMode, engine, reusable) {
@@ -13,34 +13,28 @@
                 this._scene = camera.getScene();
                 camera.attachPostProcess(this);
                 this._engine = this._scene.getEngine();
-            } else {
+            }
+            else {
                 this._engine = engine;
             }
-
             this._renderRatio = ratio;
             this.renderTargetSamplingMode = samplingMode ? samplingMode : BABYLON.Texture.NEAREST_SAMPLINGMODE;
             this._reusable = reusable || false;
-
             samplers = samplers || [];
             samplers.push("textureSampler");
-
             this._effect = this._engine.createEffect({ vertex: "postprocess", fragment: fragmentUrl }, ["position"], parameters || [], samplers, "");
         }
         PostProcess.prototype.isReusable = function () {
             return this._reusable;
         };
-
         PostProcess.prototype.activate = function (camera, sourceTexture) {
             camera = camera || this._camera;
-
             var scene = camera.getScene();
             var maxSize = camera.getEngine().getCaps().maxTextureSize;
             var desiredWidth = ((sourceTexture ? sourceTexture._width : this._engine.getRenderingCanvas().width) * this._renderRatio) | 0;
             var desiredHeight = ((sourceTexture ? sourceTexture._height : this._engine.getRenderingCanvas().height) * this._renderRatio) | 0;
-
             desiredWidth = BABYLON.Tools.GetExponantOfTwo(desiredWidth, maxSize);
             desiredHeight = BABYLON.Tools.GetExponantOfTwo(desiredHeight, maxSize);
-
             if (this.width !== desiredWidth || this.height !== desiredHeight) {
                 if (this._textures.length > 0) {
                     for (var i = 0; i < this._textures.length; i++) {
@@ -51,65 +45,50 @@
                 this.width = desiredWidth;
                 this.height = desiredHeight;
                 this._textures.push(this._engine.createRenderTargetTexture({ width: this.width, height: this.height }, { generateMipMaps: false, generateDepthBuffer: camera._postProcesses.indexOf(this) === camera._postProcessesTakenIndices[0], samplingMode: this.renderTargetSamplingMode }));
-
                 if (this._reusable) {
                     this._textures.push(this._engine.createRenderTargetTexture({ width: this.width, height: this.height }, { generateMipMaps: false, generateDepthBuffer: camera._postProcesses.indexOf(this) === camera._postProcessesTakenIndices[0], samplingMode: this.renderTargetSamplingMode }));
                 }
-
                 if (this.onSizeChanged) {
                     this.onSizeChanged();
                 }
             }
-
             this._engine.bindFramebuffer(this._textures.data[this._currentRenderTextureInd]);
-
             if (this.onActivate) {
                 this.onActivate(camera);
             }
-
             // Clear
             this._engine.clear(scene.clearColor, scene.autoClear || scene.forceWireframe, true);
-
             if (this._reusable) {
                 this._currentRenderTextureInd = (this._currentRenderTextureInd + 1) % 2;
             }
         };
-
         PostProcess.prototype.apply = function () {
             // Check
             if (!this._effect.isReady())
                 return null;
-
             // States
             this._engine.enableEffect(this._effect);
             this._engine.setState(false);
             this._engine.setAlphaMode(BABYLON.Engine.ALPHA_DISABLE);
             this._engine.setDepthBuffer(false);
             this._engine.setDepthWrite(false);
-
             // Texture
             this._effect._bindTexture("textureSampler", this._textures.data[this._currentRenderTextureInd]);
-
             // Parameters
             if (this.onApply) {
                 this.onApply(this._effect);
             }
-
             return this._effect;
         };
-
         PostProcess.prototype.dispose = function (camera) {
             camera = camera || this._camera;
-
             if (this._textures.length > 0) {
                 for (var i = 0; i < this._textures.length; i++) {
                     this._engine._releaseTexture(this._textures.data[i]);
                 }
                 this._textures.reset();
             }
-
             camera.detachPostProcess(this);
-
             var index = camera._postProcesses.indexOf(this);
             if (index === camera._postProcessesTakenIndices[0] && camera._postProcessesTakenIndices.length > 0) {
                 this._camera._postProcesses[camera._postProcessesTakenIndices[0]].width = -1; // invalidate frameBuffer to hint the postprocess to create a depth buffer
@@ -119,4 +98,4 @@
     })();
     BABYLON.PostProcess = PostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.postProcess.js.map
+//# sourceMappingURL=babylon.postProcess.js.map

Babylon/PostProcess/babylon.postProcessManager.js

@@ -1,11 +1,10 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var PostProcessManager = (function () {
         function PostProcessManager(scene) {
             this._vertexDeclaration = [2];
             this._vertexStrideSize = 2 * 4;
             this._scene = scene;
-
             // VBO
             var vertices = [];
             vertices.push(1, 1);
@@ -13,84 +12,69 @@
             vertices.push(-1, -1);
             vertices.push(1, -1);
             this._vertexBuffer = scene.getEngine().createVertexBuffer(vertices);
-
             // Indices
             var indices = [];
             indices.push(0);
             indices.push(1);
             indices.push(2);
-
             indices.push(0);
             indices.push(2);
             indices.push(3);
-
             this._indexBuffer = scene.getEngine().createIndexBuffer(indices);
         }
         // Methods
         PostProcessManager.prototype._prepareFrame = function (sourceTexture) {
             var postProcesses = this._scene.activeCamera._postProcesses;
             var postProcessesTakenIndices = this._scene.activeCamera._postProcessesTakenIndices;
-
             if (postProcessesTakenIndices.length === 0 || !this._scene.postProcessesEnabled) {
                 return false;
             }
-
             postProcesses[this._scene.activeCamera._postProcessesTakenIndices[0]].activate(this._scene.activeCamera, sourceTexture);
-
             return true;
         };
-
         PostProcessManager.prototype._finalizeFrame = function (doNotPresent, targetTexture) {
             var postProcesses = this._scene.activeCamera._postProcesses;
             var postProcessesTakenIndices = this._scene.activeCamera._postProcessesTakenIndices;
             if (postProcessesTakenIndices.length === 0 || !this._scene.postProcessesEnabled) {
                 return;
             }
-
             var engine = this._scene.getEngine();
-
             for (var index = 0; index < postProcessesTakenIndices.length; index++) {
                 if (index < postProcessesTakenIndices.length - 1) {
                     postProcesses[postProcessesTakenIndices[index + 1]].activate(this._scene.activeCamera);
-                } else {
+                }
+                else {
                     if (targetTexture) {
                         engine.bindFramebuffer(targetTexture);
-                    } else {
+                    }
+                    else {
                         engine.restoreDefaultFramebuffer();
                     }
                 }
-
                 if (doNotPresent) {
                     break;
                 }
-
                 var pp = postProcesses[postProcessesTakenIndices[index]];
                 var effect = pp.apply();
-
                 if (effect) {
                     if (pp.onBeforeRender) {
                         pp.onBeforeRender(effect);
                     }
-
                     // VBOs
                     engine.bindBuffers(this._vertexBuffer, this._indexBuffer, this._vertexDeclaration, this._vertexStrideSize, effect);
-
                     // Draw order
                     engine.draw(true, 0, 6);
                 }
             }
-
             // Restore depth buffer
             engine.setDepthBuffer(true);
             engine.setDepthWrite(true);
         };
-
         PostProcessManager.prototype.dispose = function () {
             if (this._vertexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._vertexBuffer);
                 this._vertexBuffer = null;
             }
-
             if (this._indexBuffer) {
                 this._scene.getEngine()._releaseBuffer(this._indexBuffer);
                 this._indexBuffer = null;
@@ -100,4 +84,4 @@
     })();
     BABYLON.PostProcessManager = PostProcessManager;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.postProcessManager.js.map
+//# sourceMappingURL=babylon.postProcessManager.js.map

Babylon/PostProcess/babylon.refractionPostProcess.js

@@ -1,4 +1,4 @@
-var __extends = this.__extends || function (d, b) {
+var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     __.prototype = b.prototype;
@@ -14,16 +14,13 @@ var BABYLON;
             this.color = color;
             this.depth = depth;
             this.colorLevel = colorLevel;
-
             this.onActivate = function (cam) {
                 _this._refRexture = _this._refRexture || new BABYLON.Texture(refractionTextureUrl, cam.getScene());
             };
-
             this.onApply = function (effect) {
                 effect.setColor3("baseColor", _this.color);
                 effect.setFloat("depth", _this.depth);
                 effect.setFloat("colorLevel", _this.colorLevel);
-
                 effect.setTexture("refractionSampler", _this._refRexture);
             };
         }
@@ -32,11 +29,10 @@ var BABYLON;
             if (this._refRexture) {
                 this._refRexture.dispose();
             }
-
             _super.prototype.dispose.call(this, camera);
         };
         return RefractionPostProcess;
     })(BABYLON.PostProcess);
     BABYLON.RefractionPostProcess = RefractionPostProcess;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.refractionPostProcess.js.map
+//# sourceMappingURL=babylon.refractionPostProcess.js.map

Babylon/Rendering/babylon.boundingBoxRenderer.js

@@ -1,4 +1,4 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var BoundingBoxRenderer = (function () {
         function BoundingBoxRenderer(scene) {
@@ -11,7 +11,6 @@
                 attributes: ["position"],
                 uniforms: ["worldViewProjection", "color"]
             });
-
             var engine = this._scene.getEngine();
             var boxdata = BABYLON.VertexData.CreateBox(1.0);
             this._vb = new BABYLON.VertexBuffer(engine, boxdata.positions, BABYLON.VertexBuffer.PositionKind, false);
@@ -20,12 +19,10 @@
         BoundingBoxRenderer.prototype.reset = function () {
             this.renderList.reset();
         };
-
         BoundingBoxRenderer.prototype.render = function () {
             if (this.renderList.length === 0 || !this._colorShader.isReady()) {
                 return;
             }
-
             var engine = this._scene.getEngine();
             engine.setDepthWrite(false);
             this._colorShader._preBind();
@@ -35,29 +32,23 @@
                 var max = boundingBox.maximum;
                 var diff = max.subtract(min);
                 var median = min.add(diff.scale(0.5));
-
                 var worldMatrix = BABYLON.Matrix.Scaling(diff.x, diff.y, diff.z).multiply(BABYLON.Matrix.Translation(median.x, median.y, median.z)).multiply(boundingBox.getWorldMatrix());
-
                 // VBOs
                 engine.bindBuffers(this._vb.getBuffer(), this._ib, [3], 3 * 4, this._colorShader.getEffect());
-
                 if (this.showBackLines) {
                     // Back
                     engine.setDepthFunctionToGreaterOrEqual();
                     this._scene.resetCachedMaterial();
                     this._colorShader.setColor4("color", this.backColor.toColor4());
                     this._colorShader.bind(worldMatrix);
-
                     // Draw order
                     engine.draw(false, 0, 24);
                 }
-
                 // Front
                 engine.setDepthFunctionToLess();
                 this._scene.resetCachedMaterial();
                 this._colorShader.setColor4("color", this.frontColor.toColor4());
                 this._colorShader.bind(worldMatrix);
-
                 // Draw order
                 engine.draw(false, 0, 24);
             }
@@ -65,7 +56,6 @@
             engine.setDepthFunctionToLessOrEqual();
             engine.setDepthWrite(true);
         };
-
         BoundingBoxRenderer.prototype.dispose = function () {
             this._colorShader.dispose();
             this._vb.dispose();
@@ -75,4 +65,4 @@
     })();
     BABYLON.BoundingBoxRenderer = BoundingBoxRenderer;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.boundingBoxRenderer.js.map
+//# sourceMappingURL=babylon.boundingBoxRenderer.js.map

Babylon/Rendering/babylon.depthRenderer.js

@@ -1,16 +1,15 @@
-var BABYLON;
+var BABYLON;
 (function (BABYLON) {
     var DepthRenderer = (function () {
         function DepthRenderer(scene, type) {
-            if (typeof type === "undefined") { type = BABYLON.Engine.TEXTURETYPE_FLOAT; }
             var _this = this;
+            if (type === void 0) { type = BABYLON.Engine.TEXTURETYPE_FLOAT; }
             this._viewMatrix = BABYLON.Matrix.Zero();
             this._projectionMatrix = BABYLON.Matrix.Zero();
             this._transformMatrix = BABYLON.Matrix.Zero();
             this._worldViewProjection = BABYLON.Matrix.Zero();
             this._scene = scene;
             var engine = scene.getEngine();
-
             // Render target
             this._depthMap = new BABYLON.RenderTargetTexture("depthMap", { width: engine.getRenderWidth(), height: engine.getRenderHeight() }, this._scene, false, true, type);
             this._depthMap.wrapU = BABYLON.Texture.CLAMP_ADDRESSMODE;
@@ -18,64 +17,49 @@
             this._depthMap.refreshRate = 1;
             this._depthMap.renderParticles = false;
             this._depthMap.renderList = null;
-
             // Custom render function
             var renderSubMesh = function (subMesh) {
                 var mesh = subMesh.getRenderingMesh();
                 var scene = _this._scene;
                 var engine = scene.getEngine();
-
                 // Culling
                 engine.setState(subMesh.getMaterial().backFaceCulling);
-
                 // Managing instances
                 var batch = mesh._getInstancesRenderList(subMesh._id);
-
                 if (batch.mustReturn) {
                     return;
                 }
-
                 var hardwareInstancedRendering = (engine.getCaps().instancedArrays !== null) && (batch.visibleInstances[subMesh._id] !== null);
-
                 if (_this.isReady(subMesh, hardwareInstancedRendering)) {
                     engine.enableEffect(_this._effect);
                     mesh._bind(subMesh, _this._effect, BABYLON.Material.TriangleFillMode);
                     var material = subMesh.getMaterial();
-
                     _this._effect.setMatrix("viewProjection", scene.getTransformMatrix());
-
                     _this._effect.setFloat("far", scene.activeCamera.maxZ);
-
                     // Alpha test
                     if (material && material.needAlphaTesting()) {
                         var alphaTexture = material.getAlphaTestTexture();
                         _this._effect.setTexture("diffuseSampler", alphaTexture);
                         _this._effect.setMatrix("diffuseMatrix", alphaTexture.getTextureMatrix());
                     }
-
                     // Bones
                     var useBones = mesh.skeleton && scene.skeletonsEnabled && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesIndicesKind) && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesWeightsKind);
-
                     if (useBones) {
                         _this._effect.setMatrices("mBones", mesh.skeleton.getTransformMatrices());
                     }
-
                     if (hardwareInstancedRendering) {
                         mesh._renderWithInstances(subMesh, BABYLON.Material.TriangleFillMode, batch, _this._effect, engine);
-                    } else {
+                    }
+                    else {
                         if (batch.renderSelf[subMesh._id]) {
                             _this._effect.setMatrix("world", mesh.getWorldMatrix());
-
                             // Draw
                             mesh._draw(subMesh, BABYLON.Material.TriangleFillMode);
                         }
-
                         if (batch.visibleInstances[subMesh._id]) {
                             for (var instanceIndex = 0; instanceIndex < batch.visibleInstances[subMesh._id].length; instanceIndex++) {
                                 var instance = batch.visibleInstances[subMesh._id][instanceIndex];
-
                                 _this._effect.setMatrix("world", instance.getWorldMatrix());
-
                                 // Draw
                                 mesh._draw(subMesh, BABYLON.Material.TriangleFillMode);
                             }
@@ -83,14 +67,11 @@
                     }
                 }
             };
-
             this._depthMap.customRenderFunction = function (opaqueSubMeshes, alphaTestSubMeshes) {
                 var index;
-
                 for (index = 0; index < opaqueSubMeshes.length; index++) {
                     renderSubMesh(opaqueSubMeshes.data[index]);
                 }
-
                 for (index = 0; index < alphaTestSubMeshes.length; index++) {
                     renderSubMesh(alphaTestSubMeshes.data[index]);
                 }
@@ -98,13 +79,10 @@
         }
         DepthRenderer.prototype.isReady = function (subMesh, useInstances) {
             var defines = [];
-
             var attribs = [BABYLON.VertexBuffer.PositionKind];
-
             var mesh = subMesh.getMesh();
             var scene = mesh.getScene();
             var material = subMesh.getMaterial();
-
             // Alpha test
             if (material && material.needAlphaTesting()) {
                 defines.push("#define ALPHATEST");
@@ -117,7 +95,6 @@
                     defines.push("#define UV2");
                 }
             }
-
             // Bones
             if (mesh.skeleton && scene.skeletonsEnabled && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesIndicesKind) && mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesWeightsKind)) {
                 attribs.push(BABYLON.VertexBuffer.MatricesIndicesKind);
@@ -125,7 +102,6 @@
                 defines.push("#define BONES");
                 defines.push("#define BonesPerMesh " + (mesh.skeleton.bones.length + 1));
             }
-
             // Instances
             if (useInstances) {
                 defines.push("#define INSTANCES");
@@ -134,21 +110,17 @@
                 attribs.push("world2");
                 attribs.push("world3");
             }
-
-            // Get correct effect
+            // Get correct effect      
             var join = defines.join("\n");
             if (this._cachedDefines !== join) {
                 this._cachedDefines = join;
                 this._effect = this._scene.getEngine().createEffect("depth", attribs, ["world", "mBones", "viewProjection", "diffuseMatrix", "far"], ["diffuseSampler"], join);
             }
-
             return this._effect.isReady();
         };
-
         DepthRenderer.prototype.getDepthMap = function () {
             return this._depthMap;
         };
-
         // Methods
         DepthRenderer.prototype.dispose = function () {
             this._depthMap.dispose();
@@ -157,4 +129,4 @@
     })();
     BABYLON.DepthRenderer = DepthRenderer;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.depthRenderer.js.map
+//# sourceMappingURL=babylon.depthRenderer.js.map