cesium 0.16.0 → 0.17.0

data/app/assets/javascripts/Renderer/DrawCommand.js

@@ -1,5 +1,5 @@
 /*global define*/
-define(['../Core/DeveloperError'], function(DeveloperError) {
+define(function() {
     "use strict";
 
     /**

data/app/assets/javascripts/Renderer/PickFramebuffer.js

@@ -3,7 +3,6 @@ define([
         '../Core/defaultValue',
         '../Core/destroyObject',
         '../Core/Color',
-        '../Core/DeveloperError',
         '../Core/BoundingRectangle',
         './ClearCommand',
         './PassState',
@@ -12,7 +11,6 @@ define([
         defaultValue,
         destroyObject,
         Color,
-        DeveloperError,
         BoundingRectangle,
         ClearCommand,
         PassState,

data/app/assets/javascripts/Renderer/PixelDatatype.js

@@ -32,6 +32,14 @@ define(['../Core/Enumeration'], function(Enumeration) {
          */
         UNSIGNED_INT : new Enumeration(0x1405, 'UNSIGNED_INT'),
 
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT : new Enumeration(0x1406, 'FLOAT'),
+
         /**
          * An unsigned int pixel datatype used for depth-stencil textures with 24-bit depth and 8-bit stencil values.
          *
@@ -75,6 +83,7 @@ define(['../Core/Enumeration'], function(Enumeration) {
             return ((pixelDatatype === PixelDatatype.UNSIGNED_BYTE) ||
                     (pixelDatatype === PixelDatatype.UNSIGNED_SHORT) ||
                     (pixelDatatype === PixelDatatype.UNSIGNED_INT) ||
+                    (pixelDatatype === PixelDatatype.FLOAT) ||
                     (pixelDatatype === PixelDatatype.UNSIGNED_INT_24_8_WEBGL) ||
                     (pixelDatatype === PixelDatatype.UNSIGNED_SHORT_4_4_4_4) ||
                     (pixelDatatype === PixelDatatype.UNSIGNED_SHORT_5_5_5_1) ||

data/app/assets/javascripts/Renderer/Renderbuffer.js

@@ -1,9 +1,7 @@
 /*global define*/
 define([
-        '../Core/DeveloperError',
         '../Core/destroyObject'
     ], function(
-        DeveloperError,
         destroyObject) {
     "use strict";
 

data/app/assets/javascripts/Renderer/ShaderProgram.js

@@ -1292,6 +1292,69 @@ define([
             }
         },
 
+        /**
+         * An automatic GLSL uniform representing the sun position in world coordinates.
+         * <br /><br />
+         * Like all automatic uniforms, <code>czm_sunPositionWC</code> does not need to be explicitly declared.
+         * However, it can be explicitly declared when a shader is also used by other applications such
+         * as a third-party authoring tool.
+         *
+         * @alias czm_sunPositionWC
+         * @glslUniform
+         *
+         * @see UniformState#getSunPositionWC
+         * @see czm_sunPositionColumbusView
+         * @see czm_sunDirectionWC
+         *
+         * @example
+         * // GLSL declaration
+         * uniform vec3 czm_sunPositionWC;
+         */
+        czm_sunPositionWC : {
+            getSize : function() {
+                return 1;
+            },
+
+            getDatatype : function() {
+                return UniformDatatype.FLOAT_VECTOR3;
+            },
+
+            getValue : function(uniformState) {
+                return uniformState.getSunPositionWC();
+            }
+        },
+
+        /**
+         * An automatic GLSL uniform representing the sun position in Columbus view world coordinates.
+         * <br /><br />
+         * Like all automatic uniforms, <code>czm_sunPositionColumbusView</code> does not need to be explicitly declared.
+         * However, it can be explicitly declared when a shader is also used by other applications such
+         * as a third-party authoring tool.
+         *
+         * @alias czm_sunPositionColumbusView
+         * @glslUniform
+         *
+         * @see UniformState#getSunPositionColumbusView
+         * @see czm_sunPositionWC
+         *
+         * @example
+         * // GLSL declaration
+         * uniform vec3 czm_sunPositionColumbusView;
+         */
+        czm_sunPositionColumbusView : {
+            getSize : function() {
+                return 1;
+            },
+
+            getDatatype : function() {
+                return UniformDatatype.FLOAT_VECTOR3;
+            },
+
+            getValue : function(uniformState) {
+                return uniformState.getSunPositionColumbusView();
+            }
+        },
+
         /**
          * An automatic GLSL uniform representing the normalized direction to the sun in eye coordinates.
          * This is commonly used for directional lighting computations.
@@ -1340,6 +1403,7 @@ define([
          * @glslUniform
          *
          * @see UniformState#getSunDirectionWC
+         * @see czm_sunPositionWC
          * @see czm_sunDirectionEC
          *
          * @example
@@ -2231,6 +2295,8 @@ define([
     }
 
     function getBuiltinConstants() {
+        // use toExponential instead of toString to prevent a number like 1.2e2 from expanding to 120
+        // and have a shader fail to compile because it thinks it should be an int.
         var constants = {
             /**
              * A built-in GLSL floating-point constant for <code>Math.PI</code>.
@@ -2247,7 +2313,7 @@ define([
              * // Example
              * float twoPi = 2.0 * czm_pi;
              */
-            czm_pi : Math.PI.toString(),
+            czm_pi : Math.PI.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>1/pi</code>.
@@ -2264,7 +2330,7 @@ define([
              * // Example
              * float pi = 1.0 / czm_oneOverPi;
              */
-            czm_oneOverPi : CesiumMath.ONE_OVER_PI.toString(),
+            czm_oneOverPi : CesiumMath.ONE_OVER_PI.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>pi/2</code>.
@@ -2281,7 +2347,7 @@ define([
              * // Example
              * float pi = 2.0 * czm_piOverTwo;
              */
-            czm_piOverTwo : CesiumMath.PI_OVER_TWO.toString(),
+            czm_piOverTwo : CesiumMath.PI_OVER_TWO.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>pi/3</code>.
@@ -2298,7 +2364,7 @@ define([
              * // Example
              * float pi = 3.0 * czm_piOverThree;
              */
-            czm_piOverThree : CesiumMath.PI_OVER_THREE.toString(),
+            czm_piOverThree : CesiumMath.PI_OVER_THREE.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>pi/4</code>.
@@ -2315,7 +2381,7 @@ define([
              * // Example
              * float pi = 4.0 * czm_piOverFour;
              */
-            czm_piOverFour : CesiumMath.PI_OVER_FOUR.toString(),
+            czm_piOverFour : CesiumMath.PI_OVER_FOUR.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>pi/6</code>.
@@ -2332,7 +2398,7 @@ define([
              * // Example
              * float pi = 6.0 * czm_piOverSix;
              */
-            czm_piOverSix : CesiumMath.PI_OVER_SIX.toString(),
+            czm_piOverSix : CesiumMath.PI_OVER_SIX.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>3pi/2</code>.
@@ -2349,7 +2415,7 @@ define([
              * // Example
              * float pi = (2.0 / 3.0) * czm_threePiOver2;
              */
-            czm_threePiOver2 : CesiumMath.THREE_PI_OVER_TWO.toString(),
+            czm_threePiOver2 : CesiumMath.THREE_PI_OVER_TWO.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>2pi</code>.
@@ -2366,7 +2432,7 @@ define([
              * // Example
              * float pi = czm_twoPi / 2.0;
              */
-            czm_twoPi : CesiumMath.TWO_PI.toString(),
+            czm_twoPi : CesiumMath.TWO_PI.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for <code>1/2pi</code>.
@@ -2383,7 +2449,7 @@ define([
              * // Example
              * float pi = 2.0 * czm_oneOverTwoPi;
              */
-            czm_oneOverTwoPi : CesiumMath.ONE_OVER_TWO_PI.toString(),
+            czm_oneOverTwoPi : CesiumMath.ONE_OVER_TWO_PI.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for converting degrees to radians.
@@ -2400,7 +2466,7 @@ define([
              * // Example
              * float rad = czm_radiansPerDegree * deg;
              */
-            czm_radiansPerDegree : CesiumMath.RADIANS_PER_DEGREE.toString(),
+            czm_radiansPerDegree : CesiumMath.RADIANS_PER_DEGREE.toExponential(),
 
             /**
              * A built-in GLSL floating-point constant for converting radians to degrees.
@@ -2417,7 +2483,21 @@ define([
              * // Example
              * float deg = czm_degreesPerRadian * rad;
              */
-            czm_degreesPerRadian : CesiumMath.DEGREES_PER_RADIAN.toString()
+            czm_degreesPerRadian : CesiumMath.DEGREES_PER_RADIAN.toExponential(),
+
+            /**
+             * A built-in GLSL floating-point constant for one solar radius.
+             *
+             * @alias czm_solarRadius
+             * @glslConstant
+             *
+             * @see CesiumMath.SOLAR_RADIUS
+             *
+             * @example
+             * // GLSL declaration
+             * const float czm_solarRadius = ...;
+             */
+            czm_solarRadius : CesiumMath.SOLAR_RADIUS.toExponential()
         };
 
         var glslConstants = '';

data/app/assets/javascripts/Renderer/Texture.js

@@ -6,6 +6,7 @@ define([
         '../Core/DeveloperError',
         '../Core/Math',
         './MipmapHint',
+        './PixelDatatype',
         './PixelFormat',
         './TextureMagnificationFilter',
         './TextureMinificationFilter',
@@ -17,6 +18,7 @@ define([
         DeveloperError,
         CesiumMath,
         MipmapHint,
+        PixelDatatype,
         PixelFormat,
         TextureMagnificationFilter,
         TextureMinificationFilter,
@@ -138,6 +140,7 @@ define([
      * @param {Number} [height=getHeight()] optional
      *
      * @exception {DeveloperError} Cannot call copyFromFramebuffer when the texture pixel format is DEPTH_COMPONENT or DEPTH_STENCIL.
+     * @exception {DeveloperError} Cannot call copyFromFramebuffer when the texture pixel data type is FLOAT.
      * @exception {DeveloperError} This texture was destroyed, i.e., destroy() was called.
      * @exception {DeveloperError} xOffset must be greater than or equal to zero.
      * @exception {DeveloperError} yOffset must be greater than or equal to zero.
@@ -151,6 +154,10 @@ define([
             throw new DeveloperError('Cannot call copyFromFramebuffer when the texture pixel format is DEPTH_COMPONENT or DEPTH_STENCIL.');
         }
 
+        if (this._pixelDatatype === PixelDatatype.FLOAT) {
+            throw new DeveloperError('Cannot call copyFromFramebuffer when the texture pixel data type is FLOAT.');
+        }
+
         xOffset = defaultValue(xOffset, 0);
         yOffset = defaultValue(yOffset, 0);
         framebufferXOffset = defaultValue(framebufferXOffset, 0);
@@ -258,15 +265,33 @@ define([
     */
     Texture.prototype.setSampler = function(sampler) {
         if (typeof sampler === 'undefined') {
+            var minFilter = TextureMinificationFilter.LINEAR;
+            var magFilter = TextureMagnificationFilter.LINEAR;
+            if (this._pixelDatatype === PixelDatatype.FLOAT) {
+                minFilter = TextureMinificationFilter.NEAREST;
+                magFilter = TextureMagnificationFilter.NEAREST;
+            }
+
             sampler = {
                 wrapS : TextureWrap.CLAMP,
                 wrapT : TextureWrap.CLAMP,
-                minificationFilter : TextureMinificationFilter.LINEAR,
-                magnificationFilter : TextureMagnificationFilter.LINEAR,
+                minificationFilter : minFilter,
+                magnificationFilter : magFilter,
                 maximumAnisotropy : 1.0
             };
         }
 
+        if (this._pixelDatatype === PixelDatatype.FLOAT) {
+            if (sampler.minificationFilter !== TextureMinificationFilter.NEAREST &&
+                    sampler.minificationFilter !== TextureMinificationFilter.NEAREST_MIPMAP_NEAREST) {
+                throw new DeveloperError('Only NEAREST and NEAREST_MIPMAP_NEAREST minification filters are supported for floating point textures.');
+            }
+
+            if (sampler.magnificationFilter !== TextureMagnificationFilter.NEAREST) {
+                throw new DeveloperError('Only the NEAREST magnification filter is supported for floating point textures.');
+            }
+        }
+
         var gl = this._gl;
         var target = this._textureTarget;
 

data/app/assets/javascripts/Renderer/UniformState.js

@@ -1,8 +1,5 @@
 /*global define*/
 define([
-        '../Core/DeveloperError',
-        '../Core/defaultValue',
-        '../Core/Ellipsoid',
         '../Core/Matrix3',
         '../Core/Matrix4',
         '../Core/Cartesian2',
@@ -16,9 +13,6 @@ define([
         '../Core/Simon1994PlanetaryPositions',
         '../Scene/SceneMode'
     ], function(
-        DeveloperError,
-        defaultValue,
-        Ellipsoid,
         Matrix3,
         Matrix4,
         Cartesian2,
@@ -120,6 +114,8 @@ define([
         this._encodedCameraPositionMC = new EncodedCartesian3();
         this._cameraPosition = new Cartesian3();
 
+        this._sunPositionWC = new Cartesian3();
+        this._sunPositionColumbusView = new Cartesian3();
         this._sunDirectionWC = new Cartesian3();
         this._sunDirectionEC = new Cartesian3();
         this._moonDirectionEC = new Cartesian3();
@@ -181,23 +177,30 @@ define([
         uniformState._encodedCameraPositionMCDirty = true;
     }
 
-    var position = new Cartesian3();
     var transformMatrix = new Matrix3();
+    var sunCartographicScratch = new Cartographic();
     function setSunAndMoonDirections(uniformState, frameState) {
         if (typeof Transforms.computeIcrfToFixedMatrix(frameState.time, transformMatrix) === 'undefined') {
             transformMatrix = Transforms.computeTemeToPseudoFixedMatrix(frameState.time, transformMatrix);
         }
 
-        position = Simon1994PlanetaryPositions.ComputeSunPositionInEarthInertialFrame(frameState.time, position);
-        transformMatrix.multiplyByVector(position, position);
+        var position = Simon1994PlanetaryPositions.ComputeSunPositionInEarthInertialFrame(frameState.time, uniformState._sunPositionWC);
+        Matrix3.multiplyByVector(transformMatrix, position, position);
+
         Cartesian3.normalize(position, uniformState._sunDirectionWC);
-        Matrix3.multiplyByVector(uniformState.getViewRotation3D(), position, position);
-        Cartesian3.normalize(position, uniformState._sunDirectionEC);
 
-        position = Simon1994PlanetaryPositions.ComputeMoonPositionInEarthInertialFrame(frameState.time, position);
-        transformMatrix.multiplyByVector(position, position);
+        position = Matrix3.multiplyByVector(uniformState.getViewRotation3D(), position, uniformState._sunDirectionEC);
+        Cartesian3.normalize(position, position);
+
+        position = Simon1994PlanetaryPositions.ComputeMoonPositionInEarthInertialFrame(frameState.time, uniformState._moonDirectionEC);
+        Matrix3.multiplyByVector(transformMatrix, position, position);
         Matrix3.multiplyByVector(uniformState.getViewRotation3D(), position, position);
-        Cartesian3.normalize(position, uniformState._moonDirectionEC);
+        Cartesian3.normalize(position, position);
+
+        var projection = frameState.scene2D.projection;
+        var ellipsoid = projection.getEllipsoid();
+        var sunCartographic = ellipsoid.cartesianToCartographic(uniformState._sunPositionWC, sunCartographicScratch);
+        projection.project(sunCartographic, uniformState._sunPositionColumbusView);
     }
 
     /**
@@ -924,6 +927,32 @@ define([
         return this._pixelSize;
     };
 
+    /**
+     * Returns the sun position in 3D world coordinates at the current scene time.
+     *
+     * @memberof UniformState
+     *
+     * @return {Cartesian3} The sun position in 3D world coordinates at the current scene time.
+     *
+     * @see czm_sunPositionWC
+     */
+    UniformState.prototype.getSunPositionWC = function() {
+        return this._sunPositionWC;
+    };
+
+    /**
+     * Returns the sun position in 2D world coordinates at the current scene time.
+     *
+     * @memberof UniformState
+     *
+     * @return {Cartesian3} The sun position in 2D world coordinates at the current scene time.
+     *
+     * @see czm_sunPositionColumbusView
+     */
+    UniformState.prototype.getSunPositionColumbusView = function() {
+        return this._sunPositionColumbusView;
+    };
+
     /**
      * Returns a normalized vector to the sun in 3D world coordinates at the current scene time.  Even in 2D or
      * Columbus View mode, this returns the position of the sun in the 3D scene.

data/app/assets/javascripts/Renderer/VertexArray.js

@@ -11,44 +11,7 @@ define([
         ComponentDatatype) {
     "use strict";
 
-    /**
-     * DOC_TBA
-     *
-     * @alias VertexArray
-     *
-     * @internalConstructor
-     *
-     * @see {@link Context#createVertexArray}
-     * @see {@link Context#createVertexArrayFromMesh}
-     */
-    var VertexArray = function(gl, attributes, indexBuffer) {
-        this._gl = gl;
-        this._attributes = [];
-        this._indexBuffer = indexBuffer;
-
-        if (attributes) {
-            for ( var i = 0; i < attributes.length; ++i) {
-                try {
-                    this._addAttribute(attributes[i], i);
-                } catch (e) {
-                    throw new DeveloperError(e.message);
-                }
-            }
-        }
-
-        // Verify all attribute names are unique
-        var uniqueIndices = {};
-        for ( var j = 0; j < this._attributes.length; ++j) {
-            var index = this._attributes[j].index;
-            if (uniqueIndices[index]) {
-                throw new DeveloperError('Index ' + index + ' is used by more than one attribute.');
-            }
-
-            uniqueIndices[index] = true;
-        }
-    };
-
-    VertexArray.prototype._addAttribute = function(attribute, index) {
+    function addAttribute(attributes, attribute, index) {
         if (!attribute.vertexBuffer && !attribute.value) {
             throw new DeveloperError('attribute must have a vertexBuffer or a value.');
         }
@@ -135,7 +98,67 @@ define([
             };
         }
 
-        this._attributes.push(attr);
+        attributes.push(attr);
+    }
+
+    function bind(gl, attributes, indexBuffer) {
+        for ( var i = 0; i < attributes.length; ++i) {
+            var attribute = attributes[i];
+            if (attribute.enabled) {
+                attribute.vertexAttrib(gl);
+            }
+        }
+
+        if (typeof indexBuffer !== 'undefined') {
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer._getBuffer());
+        }
+    }
+
+    /**
+     * DOC_TBA
+     *
+     * @alias VertexArray
+     *
+     * @internalConstructor
+     *
+     * @see {@link Context#createVertexArray}
+     * @see {@link Context#createVertexArrayFromMesh}
+     */
+    var VertexArray = function(gl, vertexArrayObject, attributes, indexBuffer) {
+        var vaAttributes = [];
+
+        if (typeof attributes !== 'undefined') {
+            for ( var i = 0; i < attributes.length; ++i) {
+                addAttribute(vaAttributes, attributes[i], i);
+            }
+        }
+
+        // Verify all attribute names are unique
+        var uniqueIndices = {};
+        for ( var j = 0; j < vaAttributes.length; ++j) {
+            var index = vaAttributes[j].index;
+            if (uniqueIndices[index]) {
+                throw new DeveloperError('Index ' + index + ' is used by more than one attribute.');
+            }
+
+            uniqueIndices[index] = true;
+        }
+
+        var vao;
+
+        // Setup VAO if extension is supported
+        if (vertexArrayObject !== null) {
+            vao = vertexArrayObject.createVertexArrayOES();
+            vertexArrayObject.bindVertexArrayOES(vao);
+            bind(gl, vaAttributes, indexBuffer);
+            vertexArrayObject.bindVertexArrayOES(null);
+        }
+
+        this._gl = gl;
+        this._vaoExtension = vertexArrayObject;
+        this._vao = vao;
+        this._attributes = vaAttributes;
+        this._indexBuffer = indexBuffer;
     };
 
     /**
@@ -167,64 +190,6 @@ define([
         return this._attributes.length;
     };
 
-    /**
-     * DOC_TBA
-     *
-     * @memberof VertexArray
-     *
-     * @exception {DeveloperError} Attribute must have a vertexBuffer.
-     * @exception {DeveloperError} Attribute must have a componentsPerAttribute.
-     * @exception {DeveloperError} Attribute must have a valid componentDatatype or not specify it.
-     * @exception {DeveloperError} Attribute must have a strideInBytes less than or equal to 255 or not specify it.
-     * @exception {DeveloperError} Index is already in use.
-     * @exception {DeveloperError} This vertex array was destroyed, i.e., destroy() was called.
-     */
-    VertexArray.prototype.addAttribute = function(attribute) {
-        if (attribute) {
-            var attributes = this._attributes;
-            var index = defaultValue(attribute.index, attributes.length);
-            for ( var i = 0; i < attributes.length; ++i) {
-                if (index === attributes[i].index) {
-                    throw new DeveloperError('Index ' + index + ' is already in use.');
-                }
-            }
-
-            try {
-                this._addAttribute(attribute, index);
-            } catch (e) {
-                throw new DeveloperError(e.message);
-            }
-        }
-    };
-
-    /**
-     * DOC_TBA
-     *
-     * @memberof VertexArray
-     *
-     * @return {Boolean} True if the attribute was removed; false if the attribute was not found in the vertex array.
-     *
-     * @exception {DeveloperError} Attribute must have an index.
-     * @exception {DeveloperError} This vertex array was destroyed, i.e., destroy() was called.
-     */
-    VertexArray.prototype.removeAttribute = function(attribute) {
-        if (attribute) {
-            if (typeof attribute.index === 'undefined') {
-                throw new DeveloperError('Attribute must have an index.');
-            }
-
-            var attributes = this._attributes;
-            for ( var i = 0; i < attributes.length; ++i) {
-                if (attributes[i].index === attribute.index) {
-                    attributes.splice(i, 1);
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    };
-
     /**
      * DOC_TBA
      *
@@ -237,46 +202,30 @@ define([
         return this._indexBuffer;
     };
 
-    /**
-     * DOC_TBA
-     *
-     * @memberof VertexArray
-     *
-     * @exception {DeveloperError} This vertex array was destroyed, i.e., destroy() was called.
-     */
-    VertexArray.prototype.setIndexBuffer = function(indexBuffer) {
-        this._indexBuffer = indexBuffer;
-    };
-
     VertexArray.prototype._bind = function() {
-        var attributes = this._attributes;
-        var gl = this._gl;
-
-        // TODO:  Performance: sort by vertex buffer?
-        for ( var i = 0; i < attributes.length; ++i) {
-            var attribute = attributes[i];
-            if (attribute.enabled) {
-                attribute.vertexAttrib(gl);
-            }
-        }
-
-        if (this._indexBuffer) {
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer._getBuffer());
+        if (typeof this._vao !== 'undefined') {
+            this._vaoExtension.bindVertexArrayOES(this._vao);
+        } else {
+            bind(this._gl, this._attributes, this._indexBuffer);
         }
     };
 
     VertexArray.prototype._unBind = function() {
-        var attributes = this._attributes;
-        var gl = this._gl;
+        if (typeof this._vao !== 'undefined') {
+            this._vaoExtension.bindVertexArrayOES(null);
+        } else {
+            var attributes = this._attributes;
+            var gl = this._gl;
 
-        for ( var i = 0; i < attributes.length; ++i) {
-            var attribute = attributes[i];
-            if (attribute.enabled) {
-                attribute.disableVertexAttribArray(gl);
+            for ( var i = 0; i < attributes.length; ++i) {
+                var attribute = attributes[i];
+                if (attribute.enabled) {
+                    attribute.disableVertexAttribArray(gl);
+                }
+            }
+            if (this._indexBuffer) {
+                gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
             }
-        }
-        if (this._indexBuffer) {
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
         }
     };
 
@@ -340,8 +289,10 @@ define([
      * // buffers and its index buffer.
      * var vertexBuffer = context.createVertexBuffer(new Float32Array([0, 0, 0]),
      *     BufferUsage.STATIC_DRAW);
-     * var vertexArray = context.createVertexArray();
-     * vertexArray.addAttribute({ vertexBuffer : vertexBuffer, componentsPerAttribute : 3 });
+     * var vertexArray = context.createVertexArray({
+     *     vertexBuffer : vertexBuffer,
+     *     componentsPerAttribute : 3
+     * });
      * // ...
      * vertexArray = vertexArray.destroy();
      * // Calling vertexBuffer.destroy() would throw DeveloperError at this point.
@@ -360,6 +311,10 @@ define([
             indexBuffer.destroy();
         }
 
+        if (typeof this._vao !== 'undefined') {
+            this._vaoExtension.deleteVertexArrayOES(this._vao);
+        }
+
         return destroyObject(this);
     };