cesium 0.13.0

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

@@ -0,0 +1,358 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Math',
+        './MipmapHint',
+        './TextureMagnificationFilter',
+        './TextureMinificationFilter',
+        './TextureWrap',
+        './CubeMapFace'
+    ], function(
+        DeveloperError,
+        destroyObject,
+        CesiumMath,
+        MipmapHint,
+        TextureMagnificationFilter,
+        TextureMinificationFilter,
+        TextureWrap,
+        CubeMapFace) {
+    "use strict";
+
+    /**
+     * A cube map with faces +x, -x, +y, -y, +z, and -z.  Cube maps are used for environment techniques like
+     * approximate reflection and refraction as used in the Reflection and Refraction {@link Material}s.
+     *
+     * @alias CubeMap
+     * @internalConstructor
+     *
+     * @see Context#createCubeMap
+     */
+    var CubeMap = function(gl, textureFilterAnisotropic, textureTarget, texture, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY) {
+        this._gl = gl;
+        this._textureFilterAnisotropic = textureFilterAnisotropic;
+        this._textureTarget = textureTarget;
+        this._texture = texture;
+        this._pixelFormat = pixelFormat;
+        this._pixelDatatype = pixelDatatype;
+        this._size = size;
+        this._preMultiplyAlpha = preMultiplyAlpha;
+        this._flipY = flipY;
+        this._sampler = undefined;
+
+        this._positiveX = new CubeMapFace(gl, texture, textureTarget, gl.TEXTURE_CUBE_MAP_POSITIVE_X, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY);
+        this._negativeX = new CubeMapFace(gl, texture, textureTarget, gl.TEXTURE_CUBE_MAP_NEGATIVE_X, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY);
+        this._positiveY = new CubeMapFace(gl, texture, textureTarget, gl.TEXTURE_CUBE_MAP_POSITIVE_Y, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY);
+        this._negativeY = new CubeMapFace(gl, texture, textureTarget, gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY);
+        this._positiveZ = new CubeMapFace(gl, texture, textureTarget, gl.TEXTURE_CUBE_MAP_POSITIVE_Z, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY);
+        this._negativeZ = new CubeMapFace(gl, texture, textureTarget, gl.TEXTURE_CUBE_MAP_NEGATIVE_Z, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY);
+
+        this.setSampler();
+    };
+
+    /**
+     * Returns the +x face of this cube map for modification, rendering to, etc.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {CubeMapFace} The +x face of this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getPositiveX = function() {
+        return this._positiveX;
+    };
+
+    /**
+     * Returns the -x face of this cube map for modification, rendering to, etc.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {CubeMapFace} The -x face of this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getNegativeX = function() {
+        return this._negativeX;
+    };
+
+    /**
+     * Returns the +y face of this cube map for modification, rendering to, etc.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {CubeMapFace} The +y face of this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getPositiveY = function() {
+        return this._positiveY;
+    };
+
+    /**
+     * Returns the -y face of this cube map for modification, rendering to, etc.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {CubeMapFace} The -y face of this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getNegativeY = function() {
+        return this._negativeY;
+    };
+
+    /**
+     * Returns the +z face of this cube map for modification, rendering to, etc.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {CubeMapFace} The +z face of this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getPositiveZ = function() {
+        return this._positiveZ;
+    };
+
+    /**
+     * Returns the -z face of this cube map for modification, rendering to, etc.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {CubeMapFace} The -z face of this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getNegativeZ = function() {
+        return this._negativeZ;
+    };
+
+    /**
+     * Generates a complete mipmap chain for each cubemap face.
+     *
+     * @memberof CubeMap
+     *
+     * @param {MipmapHint} [hint=MipmapHint.DONT_CARE] A performance vs. quality hint.
+     *
+     * @exception {DeveloperError} hint is invalid.
+     * @exception {DeveloperError} This CubeMap's width must be a power of two to call generateMipmap().
+     * @exception {DeveloperError} This CubeMap's height must be a power of two to call generateMipmap().
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     *
+     * @example
+     * // Generate mipmaps, and then set the sampler so mipmaps are used for
+     * // minification when the cube map is sampled.
+     * cubeMap.generateMipmap();
+     * cubeMap.setSampler(context.createSampler({
+     *   minificationFilter : TextureMinificationFilter.NEAREST_MIPMAP_LINEAR
+     * }));
+     */
+    CubeMap.prototype.generateMipmap = function(hint) {
+        if ((this._size > 1) && !CesiumMath.isPowerOfTwo(this._size)) {
+            throw new DeveloperError('width and height must be a power of two to call generateMipmap().');
+        }
+
+        hint = hint || MipmapHint.DONT_CARE;
+        if (!MipmapHint.validate(hint)) {
+            throw new DeveloperError('hint is invalid.');
+        }
+
+        var gl = this._gl;
+        var target = this._textureTarget;
+
+        gl.hint(gl.GENERATE_MIPMAP_HINT, hint);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(target, this._texture);
+        gl.generateMipmap(target);
+        gl.bindTexture(target, null);
+    };
+
+    /**
+     * DOC_TBA
+     *
+     * @memberof CubeMap
+     *
+     * @param [sampler] DOC_TBA
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.setSampler = function(sampler) {
+        var s = sampler || {
+            wrapS : TextureWrap.CLAMP,
+            wrapT : TextureWrap.CLAMP,
+            minificationFilter : TextureMinificationFilter.LINEAR,
+            magnificationFilter : TextureMagnificationFilter.LINEAR,
+            maximumAnisotropy : 1.0
+        };
+
+        var gl = this._gl;
+        var target = this._textureTarget;
+
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(target, this._texture);
+        gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, s.minificationFilter);
+        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, s.magnificationFilter);
+        gl.texParameteri(target, gl.TEXTURE_WRAP_S, s.wrapS);
+        gl.texParameteri(target, gl.TEXTURE_WRAP_T, s.wrapT);
+        if (this._textureFilterAnisotropic) {
+            gl.texParameteri(target, this._textureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, s.maximumAnisotropy);
+        }
+        gl.bindTexture(target, null);
+
+        this._sampler = {
+            wrapS : s.wrapS,
+            wrapT : s.wrapT,
+            minificationFilter : s.minificationFilter,
+            magnificationFilter : s.magnificationFilter,
+            maximumAnisotropy : s.maximumAnisotropy
+        };
+    };
+
+    /**
+     * DOC_TBA
+     *
+     * @memberof CubeMap
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getSampler = function() {
+        return this._sampler;
+    };
+
+    /**
+     * Returns the pixel format of this cube map.  All faces in the same cube map have the same pixel format.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {PixelFormat} The pixel format of this cubemap.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getPixelFormat = function() {
+        return this._pixelFormat;
+    };
+
+    /**
+     * Returns the pixel datatype of this cube map.  All faces in the same cube map have the same pixel datatype.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {PixelDatatype} The pixel datatype of this cubemap.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getPixelDatatype = function() {
+        return this._pixelDatatype;
+    };
+
+    /**
+     * Returns the width, in texels, of faces in this cube map.  All faces in the same cube map have the same width and height, and the width equals the height.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {Number} The width, in texels, of faces in this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getWidth = function() {
+        return this._size;
+    };
+
+    /**
+     * Returns the height, in texels, of faces in this cube map.  All faces in the same cube map have the same width and height, and the width equals the height.
+     *
+     * @memberof CubeMap
+     *
+     * @returns {Number} The height, in texels, of faces in this cube map.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getHeight = function() {
+        return this._size;
+    };
+
+    /**
+     * Returns true if the cubemap was created with premultiplied alpha (UNPACK_PREMULTIPLY_ALPHA_WEBGL).
+     *
+     * @memberof CubeMap
+     *
+     * @returns {Boolean} true if the cubemap was created with premultiplied alpha; otherwise, false.
+     *
+     * @exception {DeveloperError} This cube map was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getPreMultiplyAlpha = function() {
+        return this._preMultiplyAlpha;
+    };
+
+    /**
+     * Returns true if the source pixels are flipped vertically when cube-map faces are created or updated, i.e.,
+     * <code>UNPACK_FLIP_Y_WEBGL</code> is used.
+     *
+     * @memberof CubeMap
+     *
+     * @return {Boolean} True if the source pixels are flipped vertically; otherwise, false.
+     *
+     * @exception {DeveloperError} This cube map was destroyed, i.e., destroy() was called.
+     */
+    CubeMap.prototype.getFlipY = function() {
+        return this._flipY;
+    };
+
+    CubeMap.prototype._getTexture = function() {
+        return this._texture;
+    };
+
+    CubeMap.prototype._getTarget = function() {
+        return this._textureTarget;
+    };
+
+    /**
+     * 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 CubeMap
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see CubeMap#destroy
+     */
+    CubeMap.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 CubeMap
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This cube map was destroyed, i.e., destroy() was called.
+     *
+     * @see CubeMap#isDestroyed
+     * @see <a href='http://www.khronos.org/opengles/sdk/2.0/docs/man/glDeleteTextures.xml'>glDeleteTextures</a>
+     *
+     * @example
+     * cubeMap = cubeMap && cubeMap.destroy();
+     */
+    CubeMap.prototype.destroy = function() {
+        this._gl.deleteTexture(this._texture);
+        this._positiveX = destroyObject(this._positiveX);
+        this._negativeX = destroyObject(this._negativeX);
+        this._positiveY = destroyObject(this._positiveY);
+        this._negativeY = destroyObject(this._negativeY);
+        this._positiveZ = destroyObject(this._positiveZ);
+        this._negativeZ = destroyObject(this._negativeZ);
+        return destroyObject(this);
+    };
+
+    return CubeMap;
+});

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

