Merge pull request #1300 from haxiomic/master

Fixed issues with vertex attribute arrays

src/babylon.engine.ts

@@ -166,6 +166,7 @@
         public maxTextureSize: number;
         public maxCubemapTextureSize: number;
         public maxRenderTextureSize: number;
+        public maxVertexAttribs: number;
         public standardDerivatives: boolean;
         public s3tc: WEBGL_compressed_texture_s3tc;
         public textureFloat: boolean;
@@ -362,8 +363,7 @@
         private _currentEffect: Effect;
         private _currentProgram: WebGLProgram;
         private _compiledEffects = {};
-        private _vertexAttribArraysEnabled: boolean[];
-        private _vertexAttribArraysToUse: boolean[];
+        private _vertexAttribArraysEnabled: boolean[] = [];
         private _cachedViewport: Viewport;
         private _cachedVertexBuffers: any;
         private _cachedIndexBuffer: WebGLBuffer;
@@ -453,6 +453,7 @@
             this._caps.maxTextureSize = this._gl.getParameter(this._gl.MAX_TEXTURE_SIZE);
             this._caps.maxCubemapTextureSize = this._gl.getParameter(this._gl.MAX_CUBE_MAP_TEXTURE_SIZE);
             this._caps.maxRenderTextureSize = this._gl.getParameter(this._gl.MAX_RENDERBUFFER_SIZE);
+            this._caps.maxVertexAttribs = this._gl.getParameter(this._gl.MAX_VERTEX_ATTRIBS);
 
             // Infos
             this._glVersion = this._gl.getParameter(this._gl.VERSION);
@@ -1128,14 +1129,36 @@
                 this._cachedVertexBuffers = vertexBuffer;
                 this._cachedEffectForVertexBuffers = effect;
 
+                let attributesCount = effect.getAttributesCount();
+
                 var offset = 0;
