cesium 0.13.0

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

@@ -0,0 +1,133 @@
+/*global define*/
+define([
+        '../Core/Event',
+        '../Core/DeveloperError',
+        '../Core/loadImage'
+       ], function(
+         Event,
+         DeveloperError,
+         loadImage) {
+    "use strict";
+
+    function SourceHolder() {
+        this.imageLoaded = new Event();
+        this.index = -1;
+        this.loaded = false;
+    }
+
+    /**
+     * A utility class which dynamically builds a TextureAtlas by associating
+     * a unique identifier with each texture as it is added.  If a texture with
+     * the same id is needed later, the existing index is returned, rather than
+     * adding multiple copies of the same texture.
+     *
+     * @alias TextureAtlasBuilder
+     * @constructor
+     *
+     * @see TextureAtlas
+     */
+    var TextureAtlasBuilder  = function(textureAtlas) {
+        if (typeof textureAtlas === 'undefined') {
+            throw new DeveloperError('textureAtlas is required.');
+        }
+        this.textureAtlas = textureAtlas;
+        this._idHash = {};
+    };
+
+    /**
+     * Retrieves the image from the specified url and adds it to the atlas.
+     * The supplied callback is triggered with the index of the texture.
+     * If the url is already in the atlas, the atlas is unchanged and the callback
+     * is triggered immediately with the existing index.
+     *
+     * @memberof TextureAtlasBuilder
+     *
+     * @param {String} url The url of the image to add to the atlas.
+     * @param {Function} textureAvailableCallback A function taking the image index as it's only parameter.
+     *
+     * @exception {DeveloperError} url is required.
+     * @exception {DeveloperError} textureAvailableCallback is required.
+     */
+    TextureAtlasBuilder.prototype.addTextureFromUrl = function(url, textureAvailableCallback) {
+        if (typeof url === 'undefined') {
+            throw new DeveloperError('url is required.');
+        }
+
+        if (typeof textureAvailableCallback === 'undefined') {
+            throw new DeveloperError('textureAvailableCallback is required.');
+        }
+
+        this.addTextureFromFunction(url, function(id, callback) {
+            loadImage(id).then(callback);
+        }, textureAvailableCallback);
+    };
+
+    /**
+     * <p>
+     * Checks the atlas for a texture with the supplied id, if the id does not
+     * exist, the supplied callback is triggered to create it.  In either case,
+     * once the image is in the atlas, the second supplied callback is triggered
+     * with its index.
+     * </p>
+     *
+     * <p>
+     * This function is useful for dynamically generated textures that are shared
+     * across many billboards.  Only the first billboard will actually create the texture
+     * while subsequent billboards will re-use the existing one.
+     * </p>
+     *
+     * @memberof TextureAtlasBuilder
+     *
+     * @param {String} id The id of the image to add to the atlas.
+     * @param {Function} getImageCallback A function which takes two parameters; first the id of the image to
+     * retrieve and second, a function to call when the image is ready.  The function takes the image as its
+     * only parameter.
+     * @param {Function} textureAvailableCallback A function taking the image index as it's only parameter.
+     *
+     * @exception {DeveloperError} id is required.
+     * @exception {DeveloperError} getImageCallback is required.
+     * @exception {DeveloperError} textureAvailableCallback is required.
+     */
+    TextureAtlasBuilder.prototype.addTextureFromFunction = function(id, getImageCallback, textureAvailableCallback) {
+        if (typeof id === 'undefined') {
+            throw new DeveloperError('id is required.');
+        }
+
+        if (typeof getImageCallback === 'undefined') {
+            throw new DeveloperError('getImageCallback is required.');
+        }
+
+        if (typeof textureAvailableCallback === 'undefined') {
+            throw new DeveloperError('textureAvailableCallback is required.');
+        }
+
+        var sourceHolder = this._idHash[id];
+        if (typeof sourceHolder !== 'undefined') {
+            //we're already aware of this source
+            if (sourceHolder.loaded) {
+                //and it's already loaded, tell the callback what index to use
+                textureAvailableCallback(sourceHolder.index);
+            } else {
+                //add the callback to be notified once it loads
+                sourceHolder.imageLoaded.addEventListener(textureAvailableCallback);
+            }
+            return;
+        }
+
+        //not in atlas, create the source, which may be async
+        this._idHash[id] = sourceHolder = new SourceHolder();
+        sourceHolder.imageLoaded.addEventListener(textureAvailableCallback);
+
+        var that = this;
+        getImageCallback(id, function(newImage) {
+            if (!that.textureAtlas.isDestroyed()) {
+                var index = sourceHolder.index = that.textureAtlas.addImage(newImage);
+                sourceHolder.loaded = true;
+                sourceHolder.imageLoaded.raiseEvent(index, id);
+                sourceHolder.imageLoaded = undefined;
+            }
+        });
+    };
+
+    return TextureAtlasBuilder;
+});

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

