cesium 0.13.0

data/app/assets/javascripts/Core/loadArrayBuffer.js

@@ -0,0 +1,76 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './RequestErrorEvent',
+        '../ThirdParty/when'
+    ], function(
+        DeveloperError,
+        RequestErrorEvent,
+        when) {
+    "use strict";
+
+    /**
+     * Asynchronously loads the given URL as raw binary data.  Returns a promise that will resolve to
+     * an ArrayBuffer once loaded, or reject if the URL failed to load.  The data is loaded
+     * using XMLHttpRequest, which means that in order to make requests to another origin,
+     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+     *
+     * @exports loadArrayBuffer
+     *
+     * @param {String|Promise} url The URL of the binary data, or a promise for the URL.
+     * @param {Object} [headers] HTTP headers to send with the requests.
+     *
+     * @returns {Promise} a promise that will resolve to the requested data when loaded.
+     *
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     *
+     * @example
+     * // load a single URL asynchronously
+     * loadArrayBuffer('some/url').then(function(arrayBuffer) {
+     *     // use the data
+     * }, function() {
+     *     // an error occurred
+     * });
+     */
+    var loadArrayBuffer = function(url, headers) {
+        if (typeof url === 'undefined') {
+            throw new DeveloperError('url is required.');
+        }
+
+        return when(url, function(url) {
+            var xhr = new XMLHttpRequest();
+            xhr.open('GET', url, true);
+
+            if (typeof headers !== 'undefined') {
+                for ( var key in headers) {
+                    if (headers.hasOwnProperty(key)) {
+                        xhr.setRequestHeader(key, headers[key]);
+                    }
+                }
+            }
+
+            xhr.responseType = 'arraybuffer';
+
+            var deferred = when.defer();
+
+            xhr.onload = function(e) {
+                if (xhr.status === 200) {
+                    deferred.resolve(xhr.response);
+                } else {
+                    deferred.reject(new RequestErrorEvent(xhr.status, xhr.response));
+                }
+            };
+
+            xhr.onerror = function(e) {
+                deferred.reject(new RequestErrorEvent());
+            };
+
+            xhr.send();
+
+            return deferred.promise;
+        });
+    };
+
+    return loadArrayBuffer;
+});

data/app/assets/javascripts/Core/loadImage.js

@@ -0,0 +1,85 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        '../ThirdParty/when'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        when) {
+    "use strict";
+
+    var dataUriRegex = /^data:/;
+
+    /**
+     * Asynchronously loads the given image URL.  Returns a promise that will resolve to
+     * an {@link Image} once loaded, or reject if the image failed to load.
+     *
+     * @exports loadImage
+     *
+     * @param {String|Promise} url The source of the image, or a promise for the URL.
+     * @param {Boolean} [crossOrigin=true] Whether to request the image using Cross-Origin
+     *        Resource Sharing (CORS).  Data URIs are never requested using CORS.
+     *
+     * @returns {Promise} a promise that will resolve to the requested data when loaded.
+     *
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     *
+     * @example
+     * // load a single image asynchronously
+     * loadImage('some/image/url.png').then(function(image) {
+     *     // use the loaded image
+     * }, function() {
+     *     // an error occurred
+     * });
+     *
+     * // load several images in parallel
+     * when.all([loadImage('image1.png'), loadImage('image2.png')]).then(function(images) {
+     *     // images is an array containing all the loaded images
+     * });
+     */
+    var loadImage = function(url, crossOrigin) {
+        if (typeof url === 'undefined') {
+            throw new DeveloperError('url is required.');
+        }
+
+        crossOrigin = defaultValue(crossOrigin, true);
+
+        return when(url, function(url) {
+            // data URIs can't have crossOrigin set.
+            if (dataUriRegex.test(url)) {
+                crossOrigin = false;
+            }
+
+            var deferred = when.defer();
+
+            loadImage.createImage(url, crossOrigin, deferred);
+
+            return deferred.promise;
+        });
+    };
+
+    // This is broken out into a separate function so that it can be mocked for testing purposes.
+    loadImage.createImage = function(url, crossOrigin, deferred) {
+        var image = new Image();
+
+        image.onload = function(e) {
+            deferred.resolve(image);
+        };
+
+        image.onerror = function(e) {
+            deferred.reject(e);
+        };
+
+        if (crossOrigin) {
+            image.crossOrigin = '';
+        }
+
+        image.src = url;
+    };
+
+    loadImage.defaultCreateImage = loadImage.createImage;
+
+    return loadImage;
+});

data/app/assets/javascripts/Core/loadJson.js