-                for (var index = 0; index < vertexDeclaration.length; index++) {
-                    var order = effect.getAttributeLocation(index);
+                for (var index = 0; index < attributesCount; index++) {
+
+                    if(index < vertexDeclaration.length){
+
+                        var order = effect.getAttributeLocation(index);
+
+                        if (order >= 0) {
+                            if(!this._vertexAttribArraysEnabled[order]){
+                                this._gl.enableVertexAttribArray(order);
+                                this._vertexAttribArraysEnabled[order] = true;
+                            }
+                            this.vertexAttribPointer(vertexBuffer, order, vertexDeclaration[index], this._gl.FLOAT, false, vertexStrideSize, offset);
+                        }
+
+                        offset += vertexDeclaration[index] * 4;
+
+                    }else{
+
+                        //disable effect attributes that have no data
+                        var order = effect.getAttributeLocation(index);
+                        if(this._vertexAttribArraysEnabled[order]){
+                            this._gl.disableVertexAttribArray(order);
+                            this._vertexAttribArraysEnabled[order] = false;
+                        }
 
-                    if (order >= 0) {
-                        this.vertexAttribPointer(vertexBuffer, order, vertexDeclaration[index], this._gl.FLOAT, false, vertexStrideSize, offset);
                     }
-                    offset += vertexDeclaration[index] * 4;
+
                 }
             }
 
@@ -1158,9 +1181,20 @@
 
                     if (order >= 0) {
                         var vertexBuffer = vertexBuffers[attributes[index]];
+
                         if (!vertexBuffer) {
+                            if(this._vertexAttribArraysEnabled[order]){
+                                this._gl.disableVertexAttribArray(order);
+                                this._vertexAttribArraysEnabled[order] = false;
+                            }
                             continue;
                         }
+
+                        if(!this._vertexAttribArraysEnabled[order]){
+                            this._gl.enableVertexAttribArray(order);
+                            this._vertexAttribArraysEnabled[order] = true;
+                        }
+
                         var buffer = vertexBuffer.getBuffer();
                         this.vertexAttribPointer(buffer, order, vertexBuffer.getSize(), this._gl.FLOAT, false, vertexBuffer.getStrideSize() * 4, vertexBuffer.getOffset() * 4);
 
@@ -1234,7 +1268,12 @@
                 }
                 for (let i = 0; i < offsetLocations.length; i++) {
                     let ai = <InstancingAttributeInfo>offsetLocations[i];
-                    this._gl.enableVertexAttribArray(ai.index);
+
+                    if(!this._vertexAttribArraysEnabled[ai.index]){
+                        this._gl.enableVertexAttribArray(ai.index);
+                        this._vertexAttribArraysEnabled[ai.index] = true;
+                    }
+
                     this.vertexAttribPointer(instancesBuffer, ai.index, ai.attributeSize, ai.attribyteType || this._gl.FLOAT, ai.normalized || false, stride, ai.offset);
                     this._caps.instancedArrays.vertexAttribDivisorANGLE(ai.index, 1);
                     this._currentInstanceLocations.push(ai.index);
@@ -1243,7 +1282,12 @@
             } else {
                 for (let index = 0; index < 4; index++) {
                     let offsetLocation = <number>offsetLocations[index];
-                    this._gl.enableVertexAttribArray(offsetLocation);
+
+                    if(!this._vertexAttribArraysEnabled[offsetLocation]){
+                        this._gl.enableVertexAttribArray(offsetLocation);
+                        this._vertexAttribArraysEnabled[offsetLocation] = true;
+                    }
+
                     this.vertexAttribPointer(instancesBuffer, offsetLocation, 4, this._gl.FLOAT, false, 64, index * 16);
                     this._caps.instancedArrays.vertexAttribDivisorANGLE(offsetLocation, 1);
                     this._currentInstanceLocations.push(offsetLocation);
@@ -1400,43 +1444,9 @@
                 return;
             }
 
-            this._vertexAttribArraysToUse = this._vertexAttribArraysToUse || [];
-            this._vertexAttribArraysEnabled = this._vertexAttribArraysEnabled || [];
-
             // Use program
             this.setProgram(effect.getProgram());
 
-            var i, ul;
-            for (i = 0, ul = this._vertexAttribArraysToUse.length; i < ul; i++) {
-                this._vertexAttribArraysToUse[i] = false;
-            }
-
-            var attributesCount = effect.getAttributesCount();
-            for (i = 0; i < attributesCount; i++) {
-                // Attributes
-                var order = effect.getAttributeLocation(i);
-
-                if (order >= 0) {
-                    this._vertexAttribArraysToUse[order] = true;
-                }
-            }
-
-            for (i = 0, ul = this._vertexAttribArraysEnabled.length; i < ul; i++) {
-                if (i > this._gl.VERTEX_ATTRIB_ARRAY_ENABLED || !this._vertexAttribArraysEnabled[i] || this._vertexAttribArraysToUse[i]) {
-                    continue;
-                }
-                this._vertexAttribArraysEnabled[i] = false;
-                this._gl.disableVertexAttribArray(i);
-            }
-
-
-            for (i = 0, ul = this._vertexAttribArraysToUse.length; i < ul; i++) {
-                if (this._vertexAttribArraysToUse[i] && !this._vertexAttribArraysEnabled[i]) {
-                    this._vertexAttribArraysEnabled[i] = true;
-                    this._gl.enableVertexAttribArray(i);
-                }
-            }
-
             this._currentEffect = effect;
 
             if (effect.onBind) {
@@ -2747,13 +2757,11 @@
             }
 
             // Unbind
-            if (this._vertexAttribArraysEnabled) {
-                for (var i = 0, ul = this._vertexAttribArraysEnabled.length; i < ul; i++) {
-                    if (i > this._gl.VERTEX_ATTRIB_ARRAY_ENABLED || !this._vertexAttribArraysEnabled[i]) {
-                        continue;
-                    }
-                    this._gl.disableVertexAttribArray(i);
+            for (var i = 0, ul = this._vertexAttribArraysEnabled.length; i < ul; i++) {
+                if (i >= this._caps.maxVertexAttribs || !this._vertexAttribArraysEnabled[i]) {
+                    continue;
                 }
+                this._gl.disableVertexAttribArray(i);
             }
 
             this._gl = null;