Refactor buffers

Tools/Gulp/config.json

@@ -65,9 +65,8 @@
       "../../src/Rendering/babylon.renderingManager.js",
       "../../src/Rendering/babylon.renderingGroup.js",
       "../../src/babylon.scene.js",
+      "../../src/Mesh/babylon.buffer.js",
       "../../src/Mesh/babylon.vertexBuffer.js",
-      "../../src/Mesh/babylon.interleavedBuffer.js",
-      "../../src/Mesh/babylon.interleavedVertexBuffer.js",
       "../../src/Mesh/babylon.instancedMesh.js",
       "../../src/Mesh/babylon.mesh.js",
       "../../src/Mesh/babylon.subMesh.js",

src/Layer/babylon.layer.ts

@@ -9,8 +9,7 @@
         public alphaTest: boolean;
 
         private _scene: Scene;
-        private _vertexBuffer: VertexBuffer;
-        private _vertexBuffers: { [key: string]: IVertexBuffer } = {};
+        private _vertexBuffers: { [key: string]: VertexBuffer } = {};
         private _indexBuffer: WebGLBuffer;
         private _effect: Effect;
         private _alphaTestEffect: Effect;
@@ -77,8 +76,8 @@
             vertices.push(-1, -1);
             vertices.push(1, -1);
 
-            this._vertexBuffer = new VertexBuffer(engine, vertices, VertexBuffer.PositionKind, false, false, 2);
-            this._vertexBuffers[VertexBuffer.PositionKind] = this._vertexBuffer;
+            var vertexBuffer = new VertexBuffer(engine, vertices, VertexBuffer.PositionKind, false, false, 2);
+            this._vertexBuffers[VertexBuffer.PositionKind] = vertexBuffer;
 
             // Indices
             var indices = [];
