Nightly

dist/preview release/babylon.max.js

@@ -12115,6 +12115,20 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(Engine.prototype, "doNotHandleContextLost", {
+            /**
+             * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
+             * @see http://doc.babylonjs.com/how_to/optimizing_your_scene#handling-webgl-context-lost
+             */
+            get: function () {
+                return this._doNotHandleContextLost;
+            },
+            set: function (value) {
+                this._doNotHandleContextLost = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(Engine.prototype, "performanceMonitor", {
             /**
              * Gets the performance monitor attached to this engine
@@ -28281,6 +28295,25 @@ var BABYLON;
                 this.soundTracks[scIndex].dispose();
             }
         };
+        /**
+         * Call this function to reduce memory footprint of the scene.
+         * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
+         */
+        Scene.prototype.clearCachedVertexData = function () {
+            for (var meshIndex = 0; meshIndex < this.meshes.length; meshIndex++) {
+                var mesh = this.meshes[meshIndex];
+                var geometry = mesh.geometry;
+                if (geometry) {
+                    geometry._indices = [];
+                    for (var vbName in geometry._vertexBuffers) {
+                        if (!geometry._vertexBuffers.hasOwnProperty(vbName)) {
+                            continue;
+                        }
+                        geometry._vertexBuffers[vbName]._buffer._data = null;
+                    }
+                }
+            }
+        };
         // Octrees
         /**
          * Get the world extend vectors with an optional filter
@@ -39468,11 +39501,11 @@ var BABYLON;
         Geometry.prototype._generatePointsArray = function () {
             if (this._positions)
                 return true;
-            this._positions = [];
             var data = this.getVerticesData(BABYLON.VertexBuffer.PositionKind);
-            if (!data) {
+            if (!data || data.length === 0) {
                 return false;
             }
+            this._positions = [];
             for (var index = 0; index < data.length; index += 3) {
                 this._positions.push(BABYLON.Vector3.FromArray(data, index));
             }

dist/preview release/babylon.no-module.max.js

@@ -12082,6 +12082,20 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(Engine.prototype, "doNotHandleContextLost", {
+            /**
+             * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
+             * @see http://doc.babylonjs.com/how_to/optimizing_your_scene#handling-webgl-context-lost
+             */
+            get: function () {
+                return this._doNotHandleContextLost;
+            },
+            set: function (value) {
+                this._doNotHandleContextLost = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(Engine.prototype, "performanceMonitor", {
             /**
              * Gets the performance monitor attached to this engine
@@ -28248,6 +28262,25 @@ var BABYLON;
                 this.soundTracks[scIndex].dispose();
             }
         };
+        /**
+         * Call this function to reduce memory footprint of the scene.
+         * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
+         */
+        Scene.prototype.clearCachedVertexData = function () {
+            for (var meshIndex = 0; meshIndex < this.meshes.length; meshIndex++) {
+                var mesh = this.meshes[meshIndex];
+                var geometry = mesh.geometry;
+                if (geometry) {
+                    geometry._indices = [];
+                    for (var vbName in geometry._vertexBuffers) {
+                        if (!geometry._vertexBuffers.hasOwnProperty(vbName)) {
+                            continue;
+                        }
+                        geometry._vertexBuffers[vbName]._buffer._data = null;
+                    }
+                }
+            }
+        };
         // Octrees
         /**
          * Get the world extend vectors with an optional filter
@@ -39435,11 +39468,11 @@ var BABYLON;
         Geometry.prototype._generatePointsArray = function () {
             if (this._positions)
                 return true;
-            this._positions = [];
             var data = this.getVerticesData(BABYLON.VertexBuffer.PositionKind);
-            if (!data) {
+            if (!data || data.length === 0) {
                 return false;
             }
+            this._positions = [];
             for (var index = 0; index < data.length; index += 3) {
                 this._positions.push(BABYLON.Vector3.FromArray(data, index));
             }

dist/preview release/es6.js

@@ -12082,6 +12082,20 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(Engine.prototype, "doNotHandleContextLost", {
+            /**
+             * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
+             * @see http://doc.babylonjs.com/how_to/optimizing_your_scene#handling-webgl-context-lost
+             */
+            get: function () {
+                return this._doNotHandleContextLost;
+            },
+            set: function (value) {
+                this._doNotHandleContextLost = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(Engine.prototype, "performanceMonitor", {
             /**
              * Gets the performance monitor attached to this engine
@@ -28248,6 +28262,25 @@ var BABYLON;
                 this.soundTracks[scIndex].dispose();
             }
         };
+        /**
+         * Call this function to reduce memory footprint of the scene.
+         * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
+         */
+        Scene.prototype.clearCachedVertexData = function () {
+            for (var meshIndex = 0; meshIndex < this.meshes.length; meshIndex++) {
+                var mesh = this.meshes[meshIndex];
+                var geometry = mesh.geometry;
+                if (geometry) {
+                    geometry._indices = [];
+                    for (var vbName in geometry._vertexBuffers) {
+                        if (!geometry._vertexBuffers.hasOwnProperty(vbName)) {
+                            continue;
+                        }
+                        geometry._vertexBuffers[vbName]._buffer._data = null;
+                    }
+                }
+            }
+        };
         // Octrees
         /**
          * Get the world extend vectors with an optional filter
@@ -39435,11 +39468,11 @@ var BABYLON;
         Geometry.prototype._generatePointsArray = function () {
             if (this._positions)
                 return true;
-            this._positions = [];
             var data = this.getVerticesData(BABYLON.VertexBuffer.PositionKind);
-            if (!data) {
+            if (!data || data.length === 0) {
                 return false;
             }
+            this._positions = [];
             for (var index = 0; index < data.length; index += 3) {
                 this._positions.push(BABYLON.Vector3.FromArray(data, index));
             }

dist/preview release/viewer/babylon.viewer.max.js

@@ -12203,6 +12203,20 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(Engine.prototype, "doNotHandleContextLost", {
+            /**
+             * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
+             * @see http://doc.babylonjs.com/how_to/optimizing_your_scene#handling-webgl-context-lost
+             */
+            get: function () {
+                return this._doNotHandleContextLost;
+            },
+            set: function (value) {
+                this._doNotHandleContextLost = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(Engine.prototype, "performanceMonitor", {
             /**
              * Gets the performance monitor attached to this engine
@@ -28369,6 +28383,25 @@ var BABYLON;
                 this.soundTracks[scIndex].dispose();
             }
         };
+        /**
+         * Call this function to reduce memory footprint of the scene.
+         * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
+         */
+        Scene.prototype.clearCachedVertexData = function () {
+            for (var meshIndex = 0; meshIndex < this.meshes.length; meshIndex++) {
+                var mesh = this.meshes[meshIndex];
+                var geometry = mesh.geometry;
+                if (geometry) {
+                    geometry._indices = [];
+                    for (var vbName in geometry._vertexBuffers) {
+                        if (!geometry._vertexBuffers.hasOwnProperty(vbName)) {
+                            continue;
+                        }
+                        geometry._vertexBuffers[vbName]._buffer._data = null;
+                    }
+                }
+            }
+        };
         // Octrees
         /**
          * Get the world extend vectors with an optional filter
@@ -39556,11 +39589,11 @@ var BABYLON;
         Geometry.prototype._generatePointsArray = function () {
             if (this._positions)
                 return true;
-            this._positions = [];
             var data = this.getVerticesData(BABYLON.VertexBuffer.PositionKind);
-            if (!data) {
+            if (!data || data.length === 0) {
                 return false;
             }
+            this._positions = [];
             for (var index = 0; index < data.length; index += 3) {
                 this._positions.push(BABYLON.Vector3.FromArray(data, index));
             }

src/Engine/babylon.engine.ts

@@ -987,6 +987,18 @@
         private _contextWasLost = false;
         private _doNotHandleContextLost = false;
 
+        /**
+         * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events
+         * @see http://doc.babylonjs.com/how_to/optimizing_your_scene#handling-webgl-context-lost
+         */
+        public get doNotHandleContextLost(): boolean {
+            return this._doNotHandleContextLost;
+        }
+
+        public set doNotHandleContextLost(value: boolean) {
+            this._doNotHandleContextLost = value;
+        }
+
         // FPS
         private _performanceMonitor = new PerformanceMonitor();
         private _fps = 60;