cesium 0.13.0

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

@@ -0,0 +1,50 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports MipmapHint
+     */
+    var MipmapHint = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        DONT_CARE : new Enumeration(0x1100, 'DONT_CARE'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FASTEST : new Enumeration(0x1101, 'FASTEST'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        NICEST : new Enumeration(0x1102, 'NICEST'),
+
+        /**
+         * DOC_TBA
+         *
+         * @param mipmapHint
+         *
+         * @returns {Boolean}
+         */
+        validate : function(mipmapHint) {
+            return ((mipmapHint === MipmapHint.DONT_CARE) ||
+                    (mipmapHint === MipmapHint.FASTEST) ||
+                    (mipmapHint === MipmapHint.NICEST));
+        }
+    };
+
+    return MipmapHint;
+});

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

@@ -0,0 +1,178 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/destroyObject',
+        '../Core/Color',
+        '../Core/DeveloperError',
+        './ClearCommand',
+        './RenderbufferFormat'
+    ], function(
+        defaultValue,
+        destroyObject,
+        Color,
+        DeveloperError,
+        ClearCommand,
+        RenderbufferFormat) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @alias PickFramebuffer
+     * @internalConstructor
+     *
+     * @see Context#createPickFramebuffer
+     * @see Context#pick
+     */
+    var PickFramebuffer = function(context) {
+        this._context = context;
+        this._fb = null;
+        this._width = 0;
+        this._height = 0;
+
+        // Clear to black.  Since this is the background color, no objects will be black
+        this._clearCommand = new ClearCommand();
+        this._clearCommand.clearState = context.createClearState({
+            color : new Color(0.0, 0.0, 0.0, 1.0),
+            depth : 1.0,
+            stencil : 0
+        });
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof PickFramebuffer
+     */
+    PickFramebuffer.prototype.begin = function() {
+        var context = this._context;
+
+        // Initially create or recreate renderbuffers and framebuffer used for picking
+        if (!this._fb ||
+            (this._width !== context.getCanvas().clientWidth) ||
+            (this._height !== context.getCanvas().clientHeight)) {
+            this._width = context.getCanvas().clientWidth;
+            this._height = context.getCanvas().clientHeight;
+
+            this._fb = this._fb && this._fb.destroy();
+            this._fb = context.createFramebuffer({
+                colorRenderbuffer : context.createRenderbuffer(),
+                depthStencilRenderbuffer : context.createRenderbuffer({
+                    format : RenderbufferFormat.DEPTH_STENCIL
+                })
+            });
+        }
+
+        this._clearCommand.execute(context, this._fb);
+
+        return this._fb;
+    };
+
+    var colorScratch = new Color();
+
+    /**
+     * DOC_TBA
+     * @memberof PickFramebuffer
+     */
+    PickFramebuffer.prototype.end = function(screenSpaceRectangle) {
+        if (typeof screenSpaceRectangle === 'undefined') {
+            throw new DeveloperError('screenSpaceRectangle is required.');
+        }
+
+        var width = defaultValue(screenSpaceRectangle.width, 1.0);
+        var height = defaultValue(screenSpaceRectangle.height, 1.0);
+
+        var pixels = this._context.readPixels({
+            x : screenSpaceRectangle.x,
+            y : screenSpaceRectangle.y,
+            width : width,
+            height : height,
+            framebuffer : this._fb
+        });
+
+        var max = Math.max(width, height);
+        var length = max * max;
+        var halfWidth = Math.floor(width * 0.5);
+        var halfHeight = Math.floor(height * 0.5);
+
+        var x = 0;
+        var y = 0;
+        var dx = 0;
+        var dy = -1;
+
+        // Spiral around the center pixel, this is a workaround until
+        // we can access the depth buffer on all browsers.
+
+        // The region does not have to square and the dimensions do not have to be odd, but
+        // loop iterations would be wasted. Prefer square regions where the size is odd.
+        for (var i = 0; i < length; ++i) {
+            if (-halfWidth <= x && x <= halfWidth && -halfHeight <= y && y <= halfHeight) {
+                var index = 4 * ((halfHeight - y) * width + x + halfWidth);
+
+                colorScratch.red = pixels[index];
+                colorScratch.green = pixels[index + 1];
+                colorScratch.blue = pixels[index + 2];
+                colorScratch.alpha = pixels[index + 3];
+
+                var object = this._context.getObjectByPickId(colorScratch);
+                if (typeof object !== 'undefined') {
+                    return object;
+                }
+            }
+
+            // if (top right || bottom left corners) || (top left corner) || (bottom right corner + (1, 0)
+            // change spiral direction
+            if (x === y || (x < 0 && -x === y) || (x > 0 && x === 1 - y)) {
+                var temp = dx;
+                dx = -dy;
+                dy = temp;
+            }
+
+            x += dx;
+            y += dy;
+        }
+
+        return undefined;
+    };
+
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     *
+     * @memberof PickFramebuffer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see PickFramebuffer#destroy
+     */
+    PickFramebuffer.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     *
+     * @memberof PickFramebuffer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see PickFramebuffer#isDestroyed
+     *
+     * @example
+     * PickFramebuffer = PickFramebuffer && PickFramebuffer.destroy();
+     */
+    PickFramebuffer.prototype.destroy = function() {
+        this._fb = this._fb && this._fb.destroy();
+        return destroyObject(this);
+    };
+
+    return PickFramebuffer;
+});

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

