cesium 0.19.0 → 0.20.0

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Math', 'Core/Ellipsoid', 'Core/ComponentDatatype', 'Core/IndexDatatype', 'Core/PrimitiveType', 'Core/BoundingSphere', 'Core/GeometryAttribute', 'Core/GeometryAttributes', 'Core/VertexFormat'], function(
+define(['Core/defaultValue', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Math', 'Core/Ellipsoid', 'Core/ComponentDatatype', 'Core/IndexDatatype', 'Core/PrimitiveType', 'Core/BoundingSphere', 'Core/Geometry', 'Core/GeometryAttribute', 'Core/GeometryAttributes', 'Core/VertexFormat'], function(
         defaultValue,
         DeveloperError,
         Cartesian3,
@@ -9,265 +9,190 @@ define(['Core/defaultValue', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Mat
         IndexDatatype,
         PrimitiveType,
         BoundingSphere,
+        Geometry,
         GeometryAttribute,
         GeometryAttributes,
         VertexFormat) {
     "use strict";
 
-    var scratchDirection = new Cartesian3();
-
-    function addEdgePositions(i0, i1, numberOfPartitions, positions) {
-        var indices = new Array(2 + numberOfPartitions - 1);
-        indices[0] = i0;
-
-        var origin = positions[i0];
-        var direction = Cartesian3.subtract(positions[i1], positions[i0], scratchDirection);
-
-        for ( var i = 1; i < numberOfPartitions; ++i) {
-            var delta = i / numberOfPartitions;
-            var position = Cartesian3.multiplyByScalar(direction, delta);
-            Cartesian3.add(origin, position, position);
-
-            indices[i] = positions.length;
-            positions.push(position);
-        }
-
-        indices[2 + (numberOfPartitions - 1) - 1] = i1;
-
-        return indices;
-    }
-
-    var scratchX = new Cartesian3();
-    var scratchY = new Cartesian3();
-    var scratchOffsetX = new Cartesian3();
-    var scratchOffsetY = new Cartesian3();
-
-    function addFaceTriangles(leftBottomToTop, bottomLeftToRight, rightBottomToTop, topLeftToRight, numberOfPartitions, positions, indices) {
-        var origin = positions[bottomLeftToRight[0]];
-        var x = Cartesian3.subtract(positions[bottomLeftToRight[bottomLeftToRight.length - 1]], origin, scratchX);
-        var y = Cartesian3.subtract(positions[topLeftToRight[0]], origin, scratchY);
-
-        var bottomIndicesBuffer = [];
-        var topIndicesBuffer = [];
-
-        var bottomIndices = bottomLeftToRight;
-        var topIndices = topIndicesBuffer;
-
-        for ( var j = 1; j <= numberOfPartitions; ++j) {
-            if (j !== numberOfPartitions) {
-                if (j !== 1) {
-                    //
-                    // This copy could be avoided by ping ponging buffers.
-                    //
-                    bottomIndicesBuffer = topIndicesBuffer.slice(0);
-                    bottomIndices = bottomIndicesBuffer;
-                }
-
-                topIndicesBuffer[0] = leftBottomToTop[j];
-                topIndicesBuffer[numberOfPartitions] = rightBottomToTop[j];
-
-                var deltaY = j / numberOfPartitions;
-                var offsetY = Cartesian3.multiplyByScalar(y, deltaY, scratchOffsetY);
-
-                for ( var i = 1; i < numberOfPartitions; ++i) {
-                    var deltaX = i / numberOfPartitions;
-                    var offsetX = Cartesian3.multiplyByScalar(x, deltaX, scratchOffsetX);
-                    var position = Cartesian3.add(origin, offsetX);
-                    Cartesian3.add(position, offsetY, position);
-
-                    topIndicesBuffer[i] = positions.length;
-                    positions.push(position);
-                }
-            } else {
-                if (j !== 1) {
-                    bottomIndices = topIndicesBuffer;
-                }
-                topIndices = topLeftToRight;
-            }
-
-            for ( var k = 0; k < numberOfPartitions; ++k) {
-                indices.push(bottomIndices[k]);
-                indices.push(bottomIndices[k + 1]);
-                indices.push(topIndices[k + 1]);
-
-                indices.push(bottomIndices[k]);
-                indices.push(topIndices[k + 1]);
-                indices.push(topIndices[k]);
-            }
-        }
-    }
-
-    var sphericalNormal = new Cartesian3();
-    var normal = new Cartesian3();
-    var tangent = new Cartesian3();
-    var binormal = new Cartesian3();
+    var scratchPosition = new Cartesian3();
+    var scratchNormal = new Cartesian3();
+    var scratchTangent = new Cartesian3();
+    var scratchBinormal = new Cartesian3();
     var defaultRadii = new Cartesian3(1.0, 1.0, 1.0);
 
+    var cos = Math.cos;
+    var sin = Math.sin;
+
     /**
-     * A {@link Geometry} that represents vertices and indices for an ellipsoid centered at the origin.
+     * A description of an ellipsoid centered at the origin.
      *
      * @alias EllipsoidGeometry
      * @constructor
      *
      * @param {Cartesian3} [options.radii=Cartesian3(1.0, 1.0, 1.0)] The radii of the ellipsoid in the x, y, and z directions.
-     * @param {Number} [options.numberOfPartitions=32] The number of times to partition the ellipsoid in a plane formed by two radii in a single quadrant.
+     * @param {Number} [options.stackPartitions=64] The number of times to partition the ellipsoid into stacks.
+     * @param {Number} [options.slicePartitions=64] The number of times to partition the ellipsoid into radial slices.
      * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
      *
-     * @exception {DeveloperError} options.numberOfPartitions must be greater than zero.
+     * @exception {DeveloperError} options.slicePartitions cannot be less than three.
+     * @exception {DeveloperError} options.stackPartitions cannot be less than three.
+     *
+     * @see EllipsoidGeometry#createGeometry
      *
      * @example
      * var ellipsoid = new EllipsoidGeometry({
      *   vertexFormat : VertexFormat.POSITION_ONLY,
      *   radii : new Cartesian3(1000000.0, 500000.0, 500000.0)
      * });
+     * var geometry = EllipsoidGeometry.createGeometry(ellipsoid);
      */
     var EllipsoidGeometry = function(options) {
         options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
         var radii = defaultValue(options.radii, defaultRadii);
-        var ellipsoid = Ellipsoid.fromCartesian3(radii);
-        var numberOfPartitions = defaultValue(options.numberOfPartitions, 32);
-
+        var stackPartitions = defaultValue(options.stackPartitions, 64);
+        var slicePartitions = defaultValue(options.slicePartitions, 64);
         var vertexFormat = defaultValue(options.vertexFormat, VertexFormat.DEFAULT);
 
-        if (numberOfPartitions <= 0) {
-            throw new DeveloperError('options.numberOfPartitions must be greater than zero.');
+        if (slicePartitions < 3) {
+            throw new DeveloperError ('options.slicePartitions cannot be less than three.');
         }
 
-        var positions = [];
-        var indices = [];
-
-        //
-        // Initial cube.  In the plane, z = -1:
-        //
-        //                   +y
-        //                    |
-        //             Q2     * p3     Q1
-        //                  / | \
-        //              p0 *--+--* p2   +x
-        //                  \ | /
-        //             Q3     * p1     Q4
-        //                    |
-        //
-        // Similarly, p4 to p7 are in the plane z = 1.
-        //
-        positions.push(new Cartesian3(-1, 0, -1));
-        positions.push(new Cartesian3(0, -1, -1));
-        positions.push(new Cartesian3(1, 0, -1));
-        positions.push(new Cartesian3(0, 1, -1));
-        positions.push(new Cartesian3(-1, 0, 1));
-        positions.push(new Cartesian3(0, -1, 1));
-        positions.push(new Cartesian3(1, 0, 1));
-        positions.push(new Cartesian3(0, 1, 1));
-
-        //
-        // Edges
-        //
-        // 0 -> 1, 1 -> 2, 2 -> 3, 3 -> 0.  Plane z = -1
-        // 4 -> 5, 5 -> 6, 6 -> 7, 7 -> 4.  Plane z = 1
-        // 0 -> 4, 1 -> 5, 2 -> 6, 3 -> 7.  From plane z = -1 to plane z - 1
-        //
-        var edge0to1 = addEdgePositions(0, 1, numberOfPartitions, positions);
-        var edge1to2 = addEdgePositions(1, 2, numberOfPartitions, positions);
-        var edge2to3 = addEdgePositions(2, 3, numberOfPartitions, positions);
-        var edge3to0 = addEdgePositions(3, 0, numberOfPartitions, positions);
-
-        var edge4to5 = addEdgePositions(4, 5, numberOfPartitions, positions);
-        var edge5to6 = addEdgePositions(5, 6, numberOfPartitions, positions);
-        var edge6to7 = addEdgePositions(6, 7, numberOfPartitions, positions);
-        var edge7to4 = addEdgePositions(7, 4, numberOfPartitions, positions);
-
-        var edge0to4 = addEdgePositions(0, 4, numberOfPartitions, positions);
-        var edge1to5 = addEdgePositions(1, 5, numberOfPartitions, positions);
-        var edge2to6 = addEdgePositions(2, 6, numberOfPartitions, positions);
-        var edge3to7 = addEdgePositions(3, 7, numberOfPartitions, positions);
-
-        // Q3 Face
-        addFaceTriangles(edge0to4, edge0to1, edge1to5, edge4to5, numberOfPartitions, positions, indices);
-        // Q4 Face
-        addFaceTriangles(edge1to5, edge1to2, edge2to6, edge5to6, numberOfPartitions, positions, indices);
-        // Q1 Face
-        addFaceTriangles(edge2to6, edge2to3, edge3to7, edge6to7, numberOfPartitions, positions, indices);
-        // Q2 Face
-        addFaceTriangles(edge3to7, edge3to0, edge0to4, edge7to4, numberOfPartitions, positions, indices);
-        // Plane z = 1
-        addFaceTriangles(edge7to4.slice(0).reverse(), edge4to5, edge5to6, edge6to7.slice(0).reverse(), numberOfPartitions, positions, indices);
-        // Plane z = -1
-        addFaceTriangles(edge1to2, edge0to1.slice(0).reverse(), edge3to0.slice(0).reverse(), edge2to3, numberOfPartitions, positions, indices);
+        if (stackPartitions < 3) {
+            throw new DeveloperError('options.stackPartitions cannot be less than three.');
+        }
 
-        var attributes = new GeometryAttributes();
+        this._radii = Cartesian3.clone(radii);
+        this._stackPartitions = stackPartitions;
+        this._slicePartitions = slicePartitions;
+        this._vertexFormat = vertexFormat;
+        this._workerName = 'createEllipsoidGeometry';
+    };
+
+    /**
+     * Computes the geometric representation of an ellipsoid, including its vertices, indices, and a bounding sphere.
+     * @memberof EllipsoidGeometry
+     *
+     * @param {EllipsoidGeometry} ellipsoidGeometry A description of the ellipsoid.
+     * @returns {Geometry} The computed vertices and indices.
+     */
+    EllipsoidGeometry.createGeometry = function(ellipsoidGeometry) {
+        var radii = ellipsoidGeometry._radii;
+        var ellipsoid = Ellipsoid.fromCartesian3(radii);
+        var stackPartitions = ellipsoidGeometry._stackPartitions;
+        var slicePartitions = ellipsoidGeometry._slicePartitions;
+        var vertexFormat = ellipsoidGeometry._vertexFormat;
+
+        var vertexCount = 2 + (stackPartitions - 1) * slicePartitions;
+        var positions = new Float64Array(vertexCount * 3);
+
+        var numIndices = 6 * slicePartitions * (stackPartitions - 1);
+        var indices = IndexDatatype.createTypedArray(vertexCount, numIndices);
+
+        var normals = (vertexFormat.normal) ? new Float32Array(vertexCount * 3) : undefined;
+        var tangents = (vertexFormat.tangent) ? new Float32Array(vertexCount * 3) : undefined;
+        var binormals = (vertexFormat.binormal) ? new Float32Array(vertexCount * 3) : undefined;
+        var st = (vertexFormat.st) ? new Float32Array(vertexCount * 2) : undefined;
+
+        var cosTheta = new Array(slicePartitions);
+        var sinTheta = new Array(slicePartitions);
 
-        var length = positions.length;
         var i;
         var j;
+        for (i = 0; i < slicePartitions; i++) {
+            var theta = CesiumMath.TWO_PI * i / slicePartitions;
+            cosTheta[i] = cos(theta);
+            sinTheta[i] = sin(theta);
+        }
 
-        if (vertexFormat.position) {
-            // Expand cube into ellipsoid and flatten values
-            var flattenedPositions = new Float64Array(length * 3);
+        var index = 0;
+        positions[index++] = 0; // first point
+        positions[index++] = 0;
+        positions[index++] = radii.z;
 
-            for (i = j = 0; i < length; ++i) {
-                var item = positions[i];
-                Cartesian3.normalize(item, item);
-                Cartesian3.multiplyComponents(item, radii, item);
+        for (i = 1; i < stackPartitions; i++) {
+            var phi = Math.PI * i / stackPartitions;
+            var sinPhi = sin(phi);
 
-                flattenedPositions[j++] = item.x;
-                flattenedPositions[j++] = item.y;
-                flattenedPositions[j++] = item.z;
+            var xSinPhi = radii.x * sinPhi;
+            var ySinPhi = radii.y * sinPhi;
+            var zCosPhi = radii.z * cos(phi);
+
+            for (j = 0; j < slicePartitions; j++) {
+                positions[index++] = cosTheta[j] * xSinPhi;
+                positions[index++] = sinTheta[j] * ySinPhi;
+                positions[index++] = zCosPhi;
             }
+        }
+        positions[index++] = 0; // last point
+        positions[index++] = 0;
+        positions[index++] = -radii.z;
 
+        var attributes = new GeometryAttributes();
+
+        if (vertexFormat.position) {
             attributes.position = new GeometryAttribute({
                 componentDatatype : ComponentDatatype.DOUBLE,
                 componentsPerAttribute : 3,
-                values : flattenedPositions
+                values : positions
             });
         }
 
-        if (vertexFormat.st) {
-            var texCoords = new Float32Array(length * 2);
-            var oneOverRadii = ellipsoid.getOneOverRadii();
-
-            for (i = j = 0; i < length; ++i) {
-                Cartesian3.multiplyComponents(positions[i], oneOverRadii, sphericalNormal);
-                Cartesian3.normalize(sphericalNormal, sphericalNormal);
-
-                texCoords[j++] = Math.atan2(sphericalNormal.y, sphericalNormal.x) * CesiumMath.ONE_OVER_TWO_PI + 0.5;
-                texCoords[j++] = Math.asin(sphericalNormal.z) * CesiumMath.ONE_OVER_PI + 0.5;
-            }
-
-            attributes.st = new GeometryAttribute({
-                componentDatatype : ComponentDatatype.FLOAT,
-                componentsPerAttribute : 2,
-                values : texCoords
-            });
-        }
+        var stIndex = 0;
+        var normalIndex = 0;
+        var tangentIndex = 0;
+        var binormalIndex = 0;
 
-        if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.binormal) {
-            var normals = (vertexFormat.normal) ? new Float32Array(length * 3) : undefined;
-            var tangents = (vertexFormat.tangent) ? new Float32Array(length * 3) : undefined;
-            var binormals = (vertexFormat.binormal) ? new Float32Array(length * 3) : undefined;
+        if (vertexFormat.st || vertexFormat.normal || vertexFormat.tangent || vertexFormat.binormal) {
+            for( i = 0; i < vertexCount; i++) {
+                var position = Cartesian3.fromArray(positions, i * 3, scratchPosition);
+                var normal = ellipsoid.geodeticSurfaceNormal(position, scratchNormal);
 
-            for (i = j = 0; i < length; ++i, j += 3) {
-                ellipsoid.geodeticSurfaceNormal(positions[i], normal);
-                Cartesian3.cross(Cartesian3.UNIT_Z, normal, tangent).normalize(tangent);
-                Cartesian3.cross(normal, tangent, binormal).normalize(binormal);
+                if (vertexFormat.st) {
+                    st[stIndex++] = (Math.atan2(normal.y, normal.x) / CesiumMath.TWO_PI) + 0.5;
+                    st[stIndex++] = (Math.asin(normal.z) / Math.PI) + 0.5;
+                }
 
                 if (vertexFormat.normal) {
-                    normals[j] = normal.x;
-                    normals[j + 1] = normal.y;
-                    normals[j + 2] = normal.z;
+                    normals[normalIndex++] = normal.x;
+                    normals[normalIndex++] = normal.y;
+                    normals[normalIndex++] = normal.z;
                 }
 
-                if (vertexFormat.tangent) {
-                    tangents[j] = tangent.x;
-                    tangents[j + 1] = tangent.y;
-                    tangents[j + 2] = tangent.z;
+                if (vertexFormat.tangent || vertexFormat.binormal) {
+                    var tangent = scratchTangent;
+                    if (i === 0 || i === vertexCount - 1) {
+                        Cartesian3.cross(Cartesian3.UNIT_X, normal, tangent);
+                        Cartesian3.normalize(tangent, tangent);
+                    } else {
+                        Cartesian3.cross(Cartesian3.UNIT_Z, normal, tangent);
+                        Cartesian3.normalize(tangent, tangent);
+                    }
+
+                    if (vertexFormat.tangent) {
+                        tangents[tangentIndex++] = tangent.x;
+                        tangents[tangentIndex++] = tangent.y;
+                        tangents[tangentIndex++] = tangent.z;
+                    }
+
+                    if (vertexFormat.binormal) {
+                        var binormal = Cartesian3.cross(normal, tangent, scratchBinormal);
+                        Cartesian3.normalize(binormal, binormal);
+
+                        binormals[binormalIndex++] = binormal.x;
+                        binormals[binormalIndex++] = binormal.y;
+                        binormals[binormalIndex++] = binormal.z;
+                    }
                 }
+            }
 
-                if (vertexFormat.binormal) {
-                    binormals[j] = binormal.x;
-                    binormals[j + 1] = binormal.y;
-                    binormals[j + 2] = binormal.z;
-                }
+            if (vertexFormat.st) {
+                attributes.st = new GeometryAttribute({
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 2,
+                    values : st
+                });
             }
 
             if (vertexFormat.normal) {
@@ -295,36 +220,56 @@ define(['Core/defaultValue', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Mat
             }
         }
 
-        /**
-         * An object containing {@link GeometryAttribute} properties named after each of the
-         * <code>true</code> values of the {@link VertexFormat} option.
-         *
-         * @type Object
-         *
-         * @see Geometry#attributes
-         */
-        this.attributes = attributes;
-
-        /**
-         * Index data that, along with {@link Geometry#primitiveType}, determines the primitives in the geometry.
-         *
-         * @type Array
-         */
-        this.indices = IndexDatatype.createTypedArray(length, indices);
-
-        /**
-         * The type of primitives in the geometry.  For this geometry, it is {@link PrimitiveType.TRIANGLES}.
-         *
-         * @type PrimitiveType
-         */
-        this.primitiveType = PrimitiveType.TRIANGLES;
-
-        /**
-         * A tight-fitting bounding sphere that encloses the vertices of the geometry.
-         *
-         * @type BoundingSphere
-         */
-        this.boundingSphere = BoundingSphere.fromEllipsoid(ellipsoid);
+        index = 0;
+        for (i = 1; i < slicePartitions; i++) { //top row
+            indices[index++] = 0;
+            indices[index++] = i;
+            indices[index++] = i + 1;
+        }
+
+        indices[index++] = 0;
+        indices[index++] = slicePartitions;
+        indices[index++] = 1;
+
+        for (i = 0; i < stackPartitions - 2; i++) {
+            var topOffset = (i * slicePartitions) + 1;
+            var bottomOffset = ((i + 1) * slicePartitions) + 1;
+
+            for (j = 0; j < slicePartitions - 1; j++) {
+                indices[index++] = bottomOffset + j;
+                indices[index++] = bottomOffset + j + 1;
+                indices[index++] = topOffset + j + 1;
+
+                indices[index++] = bottomOffset + j;
+                indices[index++] = topOffset + j + 1;
+                indices[index++] = topOffset + j;
+            }
+
+            indices[index++] = bottomOffset + slicePartitions - 1;
+            indices[index++] = bottomOffset;
+            indices[index++] = topOffset;
+            indices[index++] = bottomOffset + slicePartitions - 1;
+            indices[index++] = topOffset;
+            indices[index++] = topOffset + slicePartitions - 1;
+        }
+
+        var lastPos = vertexCount - 1;
+        for (i = lastPos - 1; i > lastPos - slicePartitions; i--) {
+            indices[index++] = lastPos;
+            indices[index++] = i;
+            indices[index++] = i - 1;
+        }
+
+        indices[index++] = lastPos;
+        indices[index++] = lastPos - slicePartitions;
+        indices[index++] = lastPos - 1;
+
+        return new Geometry({
+            attributes : attributes,
+            indices : indices,
+            primitiveType : PrimitiveType.TRIANGLES,
+            boundingSphere : BoundingSphere.fromEllipsoid(ellipsoid)
+        });
     };
 
     return EllipsoidGeometry;