Moving static const to readonly properties

Babylon/Actions/babylon.actionManager.js

@@ -6,6 +6,46 @@
             this.actions = new Array();
             this._scene = scene;
         }
+        Object.defineProperty(ActionManager, "NoneTrigger", {
+            get: function () {
+                return ActionManager._NoneTrigger;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ActionManager, "OnPickTrigger", {
+            get: function () {
+                return ActionManager._OnPickTrigger;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ActionManager, "OnPointerOverTrigger", {
+            get: function () {
+                return ActionManager._OnPointerOverTrigger;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ActionManager, "OnPointerOutTrigger", {
+            get: function () {
+                return ActionManager._OnPointerOutTrigger;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ActionManager, "OnEveryFrameTrigger", {
+            get: function () {
+                return ActionManager._OnEveryFrameTrigger;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
         // Methods
         ActionManager.prototype.getScene = function () {
             return this._scene;
@@ -52,11 +92,11 @@
 
             return properties[properties.length - 1];
         };
-        ActionManager.NoneTrigger = 0;
-        ActionManager.OnPickTrigger = 1;
-        ActionManager.OnPointerOverTrigger = 2;
-        ActionManager.OnPointerOutTrigger = 3;
-        ActionManager.OnEveryFrameTrigger = 4;
+        ActionManager._NoneTrigger = 0;
+        ActionManager._OnPickTrigger = 1;
+        ActionManager._OnPointerOverTrigger = 2;
+        ActionManager._OnPointerOutTrigger = 3;
+        ActionManager._OnEveryFrameTrigger = 4;
         return ActionManager;
     })();
     BABYLON.ActionManager = ActionManager;

Babylon/Actions/babylon.actionManager.ts

@@ -1,11 +1,31 @@
 module BABYLON {
     export class ActionManager {
         // Statics
-        public static NoneTrigger = 0;
-        public static OnPickTrigger = 1;
-        public static OnPointerOverTrigger = 2;
-        public static OnPointerOutTrigger = 3;
-        public static OnEveryFrameTrigger = 4;
+        private static _NoneTrigger = 0;
+        private static _OnPickTrigger = 1;
+        private static _OnPointerOverTrigger = 2;
+        private static _OnPointerOutTrigger = 3;
+        private static _OnEveryFrameTrigger = 4;
+
+        public static get NoneTrigger(): number {
+            return ActionManager._NoneTrigger;
+        }
+
+        public static get OnPickTrigger(): number {
+            return ActionManager._OnPickTrigger;
+        }
+
+        public static get OnPointerOverTrigger(): number {
+            return ActionManager._OnPointerOverTrigger;
+        }
+
+        public static get OnPointerOutTrigger(): number {
+            return ActionManager._OnPointerOutTrigger;
+        }
+
+        public static get OnEveryFrameTrigger(): number {
+            return ActionManager._OnEveryFrameTrigger;
+        }
 
         // Members
         public actions = new Array<Action>();

Babylon/Animations/babylon.animation.js

@@ -213,15 +213,77 @@
             return returnValue;
         };
 
-        Animation.ANIMATIONTYPE_FLOAT = 0;
-        Animation.ANIMATIONTYPE_VECTOR3 = 1;
-        Animation.ANIMATIONTYPE_QUATERNION = 2;
-        Animation.ANIMATIONTYPE_MATRIX = 3;
-        Animation.ANIMATIONTYPE_COLOR3 = 4;
-
-        Animation.ANIMATIONLOOPMODE_RELATIVE = 0;
-        Animation.ANIMATIONLOOPMODE_CYCLE = 1;
-        Animation.ANIMATIONLOOPMODE_CONSTANT = 2;
+        Object.defineProperty(Animation, "ANIMATIONTYPE_FLOAT", {
+            get: function () {
+                return Animation._ANIMATIONTYPE_FLOAT;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Animation, "ANIMATIONTYPE_VECTOR3", {
+            get: function () {
+                return Animation._ANIMATIONTYPE_VECTOR3;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Animation, "ANIMATIONTYPE_QUATERNION", {
+            get: function () {
+                return Animation._ANIMATIONTYPE_QUATERNION;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Animation, "ANIMATIONTYPE_MATRIX", {
+            get: function () {
+                return Animation._ANIMATIONTYPE_MATRIX;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Animation, "ANIMATIONTYPE_COLOR3", {
+            get: function () {
+                return Animation._ANIMATIONTYPE_COLOR3;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Animation, "ANIMATIONLOOPMODE_RELATIVE", {
+            get: function () {
+                return Animation._ANIMATIONLOOPMODE_RELATIVE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Animation, "ANIMATIONLOOPMODE_CYCLE", {
+            get: function () {
+                return Animation._ANIMATIONLOOPMODE_CYCLE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Animation, "ANIMATIONLOOPMODE_CONSTANT", {
+            get: function () {
+                return Animation._ANIMATIONLOOPMODE_CONSTANT;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Animation._ANIMATIONTYPE_FLOAT = 0;
+        Animation._ANIMATIONTYPE_VECTOR3 = 1;
+        Animation._ANIMATIONTYPE_QUATERNION = 2;
+        Animation._ANIMATIONTYPE_MATRIX = 3;
+        Animation._ANIMATIONTYPE_COLOR3 = 4;
+        Animation._ANIMATIONLOOPMODE_RELATIVE = 0;
+        Animation._ANIMATIONLOOPMODE_CYCLE = 1;
+        Animation._ANIMATIONLOOPMODE_CONSTANT = 2;
         return Animation;
     })();
     BABYLON.Animation = Animation;

Babylon/Animations/babylon.animation.ts

@@ -215,14 +215,45 @@
         }
 
         // Statics
-        public static ANIMATIONTYPE_FLOAT = 0;
-        public static ANIMATIONTYPE_VECTOR3 = 1;
-        public static ANIMATIONTYPE_QUATERNION = 2;
-        public static ANIMATIONTYPE_MATRIX = 3;
-        public static ANIMATIONTYPE_COLOR3 = 4;
-
-        public static ANIMATIONLOOPMODE_RELATIVE = 0;
-        public static ANIMATIONLOOPMODE_CYCLE = 1;
-        public static ANIMATIONLOOPMODE_CONSTANT = 2;
+        private static _ANIMATIONTYPE_FLOAT = 0;
+        private static _ANIMATIONTYPE_VECTOR3 = 1;
+        private static _ANIMATIONTYPE_QUATERNION = 2;
+        private static _ANIMATIONTYPE_MATRIX = 3;
+        private static _ANIMATIONTYPE_COLOR3 = 4;
+        private static _ANIMATIONLOOPMODE_RELATIVE = 0;
+        private static _ANIMATIONLOOPMODE_CYCLE = 1;
+        private static _ANIMATIONLOOPMODE_CONSTANT = 2;
+
+        public static get ANIMATIONTYPE_FLOAT(): number {
+            return Animation._ANIMATIONTYPE_FLOAT;
+        }
+
+        public static get ANIMATIONTYPE_VECTOR3(): number {
+            return Animation._ANIMATIONTYPE_VECTOR3;
+        }
+
+        public static get ANIMATIONTYPE_QUATERNION(): number {
+            return Animation._ANIMATIONTYPE_QUATERNION;
+        }
+
+        public static get ANIMATIONTYPE_MATRIX(): number {
+            return Animation._ANIMATIONTYPE_MATRIX;
+        }
+
+        public static get ANIMATIONTYPE_COLOR3(): number {
+            return Animation._ANIMATIONTYPE_COLOR3;
+        }
+
+        public static get ANIMATIONLOOPMODE_RELATIVE(): number {
+            return Animation._ANIMATIONLOOPMODE_RELATIVE;
+        }
+
+        public static get ANIMATIONLOOPMODE_CYCLE(): number {
+            return Animation._ANIMATIONLOOPMODE_CYCLE;
+        }
+
+        public static get ANIMATIONLOOPMODE_CONSTANT(): number {
+            return Animation._ANIMATIONLOOPMODE_CONSTANT;
+        }
     }
 } 

Babylon/Materials/babylon.standardMaterial.js

@@ -46,7 +46,7 @@ var BABYLON;
             return this.diffuseTexture != null && this.diffuseTexture.hasAlpha;
         };
 
-        StandardMaterial.prototype._shouldUseAlphaFromDiffuseTexture = function(){
+        StandardMaterial.prototype._shouldUseAlphaFromDiffuseTexture = function () {
             return this.diffuseTexture != null && this.diffuseTexture.hasAlpha && this.useAlphaFromDiffuseTexture;
         };
 
@@ -140,7 +140,7 @@ var BABYLON;
                 defines.push("#define ALPHATEST");
             }
 
-            if(this._shouldUseAlphaFromDiffuseTexture()) {
+            if (this._shouldUseAlphaFromDiffuseTexture()) {
                 defines.push("#define ALPHAFROMDIFFUSE");
             }
 

Babylon/Mesh/babylon.mesh.js

@@ -53,6 +53,46 @@ var BABYLON;
 
             scene.meshes.push(this);
         }
+        Object.defineProperty(Mesh, "BILLBOARDMODE_NONE", {
+            get: function () {
+                return Mesh._BILLBOARDMODE_NONE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Mesh, "BILLBOARDMODE_X", {
+            get: function () {
+                return Mesh._BILLBOARDMODE_X;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Mesh, "BILLBOARDMODE_Y", {
+            get: function () {
+                return Mesh._BILLBOARDMODE_Y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Mesh, "BILLBOARDMODE_Z", {
+            get: function () {
+                return Mesh._BILLBOARDMODE_Z;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Mesh, "BILLBOARDMODE_ALL", {
+            get: function () {
+                return Mesh._BILLBOARDMODE_ALL;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
         Mesh.prototype.getBoundingInfo = function () {
             return this._boundingInfo;
         };
@@ -1210,11 +1250,11 @@ var BABYLON;
             var minMaxVector = meshesOrMinMaxVector.min !== undefined ? meshesOrMinMaxVector : BABYLON.Mesh.MinMax(meshesOrMinMaxVector);
             return BABYLON.Vector3.Center(minMaxVector.min, minMaxVector.max);
         };
-        Mesh.BILLBOARDMODE_NONE = 0;
-        Mesh.BILLBOARDMODE_X = 1;
-        Mesh.BILLBOARDMODE_Y = 2;
-        Mesh.BILLBOARDMODE_Z = 4;
-        Mesh.BILLBOARDMODE_ALL = 7;
+        Mesh._BILLBOARDMODE_NONE = 0;
+        Mesh._BILLBOARDMODE_X = 1;
+        Mesh._BILLBOARDMODE_Y = 2;
+        Mesh._BILLBOARDMODE_Z = 4;
+        Mesh._BILLBOARDMODE_ALL = 7;
         return Mesh;
     })(BABYLON.Node);
     BABYLON.Mesh = Mesh;

Babylon/Mesh/babylon.mesh.ts

@@ -1,11 +1,31 @@
 module BABYLON {
     export class Mesh extends Node implements IGetSetVerticesData {
         // Statics
-        public static BILLBOARDMODE_NONE = 0;
-        public static BILLBOARDMODE_X = 1;
-        public static BILLBOARDMODE_Y = 2;
-        public static BILLBOARDMODE_Z = 4;
-        public static BILLBOARDMODE_ALL = 7;
+        private static _BILLBOARDMODE_NONE = 0;
+        private static _BILLBOARDMODE_X = 1;
+        private static _BILLBOARDMODE_Y = 2;
+        private static _BILLBOARDMODE_Z = 4;
+        private static _BILLBOARDMODE_ALL = 7;
+
+        public static get BILLBOARDMODE_NONE(): number {
+            return Mesh._BILLBOARDMODE_NONE;
+        }
+
+        public static get BILLBOARDMODE_X(): number {
+            return Mesh._BILLBOARDMODE_X;
+        }
+
+        public static get BILLBOARDMODE_Y(): number {
+            return Mesh._BILLBOARDMODE_Y;
+        }
+
+        public static get BILLBOARDMODE_Z(): number {
+            return Mesh._BILLBOARDMODE_Z;
+        }
+
+        public static get BILLBOARDMODE_ALL(): number {
+            return Mesh._BILLBOARDMODE_ALL;
+        }
 
         // Members
         public position = new BABYLON.Vector3(0, 0, 0);

Babylon/Mesh/babylon.vertexBuffer.js

@@ -94,13 +94,68 @@
             }
         };
 
-        VertexBuffer.PositionKind = "position";
-        VertexBuffer.NormalKind = "normal";
-        VertexBuffer.UVKind = "uv";
-        VertexBuffer.UV2Kind = "uv2";
-        VertexBuffer.ColorKind = "color";
-        VertexBuffer.MatricesIndicesKind = "matricesIndices";
-        VertexBuffer.MatricesWeightsKind = "matricesWeights";
+        Object.defineProperty(VertexBuffer, "PositionKind", {
+            get: function () {
+                return VertexBuffer._PositionKind;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(VertexBuffer, "NormalKind", {
+            get: function () {
+                return VertexBuffer._NormalKind;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(VertexBuffer, "UVKind", {
+            get: function () {
+                return VertexBuffer._UVKind;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(VertexBuffer, "UV2Kind", {
+            get: function () {
+                return VertexBuffer._UV2Kind;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(VertexBuffer, "ColorKind", {
+            get: function () {
+                return VertexBuffer._ColorKind;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(VertexBuffer, "MatricesIndicesKind", {
+            get: function () {
+                return VertexBuffer._MatricesIndicesKind;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(VertexBuffer, "MatricesWeightsKind", {
+            get: function () {
+                return VertexBuffer._MatricesWeightsKind;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        VertexBuffer._PositionKind = "position";
+        VertexBuffer._NormalKind = "normal";
+        VertexBuffer._UVKind = "uv";
+        VertexBuffer._UV2Kind = "uv2";
+        VertexBuffer._ColorKind = "color";
+        VertexBuffer._MatricesIndicesKind = "matricesIndices";
+        VertexBuffer._MatricesWeightsKind = "matricesWeights";
         return VertexBuffer;
     })();
     BABYLON.VertexBuffer = VertexBuffer;

Babylon/Mesh/babylon.vertexBuffer.ts

@@ -104,12 +104,40 @@
         }
 
         // Enums
-        public static PositionKind = "position";
-        public static NormalKind = "normal";
-        public static UVKind = "uv";
-        public static UV2Kind = "uv2";
-        public static ColorKind = "color";
-        public static MatricesIndicesKind = "matricesIndices";
-        public static MatricesWeightsKind = "matricesWeights";
+        private static _PositionKind = "position";
+        private static _NormalKind = "normal";
+        private static _UVKind = "uv";
+        private static _UV2Kind = "uv2";
+        private static _ColorKind = "color";
+        private static _MatricesIndicesKind = "matricesIndices";
+        private static _MatricesWeightsKind = "matricesWeights";
+
+        public static get PositionKind(): string {
+            return VertexBuffer._PositionKind;
+        }
+
+        public static get NormalKind(): string {
+            return VertexBuffer._NormalKind;
+        }
+
+        public static get UVKind(): string {
+            return VertexBuffer._UVKind;
+        }
+
+        public static get UV2Kind(): string {
+            return VertexBuffer._UV2Kind;
+        }
+
+        public static get ColorKind(): string {
+            return VertexBuffer._ColorKind;
+        }
+
+        public static get MatricesIndicesKind(): string {
+            return VertexBuffer._MatricesIndicesKind;
+        }
+
+        public static get MatricesWeightsKind(): string {
+            return VertexBuffer._MatricesWeightsKind;
+        }
     }
 } 

Babylon/Tools/babylon.tools.js

@@ -474,7 +474,8 @@
 
         Object.defineProperty(Tools, "AllLogLevel", {
             get: function () {
-                return Tools._AllLogLevel;
+                return Tools._MessageLogLevel | Tools._WarningLogLevel | Tools._ErrorLogLevel;
+                ;
             },
             enumerable: true,
             configurable: true
@@ -512,19 +513,19 @@
 
         Object.defineProperty(Tools, "LogLevels", {
             set: function (level) {
-                if (level & Tools.MessageLogLevel) {
+                if ((level & Tools.MessageLogLevel) === Tools.MessageLogLevel) {
                     Tools.Log = Tools._LogEnabled;
                 } else {
                     Tools.Log = Tools._LogDisabled;
                 }
 
-                if (level & Tools.WarningLogLevel) {
+                if ((level & Tools.WarningLogLevel) === Tools.WarningLogLevel) {
                     Tools.Warn = Tools._WarnEnabled;
                 } else {
                     Tools.Warn = Tools._WarnDisabled;
                 }
 
-                if (level & Tools.ErrorLogLevel) {
+                if ((level & Tools.ErrorLogLevel) === Tools.ErrorLogLevel) {
                     Tools.Error = Tools._ErrorEnabled;
                 } else {
                     Tools.Error = Tools._ErrorDisabled;
@@ -539,7 +540,6 @@
         Tools._MessageLogLevel = 1;
         Tools._WarningLogLevel = 2;
         Tools._ErrorLogLevel = 4;
-        Tools._AllLogLevel = Tools._MessageLogLevel | Tools._WarningLogLevel | Tools._ErrorLogLevel;
 
         Tools.Log = Tools._LogEnabled;
 

Babylon/babylon.engine.js

@@ -195,6 +195,62 @@
             document.addEventListener("mozpointerlockchange", this._onPointerLockChange, false);
             document.addEventListener("webkitpointerlockchange", this._onPointerLockChange, false);
         }
+        Object.defineProperty(Engine, "ALPHA_DISABLE", {
+            get: function () {
+                return Engine._ALPHA_DISABLE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Engine, "ALPHA_ADD", {
+            get: function () {
+                return Engine._ALPHA_ADD;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Engine, "ALPHA_COMBINE", {
+            get: function () {
+                return Engine._ALPHA_COMBINE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Engine, "DELAYLOADSTATE_NONE", {
+            get: function () {
+                return Engine._DELAYLOADSTATE_NONE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Engine, "DELAYLOADSTATE_LOADED", {
+            get: function () {
+                return Engine._DELAYLOADSTATE_LOADED;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Engine, "DELAYLOADSTATE_LOADING", {
+            get: function () {
+                return Engine._DELAYLOADSTATE_LOADING;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Engine, "DELAYLOADSTATE_NOTLOADED", {
+            get: function () {
+                return Engine._DELAYLOADSTATE_NOTLOADED;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
         Engine.prototype.getAspectRatio = function (camera) {
             var viewport = camera.viewport;
             return (this.getRenderWidth() * viewport.width) / (this.getRenderHeight() * viewport.height);
@@ -1183,19 +1239,18 @@
                 return false;
             }
         };
-        Engine.ShadersRepository = "Babylon/Shaders/";
+        Engine._ALPHA_DISABLE = 0;
+        Engine._ALPHA_ADD = 1;
+        Engine._ALPHA_COMBINE = 2;
 
-        Engine.ALPHA_DISABLE = 0;
-        Engine.ALPHA_ADD = 1;
-        Engine.ALPHA_COMBINE = 2;
-
-        Engine.DELAYLOADSTATE_NONE = 0;
-        Engine.DELAYLOADSTATE_LOADED = 1;
-        Engine.DELAYLOADSTATE_LOADING = 2;
-        Engine.DELAYLOADSTATE_NOTLOADED = 4;
+        Engine._DELAYLOADSTATE_NONE = 0;
+        Engine._DELAYLOADSTATE_LOADED = 1;
+        Engine._DELAYLOADSTATE_LOADING = 2;
+        Engine._DELAYLOADSTATE_NOTLOADED = 4;
 
         Engine.Epsilon = 0.001;
         Engine.CollisionsEpsilon = 0.001;
+        Engine.ShadersRepository = "Babylon/Shaders/";
         return Engine;
     })();
     BABYLON.Engine = Engine;

Babylon/babylon.engine.ts

@@ -95,20 +95,49 @@
     }
 
     export class Engine {
-        // Statics
-        public static ShadersRepository = "Babylon/Shaders/";
+        // Const statics
+        private static _ALPHA_DISABLE = 0;
+        private static _ALPHA_ADD = 1;
+        private static _ALPHA_COMBINE = 2;
 
-        public static ALPHA_DISABLE = 0;
-        public static ALPHA_ADD = 1;
-        public static ALPHA_COMBINE = 2;
+        private static _DELAYLOADSTATE_NONE = 0;
+        private static _DELAYLOADSTATE_LOADED = 1;
+        private static _DELAYLOADSTATE_LOADING = 2;
+        private static _DELAYLOADSTATE_NOTLOADED = 4;
 
-        public static DELAYLOADSTATE_NONE = 0;
-        public static DELAYLOADSTATE_LOADED = 1;
-        public static DELAYLOADSTATE_LOADING = 2;
-        public static DELAYLOADSTATE_NOTLOADED = 4;
+        public static get ALPHA_DISABLE(): number {
+            return Engine._ALPHA_DISABLE;
+        }
+
+        public static get ALPHA_ADD(): number {
+            return Engine._ALPHA_ADD;
+        }
+
+        public static get ALPHA_COMBINE(): number {
+            return Engine._ALPHA_COMBINE;
+        }
+
+        public static get DELAYLOADSTATE_NONE(): number {
+            return Engine._DELAYLOADSTATE_NONE;
+        }
 
+        public static get DELAYLOADSTATE_LOADED(): number {
+            return Engine._DELAYLOADSTATE_LOADED;
+        }
+
+        public static get DELAYLOADSTATE_LOADING(): number {
+            return Engine._DELAYLOADSTATE_LOADING;
+        }
+
+        public static get DELAYLOADSTATE_NOTLOADED(): number {
+            return Engine._DELAYLOADSTATE_NOTLOADED;
+        }
+
+        // Updatable statics so stick with vars here
         public static Epsilon = 0.001;
         public static CollisionsEpsilon = 0.001;
+        public static ShadersRepository = "Babylon/Shaders/";
+
 
         // Public members
         public isFullscreen = false;