@@ -148,9 +147,10 @@
         }
 
         public dispose(): void {
-            if (this._vertexBuffer) {
-                this._vertexBuffer.dispose();
-                this._vertexBuffer = null;
+            var vertexBuffer = this._vertexBuffers[VertexBuffer.PositionKind];
+            if (vertexBuffer) {
+                vertexBuffer.dispose();
+                this._vertexBuffers[VertexBuffer.PositionKind] = null;
             }
 
             if (this._indexBuffer) {

src/LensFlare/babylon.lensFlareSystem.ts

@@ -8,8 +8,7 @@
 
         private _scene: Scene;
         private _emitter: any;
-        private _vertexBuffer: VertexBuffer;
-        private _vertexBuffers: { [key: string]: IVertexBuffer } = {};
+        private _vertexBuffers: { [key: string]: VertexBuffer } = {};
         private _indexBuffer: WebGLBuffer;
         private _effect: Effect;
         private _positionX: number;
@@ -34,8 +33,7 @@
             vertices.push(-1, -1);
             vertices.push(1, -1);
 
-            this._vertexBuffer = new VertexBuffer(engine, vertices, VertexBuffer.PositionKind, false, false, 2);
-            this._vertexBuffers[VertexBuffer.PositionKind] = this._vertexBuffer;
+            this._vertexBuffers[VertexBuffer.PositionKind] = new VertexBuffer(engine, vertices, VertexBuffer.PositionKind, false, false, 2);
 
             // Indices
             var indices = [];
@@ -219,9 +217,10 @@
         }
 
         public dispose(): void {
-            if (this._vertexBuffer) {
-                this._vertexBuffer.dispose();
-                this._vertexBuffer = null;
+            var vertexBuffer = this._vertexBuffers[VertexBuffer.PositionKind];
+            if (vertexBuffer) {
+                vertexBuffer.dispose();
+                this._vertexBuffers[VertexBuffer.PositionKind] = null;
             }
 
             if (this._indexBuffer) {

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

@@ -9,8 +9,7 @@
 
         public onGenerated: () => void;
 
-        private _vertexBuffer: VertexBuffer;
-        private _vertexBuffers: { [key: string]: IVertexBuffer } = {};
+        private _vertexBuffers: { [key: string]: VertexBuffer } = {};
         private _indexBuffer: WebGLBuffer;
         private _effect: Effect;
 
@@ -62,8 +61,7 @@
             vertices.push(-1, -1);
             vertices.push(1, -1);
 
-            this._vertexBuffer = new VertexBuffer(engine, vertices, VertexBuffer.PositionKind, false, false, 2);
-            this._vertexBuffers[VertexBuffer.PositionKind] = this._vertexBuffer;
+            this._vertexBuffers[VertexBuffer.PositionKind] = new VertexBuffer(engine, vertices, VertexBuffer.PositionKind, false, false, 2);
 
             // Indices
             var indices = [];
@@ -349,6 +347,17 @@
             if (index >= 0) {
                 this.getScene()._proceduralTextures.splice(index, 1);
             }
+
+            var vertexBuffer = this._vertexBuffers[VertexBuffer.PositionKind];
+            if (vertexBuffer) {
+                vertexBuffer.dispose();
+                this._vertexBuffers[VertexBuffer.PositionKind] = null;
+            }
+
+            if (this._indexBuffer && this.getScene().getEngine()._releaseBuffer(this._indexBuffer)) {
+                this._indexBuffer = null;
+            }
+
             super.dispose();
         }
     }

src/Mesh/babylon.interleavedBuffer.ts

@@ -1,5 +1,5 @@
 module BABYLON {
-    export class InterleavedBuffer {
+    export class Buffer {
         private _engine: Engine;
         private _buffer: WebGLBuffer;
         private _data: number[] | Float32Array;
@@ -28,6 +28,11 @@
             this._instanced = instanced;
         }
 
+        public createVertexBuffer(kind: string, offset: number, size: number, stride?: number): VertexBuffer {
+            // a lot of these parameters are ignored as they are overriden by the buffer
+            return new VertexBuffer(this._engine, this, kind, this._updatable, true, stride, this._instanced, offset, size);
+        }
+
         // Properties
         public isUpdatable(): boolean {
             return this._updatable;
@@ -60,13 +65,11 @@
             if (!this._buffer) { // create buffer
                 if (this._updatable) {
                     this._buffer = this._engine.createDynamicVertexBuffer(data);
+                    this._data = data;
                 } else {
                     this._buffer = this._engine.createVertexBuffer(data);
-                    this._data = null;
                 }
-            }
-
-            if (this._updatable) { // update buffer
+            } else if (this._updatable) { // update buffer
                 this._engine.updateDynamicVertexBuffer(this._buffer, data);
                 this._data = data;
             }

src/Mesh/babylon.geometry.ts

@@ -12,7 +12,7 @@
         private _meshes: Mesh[];
         private _totalVertices = 0;
         private _indices: number[] | Int32Array;
-        private _vertexBuffers: { [key: string]: IVertexBuffer; };
+        private _vertexBuffers: { [key: string]: VertexBuffer; };
         private _isDisposed = false;
         private _extend: { minimum: Vector3, maximum: Vector3 };
         private _boundingBias: Vector2;
@@ -97,7 +97,7 @@
             this.setVerticesBuffer(buffer);
         }
 
-        public setVerticesBuffer(buffer: IVertexBuffer): void {
+        public setVerticesBuffer(buffer: VertexBuffer): void {
             var kind = buffer.getKind();
             if (this._vertexBuffers[kind]) {
                 this._vertexBuffers[kind].dispose();
@@ -207,14 +207,14 @@
             }
         }
 
-        public getVertexBuffer(kind: string): IVertexBuffer {
+        public getVertexBuffer(kind: string): VertexBuffer {
             if (!this.isReady()) {
                 return null;
             }
             return this._vertexBuffers[kind];
         }
 
-        public getVertexBuffers(): { [key: string]: IVertexBuffer; } {
+        public getVertexBuffers(): { [key: string]: VertexBuffer; } {
             if (!this.isReady()) {
                 return null;
             }

src/Mesh/babylon.interleavedVertexBuffer.ts

@@ -1,66 +0,0 @@
-module BABYLON {
-    export class InterleavedVertexBuffer implements IVertexBuffer {
-        private _buffer: InterleavedBuffer;
-        private _offset: number;
-        private _size: number;
-        private _kind: string;
-
-        constructor(buffer: InterleavedBuffer, kind: string, size: number, offset: number) {
-            this._kind = kind;
-
-            this._buffer = buffer;
-            this._offset = offset;
-            this._size = size;
-        }
-
-        public getKind(): string {
-            return this._kind;
-        }
-
-        public getStrideSize(): number {
-            return this._buffer.getStrideSize();
-        }
-
-        public getOffset(): number {
-            return this._offset;
-        }
-
-        public getSize(): number {
-            return this._size;
-        }
-
-        public getIsInstanced(): boolean {
-            return this._buffer.getIsInstanced();
-        }
-
-        public getBuffer(): WebGLBuffer {
-            return this._buffer.getBuffer();
-        }
-
-        public getData(): number[] | Float32Array {
-            return this._buffer.getData();
-        }
-
-        public isUpdatable(): boolean {
-            return this._buffer.isUpdatable();
-        }
-
-        public create(data?: number[] | Float32Array): void
-        {
-            return this._buffer.create(data);
-        }
-
-        public update(data: number[] | Float32Array): void
-        {
-            return this._buffer.update(data);
-        }
-
-        public updateDirectly(data: Float32Array, offset: number): void
-        {
-            return this._buffer.updateDirectly(data, offset);
-        }
-
-        public dispose(): void {
-        }
-    }
-} 

src/Mesh/babylon.linesMesh.ts

@@ -3,7 +3,7 @@
         public color = new Color3(1, 1, 1);
         public alpha = 1;
 
-        private _positionBuffer: { [key: string]: IVertexBuffer } = {};
+        private _positionBuffer: { [key: string]: VertexBuffer } = {};
 
         /**
          * The intersection Threshold is the margin applied when intersection a segment of the LinesMesh with a Ray.

src/Mesh/babylon.mesh.ts

@@ -109,7 +109,7 @@
         private _renderIdForInstances = new Array<number>();
         private _batchCache = new _InstancesBatch();
         private _instancesBufferSize = 32 * 16 * 4; // let's start with a maximum of 32 instances
-        private _instancesBuffer: InterleavedBuffer;
+        private _instancesBuffer: Buffer;
         private _instancesData: Float32Array;
         private _overridenInstanceCount: number;
 
@@ -387,7 +387,7 @@
          * - BABYLON.VertexBuffer.MatricesWeightsKind
          * - BABYLON.VertexBuffer.MatricesWeightsExtraKind 
          */
-        public getVertexBuffer(kind): IVertexBuffer {
+        public getVertexBuffer(kind): VertexBuffer {
             if (!this._geometry) {
                 return undefined;
             }
@@ -535,7 +535,7 @@
         /**
          * Overrides instance count. Only applicable when custom instanced InterleavedVertexBuffer are used rather than InstancedMeshs
          */
-        public set OverridenInstanceCount(count: number) {
+        public set overridenInstanceCount(count: number) {
             this._overridenInstanceCount = count;
         }
 
@@ -669,7 +669,7 @@
             }
         }
 
-        public setVerticesBuffer(buffer: IVertexBuffer): void {
+        public setVerticesBuffer(buffer: VertexBuffer): void {
             if (!this._geometry) {
                 var scene = this.getScene();
 
@@ -955,13 +955,13 @@
                     instancesBuffer.dispose();
                 }
 
-                instancesBuffer = new BABYLON.InterleavedBuffer(engine, this._instancesData, true, 16, false, true);
+                instancesBuffer = new BABYLON.Buffer(engine, this._instancesData, true, 16, false, true);
                 this._instancesBuffer = instancesBuffer;
 
-                this.setVerticesBuffer(new BABYLON.InterleavedVertexBuffer(instancesBuffer, "world0", 4, 0));
-                this.setVerticesBuffer(new BABYLON.InterleavedVertexBuffer(instancesBuffer, "world1", 4, 4));
-                this.setVerticesBuffer(new BABYLON.InterleavedVertexBuffer(instancesBuffer, "world2", 4, 8));
-                this.setVerticesBuffer(new BABYLON.InterleavedVertexBuffer(instancesBuffer, "world3", 4, 12));
+                this.setVerticesBuffer(instancesBuffer.createVertexBuffer("world0", 0, 4));
+                this.setVerticesBuffer(instancesBuffer.createVertexBuffer("world1", 4, 4));
+                this.setVerticesBuffer(instancesBuffer.createVertexBuffer("world2", 8, 4));
+                this.setVerticesBuffer(instancesBuffer.createVertexBuffer("world3", 12, 4));
 
                 engine.bindBuffers(this.geometry.getVertexBuffers(), this.geometry.getIndexBuffer(), effect);
             } else {

src/Mesh/babylon.vertexBuffer.ts

@@ -1,158 +1,116 @@
 module BABYLON {
-    export interface IVertexBuffer extends IDisposable {
-        getKind(): string;
-        getStrideSize(): number;
-        getData(): number[] | Float32Array;
-        getBuffer(): WebGLBuffer;
-        getOffset(): number;
-        getSize(): number;
-        getIsInstanced(): boolean;
-        isUpdatable(): boolean;
-        create(data?: number[] | Float32Array): void;
-        update(data: number[] | Float32Array): void;
-        updateDirectly(data: Float32Array, offset: number): void;
-    }
-
-    export class VertexBuffer implements IVertexBuffer {
-        private _engine: Engine;
-        private _buffer: WebGLBuffer;
-        private _data: number[] | Float32Array;
-        private _updatable: boolean;
+    export class VertexBuffer {
+        private _buffer: Buffer;
         private _kind: string;
-        private _strideSize: number;
-        private _instanced: boolean;
-
-        constructor(engine: any, data: number[] | Float32Array, kind: string, updatable: boolean, postponeInternalCreation?: boolean, stride?: number, instanced?: boolean) {
-            if (engine instanceof Mesh) { // old versions of BABYLON.VertexBuffer accepted 'mesh' instead of 'engine'
-                this._engine = engine.getScene().getEngine();
-            }
-            else {
-                this._engine = engine;
+        private _offset: number;
+        private _size: number;
+        private _stride: number;
+        private _ownsBuffer: boolean;
+
+        constructor(engine: any, data: number[] | Float32Array | Buffer, kind: string, updatable: boolean, postponeInternalCreation?: boolean, stride?: number, instanced?: boolean, offset?: number, size?: number) {
+            if (!stride) {
+                // Deduce stride from kind
+                switch (kind) {
+                    case VertexBuffer.PositionKind:
+                        stride = 3;
+                        break;
+                    case VertexBuffer.NormalKind:
+                        stride = 3;
+                        break;
+                    case VertexBuffer.UVKind:
+                    case VertexBuffer.UV2Kind:
+                    case VertexBuffer.UV3Kind:
+                    case VertexBuffer.UV4Kind:
+                    case VertexBuffer.UV5Kind:
+                    case VertexBuffer.UV6Kind:
+                        stride = 2;
+                        break;
+                    case VertexBuffer.ColorKind:
+                        stride = 4;
+                        break;
+                    case VertexBuffer.MatricesIndicesKind:
+                    case VertexBuffer.MatricesIndicesExtraKind:
+                        stride = 4;
+                        break;
+                    case VertexBuffer.MatricesWeightsKind:
+                    case VertexBuffer.MatricesWeightsExtraKind:
+                        stride = 4;
+                        break;
+                }
             }
 
-            this._updatable = updatable;
+            if (data instanceof Buffer) {
+                if (!stride) {
+                    stride = data.getStrideSize();
+                }
+                this._buffer = data;
+                this._ownsBuffer = false;
+            } else {
+                this._buffer = new Buffer(engine, data, updatable, stride, postponeInternalCreation, instanced);
+                this._ownsBuffer = true;
+            }
 
-            this._data = data;
+            this._stride = stride;
 
-            this._instanced = instanced;
 
-            if (!postponeInternalCreation) { // by default
-                this.create();
-            }
+            this._offset = offset ? offset : 0;
+            this._size = size ? size : stride;
 
             this._kind = kind;
+        }
 
-            if (stride) {
-                this._strideSize = stride;
-                return;
-            }
 
-            // Deduce stride from kind
-            switch (kind) {
-                case VertexBuffer.PositionKind:
-                    this._strideSize = 3;
-                    break;
-                case VertexBuffer.NormalKind:
-                    this._strideSize = 3;
-                    break;
-                case VertexBuffer.UVKind:
-                case VertexBuffer.UV2Kind:
-                case VertexBuffer.UV3Kind:
-                case VertexBuffer.UV4Kind:
-                case VertexBuffer.UV5Kind:
-                case VertexBuffer.UV6Kind:
-                    this._strideSize = 2;
-                    break;
-                case VertexBuffer.ColorKind:
-                    this._strideSize = 4;
-                    break;
-                case VertexBuffer.MatricesIndicesKind:
-                case VertexBuffer.MatricesIndicesExtraKind:
-                    this._strideSize = 4;
-                    break;
-                case VertexBuffer.MatricesWeightsKind:
-                case VertexBuffer.MatricesWeightsExtraKind:
-                    this._strideSize = 4;
-                    break;
-            }
+        public getKind(): string {
+            return this._kind;
         }
 
         // Properties
         public isUpdatable(): boolean {
-            return this._updatable;
-        }
-
-        public getKind(): string {
-            return this._kind;
+            return this._buffer.isUpdatable();
         }
 
         public getData(): number[] | Float32Array {
-            return this._data;
+            return this._buffer.getData();
         }
 
         public getBuffer(): WebGLBuffer {
-            return this._buffer;
+            return this._buffer.getBuffer();
         }
 
         public getStrideSize(): number {
-            return this._strideSize;
+            return this._stride;
         }
 
         public getOffset(): number {
-            return 0;
+            return this._offset;
         }
 
         public getSize(): number {
-            return this._strideSize;
+            return this._size;
         }
 
         public getIsInstanced(): boolean {
-            return this._instanced;
+            return this._buffer.getIsInstanced();
         }
 
         // Methods
-        public create(data?: number[] | Float32Array): void {
-            if (!data && this._buffer) {
-                return; // nothing to do
-            }
-
-            data = data || this._data;
 
-            if (!this._buffer) { // create buffer
-                if (this._updatable) {
-                    this._buffer = this._engine.createDynamicVertexBuffer(data);
-                } else {
-                    this._buffer = this._engine.createVertexBuffer(data);
-                }
-            }
 
-            if (this._updatable) { // update buffer
-                this._engine.updateDynamicVertexBuffer(this._buffer, data);
-                this._data = data;
-            }
+        public create(data?: number[] | Float32Array): void {
+            return this._buffer.create(data);
         }
 
         public update(data: number[] | Float32Array): void {
-            this.create(data);
+            return this._buffer.update(data);
         }
 
         public updateDirectly(data: Float32Array, offset: number): void {
-            if (!this._buffer) {
-                return;
-            }
-
-            if (this._updatable) { // update buffer
-                this._engine.updateDynamicVertexBuffer(this._buffer, data, offset);
-                this._data = null;
-            }
+            return this._buffer.updateDirectly(data, offset);
         }
 
         public dispose(): void {
-            if (!this._buffer) {
-                return;
-            }
-            if (this._engine._releaseBuffer(this._buffer)) {
-                this._buffer = null;
+            if (this._ownsBuffer) {
+                this._buffer.dispose();
             }
         }
 

src/Particles/babylon.particleSystem.ts

@@ -80,8 +80,8 @@
         private _stockParticles = new Array<Particle>();
         private _newPartsExcess = 0;
         private _vertexData: Float32Array;
-        private _vertexBuffer: InterleavedBuffer;
-        private _vertexBuffers: { [key: string]: IVertexBuffer } = {};
+        private _vertexBuffer: Buffer;
+        private _vertexBuffers: { [key: string]: VertexBuffer } = {};
         private _indexBuffer: WebGLBuffer;
         private _effect: Effect;
         private _customEffect: Effect;
@@ -125,11 +125,11 @@
 
             // 11 floats per particle (x, y, z, r, g, b, a, angle, size, offsetX, offsetY)
             this._vertexData = new Float32Array(capacity * 11);
-            this._vertexBuffer = new InterleavedBuffer(scene.getEngine(), this._vertexData, true, 11);
+            this._vertexBuffer = new Buffer(scene.getEngine(), this._vertexData, true, 11);
 
-            var positions = new InterleavedVertexBuffer(this._vertexBuffer, VertexBuffer.PositionKind, 3, 0);
-            var colors = new InterleavedVertexBuffer(this._vertexBuffer, VertexBuffer.ColorKind, 4, 3);
-            var options = new InterleavedVertexBuffer(this._vertexBuffer, "options", 4, 7);
+            var positions = this._vertexBuffer.createVertexBuffer(VertexBuffer.PositionKind, 0, 3);
+            var colors = this._vertexBuffer.createVertexBuffer(VertexBuffer.ColorKind, 3, 4);
+            var options = this._vertexBuffer.createVertexBuffer("options", 7, 4);
 
             this._vertexBuffers[VertexBuffer.PositionKind] = positions;
             this._vertexBuffers[VertexBuffer.ColorKind] = colors;

src/PostProcess/babylon.postProcessManager.ts

@@ -2,15 +2,14 @@
     export class PostProcessManager {
         private _scene: Scene;
         private _indexBuffer: WebGLBuffer;
-        private _vertexBuffer: VertexBuffer;
-        private _vertexBuffers: { [key: string]: IVertexBuffer } = {};
+        private _vertexBuffers: { [key: string]: VertexBuffer } = {};
 
         constructor(scene: Scene) {
             this._scene = scene;
         }
 
         private _prepareBuffers(): void {
-            if (this._vertexBuffer) {
+            if (this._vertexBuffers[VertexBuffer.PositionKind]) {
                 return;
             }
 
@@ -21,8 +20,7 @@
             vertices.push(-1, -1);
             vertices.push(1, -1);
 
-            this._vertexBuffer = new VertexBuffer(this._scene.getEngine(), vertices, VertexBuffer.PositionKind, false, false, 2);
-            this._vertexBuffers[VertexBuffer.PositionKind] = this._vertexBuffer;
+            this._vertexBuffers[VertexBuffer.PositionKind] = new VertexBuffer(this._scene.getEngine(), vertices, VertexBuffer.PositionKind, false, false, 2);
 
             // Indices
             var indices = [];
@@ -130,9 +128,10 @@
         }
 
         public dispose(): void {
-            if (this._vertexBuffer) {
-                this._vertexBuffer.dispose();
-                this._vertexBuffer = null;
+            var buffer = this._vertexBuffers[VertexBuffer.PositionKind];
+            if (buffer) {
+                buffer.dispose();
+                this._vertexBuffers[VertexBuffer.PositionKind] = null;
             }
 
             if (this._indexBuffer) {

src/Rendering/babylon.boundingBoxRenderer.ts

@@ -7,8 +7,7 @@
 
         private _scene: Scene;
         private _colorShader: ShaderMaterial;
-        private _vertexBuffer: VertexBuffer;
-        private _vertexBuffers: { [key: string]: IVertexBuffer } = {};
+        private _vertexBuffers: { [key: string]: VertexBuffer } = {};
         private _indexBuffer: WebGLBuffer;
 
         constructor(scene: Scene) {
@@ -29,8 +28,7 @@
 
             var engine = this._scene.getEngine();
             var boxdata = VertexData.CreateBox(1.0);
-            this._vertexBuffer = new VertexBuffer(engine, boxdata.positions, VertexBuffer.PositionKind, false);
-            this._vertexBuffers[VertexBuffer.PositionKind] = this._vertexBuffer;
+            this._vertexBuffers[VertexBuffer.PositionKind] = new VertexBuffer(engine, boxdata.positions, VertexBuffer.PositionKind, false);
             this._indexBuffer = engine.createIndexBuffer([0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 7, 1, 6, 2, 5, 3, 4]);
         }
 
@@ -97,7 +95,12 @@
             }
 
             this._colorShader.dispose();
-            this._vertexBuffer.dispose();
+
+            var buffer = this._vertexBuffers[VertexBuffer.PositionKind];
+            if (buffer) {
+                buffer.dispose();
+                this._vertexBuffers[VertexBuffer.PositionKind] = null;
+            }
             this._scene.getEngine()._releaseBuffer(this._indexBuffer);
         }
     }

src/Rendering/babylon.edgesRenderer.ts

@@ -19,10 +19,8 @@
         private _indicesCount: number;
 
         private _lineShader: ShaderMaterial;
-        private _vb0: VertexBuffer;
-        private _vb1: VertexBuffer;
         private _ib: WebGLBuffer;
-        private _buffers: { [key: string]: IVertexBuffer; } = {};
+        private _buffers: { [key: string]: VertexBuffer; } = {};
         private _checkVerticesInsteadOfIndices = false;
 
         // Beware when you use this class with complex objects as the adjacencies computation can be really long
@@ -52,8 +50,18 @@
         }
 
         public dispose(): void {
-            this._vb0.dispose();
-            this._vb1.dispose();
+
+            var buffer = this._buffers[VertexBuffer.PositionKind];
+            if (buffer) {
+                buffer.dispose();
+                this._buffers[VertexBuffer.PositionKind] = null;
+            }
+            buffer = this._buffers[VertexBuffer.NormalKind];
+            if (buffer) {
+                buffer.dispose();
+                this._buffers[VertexBuffer.NormalKind] = null;
+            }
+
             this._source.getScene().getEngine()._releaseBuffer(this._ib);
             this._lineShader.dispose();
         }
@@ -261,11 +269,9 @@
 
             // Merge into a single mesh
             var engine = this._source.getScene().getEngine();
-            this._vb0 = new VertexBuffer(engine, this._linesPositions, VertexBuffer.PositionKind, false);
-            this._vb1 = new VertexBuffer(engine, this._linesNormals, VertexBuffer.NormalKind, false, false, 4);
 
-            this._buffers[VertexBuffer.PositionKind] = this._vb0;
-            this._buffers[VertexBuffer.NormalKind] = this._vb1;
+            this._buffers[VertexBuffer.PositionKind] = new VertexBuffer(engine, this._linesPositions, VertexBuffer.PositionKind, false);
+            this._buffers[VertexBuffer.NormalKind] = new VertexBuffer(engine, this._linesNormals, VertexBuffer.NormalKind, false, false, 4);
 
             this._ib = engine.createIndexBuffer(this._linesIndices);
 

src/Sprites/babylon.spriteManager.ts

@@ -27,8 +27,8 @@
         private _scene: Scene;
 
         private _vertexData: Float32Array;
-        private _vertexBuffer: InterleavedBuffer;
-        private _vertexBuffers: { [key: string]: IVertexBuffer } = {};
+        private _buffer: Buffer;
+        private _vertexBuffers: { [key: string]: VertexBuffer } = {};
         private _indexBuffer: WebGLBuffer;
         private _effectBase: Effect;
         private _effectFog: Effect;
@@ -69,12 +69,12 @@
             // VBO
             // 16 floats per sprite (x, y, z, angle, sizeX, sizeY, offsetX, offsetY, invertU, invertV, cellIndexX, cellIndexY, color r, color g, color b, color a)
             this._vertexData = new Float32Array(capacity * 16);
-            this._vertexBuffer = new InterleavedBuffer(scene.getEngine(), this._vertexData, true, 16);
+            this._buffer = new Buffer(scene.getEngine(), this._vertexData, true, 16);
 
-            var positions = new InterleavedVertexBuffer(this._vertexBuffer, VertexBuffer.PositionKind, 4, 0);
-            var options = new InterleavedVertexBuffer(this._vertexBuffer, "options", 4, 4);
-            var cellInfo = new InterleavedVertexBuffer(this._vertexBuffer, "cellInfo", 4, 8);
-            var colors = new InterleavedVertexBuffer(this._vertexBuffer, VertexBuffer.ColorKind, 4, 12);
+            var positions = this._buffer.createVertexBuffer(VertexBuffer.PositionKind, 0, 4);
+            var options = this._buffer.createVertexBuffer("options", 4, 4);
+            var cellInfo = this._buffer.createVertexBuffer("cellInfo", 8, 4);
+            var colors = this._buffer.createVertexBuffer(VertexBuffer.ColorKind, 12, 4);
 
             this._vertexBuffers[VertexBuffer.PositionKind] = positions;
             this._vertexBuffers["options"] = options;
@@ -208,7 +208,7 @@
                 this._appendSpriteVertex(offset++, sprite, 1, 1, rowSize);
                 this._appendSpriteVertex(offset++, sprite, 0, 1, rowSize);
             }
-            this._vertexBuffer.update(this._vertexData);
+            this._buffer.update(this._vertexData);
 
             // Render
             var effect = this._effectBase;
@@ -249,9 +249,9 @@
         }
 
         public dispose(): void {
-            if (this._vertexBuffer) {
-                this._vertexBuffer.dispose();
-                this._vertexBuffer = null;
+            if (this._buffer) {
+                this._buffer.dispose();
+                this._buffer = null;
             }
 
             if (this._indexBuffer) {

src/babylon.engine.ts

@@ -983,7 +983,7 @@
             }
         }
 
-        public bindBuffers(vertexBuffers: { [key: string]: IVertexBuffer; }, indexBuffer: WebGLBuffer, effect: Effect): void {
+        public bindBuffers(vertexBuffers: { [key: string]: VertexBuffer; }, indexBuffer: WebGLBuffer, effect: Effect): void {
             if (this._cachedVertexBuffers !== vertexBuffers || this._cachedEffectForVertexBuffers !== effect) {
                 this._cachedVertexBuffers = vertexBuffers;
                 this._cachedEffectForVertexBuffers = effect;