@@ -0,0 +1,41 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports TextureMagnificationFilter
+     */
+    var TextureMagnificationFilter = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        NEAREST : new Enumeration(0x2600, 'NEAREST'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LINEAR : new Enumeration(0x2601, 'LINEAR'),
+
+        /**
+         * DOC_TBA
+         *
+         * @param textureMagnificationFilter
+         *
+         * @returns {Boolean}
+         */
+        validate : function(textureMagnificationFilter) {
+            return ((textureMagnificationFilter === TextureMagnificationFilter.NEAREST) ||
+                    (textureMagnificationFilter === TextureMagnificationFilter.LINEAR));
+        }
+    };
+
+    return TextureMagnificationFilter;
+});

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

@@ -0,0 +1,77 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports TextureMinificationFilter
+     */
+    var TextureMinificationFilter = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        NEAREST : new Enumeration(0x2600, 'NEAREST'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LINEAR : new Enumeration(0x2601, 'LINEAR'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        NEAREST_MIPMAP_NEAREST : new Enumeration(0x2700, 'NEAREST_MIPMAP_NEAREST'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LINEAR_MIPMAP_NEAREST : new Enumeration(0x2701, 'LINEAR_MIPMAP_NEAREST'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        NEAREST_MIPMAP_LINEAR : new Enumeration(0x2702, 'NEAREST_MIPMAP_LINEAR'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LINEAR_MIPMAP_LINEAR : new Enumeration(0x2703, 'LINEAR_MIPMAP_LINEAR'),
+
+        /**
+         * DOC_TBA
+         *
+         * @param textureMinificationFilter
+         *
+         * @returns {Boolean}
+         */
+        validate : function(textureMinificationFilter) {
+            return ((textureMinificationFilter === TextureMinificationFilter.NEAREST) ||
+                    (textureMinificationFilter === TextureMinificationFilter.LINEAR) ||
+                    (textureMinificationFilter === TextureMinificationFilter.NEAREST_MIPMAP_NEAREST) ||
+                    (textureMinificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_NEAREST) ||
+                    (textureMinificationFilter === TextureMinificationFilter.NEAREST_MIPMAP_LINEAR) ||
+                    (textureMinificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_LINEAR));
+        }
+    };
+
+    return TextureMinificationFilter;
+});

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

@@ -0,0 +1,50 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports TextureWrap
+     */
+    var TextureWrap = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        CLAMP : new Enumeration(0x812F, 'CLAMP'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        REPEAT : new Enumeration(0x2901, 'REPEAT'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        MIRRORED_REPEAT : new Enumeration(0x8370, 'MIRRORED_REPEAT'),
+
+        /**
+         * DOC_TBA
+         *
+         * @param textureWrap
+         *
+         * @returns {Boolean}
+         */
+        validate : function(textureWrap) {
+            return ((textureWrap === TextureWrap.CLAMP) ||
+                    (textureWrap === TextureWrap.REPEAT) ||
+                    (textureWrap === TextureWrap.MIRRORED_REPEAT));
+        }
+    };
+
+    return TextureWrap;
+});

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

@@ -0,0 +1,218 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * Indicates a GLSL uniform's datatype.
+     *
+     * @exports UniformDatatype
+     * @see Uniform.getDatatype
+     */
+    var UniformDatatype = {
+        /**
+         * A <code>float</code> uniform.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT : new Enumeration(0x1406, 'FLOAT', {
+            getGLSL : function() {
+                return 'float';
+            }
+        }), // FLOAT
+
+        /**
+         * A <code>vec2</code> uniform: a two-component floating-point vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT_VECTOR2 : new Enumeration(0x8B50, 'FLOAT_VECTOR2', {
+            getGLSL : function() {
+                return 'vec2';
+            }
+        }), // FLOAT_VEC2
+
+        /**
+         * A <code>vec3</code> uniform: a three-component floating-point vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT_VECTOR3 : new Enumeration(0x8B51, 'FLOAT_VECTOR3', {
+            getGLSL : function() {
+                return 'vec3';
+            }
+        }), // FLOAT_VEC3
+
+        /**
+         * A <code>vec4</code> uniform: a four-component floating-point vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT_VECTOR4 : new Enumeration(0x8B52, 'FLOAT_VECTOR4', {
+            getGLSL : function() {
+                return 'vec4';
+            }
+        }), // FLOAT_VEC4
+
+        /**
+         * An <code>int</code> uniform.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        INT : new Enumeration(0x1404, 'INT', {
+            getGLSL : function() {
+                return 'int';
+            }
+        }), // INT
+
+        /**
+         * An <code>ivec2</code> uniform: a two-component integer vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        INT_VECTOR2 : new Enumeration(0x8B53, 'INT_VECTOR2', {
+            getGLSL : function() {
+                return 'ivec2';
+            }
+        }), // INT_VEC2
+
+        /**
+         * An <code>ivec3</code> uniform: a three-component integer vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        INT_VECTOR3 : new Enumeration(0x8B54, 'INT_VECTOR3', {
+            getGLSL : function() {
+                return 'ivec3';
+            }
+        }), // INT_VEC3
+
+        /**
+         * An <code>ivec4</code> uniform: a four-component integer vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        INT_VECTOR4 : new Enumeration(0x8B55, 'INT_VECTOR4', {
+            getGLSL : function() {
+                return 'ivec4';
+            }
+        }), // INT_VEC4
+
+        /**
+         * A <code>bool</code> uniform.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        BOOL : new Enumeration(0x8B56, 'BOOL', {
+            getGLSL : function() {
+                return 'bool';
+            }
+        }), // BOOL
+
+        /**
+         * A <code>bvec2</code> uniform: a two-component boolean vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        BOOL_VECTOR2 : new Enumeration(0x8B57, 'BOOL_VECTOR2', {
+            getGLSL : function() {
+                return 'bvec2';
+            }
+        }), // BOOL_VEC2
+
+        /**
+         * A <code>bvec3</code> uniform: a three-component boolean vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        BOOL_VECTOR3 : new Enumeration(0x8B58, 'BOOL_VECTOR3', {
+            getGLSL : function() {
+                return 'bvec3';
+            }
+        }), // BOOL_VEC3
+
+        /**
+         * A <code>bvec4</code> uniform: a four-component boolean vector.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        BOOL_VECTOR4 : new Enumeration(0x8B59, 'BOOL_VECTOR4', {
+            getGLSL : function() {
+                return 'bvec4';
+            }
+        }), // BOOL_VEC4
+
+        /**
+         * An <code>mat2</code> uniform: a 2x2 floating-point matrix.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT_MATRIX2 : new Enumeration(0x8B5A, 'FLOAT_MATRIX2', {
+            getGLSL : function() {
+                return 'mat2';
+            }
+        }), // FLOAT_MAT2
+
+        /**
+         * An <code>mat3</code> uniform: a 3x3 floating-point matrix.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT_MATRIX3 : new Enumeration(0x8B5B, 'FLOAT_MATRIX3', {
+            getGLSL : function() {
+                return 'mat3';
+            }
+        }), // FLOAT_MAT3
+
+        /**
+         * An <code>mat4</code> uniform: a 4x4 floating-point matrix.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        FLOAT_MATRIX4 : new Enumeration(0x8B5C, 'FLOAT_MATRIX4', {
+            getGLSL : function() {
+                return 'mat4';
+            }
+        }), // FLOAT_MAT4
+
+        /**
+         * A <code>sampler2D</code> uniform: an opaque type to access 2D textures.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SAMPLER_2D : new Enumeration(0x8B5E, 'SAMPLER_2D', {
+            getGLSL : function() {
+                return 'sampler2D';
+            }
+        }), // SAMPLER_2D
+
+        /**
+         * A <code>samplerCube</code> uniform: an opaque type to access cube-map textures.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SAMPLER_CUBE : new Enumeration(0x8B60, 'SAMPLER_CUBE', {
+            getGLSL : function() {
+                return 'samplerCube';
+            }
+        }) // SAMPLER_CUBE
+    };
+
+    return UniformDatatype;
+});