cesium 0.23.0 → 0.24.0

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

@@ -1,5 +1,6 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destroyObject', 'Core/Color', 'Core/ComponentDatatype', 'Core/IndexDatatype', 'Core/RuntimeError', 'Core/PrimitiveType', 'Core/Geometry', 'Core/createGuid', 'Core/Matrix4', 'Core/Math', 'Renderer/Buffer', 'Renderer/BufferUsage', 'Renderer/CubeMap', 'Renderer/Framebuffer', 'Renderer/PixelDatatype', 'Renderer/PixelFormat', 'Renderer/PickFramebuffer', 'Renderer/Renderbuffer', 'Renderer/RenderbufferFormat', 'Renderer/RenderState', 'Renderer/ShaderCache', 'Renderer/ShaderProgram', 'Renderer/Texture', 'Renderer/TextureAtlas', 'Renderer/TextureMagnificationFilter', 'Renderer/TextureMinificationFilter', 'Renderer/TextureWrap', 'Renderer/UniformState', 'Renderer/VertexArray', 'Renderer/VertexLayout', 'Renderer/ClearCommand', 'Renderer/PassState'], function(
+define(['Core/clone', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destroyObject', 'Core/Color', 'Core/ComponentDatatype', 'Core/IndexDatatype', 'Core/RuntimeError', 'Core/PrimitiveType', 'Core/Geometry', 'Core/createGuid', 'Core/Matrix4', 'Core/Math', 'Renderer/Buffer', 'Renderer/BufferUsage', 'Renderer/CubeMap', 'Renderer/Framebuffer', 'Renderer/PixelDatatype', 'Renderer/PixelFormat', 'Renderer/PickFramebuffer', 'Renderer/Renderbuffer', 'Renderer/RenderbufferFormat', 'Renderer/RenderState', 'Renderer/ShaderCache', 'Renderer/ShaderProgram', 'Renderer/Texture', 'Renderer/TextureAtlas', 'Renderer/TextureMagnificationFilter', 'Renderer/TextureMinificationFilter', 'Renderer/TextureWrap', 'Renderer/UniformState', 'Renderer/VertexArray', 'Renderer/VertexLayout', 'Renderer/ClearCommand', 'Renderer/PassState'], function(
+        clone,
         defaultValue,
         defined,
         DeveloperError,
@@ -131,6 +132,18 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         return glWrapper;
     }
 
+    function getExtension(gl, names) {
+        var length = names.length;
+        for (var i = 0; i < length; ++i) {
+            var extension = gl.getExtension(names[i]);
+            if (extension) {
+                return extension;
+            }
+        }
+
+        return undefined;
+    }
+
     /**
      * DOC_TBA
      *
@@ -146,22 +159,26 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
             throw new RuntimeError('The browser does not support WebGL.  Visit http://get.webgl.org.');
         }
 
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(canvas)) {
             throw new DeveloperError('canvas is required.');
         }
+        //>>includeEnd('debug');
 
         this._canvas = canvas;
 
-        if (!defined(options)) {
-            options = {};
-        }
-        if (!defined(options.alpha)) {
-            options.alpha = false;
-        }
+        options = clone(options, true);
+        options = defaultValue(options, {});
+        options.allowTextureFilterAnisotropic = defaultValue(options.allowTextureFilterAnisotropic, true);
+        var webglOptions = defaultValue(options.webgl, {});
+
+        // Override select WebGL defaults
+        webglOptions.alpha = defaultValue(webglOptions.alpha, false); // WebGL default is true
+        webglOptions.failIfMajorPerformanceCaveat = defaultValue(webglOptions.failIfMajorPerformanceCaveat, true); // WebGL default is false
 
-        this._originalGLContext = canvas.getContext('webgl', options) || canvas.getContext('experimental-webgl', options);
+        this._originalGLContext = canvas.getContext('webgl', webglOptions) || canvas.getContext('experimental-webgl', webglOptions) || undefined;
 
-        if (!this._originalGLContext) {
+        if (!defined(this._originalGLContext)) {
             throw new RuntimeError('The browser supports WebGL, but initialization failed.');
         }
 
@@ -204,15 +221,17 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         this._antialias = gl.getContextAttributes().antialias;
 
         // Query and initialize extensions
-        this._standardDerivatives = gl.getExtension('OES_standard_derivatives');
-        this._elementIndexUint = gl.getExtension('OES_element_index_uint');
-        this._depthTexture = gl.getExtension('WEBKIT_WEBGL_depth_texture') || gl.getExtension('MOZ_WEBGL_depth_texture');
-        this._textureFloat = gl.getExtension('OES_texture_float');
-        var textureFilterAnisotropic = gl.getExtension('EXT_texture_filter_anisotropic') || gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic') || gl.getExtension('MOZ_EXT_texture_filter_anisotropic');
+        this._standardDerivatives = getExtension(gl, ['OES_standard_derivatives']);
+        this._elementIndexUint = getExtension(gl, ['OES_element_index_uint']);
+        this._depthTexture = getExtension(gl, ['WEBGL_depth_texture', 'WEBKIT_WEBGL_depth_texture']);
+        this._textureFloat = getExtension(gl, ['OES_texture_float']);
+
+        var textureFilterAnisotropic = options.allowTextureFilterAnisotropic ? getExtension(gl, ['EXT_texture_filter_anisotropic', 'WEBKIT_EXT_texture_filter_anisotropic']) : undefined;
         this._textureFilterAnisotropic = textureFilterAnisotropic;
-        this._maximumTextureFilterAnisotropy = textureFilterAnisotropic ? gl.getParameter(textureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1.0;
-        this._vertexArrayObject = gl.getExtension('OES_vertex_array_object');
-        this._fragDepth = gl.getExtension('EXT_frag_depth');
+        this._maximumTextureFilterAnisotropy = defined(textureFilterAnisotropic) ? gl.getParameter(textureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1.0;
+
+        this._vertexArrayObject = getExtension(gl, ['OES_vertex_array_object']);
+        this._fragDepth = getExtension(gl, ['EXT_frag_depth']);
 
         var cc = gl.getParameter(gl.COLOR_CLEAR_VALUE);
         this._clearColor = new Color(cc[0], cc[1], cc[2], cc[3]);
@@ -235,6 +254,48 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         this._pickObjects = {};
         this._nextPickColor = new Uint32Array(1);
 
+        /**
+         * Returns the read-only options used to create this context.  The <code>webgl</code> property corresponds to the
+         * <a href='http://www.khronos.org/registry/webgl/specs/latest/#5.2'>WebGLContextAttributes</a> object used to
+         * create the WebGL context.  Default values are shown in the code example below.
+         * <p>
+         * <code>options.webgl.alpha</code> defaults to false, which can improve performance compared to the standard WebGL default
+         * of true.  If an application needs to composite Cesium above other HTML elements using alpha-blending, set
+         * <code>options.webgl.alpha</code> to true.
+         * </p>
+         * <p>
+         * <code>options.webgl.failIfMajorPerformanceCaveat</code> defaults to true, which ensures a context is not successfully created
+         * if the system has a major performance issue such as only supporting software rendering.  The standard WebGL default is false,
+         * which is not appropriate for almost any Cesium app.
+         * </p>
+         * <p>
+         * The other <code>options.webgl</code> properties match the WebGL defaults for <a href='http://www.khronos.org/registry/webgl/specs/latest/#5.2'>WebGLContextAttributes</a>.
+         * </p>
+         * <p>
+         * <code>options.allowTextureFilterAnisotropic</code> defaults to true, which enables anisotropic texture filtering when the
+         * WebGL extension is supported.  Check {@link Context#getTextureFilterAnisotropic}.  Setting this to false will improve
+         * performance, but hurt visual quality, especially for horizon views.
+         * </p>
+         *
+         * @type {Object}
+         * @constant
+         *
+         * @example
+         * {
+         *   webgl : {
+         *     alpha : false,
+         *     depth : true,
+         *     stencil : false,
+         *     antialias : true,
+         *     premultipliedAlpha : true,
+         *     preserveDrawingBuffer : false
+         *     failIfMajorPerformanceCaveat : true
+         *   },
+         *   allowTextureFilterAnisotropic : true
+         * }
+         */
+        this.options = options;
+
         /**
          * A cache of objects tied to this context.  Just before the Context is destroyed,
          * <code>destroy</code> will be invoked on each object in this object literal that has
@@ -1034,9 +1095,12 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         } else if (typeof typedArrayOrSizeInBytes === 'object' && typeof typedArrayOrSizeInBytes.byteLength === 'number') {
             sizeInBytes = typedArrayOrSizeInBytes.byteLength;
         } else {
+            //>>includeStart('debug', pragmas.debug);
             throw new DeveloperError('typedArrayOrSizeInBytes must be either a typed array or a number.');
+            //>>includeEnd('debug');
         }
 
+        //>>includeStart('debug', pragmas.debug);
         if (sizeInBytes <= 0) {
             throw new DeveloperError('typedArrayOrSizeInBytes must be greater than zero.');
         }
@@ -1044,6 +1108,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (!BufferUsage.validate(usage)) {
             throw new DeveloperError('usage is invalid.');
         }
+        //>>includeEnd('debug');
 
         var buffer = gl.createBuffer();
         gl.bindBuffer(bufferTarget, buffer);
@@ -1132,9 +1197,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      *     BufferUsage.STATIC_DRAW, IndexDatatype.UNSIGNED_SHORT)
      */
     Context.prototype.createIndexBuffer = function(typedArrayOrSizeInBytes, usage, indexDatatype) {
+        //>>includeStart('debug', pragmas.debug);
         if (!IndexDatatype.validate(indexDatatype)) {
             throw new DeveloperError('Invalid indexDatatype.');
         }
+        //>>includeEnd('debug');
 
         if ((indexDatatype === IndexDatatype.UNSIGNED_INT) && !this.getElementIndexUint()) {
             throw new RuntimeError('IndexDatatype.UNSIGNED_INT requires OES_element_index_uint, which is not supported on this system.');
@@ -1262,7 +1329,6 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      *
      * @exception {RuntimeError} When options.pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, this WebGL implementation must support WEBGL_depth_texture.
      * @exception {RuntimeError} When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension.
-     * @exception {DeveloperError} options is required.
      * @exception {DeveloperError} options requires a source field to create an initialized texture or width and height fields to create a blank texture.
      * @exception {DeveloperError} Width must be greater than zero.
      * @exception {DeveloperError} Width must be less than or equal to the maximum texture size.
@@ -1279,14 +1345,15 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      * @see Context#createSampler
      */
     Context.prototype.createTexture2D = function(options) {
-        if (!defined(options)) {
-            throw new DeveloperError('options is required.');
-        }
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
         var source = options.source;
         var width = defined(source) ? source.width : options.width;
         var height = defined(source) ? source.height : options.height;
+        var pixelFormat = defaultValue(options.pixelFormat, PixelFormat.RGBA);
+        var pixelDatatype = defaultValue(options.pixelDatatype, PixelDatatype.UNSIGNED_BYTE);
 
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(width) || !defined(height)) {
             throw new DeveloperError('options requires a source field to create an initialized texture or width and height fields to create a blank texture.');
         }
@@ -1307,20 +1374,14 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
             throw new DeveloperError('Height must be less than or equal to the maximum texture size (' + this._maximumTextureSize + ').  Check getMaximumTextureSize().');
         }
 
-        var pixelFormat = defaultValue(options.pixelFormat, PixelFormat.RGBA);
         if (!PixelFormat.validate(pixelFormat)) {
             throw new DeveloperError('Invalid options.pixelFormat.');
         }
 
-        var pixelDatatype = defaultValue(options.pixelDatatype, PixelDatatype.UNSIGNED_BYTE);
         if (!PixelDatatype.validate(pixelDatatype)) {
             throw new DeveloperError('Invalid options.pixelDatatype.');
         }
 
-        if ((pixelDatatype === PixelDatatype.FLOAT) && !this.getFloatingPointTexture()) {
-            throw new RuntimeError('When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension.');
-        }
-
         if ((pixelFormat === PixelFormat.DEPTH_COMPONENT) &&
             ((pixelDatatype !== PixelDatatype.UNSIGNED_SHORT) && (pixelDatatype !== PixelDatatype.UNSIGNED_INT))) {
             throw new DeveloperError('When options.pixelFormat is DEPTH_COMPONENT, options.pixelDatatype must be UNSIGNED_SHORT or UNSIGNED_INT.');
@@ -1329,11 +1390,18 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if ((pixelFormat === PixelFormat.DEPTH_STENCIL) && (pixelDatatype !== PixelDatatype.UNSIGNED_INT_24_8_WEBGL)) {
             throw new DeveloperError('When options.pixelFormat is DEPTH_STENCIL, options.pixelDatatype must be UNSIGNED_INT_24_8_WEBGL.');
         }
+        //>>includeEnd('debug');
+
+        if ((pixelDatatype === PixelDatatype.FLOAT) && !this.getFloatingPointTexture()) {
+            throw new RuntimeError('When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension.');
+        }
 
         if (PixelFormat.isDepthFormat(pixelFormat)) {
+            //>>includeStart('debug', pragmas.debug);
             if (defined(source)) {
                 throw new DeveloperError('When options.pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, source cannot be provided.');
             }
+            //>>includeEnd('debug');
 
             if (!this.getDepthTexture()) {
                 throw new RuntimeError('When options.pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, this WebGL implementation must support WEBGL_depth_texture.  Check getDepthTexture().');
@@ -1410,6 +1478,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         width = defaultValue(width, gl.drawingBufferWidth);
         height = defaultValue(height, gl.drawingBufferHeight);
 
+        //>>includeStart('debug', pragmas.debug);
         if (!PixelFormat.validate(pixelFormat)) {
             throw new DeveloperError('Invalid pixelFormat.');
         }
@@ -1433,6 +1502,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (framebufferYOffset + height > gl.drawingBufferHeight) {
             throw new DeveloperError('framebufferYOffset + height must be less than or equal to drawingBufferHeight.');
         }
+        //>>includeEnd('debug');
 
         var textureTarget = gl.TEXTURE_2D;
         var texture = gl.createTexture();
@@ -1476,7 +1546,6 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      * @returns {CubeMap} DOC_TBA.
      *
      * @exception {RuntimeError} When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension.
-     * @exception {DeveloperError} options is required.
      * @exception {DeveloperError} options.source requires positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ faces.
      * @exception {DeveloperError} Each face in options.sources must have the same width and height.
      * @exception {DeveloperError} options requires a source field to create an initialized cube map or width and height fields to create a blank cube map.
@@ -1492,9 +1561,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      * @see Context#createSampler
      */
     Context.prototype.createCubeMap = function(options) {
-        if (!defined(options)) {
-            throw new DeveloperError('options is required.');
-        }
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
         var source = options.source;
         var width;
@@ -1503,23 +1570,32 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (defined(source)) {
             var faces = [source.positiveX, source.negativeX, source.positiveY, source.negativeY, source.positiveZ, source.negativeZ];
 
+            //>>includeStart('debug', pragmas.debug);
             if (!faces[0] || !faces[1] || !faces[2] || !faces[3] || !faces[4] || !faces[5]) {
                 throw new DeveloperError('options.source requires positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ faces.');
             }
+            //>>includeEnd('debug');
 
             width = faces[0].width;
             height = faces[0].height;
 
+            //>>includeStart('debug', pragmas.debug);
             for ( var i = 1; i < 6; ++i) {
                 if ((Number(faces[i].width) !== width) || (Number(faces[i].height) !== height)) {
                     throw new DeveloperError('Each face in options.source must have the same width and height.');
                 }
             }
+            //>>includeEnd('debug');
         } else {
             width = options.width;
             height = options.height;
         }
 
+        var size = width;
+        var pixelFormat = defaultValue(options.pixelFormat, PixelFormat.RGBA);
+        var pixelDatatype = defaultValue(options.pixelDatatype, PixelDatatype.UNSIGNED_BYTE);
+
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(width) || !defined(height)) {
             throw new DeveloperError('options requires a source field to create an initialized cube map or width and height fields to create a blank cube map.');
         }
@@ -1528,8 +1604,6 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
             throw new DeveloperError('Width must equal height.');
         }
 
-        var size = width;
-
         if (size <= 0) {
             throw new DeveloperError('Width and height must be greater than zero.');
         }
@@ -1538,7 +1612,6 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
             throw new DeveloperError('Width and height must be less than or equal to the maximum cube map size (' + this._maximumCubeMapSize + ').  Check getMaximumCubeMapSize().');
         }
 
-        var pixelFormat = defaultValue(options.pixelFormat, PixelFormat.RGBA);
         if (!PixelFormat.validate(pixelFormat)) {
             throw new DeveloperError('Invalid options.pixelFormat.');
         }
@@ -1547,10 +1620,10 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
             throw new DeveloperError('options.pixelFormat cannot be DEPTH_COMPONENT or DEPTH_STENCIL.');
         }
 
-        var pixelDatatype = defaultValue(options.pixelDatatype, PixelDatatype.UNSIGNED_BYTE);
         if (!PixelDatatype.validate(pixelDatatype)) {
             throw new DeveloperError('Invalid options.pixelDatatype.');
         }
+        //>>includeEnd('debug');
 
         if ((pixelDatatype === PixelDatatype.FLOAT) && !this.getFloatingPointTexture()) {
             throw new RuntimeError('When options.pixelDatatype is FLOAT, this WebGL implementation must support the OES_texture_float extension.');
@@ -1682,6 +1755,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         var width = defined(options.width) ? options.width : gl.drawingBufferWidth;
         var height = defined(options.height) ? options.height : gl.drawingBufferHeight;
 
+        //>>includeStart('debug', pragmas.debug);
         if (!RenderbufferFormat.validate(format)) {
             throw new DeveloperError('Invalid format.');
         }
@@ -1701,6 +1775,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (height > this.getMaximumRenderbufferSize()) {
             throw new DeveloperError('Height must be less than or equal to the maximum renderbuffer size (' + this.getMaximumRenderbufferSize() + ').  Check getMaximumRenderbufferSize().');
         }
+        //>>includeEnd('debug');
 
         return new Renderbuffer(gl, format, width, height);
     };
@@ -1877,6 +1952,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
             maximumAnisotropy : (defined(sampler.maximumAnisotropy)) ? sampler.maximumAnisotropy : 1.0
         };
 
+        //>>includeStart('debug', pragmas.debug);
         if (!TextureWrap.validate(s.wrapS)) {
             throw new DeveloperError('Invalid sampler.wrapS.');
         }
@@ -1896,6 +1972,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (s.maximumAnisotropy < 1.0) {
             throw new DeveloperError('sampler.maximumAnisotropy must be greater than or equal to one.');
         }
+        //>>includeEnd('debug');
 
         return s;
     };