@@ -0,0 +1,202 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        './MipmapHint',
+        './TextureMagnificationFilter',
+        './TextureMinificationFilter',
+        './TextureWrap'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        destroyObject,
+        MipmapHint,
+        TextureMagnificationFilter,
+        TextureMinificationFilter,
+        TextureWrap) {
+    "use strict";
+
+    /**
+     * A face of a cube map (+x, -x, +y, -y, +z, or -z) that can be modified and rendered to.
+     *
+     * @alias CubeMapFace
+     * @internalConstructor
+     *
+     * @see CubeMap
+     */
+    var CubeMapFace = function(gl, texture, textureTarget, targetFace, pixelFormat, pixelDatatype, size, preMultiplyAlpha, flipY) {
+        this._gl = gl;
+        this._texture = texture;
+        this._textureTarget = textureTarget;
+        this._targetFace = targetFace;
+        this._pixelFormat = pixelFormat;
+        this._pixelDatatype = pixelDatatype;
+        this._size = size;
+        this._preMultiplyAlpha = preMultiplyAlpha;
+        this._flipY = flipY;
+    };
+
+    /**
+     * Copies texels from the source to the cubemap's face.
+     *
+     * @memberof CubeMapFace
+     *
+     * @param {Object} source The source ImageData, HTMLImageElement, HTMLCanvasElement, HTMLVideoElement, or an object with a width, height, and typed array as shown in the example.
+     * @param {Number} [xOffset=0] An offset in the x direction in the cubemap where copying begins.
+     * @param {Number} [yOffset=0] An offset in the y direction in the cubemap where copying begins.
+     *
+     * @exception {DeveloperError} source is required.
+     * @exception {DeveloperError} xOffset must be greater than or equal to zero.
+     * @exception {DeveloperError} yOffset must be greater than or equal to zero.
+     * @exception {DeveloperError} xOffset + source.width must be less than or equal to getWidth().
+     * @exception {DeveloperError} yOffset + source.height must be less than or equal to getHeight().
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     *
+     * @example
+     * // Create a cubemap with 1x1 faces, and make the +x face red.
+     * var cubeMap = context.createCubeMap({
+     *   width : 1,
+     *   height : 1
+     * });
+     * cubeMap.getPositiveX().copyFrom({
+     *   width : 1,
+     *   height : 1,
+     *   arrayBufferView : new Uint8Array([255, 0, 0, 255])
+     * });
+     */
+    CubeMapFace.prototype.copyFrom = function(source, xOffset, yOffset) {
+        if (!source) {
+            throw new DeveloperError('source is required.');
+        }
+
+        xOffset = defaultValue(xOffset, 0);
+        yOffset = defaultValue(yOffset, 0);
+
+        var width = source.width;
+        var height = source.height;
+
+        if (xOffset < 0) {
+            throw new DeveloperError('xOffset must be greater than or equal to zero.');
+        }
+
+        if (yOffset < 0) {
+            throw new DeveloperError('yOffset must be greater than or equal to zero.');
+        }
+
+        if (xOffset + width > this._size) {
+            throw new DeveloperError('xOffset + source.width must be less than or equal to getWidth().');
+        }
+
+        if (yOffset + height > this._size) {
+            throw new DeveloperError('yOffset + source.height must be less than or equal to getHeight().');
+        }
+
+        var gl = this._gl;
+        var target = this._textureTarget;
+
+        // TODO: gl.pixelStorei(gl._UNPACK_ALIGNMENT, 4);
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this._preMultiplyAlpha);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this._flipY);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(target, this._texture);
+
+        //Firefox bug: texSubImage2D has overloads and can't resolve our enums, so we use + to explicitly convert to a number.
+        if (source.arrayBufferView) {
+            gl.texSubImage2D(this._targetFace, 0, xOffset, yOffset, width, height, +this._pixelFormat, +this._pixelDatatype, source.arrayBufferView);
+        } else {
+            gl.texSubImage2D(this._targetFace, 0, xOffset, yOffset, +this._pixelFormat, +this._pixelDatatype, source);
+        }
+
+        gl.bindTexture(target, null);
+    };
+
+    /**
+     * Copies texels from the framebuffer to the cubemap's face.
+     *
+     * @memberof CubeMapFace
+     *
+     * @param {Number} [xOffset=0] An offset in the x direction in the cubemap where copying begins.
+     * @param {Number} [yOffset=0] An offset in the y direction in the cubemap where copying begins.
+     * @param {Number} [framebufferXOffset=0] An offset in the x direction in the framebuffer where copying begins from.
+     * @param {Number} [framebufferYOffset=0] An offset in the y direction in the framebuffer where copying begins from.
+     * @param {Number} [width=CubeMap's width] The width of the subimage to copy.
+     * @param {Number} [height=CubeMap's height] The height of the subimage to copy.
+     *
+     * @exception {DeveloperError} This CubeMap 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.
+     * @exception {DeveloperError} framebufferXOffset must be greater than or equal to zero.
+     * @exception {DeveloperError} framebufferYOffset must be greater than or equal to zero.
+     * @exception {DeveloperError} xOffset + source.width must be less than or equal to getWidth().
+     * @exception {DeveloperError} yOffset + source.height must be less than or equal to getHeight().
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     *
+     * @example
+     * // Copy the framebuffer contents to the +x cube map face.
+     * cubeMap.getPositiveX().copyFromFramebuffer();
+     */
+    CubeMapFace.prototype.copyFromFramebuffer = function(xOffset, yOffset, framebufferXOffset, framebufferYOffset, width, height) {
+        xOffset = defaultValue(xOffset, 0);
+        yOffset = defaultValue(yOffset, 0);
+        framebufferXOffset = defaultValue(framebufferXOffset, 0);
+        framebufferYOffset = defaultValue(framebufferYOffset, 0);
+        width = defaultValue(width, this._size);
+        height = defaultValue(height, this._size);
+
+        if (xOffset < 0) {
+            throw new DeveloperError('xOffset must be greater than or equal to zero.');
+        }
+
+        if (yOffset < 0) {
+            throw new DeveloperError('yOffset must be greater than or equal to zero.');
+        }
+
+        if (framebufferXOffset < 0) {
+            throw new DeveloperError('framebufferXOffset must be greater than or equal to zero.');
+        }
+
+        if (framebufferYOffset < 0) {
+            throw new DeveloperError('framebufferYOffset must be greater than or equal to zero.');
+        }
+
+        if (xOffset + width > this._size) {
+            throw new DeveloperError('xOffset + source.width must be less than or equal to getWidth().');
+        }
+
+        if (yOffset + height > this._size) {
+            throw new DeveloperError('yOffset + source.height must be less than or equal to getHeight().');
+        }
+
+        var gl = this._gl;
+        var target = this._textureTarget;
+
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(target, this._texture);
+        gl.copyTexSubImage2D(this._targetFace, 0, xOffset, yOffset, framebufferXOffset, framebufferYOffset, width, height);
+        gl.bindTexture(target, null);
+    };
+
+    /**
+     * Returns the pixel format of this cube map face.  All faces in the same cube map have the same pixel format.
+     *
+     * @memberof CubeMapFace
+     *
+     * @returns {PixelFormat} The pixel format of this cubemap face.
+     *
+     * @exception {DeveloperError} This CubeMap was destroyed, i.e., destroy() was called.
+     */
+    CubeMapFace.prototype.getPixelFormat = function() {
+        return this._pixelFormat;
+    };
+
+    CubeMapFace.prototype._getTexture = function() {
+        return this._texture;
+    };
+
+    CubeMapFace.prototype._getTarget = function() {
+        return this._targetFace;
+    };
+
+    return CubeMapFace;
+});