cesium 0.18.0 → 0.19.0

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

@@ -1,12 +1,5 @@
 /*global define*/
-define([
-        './defaultValue',
-        './freezeObject',
-        './DeveloperError',
-        './Cartesian3',
-        './Ellipsoid',
-        './Math'
-    ], function(
+define(['Core/defaultValue', 'Core/freezeObject', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Ellipsoid', 'Core/Math'], function(
         defaultValue,
         freezeObject,
         DeveloperError,
@@ -19,11 +12,6 @@ define([
      * Contains functions to create a mesh from a heightmap image.
      *
      * @exports HeightmapTessellator
-     *
-     * @see ExtentTessellator
-     * @see CubeMapEllipsoidTessellator
-     * @see BoxTessellator
-     * @see PlaneTessellator
      */
     var HeightmapTessellator = {};
 

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

@@ -1,6 +1,5 @@
 /*global define*/
-define(['./Math'
-       ], function(
+define(['Core/Math'], function(
         CesiumMath) {
     "use strict";
 

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

@@ -1,10 +1,5 @@
 /*global define*/
-define(['./defaultValue',
-        './DeveloperError',
-        './Matrix4',
-        './Cartesian4',
-        './TridiagonalSystemSolver'
-        ], function(
+define(['Core/defaultValue', 'Core/DeveloperError', 'Core/Matrix4', 'Core/Cartesian4', 'Core/TridiagonalSystemSolver'], function(
                 defaultValue,
                 DeveloperError,
                 Matrix4,

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

@@ -1,13 +1,5 @@
 /*global define*/
-define([
-        './buildModuleUrl',
-        './defaultValue',
-        './Iau2006XysSample',
-        './JulianDate',
-        './loadJson',
-        './TimeStandard',
-        '../ThirdParty/when'
-    ], function(
+define(['Core/buildModuleUrl', 'Core/defaultValue', 'Core/Iau2006XysSample', 'Core/JulianDate', 'Core/loadJson', 'Core/TimeStandard', 'ThirdParty/when'], function(
         buildModuleUrl,
         defaultValue,
         Iau2006XysSample,

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

@@ -1,29 +1,104 @@
 /*global define*/
-define(['./Enumeration'], function(Enumeration) {
+define(['Core/Enumeration', 'Core/DeveloperError', 'Core/Math'], function(
+        Enumeration,
+        DeveloperError,
+        CesiumMath) {
     "use strict";
 
+    // Bail out if the browser doesn't support typed arrays, to prevent the setup function
+    // from failing, since we won't be able to create a WebGL context anyway.
+    if (typeof Int8Array === 'undefined') {
+        return {};
+    }
+
     /**
-     * DOC_TBA
+     * Enumerations for WebGL index datatypes.  These corresponds to the
+     * <code>type</code> parameter of <a href="http://www.khronos.org/opengles/sdk/docs/man/xhtml/glDrawElements.xml">drawElements</a>.
      *
-     * @exports IndexDatatype
+     * @alias IndexDatatype
+     * @enumeration
      */
     var IndexDatatype = {
         /**
-         * DOC_TBA
+         * 8-bit unsigned byte enumeration corresponding to <code>UNSIGNED_BYTE</code> and the type
+         * of an element in <code>Uint8Array</code>.
          *
          * @type {Enumeration}
          * @constant
          * @default 0x1401
          */
-        UNSIGNED_BYTE : new Enumeration(0x1401, 'UNSIGNED_BYTE'),
+        UNSIGNED_BYTE : new Enumeration(0x1401, 'UNSIGNED_BYTE', {
+            sizeInBytes : Uint8Array.BYTES_PER_ELEMENT
+        }),
+
         /**
-         * DOC_TBA
+         * 16-bit unsigned short enumeration corresponding to <code>UNSIGNED_SHORT</code> and the type
+         * of an element in <code>Uint16Array</code>.
          *
          * @type {Enumeration}
          * @constant
          * @default 0x1403
          */
-        UNSIGNED_SHORT : new Enumeration(0x1403, 'UNSIGNED_SHORT')
+        UNSIGNED_SHORT : new Enumeration(0x1403, 'UNSIGNED_SHORT', {
+            sizeInBytes : Uint16Array.BYTES_PER_ELEMENT
+        }),
+
+        /**
+         * 32-bit unsigned int enumeration corresponding to <code>UNSIGNED_INT</code> and the type
+         * of an element in <code>Uint32Array</code>.
+         *
+         * @memberOf ComponentDatatype
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        UNSIGNED_INT : new Enumeration(0x1405, 'UNSIGNED_INT', {
+            sizeInBytes : Uint32Array.BYTES_PER_ELEMENT
+        })
+    };
+
+    /**
+     * Validates that the provided index datatype is a valid {@link IndexDatatype}
+     *
+     * @param {IndexDatatype} indexDatatype The index datatype to validate.
+     *
+     * @return {Boolean} <code>true</code> if the provided index datatype is a valid enumeration value; otherwise, <code>false</code>.
+     *
+     * @example
+     * if (!IndexDatatype.validate(indexDatatype)) {
+     *   throw new DeveloperError('indexDatatype must be a valid enumeration value.');
+     * }
+     */
+    IndexDatatype.validate = function(indexDatatype) {
+        return indexDatatype === IndexDatatype.UNSIGNED_BYTE ||
+               indexDatatype === IndexDatatype.UNSIGNED_SHORT ||
+               indexDatatype === IndexDatatype.UNSIGNED_INT;
+    };
+
+    /**
+     * Creates a typed array that will store indices, using either <code><Uint16Array</code>
+     * or <code>Uint32Array</code> depending on the number of vertices.
+     *
+     * @param {Number} numberOfVertices Number of vertices that the indices will reference.
+     * @param {Any} indicesLengthOrArray Passed through to the typed array constructor.
+     *
+     * @return {Array} A <code>Uint16Array</code> or <code>Uint32Array</code> constructed with <code>indicesLengthOrArray</code>.
+     *
+     * @exception {DeveloperError} center is required.
+     *
+     * @example
+     * this.indices = IndexDatatype.createTypedArray(positions.length / 3, numberOfIndices);
+     */
+    IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
+        if (typeof numberOfVertices === 'undefined') {
+            throw new DeveloperError('numberOfVertices is required.');
+        }
+
+        if (numberOfVertices > CesiumMath.SIXTY_FOUR_KILOBYTES) {
+            return new Uint32Array(indicesLengthOrArray);
+        }
+
+        return new Uint16Array(indicesLengthOrArray);
     };
 
     return IndexDatatype;

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['./Enumeration'], function(Enumeration) {
+define(['Core/Enumeration'], function(Enumeration) {
     "use strict";
 
     /**

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

@@ -1,13 +1,5 @@
 /*global define*/
-define([
-        './DeveloperError',
-        './Math',
-        './Cartesian3',
-        './Cartographic',
-        './Matrix3',
-        './QuadraticRealPolynomial',
-        './QuarticRealPolynomial'
-    ],
+define(['Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Matrix3', 'Core/QuadraticRealPolynomial', 'Core/QuarticRealPolynomial'],
     function(
         DeveloperError,
         CesiumMath,

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['./defaultValue'], function(defaultValue) {
+define(['Core/defaultValue'], function(defaultValue) {
     "use strict";
 
     /**

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

@@ -1,9 +1,5 @@
 /*global define*/
-define([
-        './freezeObject',
-        './JulianDate',
-        './TimeInterval'
-    ], function(
+define(['Core/freezeObject', 'Core/JulianDate', 'Core/TimeInterval'], function(
         freezeObject,
         JulianDate,
         TimeInterval) {

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

@@ -1,13 +1,5 @@
 /*global define*/
-define([
-        './DeveloperError',
-        './binarySearch',
-        './TimeConstants',
-        './LeapSecond',
-        './TimeStandard',
-        './isLeapYear',
-        '../ThirdParty/sprintf'
-    ], function(
+define(['Core/DeveloperError', 'Core/binarySearch', 'Core/TimeConstants', 'Core/LeapSecond', 'Core/TimeStandard', 'Core/isLeapYear', 'ThirdParty/sprintf'], function(
         DeveloperError,
         binarySearch,
         TimeConstants,

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['./Enumeration'], function(Enumeration) {
+define(['Core/Enumeration'], function(Enumeration) {
     "use strict";
 
     /**

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

@@ -1,7 +1,5 @@
 /*global define*/
-define([
-        './DeveloperError'
-    ], function(
+define(['Core/DeveloperError'], function(
         DeveloperError) {
     "use strict";
 

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

@@ -1,7 +1,5 @@
 /*global define*/
-define([
-        './DeveloperError'
-       ],function(
+define(['Core/DeveloperError'],function(
          DeveloperError) {
     "use strict";
 

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

@@ -1,8 +1,5 @@
 /*global define*/
-define([
-        './defaultValue',
-        './DeveloperError'
-       ], function(
+define(['Core/defaultValue', 'Core/DeveloperError'], function(
          defaultValue,
          DeveloperError) {
     "use strict";
@@ -164,10 +161,16 @@ define([
      * Radius of the sun in meters: 6.995e8
      * @type {Number}
      * @constant
-     * @default
      */
     CesiumMath.SOLAR_RADIUS = 6.995e8;
 
+    /**
+     * 64 * 1024
+     * @type {Number}
+     * @constant
+     */
+    CesiumMath.SIXTY_FOUR_KILOBYTES = 64 * 1024;
+
     /**
      * Returns the sign of the value; 1 if the value is positive, -1 if the value is
      * negative, or 0 if the value is 0.

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

@@ -1,10 +1,5 @@
 /*global define*/
-define([
-        './Cartesian2',
-        './defaultValue',
-        './DeveloperError',
-        './freezeObject'
-    ], function(
+define(['Core/Cartesian2', 'Core/defaultValue', 'Core/DeveloperError', 'Core/freezeObject'], function(
         Cartesian2,
         defaultValue,
         DeveloperError,

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

@@ -1,10 +1,5 @@
 /*global define*/
-define([
-        './Cartesian3',
-        './defaultValue',
-        './DeveloperError',
-        './freezeObject'
-    ], function(
+define(['Core/Cartesian3', 'Core/defaultValue', 'Core/DeveloperError', 'Core/freezeObject'], function(
         Cartesian3,
         defaultValue,
         DeveloperError,

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

@@ -1,14 +1,5 @@
 /*global define*/
-define([
-        './Cartesian3',
-        './Cartesian4',
-        './defaultValue',
-        './DeveloperError',
-        './freezeObject',
-        './Math',
-        './Matrix3',
-        './RuntimeError'
-    ], function(
+define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Math', 'Core/Matrix3', 'Core/RuntimeError'], function(
         Cartesian3,
         Cartesian4,
         defaultValue,
@@ -87,32 +78,32 @@ define([
      * @param {Matrix4} [result] The object onto which to store the result.
      * @return {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided. (Returns undefined if matrix is undefined)
      */
-    Matrix4.clone = function(values, result) {
-        if (typeof values === 'undefined') {
+    Matrix4.clone = function(matrix, result) {
+        if (typeof matrix === 'undefined') {
             return undefined;
         }
         if (typeof result === 'undefined') {
-            return new Matrix4(values[0], values[4], values[8], values[12],
-                               values[1], values[5], values[9], values[13],
-                               values[2], values[6], values[10], values[14],
-                               values[3], values[7], values[11], values[15]);
+            return new Matrix4(matrix[0], matrix[4], matrix[8], matrix[12],
+                               matrix[1], matrix[5], matrix[9], matrix[13],
+                               matrix[2], matrix[6], matrix[10], matrix[14],
+                               matrix[3], matrix[7], matrix[11], matrix[15]);
         }
-        result[0] = values[0];
-        result[1] = values[1];
-        result[2] = values[2];
-        result[3] = values[3];
-        result[4] = values[4];
-        result[5] = values[5];
-        result[6] = values[6];
-        result[7] = values[7];
-        result[8] = values[8];
-        result[9] = values[9];
-        result[10] = values[10];
-        result[11] = values[11];
-        result[12] = values[12];
-        result[13] = values[13];
-        result[14] = values[14];
-        result[15] = values[15];
+        result[0] = matrix[0];
+        result[1] = matrix[1];
+        result[2] = matrix[2];
+        result[3] = matrix[3];
+        result[4] = matrix[4];
+        result[5] = matrix[5];
+        result[6] = matrix[6];
+        result[7] = matrix[7];
+        result[8] = matrix[8];
+        result[9] = matrix[9];
+        result[10] = matrix[10];
+        result[11] = matrix[11];
+        result[12] = matrix[12];
+        result[13] = matrix[13];
+        result[14] = matrix[14];
+        result[15] = matrix[15];
         return result;
     };
 

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

@@ -1,13 +1,5 @@
 /*global define*/
-define([
-        './defaultValue',
-        './DeveloperError',
-        './Math',
-        './Cartesian3',
-        './Visibility',
-        './Ellipsoid',
-        './BoundingSphere'
-    ], function(
+define(['Core/defaultValue', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', 'Core/Visibility', 'Core/Ellipsoid', 'Core/BoundingSphere'], function(
         defaultValue,
         DeveloperError,
         CesiumMath,
@@ -374,7 +366,7 @@ define([
         }
 
         ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
-        var positions = extent.subsample(ellipsoid, computeOccludeePointFromExtentScratch);
+        var positions = extent.subsample(ellipsoid, 0.0, computeOccludeePointFromExtentScratch);
         var bs = BoundingSphere.fromPoints(positions);
 
         // TODO: get correct ellipsoid center

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

@@ -1,7 +1,5 @@
 /*global define*/
-define([
-        './DeveloperError'
-    ], function(
+define(['Core/DeveloperError'], function(
         DeveloperError) {
     "use strict";
 

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

@@ -1,8 +1,5 @@
 /*global define*/
-define([
-        './Cartesian3',
-        './DeveloperError'
-    ], function(
+define(['Core/Cartesian3', 'Core/DeveloperError'], function(
         Cartesian3,
         DeveloperError) {
     "use strict";

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

@@ -0,0 +1,774 @@
+/*global define*/
+define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/ComponentDatatype', 'Core/DeveloperError', 'Core/Ellipsoid', 'Core/EllipsoidTangentPlane', 'Core/Geometry', 'Core/GeometryAttribute', 'Core/GeometryAttributes', 'Core/GeometryInstance', 'Core/GeometryPipeline', 'Core/IndexDatatype', 'Core/Intersect', 'Core/Math', 'Core/Matrix3', 'Core/PolygonPipeline', 'Core/PrimitiveType', 'Core/Quaternion', 'Core/Queue', 'Core/VertexFormat', 'Core/WindingOrder'], function(
+        defaultValue,
+        BoundingRectangle,
+        BoundingSphere,
+        Cartesian2,
+        Cartesian3,
+        Cartesian4,
+        ComponentDatatype,
+        DeveloperError,
+        Ellipsoid,
+        EllipsoidTangentPlane,
+        Geometry,
+        GeometryAttribute,
+        GeometryAttributes,
+        GeometryInstance,
+        GeometryPipeline,
+        IndexDatatype,
+        Intersect,
+        CesiumMath,
+        Matrix3,
+        PolygonPipeline,
+        PrimitiveType,
+        Quaternion,
+        Queue,
+        VertexFormat,
+        WindingOrder) {
+    "use strict";
+
+    var computeBoundingRectangleCartesian2 = new Cartesian2();
+    var computeBoundingRectangleCartesian3 = new Cartesian3();
+    var computeBoundingRectangleQuaternion = new Quaternion();
+    var computeBoundingRectangleMatrix3 = new Matrix3();
+
+    function computeBoundingRectangle(tangentPlane, positions, angle, result) {
+        var rotation = Quaternion.fromAxisAngle(tangentPlane._plane.normal, angle, computeBoundingRectangleQuaternion);
+        var textureMatrix = Matrix3.fromQuaternion(rotation, computeBoundingRectangleMatrix3);
+
+        var minX = Number.POSITIVE_INFINITY;
+        var maxX = Number.NEGATIVE_INFINITY;
+        var minY = Number.POSITIVE_INFINITY;
+        var maxY = Number.NEGATIVE_INFINITY;
+
+        var length = positions.length;
+        for ( var i = 0; i < length; ++i) {
+            var p = Cartesian3.clone(positions[i], computeBoundingRectangleCartesian3);
+            Matrix3.multiplyByVector(textureMatrix, p, p);
+            var st = tangentPlane.projectPointOntoPlane(p, computeBoundingRectangleCartesian2);
+
+            if (typeof st !== 'undefined') {
+                minX = Math.min(minX, st.x);
+                maxX = Math.max(maxX, st.x);
+
+                minY = Math.min(minY, st.y);
+                maxY = Math.max(maxY, st.y);
+            }
+        }
+
+        result.x = minX;
+        result.y = minY;
+        result.width = maxX - minX;
+        result.height = maxY - minY;
+        return result;
+    }
+
+    var createGeometryFromPositionsPositions = [];
+
+    function createGeometryFromPositions(ellipsoid, positions, granularity) {
+        var cleanedPositions = PolygonPipeline.removeDuplicates(positions);
+        if (cleanedPositions.length < 3) {
+            throw new DeveloperError('Duplicate positions result in not enough positions to form a polygon.');
+        }
+
+        var tangentPlane = EllipsoidTangentPlane.fromPoints(cleanedPositions, ellipsoid);
+        var positions2D = tangentPlane.projectPointsOntoPlane(cleanedPositions, createGeometryFromPositionsPositions);
+
+        var originalWindingOrder = PolygonPipeline.computeWindingOrder2D(positions2D);
+        if (originalWindingOrder === WindingOrder.CLOCKWISE) {
+            positions2D.reverse();
+            cleanedPositions.reverse();
+        }
+
+        var indices = PolygonPipeline.earClip2D(positions2D);
+        return new GeometryInstance({
+            geometry : PolygonPipeline.computeSubdivision(cleanedPositions, indices, granularity)
+        });
+    }
+
+    var scratchBoundingRectangle = new BoundingRectangle();
+    var scratchPosition = new Cartesian3();
+    var scratchNormal = new Cartesian3();
+    var scratchTangent = new Cartesian3();
+    var scratchBinormal = new Cartesian3();
+    var scratchBoundingSphere = new BoundingSphere();
+    var p1 = new Cartesian3();
+    var p2 = new Cartesian3();
+
+    var appendTextureCoordinatesOrigin = new Cartesian2();
+    var appendTextureCoordinatesCartesian2 = new Cartesian2();
+    var appendTextureCoordinatesCartesian3 = new Cartesian3();
+    var appendTextureCoordinatesQuaternion = new Quaternion();
+    var appendTextureCoordinatesMatrix3 = new Matrix3();
+
+    function computeAttributes(vertexFormat, geometry, outerPositions, ellipsoid, stRotation, bottom, wall) {
+        if (vertexFormat.st || vertexFormat.normal || vertexFormat.tangent || vertexFormat.binormal) {
+            // PERFORMANCE_IDEA: Compute before subdivision, then just interpolate during subdivision.
+            // PERFORMANCE_IDEA: Compute with createGeometryFromPositions() for fast path when there's no holes.
+            var cleanedPositions = PolygonPipeline.removeDuplicates(outerPositions);
+            var tangentPlane = EllipsoidTangentPlane.fromPoints(cleanedPositions, ellipsoid);
+            var boundingRectangle = computeBoundingRectangle(tangentPlane, outerPositions, stRotation, scratchBoundingRectangle);
+
+            var origin = appendTextureCoordinatesOrigin;
+            origin.x = boundingRectangle.x;
+            origin.y = boundingRectangle.y;
+
+            var flatPositions = geometry.attributes.position.values;
+            var length = flatPositions.length;
+
+            var textureCoordinates = vertexFormat.st ? new Float32Array(2 * (length / 3)) : undefined;
+            var normals = vertexFormat.normal ? new Float32Array(length) : undefined;
+            var tangents = vertexFormat.tangent ? new Float32Array(length) : undefined;
+            var binormals = vertexFormat.binormal ? new Float32Array(length) : undefined;
+
+            var textureCoordIndex = 0;
+            var attrIndex = 0;
+
+            var normal = scratchNormal;
+            var tangent = scratchTangent;
+            var binormal = scratchBinormal;
+            var recomputeNormal = true;
+
+            var rotation = Quaternion.fromAxisAngle(tangentPlane._plane.normal, stRotation, appendTextureCoordinatesQuaternion);
+            var textureMatrix = Matrix3.fromQuaternion(rotation, appendTextureCoordinatesMatrix3);
+
+            var bottomOffset = length / 2;
+            var bottomOffset2 = length / 3;
+
+            if (bottom) {
+                length /= 2;
+            }
+
+            for (var i = 0; i < length; i += 3) {
+                var position = Cartesian3.fromArray(flatPositions, i, appendTextureCoordinatesCartesian3);
+
+                if (vertexFormat.st) {
+                    var p = Matrix3.multiplyByVector(textureMatrix, position, scratchPosition);
+                    var st = tangentPlane.projectPointOntoPlane(p, appendTextureCoordinatesCartesian2);
+                    Cartesian2.subtract(st, origin, st);
+
+                    if (bottom){
+                        textureCoordinates[textureCoordIndex + bottomOffset2] = st.x / boundingRectangle.width;
+                        textureCoordinates[textureCoordIndex + 1 + bottomOffset2] = st.y / boundingRectangle.height;
+                    }
+
+                    textureCoordinates[textureCoordIndex] = st.x / boundingRectangle.width;
+                    textureCoordinates[textureCoordIndex + 1] = st.y / boundingRectangle.height;
+
+                    textureCoordIndex += 2;
+                }
+
+                if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.binormal) {
+                    var attrIndex1 = attrIndex + 1;
+                    var attrIndex2 = attrIndex + 2;
+
+                    if (wall) {
+                        if (i+3 < length) {
+                            p1 = Cartesian3.fromArray(flatPositions, i + 3, p1);
+
+                            if (recomputeNormal) {
+                                p2 = Cartesian3.fromArray(flatPositions, i + length, p2);
+                                p1.subtract(position, p1);
+                                p2.subtract(position, p2);
+                                normal = Cartesian3.cross(p2, p1, normal).normalize(normal);
+                                recomputeNormal = false;
+                            }
+
+                            if (p1.equalsEpsilon(position, CesiumMath.EPSILON10)) { // if we've reached a corner
+                                recomputeNormal = true;
+                            }
+                        }
+
+                        if (vertexFormat.tangent || vertexFormat.binormal) {
+                            binormal = ellipsoid.geodeticSurfaceNormal(position, binormal);
+                            if (vertexFormat.tangent) {
+                                tangent = Cartesian3.cross(binormal, normal, tangent).normalize(tangent);
+                            }
+                        }
+
+                    } else {
+                        normal = ellipsoid.geodeticSurfaceNormal(position, normal);
+                        if (vertexFormat.tangent || vertexFormat.binormal) {
+                            tangent = Cartesian3.cross(Cartesian3.UNIT_Z, normal, tangent);
+                            tangent = Matrix3.multiplyByVector(textureMatrix, tangent, tangent).normalize(tangent);
+                            if (vertexFormat.binormal) {
+                                binormal = Cartesian3.cross(normal, tangent, binormal).normalize(binormal);
+                            }
+                        }
+                    }
+
+                    if (vertexFormat.normal) {
+                        if (bottom && !wall) {
+                            normals[attrIndex + bottomOffset] = -normal.x;
+                            normals[attrIndex1 + bottomOffset] = -normal.y;
+                            normals[attrIndex2 + bottomOffset] = -normal.z;
+                        } else {
+                            normals[attrIndex + bottomOffset] = normal.x;
+                            normals[attrIndex1 + bottomOffset] = normal.y;
+                            normals[attrIndex2 + bottomOffset] = normal.z;
+                        }
+
+                        normals[attrIndex] = normal.x;
+                        normals[attrIndex1] = normal.y;
+                        normals[attrIndex2] = normal.z;
+                    }
+
+                    if (vertexFormat.tangent) {
+                        if (bottom && !wall) {
+                            tangents[attrIndex + bottomOffset] = -tangent.x;
+                            tangents[attrIndex1 + bottomOffset] = -tangent.y;
+                            tangents[attrIndex2 + bottomOffset] = -tangent.z;
+                        } else {
+                            tangents[attrIndex + bottomOffset] = tangent.x;
+                            tangents[attrIndex1 + bottomOffset] = tangent.y;
+                            tangents[attrIndex2 + bottomOffset] = tangent.z;
+                        }
+
+                        tangents[attrIndex] = tangent.x;
+                        tangents[attrIndex1] = tangent.y;
+                        tangents[attrIndex2] = tangent.z;
+                    }
+
+                    if (vertexFormat.binormal) {
+                        if (bottom) {
+                            binormals[attrIndex + bottomOffset] = binormal.x;
+                            binormals[attrIndex1 + bottomOffset] = binormal.y;
+                            binormals[attrIndex2 + bottomOffset] = binormal.z;
+                        }
+
+                        binormals[attrIndex] = binormal.x;
+                        binormals[attrIndex1] = binormal.y;
+                        binormals[attrIndex2] = binormal.z;
+                    }
+                    attrIndex += 3;
+                }
+            }
+
+            if (vertexFormat.st) {
+                geometry.attributes.st = new GeometryAttribute({
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 2,
+                    values : textureCoordinates
+                });
+            }
+
+            if (vertexFormat.normal) {
+                geometry.attributes.normal = new GeometryAttribute({
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 3,
+                    values : normals
+                });
+            }
+
+            if (vertexFormat.tangent) {
+                geometry.attributes.tangent = new GeometryAttribute({
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 3,
+                    values : tangents
+                });
+            }
+
+            if (vertexFormat.binormal) {
+                geometry.attributes.binormal = new GeometryAttribute({
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 3,
+                    values : binormals
+                });
+            }
+        }
+        return geometry;
+    }
+
+    var scaleToGeodeticHeightN1 = new Cartesian3();
+    var scaleToGeodeticHeightN2 = new Cartesian3();
+    var scaleToGeodeticHeightP = new Cartesian3();
+    function scaleToGeodeticHeightExtruded(geometry, maxHeight, minHeight, ellipsoid) {
+        ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
+
+        var n1 = scaleToGeodeticHeightN1;
+        var n2 = scaleToGeodeticHeightN2;
+        var p = scaleToGeodeticHeightP;
+
+        if (typeof geometry !== 'undefined' && typeof geometry.attributes !== 'undefined' && typeof geometry.attributes.position !== 'undefined') {
+            var positions = geometry.attributes.position.values;
+            var length = positions.length / 2;
+
+            for ( var i = 0; i < length; i += 3) {
+                Cartesian3.fromArray(positions, i, p);
+
+                ellipsoid.scaleToGeodeticSurface(p, p);
+                ellipsoid.geodeticSurfaceNormal(p, n1);
+
+                Cartesian3.multiplyByScalar(n1, maxHeight, n2);
+                Cartesian3.add(p, n2, n2);
+                positions[i] = n2.x;
+                positions[i + 1] = n2.y;
+                positions[i + 2] = n2.z;
+
+                Cartesian3.multiplyByScalar(n1, minHeight, n2);
+                Cartesian3.add(p, n2, n2);
+                positions[i + length] = n2.x;
+                positions[i + 1 + length] = n2.y;
+                positions[i + 2 + length] = n2.z;
+            }
+        }
+        return geometry;
+    }
+
+    var distanceScratch = new Cartesian3();
+    function getPointAtDistance(p0, p1, distance, length) {
+        distanceScratch = p1.subtract(p0, distanceScratch);
+        distanceScratch = distanceScratch.multiplyByScalar(distance/length, distanceScratch);
+        distanceScratch = p0.add(distanceScratch, distanceScratch);
+        return [distanceScratch.x, distanceScratch.y, distanceScratch.z];
+    }
+
+    function subdivideLine(p0, p1, granularity) {
+        var length = Cartesian3.distance(p0, p1);
+        var angleBetween = Cartesian3.angleBetween(p0, p1);
+        var n = angleBetween/granularity;
+        var countDivide = Math.ceil(Math.log(n)/Math.log(2));
+        if (countDivide < 1) {
+            countDivide = 0;
+        }
+        var numVertices = Math.pow(2, countDivide);
+
+        var distanceBetweenVertices = length / numVertices;
+
+        var positions = new Array(numVertices * 3);
+        var index = 0;
+        positions[index++] = p0.x;
+        positions[index++] = p0.y;
+        positions[index++] = p0.z;
+        for (var i = 1; i < numVertices; i++) {
+            var p = getPointAtDistance(p0, p1, i*distanceBetweenVertices, length);
+            positions[index++] = p[0];
+            positions[index++] = p[1];
+            positions[index++] = p[2];
+        }
+        positions[index++] = p1.x;
+        positions[index++] = p1.y;
+        positions[index++] = p1.z;
+
+        return positions;
+    }
+
+    function computeWallIndices(positions, granularity){
+        var edgePositions = [];
+        var subdividedEdge;
+        var edgeIndex;
+        var UL, UR, LL, LR;
+        var i;
+
+        var length = positions.length;
+        for (i = 0; i < length; i++) {
+            subdividedEdge = subdivideLine(positions[i], positions[(i+1)%length], granularity);
+            edgePositions = edgePositions.concat(subdividedEdge);
+        }
+
+        edgePositions = edgePositions.concat(edgePositions);
+        length = edgePositions.length;
+        var indices = IndexDatatype.createTypedArray(length/3, length - positions.length*6);
+        edgeIndex = 0;
+        length /= 6;
+
+        for (i = 0 ; i < length; i++) {
+            UL = i;
+            UR = UL + 1;
+            p1 = Cartesian3.fromArray(edgePositions, UL*3, p1);
+            p2 = Cartesian3.fromArray(edgePositions, UR*3, p2);
+            if (Cartesian3.equalsEpsilon(p1, p2, CesiumMath.EPSILON6)) {
+                continue;
+            }
+            LL = UL + length;
+            LR = LL + 1;
+            indices[edgeIndex++] = UL;
+            indices[edgeIndex++] = LL;
+            indices[edgeIndex++] = UR;
+            indices[edgeIndex++] = UR;
+            indices[edgeIndex++] = LL;
+            indices[edgeIndex++] = LR;
+        }
+
+        return new Geometry({
+            attributes : new GeometryAttributes({
+                position : new GeometryAttribute({
+                    componentDatatype : ComponentDatatype.DOUBLE,
+                    componentsPerAttribute : 3,
+                    values : edgePositions
+                })
+            }),
+            indices : indices,
+            primitiveType : PrimitiveType.TRIANGLES
+        });
+    }
+
+    function createGeometryFromPositionsExtruded(ellipsoid, positions, granularity, hierarchy) {
+        var topGeo = createGeometryFromPositions(ellipsoid, positions, granularity).geometry;
+        var edgePoints = topGeo.attributes.position.values;
+        var indices = topGeo.indices;
+        var topBottomPositions = edgePoints.concat(edgePoints);
+        var numPositions = topBottomPositions.length/3;
+        var newIndices = IndexDatatype.createTypedArray(numPositions, indices.length*2);
+        newIndices.set(indices);
+        var ilength = indices.length;
+        var i;
+        var length = numPositions / 2;
+        for (i = 0 ; i < ilength; i += 3) {
+            var i0 = newIndices[i] + length;
+            var i1 = newIndices[i + 1] + length;
+            var i2 = newIndices[i + 2] + length;
+
+            newIndices[i + ilength] = i2;
+            newIndices[i + 1 + ilength] = i1;
+            newIndices[i + 2 + ilength] = i0;
+        }
+        var topAndBottomGeo = new Geometry({
+            attributes: new GeometryAttributes({
+                position: new GeometryAttribute({
+                    componentDatatype : ComponentDatatype.DOUBLE,
+                    componentsPerAttribute : 3,
+                    values : topBottomPositions
+                })
+            }),
+            indices: newIndices,
+            primitiveType: topGeo.primitiveType
+        });
+
+        var geos = {
+                topAndBottom: new GeometryInstance({
+                    geometry : topAndBottomGeo
+                })
+        };
+
+        geos.walls = [];
+        var outerRing = hierarchy.outerRing;
+        var windingOrder = PolygonPipeline.computeWindingOrder2D(outerRing);
+        if (windingOrder === WindingOrder.CLOCKWISE) {
+            outerRing = outerRing.reverse();
+        }
+        var wallGeo = computeWallIndices(outerRing, granularity);
+        geos.walls.push(new GeometryInstance({
+            geometry: wallGeo
+        }));
+
+        var holes = hierarchy.holes;
+        for (i = 0; i < holes.length; i++) {
+            var hole = holes[i];
+            windingOrder = PolygonPipeline.computeWindingOrder2D(hole);
+            if (windingOrder !== WindingOrder.CLOCKWISE) {
+                hole = hole.reverse();
+            }
+            wallGeo = computeWallIndices(hole, granularity);
+            geos.walls.push(new GeometryInstance({
+                geometry: wallGeo
+            }));
+        }
+
+        return geos;
+    }
+
+    /**
+     * A {@link Geometry} that represents vertices and indices for a polygon on the ellipsoid. The polygon is either defined
+     * by an array of Cartesian points, or a polygon hierarchy.
+     *
+     * @alias PolygonGeometry
+     * @constructor
+     *
+     * @param {Object} options.polygonHierarchy A polygon hierarchy that can include holes.
+     * @param {Number} [options.height=0.0] The height of the polygon.
+     * @param {Number} [options.extrudedHeight] The height of the polygon.
+     * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
+     * @param {Number} [options.stRotation=0.0] The rotation of the texture coordinates, in radians. A positive rotation is counter-clockwise.
+     * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
+     * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
+     *
+     * @exception {DeveloperError} polygonHierarchy is required.
+     * @exception {DeveloperError} At least three positions are required.
+     * @exception {DeveloperError} Duplicate positions result in not enough positions to form a polygon.
+     *
+     * @example
+     * // create a polygon from points
+     * var geometry = new PolygonGeometry({
+     *     polygonHierarchy : {
+     *         positions : ellipsoid.cartographicArrayToCartesianArray([
+     *             Cartographic.fromDegrees(-72.0, 40.0),
+     *             Cartographic.fromDegrees(-70.0, 35.0),
+     *             Cartographic.fromDegrees(-75.0, 30.0),
+     *             Cartographic.fromDegrees(-70.0, 30.0),
+     *             Cartographic.fromDegrees(-68.0, 40.0)
+     *         ])
+     *     }
+     * });
+     *
+     * // create a nested polygon with holes
+     * var geometryWithHole = new PolygonGeometry({
+     *     polygonHierarchy : {
+     *         positions : ellipsoid.cartographicArrayToCartesianArray([
+     *             Cartographic.fromDegrees(-109.0, 30.0),
+     *             Cartographic.fromDegrees(-95.0, 30.0),
+     *             Cartographic.fromDegrees(-95.0, 40.0),
+     *             Cartographic.fromDegrees(-109.0, 40.0)
+     *         ]),
+     *         holes : [{
+     *             positions : ellipsoid.cartographicArrayToCartesianArray([
+     *                 Cartographic.fromDegrees(-107.0, 31.0),
+     *                 Cartographic.fromDegrees(-107.0, 39.0),
+     *                 Cartographic.fromDegrees(-97.0, 39.0),
+     *                 Cartographic.fromDegrees(-97.0, 31.0)
+     *             ]),
+     *             holes : [{
+     *                 positions : ellipsoid.cartographicArrayToCartesianArray([
+     *                     Cartographic.fromDegrees(-105.0, 33.0),
+     *                     Cartographic.fromDegrees(-99.0, 33.0),
+     *                     Cartographic.fromDegrees(-99.0, 37.0),
+     *                     Cartographic.fromDegrees(-105.0, 37.0)
+     *                     ]),
+     *                 holes : [{
+     *                     positions : ellipsoid.cartographicArrayToCartesianArray([
+     *                         Cartographic.fromDegrees(-103.0, 34.0),
+     *                         Cartographic.fromDegrees(-101.0, 34.0),
+     *                         Cartographic.fromDegrees(-101.0, 36.0),
+     *                         Cartographic.fromDegrees(-103.0, 36.0)
+     *                     ])
+     *                 }]
+     *              }]
+     *         }]
+     *     }
+     * });
+     *
+     * //create extruded polygon
+     * var geometry = new Cesium.PolygonGeometry({
+     *     positions : ellipsoid.cartographicArrayToCartesianArray([
+     *         Cesium.Cartographic.fromDegrees(-72.0, 40.0),
+     *         Cesium.Cartographic.fromDegrees(-70.0, 35.0),
+     *         Cesium.Cartographic.fromDegrees(-75.0, 30.0),
+     *         Cesium.Cartographic.fromDegrees(-70.0, 30.0),
+     *         Cesium.Cartographic.fromDegrees(-68.0, 40.0)
+     *     ]),
+     *     extrudedHeight: 300000
+     * });
+     *
+     */
+    var PolygonGeometry = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+        var vertexFormat = defaultValue(options.vertexFormat, VertexFormat.DEFAULT);
+        var ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
+        var granularity = defaultValue(options.granularity, CesiumMath.RADIANS_PER_DEGREE);
+        var stRotation = defaultValue(options.stRotation, 0.0);
+        var height = defaultValue(options.height, 0.0);
+
+        var extrudedHeight = defaultValue(options.extrudedHeight, undefined);
+        var extrude = (typeof extrudedHeight !== 'undefined' && !CesiumMath.equalsEpsilon(height, extrudedHeight, CesiumMath.EPSILON6));
+        if (extrude) {
+            var h = extrudedHeight;
+            extrudedHeight = Math.min(h, height);
+            height = Math.max(h, height);
+        }
+
+        var polygonHierarchy = options.polygonHierarchy;
+        if (typeof polygonHierarchy === 'undefined') {
+            throw new DeveloperError('options.polygonHierarchy is required.');
+        }
+
+        var boundingSphere;
+        var walls;
+        var topAndBottom;
+        var outerPositions;
+
+        // create from a polygon hierarchy
+        // Algorithm adapted from http://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf
+        var polygons = [];
+        var queue = new Queue();
+        queue.enqueue(polygonHierarchy);
+        polygonHierarchy = [];
+        var i;
+        while (queue.length !== 0) {
+            var outerNode = queue.dequeue();
+            var outerRing = outerNode.positions;
+
+            if (outerRing.length < 3) {
+                throw new DeveloperError('At least three positions are required.');
+            }
+
+            var numChildren = outerNode.holes ? outerNode.holes.length : 0;
+            if (numChildren === 0) {
+                // The outer polygon is a simple polygon with no nested inner polygon.
+                polygonHierarchy.push({
+                    outerRing: outerRing,
+                    holes: []
+                });
+                polygons.push(outerNode.positions);
+            } else {
+                // The outer polygon contains inner polygons
+                var holes = [];
+                for (i = 0; i < numChildren; i++) {
+                    var hole = outerNode.holes[i];
+                    holes.push(hole.positions);
+
+                    var numGrandchildren = 0;
+                    if (typeof hole.holes !== 'undefined') {
+                        numGrandchildren = hole.holes.length;
+                    }
+
+                    for (var j = 0; j < numGrandchildren; j++) {
+                        queue.enqueue(hole.holes[j]);
+                    }
+                }
+                polygonHierarchy.push({
+                    outerRing: outerRing,
+                    holes: holes
+                });
+                var combinedPolygon = PolygonPipeline.eliminateHoles(outerRing, holes);
+                polygons.push(combinedPolygon);
+            }
+        }
+
+        outerPositions =  polygons[0];
+        // The bounding volume is just around the boundary points, so there could be cases for
+        // contrived polygons on contrived ellipsoids - very oblate ones - where the bounding
+        // volume doesn't cover the polygon.
+        boundingSphere = BoundingSphere.fromPoints(outerPositions);
+
+        var geometry;
+        var geometries = [];
+
+        if (extrude) {
+            for (i = 0; i < polygons.length; i++) {
+                geometry = createGeometryFromPositionsExtruded(ellipsoid, polygons[i], granularity, polygonHierarchy[i]);
+                if (typeof geometry !== 'undefined') {
+                    topAndBottom = geometry.topAndBottom;
+                    topAndBottom.geometry = scaleToGeodeticHeightExtruded(topAndBottom.geometry, height, extrudedHeight, ellipsoid);
+                    topAndBottom.geometry = computeAttributes(vertexFormat, topAndBottom.geometry, outerPositions, ellipsoid, stRotation, true, false);
+                    geometries.push(topAndBottom);
+
+                    walls = geometry.walls;
+                    for (var k = 0; k < walls.length; k++) {
+                        var wall = walls[k];
+                        wall.geometry = scaleToGeodeticHeightExtruded(wall.geometry, height, extrudedHeight, ellipsoid);
+                        wall.geometry = computeAttributes(vertexFormat, wall.geometry, outerPositions, ellipsoid, stRotation, true, true);
+                        geometries.push(wall);
+                    }
+                }
+            }
+        } else {
+            for (i = 0; i < polygons.length; i++) {
+                geometry = createGeometryFromPositions(ellipsoid, polygons[i], granularity);
+                if (typeof geometry !== 'undefined') {
+                    geometry.geometry = PolygonPipeline.scaleToGeodeticHeight(geometry.geometry, height, ellipsoid);
+                    geometry.geometry = computeAttributes(vertexFormat, geometry.geometry, outerPositions, ellipsoid, stRotation, false, false);
+                    geometries.push(geometry);
+                }
+            }
+        }
+
+
+        geometry = GeometryPipeline.combine(geometries);
+
+        var center = boundingSphere.center;
+        scratchNormal = ellipsoid.geodeticSurfaceNormal(center, scratchNormal);
+        scratchPosition = Cartesian3.multiplyByScalar(scratchNormal, height, scratchPosition);
+        center = Cartesian3.add(center, scratchPosition, center);
+
+        if (extrude) {
+            scratchBoundingSphere = boundingSphere.clone(scratchBoundingSphere);
+            center = scratchBoundingSphere.center;
+            scratchPosition = Cartesian3.multiplyByScalar(scratchNormal, extrudedHeight, scratchPosition);
+            center = Cartesian3.add(center, scratchPosition, center);
+            boundingSphere = BoundingSphere.union(boundingSphere, scratchBoundingSphere, boundingSphere);
+        }
+
+        geometry.attributes.position.values = new Float64Array(geometry.attributes.position.values);
+        geometry.indices = IndexDatatype.createTypedArray(geometry.attributes.position.values.length / 3, geometry.indices);
+
+        var attributes = geometry.attributes;
+
+        if (!vertexFormat.position) {
+            delete attributes.position;
+        }
+
+        /**
+         * An object containing {@link GeometryAttribute} properties named after each of the
+         * <code>true</code> values of the {@link VertexFormat} option.
+         *
+         * @type GeometryAttributes
+         *
+         * @see Geometry#attributes
+         */
+        this.attributes = attributes;
+
+        /**
+         * Index data that, along with {@link Geometry#primitiveType}, determines the primitives in the geometry.
+         *
+         * @type Array
+         */
+        this.indices = geometry.indices;
+
+        /**
+         * The type of primitives in the geometry.  For this geometry, it is {@link PrimitiveType.TRIANGLES}.
+         *
+         * @type PrimitiveType
+         */
+        this.primitiveType = geometry.primitiveType;
+
+        /**
+         * A tight-fitting bounding sphere that encloses the vertices of the geometry.
+         *
+         * @type BoundingSphere
+         */
+        this.boundingSphere = boundingSphere;
+    };
+
+    /**
+     * Creates a polygon from an array of positions.
+     *
+     * @memberof PolygonGeometry
+     *
+     * @param {Array} options.positions An array of positions that defined the corner points of the polygon.
+     * @param {Number} [options.height=0.0] The height of the polygon.
+     * @param {Number} [options.extrudedHeight] The height of the polygon extrusion.
+     * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
+     * @param {Number} [options.stRotation=0.0] The rotation of the texture coordiantes, in radians. A positive rotation is counter-clockwise.
+     * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
+     * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
+     *
+     * @exception {DeveloperError} options.positions is required.
+     * @exception {DeveloperError} At least three positions are required.
+     * @exception {DeveloperError} Duplicate positions result in not enough positions to form a polygon.
+     *
+     * @example
+     * // create a polygon from points
+     * var geometry = new PolygonGeometry({
+     *     positions : ellipsoid.cartographicArrayToCartesianArray([
+     *         Cartographic.fromDegrees(-72.0, 40.0),
+     *         Cartographic.fromDegrees(-70.0, 35.0),
+     *         Cartographic.fromDegrees(-75.0, 30.0),
+     *         Cartographic.fromDegrees(-70.0, 30.0),
+     *         Cartographic.fromDegrees(-68.0, 40.0)
+     *     ])
+     * });
+     */
+    PolygonGeometry.fromPositions = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+        if (typeof options.positions === 'undefined') {
+            throw new DeveloperError('options.positions is required.');
+        }
+
+        var newOptions = {
+            polygonHierarchy : {
+                positions : options.positions
+            },
+            height : options.height,
+            extrudedHeight : options.extrudedHeight,
+            vertexFormat : options.vertexFormat,
+            stRotation : options.stRotation,
+            ellipsoid : options.ellipsoid,
+            granularity : options.granularity
+        };
+        return new PolygonGeometry(newOptions);
+    };
+
+    return PolygonGeometry;
+});