Merge pull request #196 from MaxenceBrasselet/Tools.Log

Tools.log update

Babylon/Tools/babylon.tools.js

@@ -440,6 +440,46 @@
             texture.dispose();
         };
 
+        Object.defineProperty(Tools, "NoneLogLevel", {
+            get: function () {
+                return Tools._NoneLogLevel;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Tools, "MessageLogLevel", {
+            get: function () {
+                return Tools._MessageLogLevel;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Tools, "WarningLogLevel", {
+            get: function () {
+                return Tools._WarningLogLevel;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Tools, "ErrorLogLevel", {
+            get: function () {
+                return Tools._ErrorLogLevel;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(Tools, "AllLogLevel", {
+            get: function () {
+                return Tools._AllLogLevel;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
         Tools._FormatMessage = function (message) {
             var padStr = function (i) {
                 return (i < 10) ? "0" + i : "" + i;
@@ -449,33 +489,63 @@
             return "BJS - [" + padStr(date.getHours()) + ":" + padStr(date.getMinutes()) + ":" + padStr(date.getSeconds()) + "]: " + message;
         };
 
-        Tools.Log = function (message) {
-            if (Tools.CurrentLogLevel > Tools.MessageLogLevel) {
-                return;
-            }
+        Tools._LogDisabled = function (message) {
+            // nothing to do
+        };
+        Tools._LogEnabled = function (message) {
             console.log(Tools._FormatMessage(message));
         };
 
-        Tools.Warn = function (message) {
-            if (Tools.CurrentLogLevel > Tools.WarningLogLevel) {
-                return;
-            }
+        Tools._WarnDisabled = function (message) {
+            // nothing to do
+        };
+        Tools._WarnEnabled = function (message) {
             console.warn(Tools._FormatMessage(message));
         };
 
-        Tools.Error = function (message) {
-            if (Tools.CurrentLogLevel > Tools.ErrorLogLevel) {
-                return;
-            }
+        Tools._ErrorDisabled = function (message) {
+            // nothing to do
+        };
+        Tools._ErrorEnabled = function (message) {
             console.error(Tools._FormatMessage(message));
         };
+
+        Object.defineProperty(Tools, "LogLevels", {
+            set: function (level) {
+                if (level & Tools.MessageLogLevel) {
+                    Tools.Log = Tools._LogEnabled;
+                } else {
+                    Tools.Log = Tools._LogDisabled;
+                }
+
+                if (level & Tools.WarningLogLevel) {
+                    Tools.Warn = Tools._WarnEnabled;
+                } else {
+                    Tools.Warn = Tools._WarnDisabled;
+                }
+
+                if (level & Tools.ErrorLogLevel) {
+                    Tools.Error = Tools._ErrorEnabled;
+                } else {
+                    Tools.Error = Tools._ErrorDisabled;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
         Tools.BaseUrl = "";
 
-        Tools.MessageLogLevel = 0;
-        Tools.WarningLogLevel = 1;
-        Tools.ErrorLogLevel = 2;
-        Tools.NoneLogLevel = 3;
-        Tools.CurrentLogLevel = Tools.MessageLogLevel;
+        Tools._NoneLogLevel = 0;
+        Tools._MessageLogLevel = 1;
+        Tools._WarningLogLevel = 2;
+        Tools._ErrorLogLevel = 4;
+        Tools._AllLogLevel = Tools._MessageLogLevel | Tools._WarningLogLevel | Tools._ErrorLogLevel;
+
+        Tools.Log = Tools._LogEnabled;
+
+        Tools.Warn = Tools._WarnEnabled;
+
+        Tools.Error = Tools._ErrorEnabled;
         return Tools;
     })();
     BABYLON.Tools = Tools;

Babylon/Tools/babylon.tools.ts

@@ -474,11 +474,30 @@
         }
 
         // Logs
-        public static MessageLogLevel = 0;
-        public static WarningLogLevel = 1;
-        public static ErrorLogLevel = 2;
-        public static NoneLogLevel = 3;
-        public static CurrentLogLevel = Tools.MessageLogLevel;
+        private static _NoneLogLevel = 0;
+        private static _MessageLogLevel = 1;
+        private static _WarningLogLevel = 2;
+        private static _ErrorLogLevel = 4;
+
+        static get NoneLogLevel(): number {
+            return Tools._NoneLogLevel;
+        }
+
+        static get MessageLogLevel(): number {
+            return Tools._MessageLogLevel;
+        }
+
+        static get WarningLogLevel(): number {
+            return Tools._WarningLogLevel;
+        }
+
+        static get ErrorLogLevel(): number {
+            return Tools._ErrorLogLevel;
+        }
+
+        static get AllLogLevel(): number {
+            return Tools._MessageLogLevel | Tools._WarningLogLevel | Tools._ErrorLogLevel;;
+        }
 
         private static _FormatMessage(message: string): string {
             var padStr = i => (i < 10) ? "0" + i : "" + i;
@@ -487,25 +506,54 @@
             return "BJS - [" + padStr(date.getHours()) + ":" + padStr(date.getMinutes()) +  ":" + padStr(date.getSeconds()) + "]: " + message;
         }
 
-        public static Log(message: string): void {
-            if (Tools.CurrentLogLevel > Tools.MessageLogLevel) {
-                return;
-            }
+        public static Log: (message: string) => void = Tools._LogEnabled;
+
+        private static _LogDisabled(message: string): void {
+            // nothing to do
+        }
+        private static _LogEnabled(message: string): void {
             console.log(Tools._FormatMessage(message));
         }
 
-        public static Warn(message: string): void {
-            if (Tools.CurrentLogLevel > Tools.WarningLogLevel) {
-                return;
-            }
+        public static Warn: (message: string) => void = Tools._WarnEnabled;
+
+        private static _WarnDisabled(message: string): void {
+            // nothing to do
+        }
+        private static _WarnEnabled(message: string): void {
             console.warn(Tools._FormatMessage(message));
         }
 
-        public static Error(message: string): void {
-            if (Tools.CurrentLogLevel > Tools.ErrorLogLevel) {
-                return;
-            }
+        public static Error: (message: string) => void = Tools._ErrorEnabled;
+
+        private static _ErrorDisabled(message: string): void {
+            // nothing to do
+        }
+        private static _ErrorEnabled(message: string): void {
             console.error(Tools._FormatMessage(message));
         }
+        
+        public static set LogLevels(level: number) {
+            if ((level & Tools.MessageLogLevel) === Tools.MessageLogLevel) {
+                Tools.Log = Tools._LogEnabled;
+            }
+            else {
+                Tools.Log = Tools._LogDisabled;
+            }
+
+            if ((level & Tools.WarningLogLevel) === Tools.WarningLogLevel) {
+                Tools.Warn = Tools._WarnEnabled;
+            }
+            else {
+                Tools.Warn = Tools._WarnDisabled;
+            }
+
+            if ((level & Tools.ErrorLogLevel) === Tools.ErrorLogLevel) {
+                Tools.Error = Tools._ErrorEnabled;
+            }
+            else {
+                Tools.Error = Tools._ErrorDisabled;
+            }
+        }
     }
 }