@@ -0,0 +1,86 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports PixelDatatype
+     */
+    var PixelDatatype = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_BYTE : new Enumeration(0x1401, 'UNSIGNED_BYTE'),
+
+        /**
+         * An unsigned short pixel datatype used for depth textures with 16-bit depth values.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_SHORT : new Enumeration(0x1403, 'UNSIGNED_SHORT'),
+
+        /**
+         * An unsigned int pixel datatype used for depth textures with 32-bit depth values.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_INT : new Enumeration(0x1405, 'UNSIGNED_INT'),
+
+        /**
+         * An unsigned int pixel datatype used for depth-stencil textures with 24-bit depth and 8-bit stencil values.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_INT_24_8_WEBGL : new Enumeration(0x84FA, 'UNSIGNED_INT_24_8_WEBGL'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_SHORT_4_4_4_4 : new Enumeration(0x8033, 'UNSIGNED_SHORT_4_4_4_4'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_SHORT_5_5_5_1 : new Enumeration(0x8034, 'UNSIGNED_SHORT_5_5_5_1'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_SHORT_5_6_5 : new Enumeration(0x8363, 'UNSIGNED_SHORT_5_6_5'),
+
+        /**
+         * DOC_TBA
+         *
+         * @param pixelDatatype
+         *
+         * @returns {Boolean}
+         */
+        validate : function(pixelDatatype) {
+            return ((pixelDatatype === PixelDatatype.UNSIGNED_BYTE) ||
+                    (pixelDatatype === PixelDatatype.UNSIGNED_SHORT) ||
+                    (pixelDatatype === PixelDatatype.UNSIGNED_INT) ||
+                    (pixelDatatype === PixelDatatype.UNSIGNED_INT_24_8_WEBGL) ||
+                    (pixelDatatype === PixelDatatype.UNSIGNED_SHORT_4_4_4_4) ||
+                    (pixelDatatype === PixelDatatype.UNSIGNED_SHORT_5_5_5_1) ||
+                    (pixelDatatype === PixelDatatype.UNSIGNED_SHORT_5_6_5));
+        }
+    };
+
+    return PixelDatatype;
+});

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