@@ -2007,13 +2084,13 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
     function beginDraw(context, framebuffer, drawCommand, passState) {
         var rs = defined(drawCommand.renderState) ? drawCommand.renderState : context._defaultRenderState;
 
+        //>>includeStart('debug', pragmas.debug);
         if (defined(framebuffer) && rs.depthTest) {
             if (rs.depthTest.enabled && !framebuffer.hasDepthAttachment()) {
                 throw new DeveloperError('The depth test can not be enabled (drawCommand.renderState.depthTest.enabled) because the framebuffer (drawCommand.framebuffer) does not have a depth or depth-stencil renderbuffer.');
             }
         }
-
-        ///////////////////////////////////////////////////////////////////////
+        //>>includeEnd('debug');
 
         if (defined(framebuffer)) {
             framebuffer._bind();
@@ -2033,6 +2110,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         var offset = drawCommand.offset;
         var count = drawCommand.count;
 
+        //>>includeStart('debug', pragmas.debug);
         if (!PrimitiveType.validate(primitiveType)) {
             throw new DeveloperError('drawCommand.primitiveType is required and must be valid.');
         }
@@ -2048,6 +2126,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (count < 0) {
             throw new DeveloperError('drawCommand.count must be omitted or greater than or equal to zero.');
         }
+        //>>includeEnd('debug');
 
         context._us.setModel(defaultValue(drawCommand.modelMatrix, Matrix4.IDENTITY));
         drawCommand.shaderProgram._setUniforms(drawCommand.uniformMap, context._us, context._validateSP);
@@ -2122,6 +2201,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      * @see Context#createRenderState
      */
     Context.prototype.draw = function(drawCommand, passState) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(drawCommand)) {
             throw new DeveloperError('drawCommand is required.');
         }
@@ -2129,6 +2209,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (!defined(drawCommand.shaderProgram)) {
             throw new DeveloperError('drawCommand.shaderProgram is required.');
         }
+        //>>includeEnd('debug');
 
         passState = defaultValue(passState, this._defaultPassState);
         // The command's framebuffer takes presidence over the pass' framebuffer, e.g., for off-screen rendering.
@@ -2174,6 +2255,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         var height = readState.height || gl.drawingBufferHeight;
         var framebuffer = readState.framebuffer || null;
 
+        //>>includeStart('debug', pragmas.debug);
         if (width <= 0) {
             throw new DeveloperError('readState.width must be greater than zero.');
         }
@@ -2181,6 +2263,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
         if (height <= 0) {
             throw new DeveloperError('readState.height must be greater than zero.');
         }
+        //>>includeEnd('debug');
 
         var pixels = new Uint8Array(4 * width * height);
 
@@ -2502,9 +2585,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      * @see Context#createPickId
      */
     Context.prototype.getObjectByPickColor = function(pickColor) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(pickColor)) {
             throw new DeveloperError('pickColor is required.');
         }