@@ -0,0 +1,54 @@
+/*global define*/
+define([
+        './defaultValue',
+        './loadText',
+        './DeveloperError'
+    ], function(
+        defaultValue,
+        loadText,
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * Asynchronously loads the given URL as JSON.  Returns a promise that will resolve to
+     * a JSON object once loaded, or reject if the URL failed to load.  The data is loaded
+     * using XMLHttpRequest, which means that in order to make requests to another origin,
+     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled. This function
+     * always adds 'Accept: application/json' to the request headers.
+     *
+     * @exports loadJson
+     *
+     * @param {String|Promise} url The URL to request, or a promise for the URL.
+     * @param {Object} [headers] HTTP headers to send with the request.
+     * 'Accept: application/json' is added to the request headers automatically
+     * and does not need to be specified.
+     * @returns {Promise} a promise that will resolve to the requested data when loaded.
+     *
+     * @exception {DeveloperError} url is required.
+     *
+     * @example
+     * loadJson('http://someUrl.com/someJson.txt').then(function(jsonData) {
+     *     //Do something with the JSON object
+     * }, function() {
+     *     // an error occurred
+     * });
+     *
+     * @see loadText
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     */
+    var loadJson = function loadJson(url, headers) {
+        if (typeof url === 'undefined') {
+            throw new DeveloperError('url is required.');
+        }
+
+        headers = defaultValue(headers, {});
+        headers.Accept = 'application/json';
+
+        return loadText(url, headers).then(function(value) {
+            return JSON.parse(value);
+        });
+    };
+
+    return loadJson;
+});

data/app/assets/javascripts/Core/loadText.js

@@ -0,0 +1,78 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './RequestErrorEvent',
+        '../ThirdParty/when'
+    ], function(
+        DeveloperError,
+        RequestErrorEvent,
+        when) {
+    "use strict";
+
+    /**
+     * Asynchronously loads the given URL as text.  Returns a promise that will resolve to
+     * a String once loaded, or reject if the URL failed to load.  The data is loaded
+     * using XMLHttpRequest, which means that in order to make requests to another origin,
+     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+     *
+     * @exports loadText
+     *
+     * @param {String|Promise} url The URL to request, or a promise for the URL.
+     * @param {Object} [headers] HTTP headers to send with the request.
+     * @returns {Promise} a promise that will resolve to the requested data when loaded.
+     *
+     * @exception {DeveloperError} url is required.
+     *
+     * @example
+     * // load text from a URL, setting a custom header
+     * loadText('http://someUrl.com/someJson.txt', {
+     *   'X-Custom-Header' : 'some value'
+     * }).then(function(text) {
+     *     //Do something with the text
+     * }, function() {
+     *     // an error occurred
+     * });
+     *
+     * @see <a href="http://en.wikipedia.org/wiki/XMLHttpRequest">XMLHttpRequest</a>
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     */
+    var loadText = function(url, headers) {
+        if (typeof url === 'undefined') {
+            throw new DeveloperError('url is required.');
+        }
+
+        return when(url, function(url) {
+            var xhr = new XMLHttpRequest();
+            xhr.open("GET", url, true);
+
+            if (typeof headers !== 'undefined') {
+                for ( var key in headers) {
+                    if (headers.hasOwnProperty(key)) {
+                        xhr.setRequestHeader(key, headers[key]);
+                    }
+                }
+            }
+
+            var deferred = when.defer();
+
+            xhr.onload = function(e) {
+                if (xhr.status === 200) {
+                    deferred.resolve(xhr.response);
+                } else {
+                    deferred.reject(new RequestErrorEvent(xhr.status, xhr.response));
+                }
+            };
+
+            xhr.onerror = function(e) {
+                deferred.reject(new RequestErrorEvent());
+            };
+
+            xhr.send();
+
+            return deferred.promise;
+        });
+    };
+
+    return loadText;
+});

data/app/assets/javascripts/Core/loadXML.js

@@ -0,0 +1,76 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './RequestErrorEvent',
+        '../ThirdParty/when'
+    ], function(
+        DeveloperError,
+        RequestErrorEvent,
+        when) {
+    "use strict";
+
+    /**
+     * Asynchronously loads the given URL and returns the responseXML.  Returns a promise that will resolve to
+     * an XML object once loaded, or reject if the URL failed to load.  The data is loaded
+     * using XMLHttpRequest, which means that in order to make requests to another origin,
+     * the server must have Cross-Origin Resource Sharing (CORS) headers enabled.
+     *
+     * @exports loadXML
+     *
+     * @param {String|Promise} url The URL to request, or a promise for the URL.
+     * @param {Object} [headers] HTTP headers to send with the request.
+     * @returns {Promise} a promise that will resolve to the requested data when loaded.
+     *
+     * @exception {DeveloperError} url is required.
+     *
+     * @see <a href="http://en.wikipedia.org/wiki/XMLHttpRequest">XMLHttpRequest</a>
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     */
+    var loadXML = function(url, headers) {
+        if (typeof url === 'undefined') {
+            throw new DeveloperError('url is required.');
+        }
+
+        return when(url, function(url) {
+            var deferred = when.defer();
+
+            loadXML.loadXML(url, headers, deferred);
+
+            return deferred.promise;
+        });
+    };
+
+    // This is broken out into a separate function so that it can be mocked for testing purposes.
+    loadXML.loadXML = function(url, headers, deferred) {
+        var xhr = new XMLHttpRequest();
+        xhr.overrideMimeType('text/xml');
+        xhr.open("GET", url, true);
+
+        if (typeof headers !== 'undefined') {
+            for ( var key in headers) {
+                if (headers.hasOwnProperty(key)) {
+                    xhr.setRequestHeader(key, headers[key]);
+                }
+            }
+        }
+
+        xhr.onload = function(e) {
+            if (xhr.status === 200) {
+                deferred.resolve(xhr.responseXML);
+            } else {
+                deferred.reject(new RequestErrorEvent(xhr.status, xhr.response));
+            }
+        };
+
+        xhr.onerror = function(e) {
+            deferred.reject(new RequestErrorEvent());
+        };
+
+        xhr.send();
+    };
+
+    loadXML.defaultLoadXML = loadXML.loadXML;
+
+    return loadXML;
+});