@@ -0,0 +1,113 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports PixelFormat
+     */
+    var PixelFormat = {
+        /**
+         * A pixel format containing a depth value.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        DEPTH_COMPONENT : new Enumeration(0x1902, 'DEPTH_COMPONENT'),
+
+        /**
+         * A pixel format containing a depth and stencil value, most often used with {@link PixelDatatype.UNSIGNED_INT_24_8_WEBGL}.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        DEPTH_STENCIL : new Enumeration(0x84F9, 'DEPTH_STENCIL'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ALPHA : new Enumeration(0x1906, 'ALPHA'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        RGB : new Enumeration(0x1907, 'RGB'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        RGBA : new Enumeration(0x1908, 'RGBA'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LUMINANCE : new Enumeration(0x1909, 'LUMINANCE'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LUMINANCE_ALPHA : new Enumeration(0x190A, 'LUMINANCE_ALPHA'),
+
+        /**
+         * Returns true if the pixel format is a valid enumeration value.
+         *
+         * @param {PixelFormat} pixelFormat The pixel format to test.
+         *
+         * @returns {Boolean} Returns true if the pixel format is a valid enumeration value; otherwise, false.
+         */
+        validate : function(pixelFormat) {
+            return ((pixelFormat === PixelFormat.DEPTH_COMPONENT) ||
+                    (pixelFormat === PixelFormat.DEPTH_STENCIL) ||
+                    (pixelFormat === PixelFormat.ALPHA) ||
+                    (pixelFormat === PixelFormat.RGB) ||
+                    (pixelFormat === PixelFormat.RGBA) ||
+                    (pixelFormat === PixelFormat.LUMINANCE) ||
+                    (pixelFormat === PixelFormat.LUMINANCE_ALPHA));
+        },
+
+        /**
+         * Returns true if the pixel format is a color format.
+         *
+         * @param {PixelFormat} pixelFormat The pixel format to test.
+         *
+         * @returns {Boolean} Returns true if the pixel format is a color format; otherwise false.
+         */
+        isColorFormat : function(pixelFormat) {
+            return ((pixelFormat === PixelFormat.ALPHA) ||
+                    (pixelFormat === PixelFormat.RGB) ||
+                    (pixelFormat === PixelFormat.RGBA) ||
+                    (pixelFormat === PixelFormat.LUMINANCE) ||
+                    (pixelFormat === PixelFormat.LUMINANCE_ALPHA));
+        },
+
+        /**
+         * Returns true if the pixel format is a depth format.
+         *
+         * @param {PixelFormat} pixelFormat The pixel format to test.
+         *
+         * @returns {Boolean} Returns true if the pixel format is a depth format; otherwise false.
+         */
+        isDepthFormat : function(pixelFormat) {
+            return ((pixelFormat === PixelFormat.DEPTH_COMPONENT) ||
+                    (pixelFormat === PixelFormat.DEPTH_STENCIL));
+        }
+    };
+
+    return PixelFormat;
+});

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

@@ -0,0 +1,102 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject'
+    ], function(
+        DeveloperError,
+        destroyObject) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @alias Renderbuffer
+     * @internalConstructor
+     *
+     * @see Context#createRenderbuffer
+     */
+    function Renderbuffer(_gl, _format, _width, _height) {
+        var _renderbuffer = _gl.createRenderbuffer();
+
+        _gl.bindRenderbuffer(_gl.RENDERBUFFER, _renderbuffer);
+        _gl.renderbufferStorage(_gl.RENDERBUFFER, _format, _width, _height);
+        _gl.bindRenderbuffer(_gl.RENDERBUFFER, null);
+
+        /**
+        * DOC_TBA
+        * @memberof Renderbuffer
+        * @return {Boolean} DOC_TBA
+        * @exception {DeveloperError} This renderbuffer was destroyed, i.e., destroy() was called.
+        */
+        this.getFormat = function() {
+            return _format;
+        };
+
+        /**
+        * DOC_TBA
+        * @memberof Renderbuffer
+        * @return {Boolean} DOC_TBA
+        * @exception {DeveloperError} This renderbuffer was destroyed, i.e., destroy() was called.
+        */
+        this.getWidth = function() {
+            return _width;
+        };
+
+        /**
+        * DOC_TBA
+        * @memberof Renderbuffer
+        * @return {Boolean} DOC_TBA
+        * @exception {DeveloperError} This renderbuffer was destroyed, i.e., destroy() was called.
+        */
+        this.getHeight = function() {
+            return _height;
+        };
+
+        this._getRenderbuffer = function() {
+            return _renderbuffer;
+        };
+
+        /**
+         * Returns true if this object was destroyed; otherwise, false.
+         * <br /><br />
+         * If this object was destroyed, it should not be used; calling any function other than
+         * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+         *
+         * @memberof Renderbuffer
+         *
+         * @return {Boolean} True if this object was destroyed; otherwise, false.
+         *
+         * @see Renderbuffer.destroy
+         */
+        this.isDestroyed = function() {
+            return false;
+        };
+
+        /**
+         * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+         * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+         * <br /><br />
+         * Once an object is destroyed, it should not be used; calling any function other than
+         * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+         * assign the return value (<code>undefined</code>) to the object as done in the example.
+         *
+         * @memberof Renderbuffer
+         *
+         * @return {undefined}
+         *
+         * @exception {DeveloperError} This shader renderbuffer destroyed, i.e., destroy() was called.
+         *
+         * @see Renderbuffer.isDestroyed
+         * @see <a href='http://www.khronos.org/opengles/sdk/2.0/docs/man/glDeleteRenderbuffers.xml'>glDeleteRenderbuffers</a>
+         *
+         * @example
+         * renderbuffer = renderbuffer && renderbuffer.destroy();
+         */
+        this.destroy = function() {
+            _gl.deleteRenderbuffer(_renderbuffer);
+            return destroyObject(this);
+        };
+    }
+
+    return Renderbuffer;
+});