cesium 0.13.0

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

@@ -0,0 +1,158 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports BlendFunction
+     */
+    var BlendFunction = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ZERO : new Enumeration(0, 'ZERO'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ONE : new Enumeration(1, 'ONE'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SOURCE_COLOR : new Enumeration(0x0300, 'SOURCE_COLOR'), // WebGL: SRC_COLOR
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ONE_MINUS_SOURCE_COLOR : new Enumeration(0x0301, 'ONE_MINUS_SOURCE_COLOR'), // WebGL: ONE_MINUS_SRC_COLOR
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        DESTINATION_COLOR : new Enumeration(0x0306, 'DESTINATION_COLOR'), // WebGL: DEST_COLOR
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ONE_MINUS_DESTINATION_COLOR : new Enumeration(0x0307, 'ONE_MINUS_DESTINATION_COLOR'), // WebGL: ONE_MINUS_DEST_COLOR
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SOURCE_ALPHA : new Enumeration(0x0302, 'SOURCE_ALPHA'), // WebGL: SRC_ALPHA
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ONE_MINUS_SOURCE_ALPHA : new Enumeration(0x0303, 'ONE_MINUS_SOURCE_ALPHA'), // WebGL: ONE_MINUS_SRC_ALPHA
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        DESTINATION_ALPHA : new Enumeration(0x0304, 'DESTINATION_ALPHA'), // WebGL: DST_ALPHA
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ONE_MINUS_DESTINATION_ALPHA : new Enumeration(0x0305, 'ONE_MINUS_DESTINATION_ALPHA'), // WebGL: ONE_MINUS_DST_ALPHA
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        CONSTANT_COLOR : new Enumeration(0x8001, 'CONSTANT_COLOR'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ONE_MINUS_CONSTANT_COLOR : new Enumeration(0x8002, 'ONE_MINUS_CONSTANT_COLOR'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        CONSTANT_ALPHA : new Enumeration(0x8003, 'CONSTANT_ALPHA'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ONE_MINUS_CONSTANT_ALPHA : new Enumeration(0x8004, 'ONE_MINUS_CONSTANT_ALPHA'),
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SOURCE_ALPHA_SATURATE : new Enumeration(0x0308, 'SOURCE_ALPHA_SATURATE'), // WebGL: SRC_ALPHA_SATURATE
+
+        /**
+         * DOC_TBA
+         *
+         * @param blendFunction
+         *
+         * @returns {Boolean}
+         */
+        validate : function(blendFunction) {
+            return ((blendFunction === BlendFunction.ZERO) ||
+                    (blendFunction === BlendFunction.ONE) ||
+                    (blendFunction === BlendFunction.SOURCE_COLOR) ||
+                    (blendFunction === BlendFunction.ONE_MINUS_SOURCE_COLOR) ||
+                    (blendFunction === BlendFunction.DESTINATION_COLOR) ||
+                    (blendFunction === BlendFunction.ONE_MINUS_DESTINATION_COLOR) ||
+                    (blendFunction === BlendFunction.SOURCE_ALPHA) ||
+                    (blendFunction === BlendFunction.ONE_MINUS_SOURCE_ALPHA) ||
+                    (blendFunction === BlendFunction.DESTINATION_ALPHA) ||
+                    (blendFunction === BlendFunction.ONE_MINUS_DESTINATION_ALPHA) ||
+                    (blendFunction === BlendFunction.CONSTANT_COLOR) ||
+                    (blendFunction === BlendFunction.ONE_MINUS_CONSTANT_COLOR) ||
+                    (blendFunction === BlendFunction.CONSTANT_ALPHA) ||
+                    (blendFunction === BlendFunction.ONE_MINUS_CONSTANT_ALPHA) ||
+                    (blendFunction === BlendFunction.SOURCE_ALPHA_SATURATE));
+        }
+    };
+
+    return BlendFunction;
+});

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

@@ -0,0 +1,64 @@
+/*global define*/
+define([
+        './BlendEquation',
+        './BlendFunction'
+    ], function(
+        BlendEquation,
+        BlendFunction) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports BlendingState
+     */
+    var BlendingState = {
+        /**
+         * DOC_TBA
+         */
+        DISABLED : {
+            enabled : false
+        },
+
+        /**
+         * DOC_TBA
+         */
+        ALPHA_BLEND : {
+            enabled : true,
+            equationRgb : BlendEquation.ADD,
+            equationAlpha : BlendEquation.ADD,
+            functionSourceRgb : BlendFunction.SOURCE_ALPHA,
+            functionSourceAlpha : BlendFunction.SOURCE_ALPHA,
+            functionDestinationRgb : BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+            functionDestinationAlpha : BlendFunction.ONE_MINUS_SOURCE_ALPHA
+        },
+
+        /**
+         * DOC_TBA
+         */
+        PRE_MULTIPLIED_ALPHA_BLEND : {
+            enabled : true,
+            equationRgb : BlendEquation.ADD,
+            equationAlpha : BlendEquation.ADD,
+            functionSourceRgb : BlendFunction.ONE,
+            functionSourceAlpha : BlendFunction.ONE,
+            functionDestinationRgb : BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+            functionDestinationAlpha : BlendFunction.ONE_MINUS_SOURCE_ALPHA
+        },
+
+        /**
+         * DOC_TBA
+         */
+        ADDITIVE_BLEND : {
+            enabled : true,
+            equationRgb : BlendEquation.ADD,
+            equationAlpha : BlendEquation.ADD,
+            functionSourceRgb : BlendFunction.SOURCE_ALPHA,
+            functionSourceAlpha : BlendFunction.SOURCE_ALPHA,
+            functionDestinationRgb : BlendFunction.ONE,
+            functionDestinationAlpha : BlendFunction.ONE
+        }
+    };
+
+    return BlendingState;
+});

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

@@ -0,0 +1,141 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject'
+    ], function(
+        DeveloperError,
+        destroyObject) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @alias Buffer
+     * @internalConstructor
+     *
+     * @see Context#createVertexBuffer
+     * @see Context#createIndexBuffer
+     */
+    var Buffer = function(gl, bufferTarget, sizeInBytes, usage, buffer) {
+        this._gl = gl;
+        this._bufferTarget = bufferTarget;
+        this._sizeInBytes = sizeInBytes;
+        this._usage = usage;
+        this._buffer = buffer;
+        this._vertexArrayDestroyable = true;
+    };
+
+    /**
+     * DOC_TBA
+     * DOC_TBA: arrayView
+     *
+     * @memberof Buffer
+     * @param {Number} [offsetInBytes=0] DOC_TBA
+     *
+     * @exception {DeveloperError} arrayView is required.
+     * @exception {DeveloperError} This buffer is not large enough.
+     * @exception {DeveloperError} This buffer was destroyed, i.e., destroy() was called.
+     */
+    Buffer.prototype.copyFromArrayView = function(arrayView, offsetInBytes) {
+        if (!arrayView) {
+            throw new DeveloperError('arrayView is required.');
+        }
+
+        offsetInBytes = offsetInBytes || 0;
+
+        if (offsetInBytes + arrayView.byteLength > this._sizeInBytes) {
+            throw new DeveloperError('This buffer is not large enough.');
+        }
+
+        var gl = this._gl;
+        var target = this._bufferTarget;
+        gl.bindBuffer(target, this._buffer);
+        gl.bufferSubData(target, offsetInBytes, arrayView);
+        gl.bindBuffer(target, null);
+    };
+
+    Buffer.prototype._getBuffer = function() {
+        return this._buffer;
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof Buffer
+     *
+     * @return {Number} DOC_TBA
+     * @exception {DeveloperError} This buffer was destroyed, i.e., destroy() was called.
+     */
+    Buffer.prototype.getSizeInBytes = function() {
+        return this._sizeInBytes;
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof Buffer
+     *
+     * @return {GLenum} DOC_TBA
+     * @exception {DeveloperError} This buffer was destroyed, i.e., destroy() was called.
+     */
+    Buffer.prototype.getUsage = function() {
+        return this._usage;
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof Buffer
+     */
+    Buffer.prototype.getVertexArrayDestroyable = function() {
+        return this._vertexArrayDestroyable;
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof Buffer
+     */
+    Buffer.prototype.setVertexArrayDestroyable = function(value) {
+        this._vertexArrayDestroyable = value;
+    };
+
+    /**
+     * 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 Buffer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see Buffer#destroy
+     */
+    Buffer.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 Buffer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This buffer was destroyed, i.e., destroy() was called.
+     *
+     * @see Buffer#isDestroyed
+     * @see <a href='http://www.khronos.org/opengles/sdk/2.0/docs/man/glDeleteBuffers.xml'>glDeleteBuffers</a>
+     *
+     * @example
+     * buffer = buffer && buffer.destroy();
+     */
+    Buffer.prototype.destroy = function() {
+        this._gl.deleteBuffer(this._buffer);
+        return destroyObject(this);
+    };
+
+    return Buffer;
+});

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

@@ -0,0 +1,48 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports BufferUsage
+     */
+    var BufferUsage = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        STREAM_DRAW : new Enumeration(0x88E0, 'STREAM_DRAW'),
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        STATIC_DRAW : new Enumeration(0x88E4, 'STATIC_DRAW'),
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        DYNAMIC_DRAW : new Enumeration(0x88E8, 'DYNAMIC_DRAW'),
+
+        /**
+         * DOC_TBA
+         *
+         * @param bufferUsage
+         *
+         * @returns {Boolean}
+         */
+        validate : function(bufferUsage) {
+            return ((bufferUsage === BufferUsage.STREAM_DRAW) ||
+                    (bufferUsage === BufferUsage.STATIC_DRAW) ||
+                    (bufferUsage === BufferUsage.DYNAMIC_DRAW));
+        }
+    };
+
+    return BufferUsage;
+});

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

@@ -0,0 +1,40 @@
+/*global define*/
+define(['../Core/DeveloperError'], function(DeveloperError) {
+    "use strict";
+
+    /**
+     * Represents a command to the renderer for clearing.
+     *
+     * @alias Command
+     * @constructor
+     *
+     * @param {ClearState} [clearState] The clear state.
+     */
+    var ClearCommand = function(clearState) {
+        /**
+         * The clear state.  If this property is undefined, a default clear state is used.
+         * @type Object
+         */
+        this.clearState = clearState;
+
+        /**
+         * The framebuffer to clear.
+         * @type Framebuffer
+         */
+        this.framebuffer = undefined;
+    };
+
+    /**
+     * Executes the clear command.
+     *
+     * @memberof ClearCommand
+     *
+     * @param {Context} context The renderer context in which to clear.
+     * @param {Framebuffer} [framebuffer] The framebuffer to clear if one is not specified by the command.
+     */
+    ClearCommand.prototype.execute = function(context, framebuffer) {
+        context.clear(this, framebuffer);
+    };
+
+    return ClearCommand;
+});