data/app/assets/javascripts/Core/package.json

@@ -0,0 +1,6 @@
+{
+	"name": "Core",
+	"description": "Cesium Core",
+	"version": "0.6.0",
+	"dojoBuild": "Core.profile.js"
+}

data/app/assets/javascripts/Core/pointInsideTriangle2D.js

@@ -0,0 +1,41 @@
+/*global define*/
+define(['./DeveloperError'], function(DeveloperError) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @param point
+     * @param p0
+     * @param p1
+     * @param p2
+     *
+     * @exports pointInsideTriangle2D
+     *
+     * @exception {DeveloperError} point, p0, p1, and p2 are required.
+     */
+    var pointInsideTriangle2D = function(point, p0, p1, p2) {
+        if (!point || !p0 || !p1 || !p2) {
+            throw new DeveloperError('point, p0, p1, and p2 are required.');
+        }
+
+        // Implementation based on http://www.blackpawn.com/texts/pointinpoly/default.html.
+        var v0 = p1.subtract(p0);
+        var v1 = p2.subtract(p0);
+        var v2 = point.subtract(p0);
+
+        var dot00 = v0.dot(v0);
+        var dot01 = v0.dot(v1);
+        var dot02 = v0.dot(v2);
+        var dot11 = v1.dot(v1);
+        var dot12 = v1.dot(v2);
+
+        var q = 1.0 / (dot00 * dot11 - dot01 * dot01);
+        var u = (dot11 * dot02 - dot01 * dot12) * q;
+        var v = (dot00 * dot12 - dot01 * dot02) * q;
+
+        return (u > 0) && (v > 0) && (u + v < 1);
+    };
+
+    return pointInsideTriangle2D;
+});

data/app/assets/javascripts/Core/requestAnimationFrame.js

@@ -0,0 +1,61 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    var requestAnimationFrameImplementation = window.requestAnimationFrame;
+
+    // look for vendor prefixed function
+    if (typeof requestAnimationFrameImplementation === 'undefined') {
+        var vendors = ['webkit', 'moz', 'ms', 'o'];
+        var i = 0;
+        var len = vendors.length;
+        while (i < len && typeof requestAnimationFrameImplementation === 'undefined') {
+            requestAnimationFrameImplementation = window[vendors[i] + 'RequestAnimationFrame'];
+            ++i;
+        }
+    }
+
+    // build an implementation based on setTimeout
+    if (typeof requestAnimationFrameImplementation === 'undefined') {
+        var lastFrameTime = 0;
+        requestAnimationFrameImplementation = function(callback) {
+            var currentTime = Date.now();
+
+            // schedule the callback to target 60fps, 16.7ms per frame,
+            // accounting for the time taken by the callback
+            var delay = Math.max(16 - (currentTime - lastFrameTime), 0);
+            lastFrameTime = currentTime + delay;
+
+            return setTimeout(function() {
+                callback(lastFrameTime);
+            }, delay);
+        };
+    }
+
+    /**
+     * A browser-independent function to request a new animation frame.  This is used to create
+     * an application's draw loop as shown in the example below.
+     *
+     * @exports requestAnimationFrame
+     *
+     * @param {Function} callback The function to call when animation is ready.
+     *
+     * @example
+     * // Create a draw loop using requestAnimationFrame. The
+     * // tick callback function is called for every animation frame.
+     * function tick() {
+     *   scene.render();
+     *   requestAnimationFrame(tick);
+     * }
+     * tick();
+     *
+     * @see <a href='http://www.w3.org/TR/animation-timing/#the-WindowAnimationTiming-interface'>The WindowAnimationTiming interface</a>
+     */
+    var requestAnimationFrame = function(callback) {
+        // we need this extra wrapper function because the native requestAnimationFrame
+        // functions must be invoked on the global scope (window), which is not the case
+        // if invoked as Cesium.requestAnimationFrame(callback)
+        requestAnimationFrameImplementation(callback);
+    };
+    return requestAnimationFrame;
+});