+        //>>includeEnd('debug');
 
         return this._pickObjects[pickColor.toRgba()];
     };
@@ -2543,9 +2628,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/destro
      * });
      */
     Context.prototype.createPickId = function(object) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(object)) {
             throw new DeveloperError('object is required.');
         }
+        //>>includeEnd('debug');
 
         // the increment and assignment have to be separate statements to
         // actually detect overflow in the Uint32 value

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

@@ -208,7 +208,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/destroyObject', 'Core/Math'
         gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, sampler.magnificationFilter);
         gl.texParameteri(target, gl.TEXTURE_WRAP_S, sampler.wrapS);
         gl.texParameteri(target, gl.TEXTURE_WRAP_T, sampler.wrapT);
-        if (this._textureFilterAnisotropic) {
+        if (defined(this._textureFilterAnisotropic)) {
             gl.texParameteri(target, this._textureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, sampler.maximumAnisotropy);
         }
         gl.bindTexture(target, null);

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

@@ -22,7 +22,6 @@ define(function() {
          * </p>
          *
          * @type {Object}
-         *
          * @default undefined
          *
          * @see DrawCommand#debugShowBoundingVolume
@@ -34,7 +33,6 @@ define(function() {
          * If the command was already culled, set this to <code>false</code> for a performance improvement.
          *
          * @type {Boolean}
-         *
          * @default true
          */
         this.cull = true;
@@ -46,7 +44,6 @@ define(function() {
          * </p>
          *
          * @type {Matrix4}
-         *
          * @default undefined
          */
         this.modelMatrix = undefined;
@@ -55,7 +52,6 @@ define(function() {
          * The type of geometry in the vertex array.
          *
          * @type {PrimitiveType}
-         *
          * @default undefined
          */
         this.primitiveType = undefined;
@@ -64,7 +60,6 @@ define(function() {
          * The vertex array.
          *
          * @type {VertexArray}
-         *
          * @default undefined
          */
         this.vertexArray = undefined;
@@ -73,7 +68,6 @@ define(function() {
          * The number of vertices to draw in the vertex array.
          *
          * @type {Number}
-         *
          * @default undefined
          */
         this.count = undefined;
@@ -82,7 +76,6 @@ define(function() {
          * The offset to start drawing in the vertex array.
          *
          * @type {Number}
-         *
          * @default undefined
          */
         this.offset = 0;
@@ -91,7 +84,6 @@ define(function() {
          * The shader program to apply.
          *
          * @type {ShaderProgram}
-         *
          * @default undefined
          */
         this.shaderProgram = undefined;
@@ -101,7 +93,6 @@ define(function() {
          * and return values to set those uniforms.
          *
          * @type {Object}
-         *
          * @default undefined
          */
         this.uniformMap = undefined;
@@ -110,7 +101,6 @@ define(function() {
          * The render state.
          *
          * @type {RenderState}
-         *
          * @default undefined
          *
          * @see Context#createRenderState
@@ -121,17 +111,23 @@ define(function() {
          * The framebuffer to draw to.
          *
          * @type {Framebuffer}
-         *
          * @default undefined
          */
         this.framebuffer = undefined;
 
+        /**
+         * The pass when to render.
+         *
+         * @type {Pass}
+         * @default undefined
+         */
+        this.pass = undefined;
+
         /**
          * Specifies if this command is only to be executed in the frustum closest
          * to the eye containing the bounding volume. Defaults to <code>false</code>.
          *
          * @type {Boolean}
-         *
          * @default false
          */
         this.executeInClosestFrustum = false;
@@ -143,7 +139,6 @@ define(function() {
          * with {@link Scene#debugCommandFilter}.
          *
          * @type {Object}
-         *
          * @default undefined
          *
          * @see Scene#debugCommandFilter
@@ -157,7 +152,6 @@ define(function() {
          * </p>
          *
          * @type {Boolean}
-         *
          * @default false
          *
          * @see DrawCommand#boundingVolume
@@ -184,4 +178,4 @@ define(function() {
     };
 
     return DrawCommand;
-});
+});