cesium 0.21 → 0.21.1

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

@@ -2048,196 +2048,6 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         return Matrix4.clone(this, result);
     };
 
-    /**
-     * Computes an Array from this Matrix4 instance.
-     * @memberof Matrix4
-     *
-     * @param {Array} [result] The Array onto which to store the result.
-     * @returns {Array} The modified Array parameter or a new Array instance if one was not provided.
-     */
-    Matrix4.prototype.toArray = function(result) {
-        return Matrix4.toArray(this, result);
-    };
-
-    /**
-     * Retrieves a copy of the matrix column at the provided index as a Cartesian4 instance.
-     * @memberof Matrix4
-     *
-     * @param {Number} index The zero-based index of the column to retrieve.
-     * @param {Cartesian4} [result] The object onto which to store the result.
-     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} index is required and must be 0, 1, 2, or 3.
-     *
-     * @see Cartesian4
-     */
-    Matrix4.prototype.getColumn = function(index, result) {
-        return Matrix4.getColumn(this, index, result);
-    };
-
-    /**
-     * Computes a new matrix that replaces the specified column in this matrix with the provided Cartesian4 instance.
-     * @memberof Matrix4
-     *
-     * @param {Number} index The zero-based index of the column to set.
-     * @param {Cartesian4} cartesian The Cartesian whose values will be assigned to the specified column.
-     *
-     * @exception {DeveloperError} cartesian is required.
-     * @exception {DeveloperError} index is required and must be 0, 1, 2, or 3.
-     *
-     * @see Cartesian4
-     */
-    Matrix4.prototype.setColumn = function(index, cartesian, result) {
-        return Matrix4.setColumn(this, index, cartesian, result);
-    };
-
-    /**
-     * Retrieves a copy of the matrix row at the provided index as a Cartesian4 instance.
-     * @memberof Matrix4
-     *
-     * @param {Number} index The zero-based index of the row to retrieve.
-     * @param {Cartesian4} [result] The object onto which to store the result.
-     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} index is required and must be 0, 1, 2, or 3.
-     *
-     * @see Cartesian4
-     */
-    Matrix4.prototype.getRow = function(index, result) {
-        return Matrix4.getRow(this, index, result);
-    };
-
-    /**
-     * Computes a new matrix that replaces the specified row in this matrix with the provided Cartesian4 instance.
-     * @memberof Matrix4
-     *
-     * @param {Number} index The zero-based index of the row to set.
-     * @param {Cartesian4} cartesian The Cartesian whose values will be assigned to the specified row.
-     *
-     * @exception {DeveloperError} cartesian is required.
-     * @exception {DeveloperError} index is required and must be 0, 1, 2, or 3.
-     *
-     * @see Cartesian4
-     */
-    Matrix4.prototype.setRow = function(index, cartesian, result) {
-        return Matrix4.setRow(this, index, cartesian, result);
-    };
-
-    /**
-     * Computes the product of this matrix and the provided matrix.
-     * @memberof Matrix4
-     *
-     * @param {Matrix4} right The right hand side matrix.
-     * @param {Matrix4} [result] The object onto which to store the result.
-     * @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} right is required.
-     */
-    Matrix4.prototype.multiply = function(right, result) {
-        return Matrix4.multiply(this, right, result);
-    };
-
-    /**
-     * Multiplies this matrix, assuming it is a transformation matrix (with a bottom row of
-     * <code>[0.0, 0.0, 0.0, 1.0]</code>), by an implicit translation matrix defined by a {@link Cartesian3}.
-     *
-     * @memberof Matrix4
-     *
-     * @param {Cartesian3} translation The translation on the right-hand side of the multiplication.
-     * @param {Matrix4} [result] The object onto which to store the result.
-     *
-     * @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} translation is required.
-     */
-    Matrix4.prototype.multiplyByTranslation = function(translation, result) {
-        return Matrix4.multiplyByTranslation(this, translation, result);
-    };
-
-    /**
-     * Multiplies this matrix, assuming it is a transformation matrix (with a bottom row of
-     * <code>[0.0, 0.0, 0.0, 1.0]</code>), by an implicit uniform scale matrix.
-     *
-     * @memberof Matrix4
-     *
-     * @param {Number} scale The scale on the right-hand side of the multiplication.
-     * @param {Matrix4} [result] The object onto which to store the result.
-     *
-     * @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} scale is required.
-     */
-    Matrix4.prototype.multiplyByUniformScale = function(scale, result) {
-        return Matrix4.multiplyByUniformScale(this, scale, result);
-    };
-
-    /**
-     * Computes the product of this matrix and a column vector.
-     * @memberof Matrix4
-     *
-     * @param {Cartesian4} cartesian The vector.
-     * @param {Cartesian4} [result] The object onto which to store the result.
-     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} cartesian is required.
-     */
-    Matrix4.prototype.multiplyByVector = function(cartesian, result) {
-        return Matrix4.multiplyByVector(this, cartesian, result);
-    };
-
-    /**
-     * Computes the product of a matrix and a {@link Cartesian3}.  This is equivalent to calling {@link Matrix4#multiplyByVector}
-     * with a {@link Cartesian4} with a <code>w</code> component of one.
-     * @memberof Matrix4
-     *
-     * @param {Cartesian3} cartesian The point.
-     * @param {Cartesian4} [result] The object onto which to store the result.
-     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} cartesian is required.
-     */
-    Matrix4.prototype.multiplyByPoint = function(cartesian, result) {
-        return Matrix4.multiplyByPoint(this, cartesian, result);
-    };
-
-    /**
-     * Computes the product of this matrix and a scalar.
-     * @memberof Matrix4
-     *
-     * @param {Number} scalar The number to multiply by.
-     * @param {Matrix4} [result] The object onto which to store the result.
-     * @returns {Matrix4} The modified result parameter or a new Cartesian4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} scalar is required and must be a number.
-     */
-    Matrix4.prototype.multiplyByScalar = function(scalar, result) {
-        return Matrix4.multiplyByScalar(this, scalar, result);
-    };
-    /**
-     * Computes a negated copy of this matrix.
-     * @memberof Matrix4
-     *
-     * @param {Matrix4} matrix The matrix to negate.
-     * @param {Matrix4} [result] The object onto which to store the result.
-     * @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
-     *
-     * @exception {DeveloperError} matrix is required.
-     */
-    Matrix4.prototype.negate = function(result) {
-        return Matrix4.negate(this, result);
-    };
-
-    /**
-     * Computes the transpose of this matrix.
-     * @memberof Matrix4
-     *
-     * @param {Matrix4} [result] The object onto which to store the result.
-     * @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
-     */
-    Matrix4.prototype.transpose = function(result) {
-        return Matrix4.transpose(this, result);
-    };
-
     /**
      * Compares this matrix to the provided matrix componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.
@@ -2280,64 +2090,5 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
                '(' + this[3] + ', ' + this[7] + ', ' + this[11] + ', ' + this[15] +')';
     };
 
-    /**
-     * Gets the translation portion of this matrix, assuming the matrix is a affine transformation matrix.
-     * @memberof Matrix4
-     *
-     * @param {Cartesian3} [result] The object onto which to store the result.
-     * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
-     *
-     * @see Cartesian3
-     */
-    Matrix4.prototype.getTranslation = function(result) {
-        return Matrix4.getTranslation(this, result);
-    };
-
-    /**
-     * Gets the upper left 3x3 rotation matrix of this matrix, assuming the matrix is a affine transformation matrix.
-     * @memberof Matrix4
-     *
-     * @param {Matrix3} [result] The object onto which to store the result.
-     * @returns {Matrix3} The modified result parameter or a new Cartesian3 instance if one was not provided.
-     *
-     * @see Matrix3
-     */
-    Matrix4.prototype.getRotation = function(result) {
-        return Matrix4.getRotation(this, result);
-    };
-
-    /**
-     * Computes the inverse of this matrix using Cramers Rule.
-     * If the determinant is zero, the matrix can not be inverted, and an exception is thrown.
-     * If the matrix is an affine transformation matrix, it is more efficient
-     * to invert it with {@link #inverseTransformation}.
-     * @memberof Matrix4
-     *
-     * @param {Matrix4} [result] The object onto which to store the result.
-     * @returns {Matrix4} The modified result parameter or a new Cartesian3 instance if one was not provided.
-     *
-     * @exception {RuntimeError} matrix is not invertible because its determinate is zero.
-     */
-    Matrix4.prototype.inverse = function(result) {
-        return Matrix4.inverse(this, result);
-    };
-
-    /**
-     * Computes the inverse of this matrix assuming it is
-     * an affine transformation matrix, where the upper left 3x3 elements
-     * are a rotation matrix, and the upper three elements in the fourth
-     * column are the translation.  The bottom row is assumed to be [0, 0, 0, 1].
-     * The matrix is not verified to be in the proper form.
-     * This method is faster than computing the inverse for a general 4x4
-     * matrix using {@link #inverse}.
-     * @memberof Matrix4
-     *
-     * @param {Matrix4} [result] The object onto which to store the result.
-     * @returns {Matrix4} The modified result parameter or a new Cartesian3 instance if one was not provided.
-     */
-    Matrix4.prototype.inverseTransformation = function(result) {
-        return Matrix4.inverseTransformation(this, result);
-    };
-
     return Matrix4;
 });

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

@@ -161,5 +161,18 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError'], function(
         return NearFarScalar.clone(this, result);
     };
 
+    /**
+     * Compares this instance to the provided NearFarScalar and returns <code>true</code> if they are equal,
+     * <code>false</code> otherwise.
+     * @memberof NearFarScalar
+     *
+     * @param {NearFarScalar} [right] The right hand side NearFarScalar.
+     *
+     * @returns {Boolean} <code>true</code> if left and right are equal; otherwise <code>false</code>.
+     */
+    NearFarScalar.prototype.equals = function(right) {
+        return NearFarScalar.equals(this, right);
+    };
+
     return NearFarScalar;
 });

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

@@ -690,7 +690,7 @@ define(['Core/defaultValue', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'C
         center = Cartesian3.add(center, scratchPosition, center);
 
         if (extrude) {
-            scratchBoundingSphere = boundingSphere.clone(scratchBoundingSphere);
+            scratchBoundingSphere = BoundingSphere.clone(boundingSphere, scratchBoundingSphere);
             center = scratchBoundingSphere.center;
             scratchPosition = Cartesian3.multiplyByScalar(scratchNormal, extrudedHeight, scratchPosition);
             center = Cartesian3.add(ellipsoid.scaleToGeodeticSurface(center, center), scratchPosition, center);

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

@@ -387,7 +387,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
         center = Cartesian3.add(center, scratchPosition, center);
 
         if (extrude) {
-            scratchBoundingSphere = boundingSphere.clone(scratchBoundingSphere);
+            scratchBoundingSphere = BoundingSphere.clone(boundingSphere, scratchBoundingSphere);
             center = scratchBoundingSphere.center;
             scratchPosition = Cartesian3.multiplyByScalar(scratchNormal, extrudedHeight, scratchPosition);
             center = Cartesian3.add(center, scratchPosition, center);
@@ -403,4 +403,4 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
     };
 
     return PolygonOutlineGeometry;
-});
+});

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

@@ -371,7 +371,7 @@ define(['Core/DeveloperError', 'Core/Math', 'Core/Cartesian2', 'Core/Cartesian3'
         var after = getNextVertex(a1i, pArray, AFTER);
 
         var s1 = Cartesian2.subtract(pArray[before].position, a1.position);
-        var s2 = Cartesian2.subtract(pArray[after].position,  a1.position);
+        var s2 = Cartesian2.subtract(pArray[after].position, a1.position);
         var cut = Cartesian2.subtract(a2.position, a1.position);
 
         // Convert to 3-dimensional so we can use cross product
@@ -499,7 +499,7 @@ define(['Core/DeveloperError', 'Core/Math', 'Core/Cartesian2', 'Core/Cartesian3'
         }
 
         var s1 = Cartesian2.subtract(pArray[before].position, pArray[index].position);
-        var s2 = Cartesian2.subtract(pArray[after].position,  pArray[index].position);
+        var s2 = Cartesian2.subtract(pArray[after].position, pArray[index].position);
 
         // Convert to 3-dimensional so we can use cross product
         s1 = new Cartesian3(s1.x, s1.y, 0.0);

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

@@ -33,16 +33,20 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartog
     var carto1 = new Cartographic();
     var carto2 = new Cartographic();
     var cartesian = new Cartesian3();
+    var scaleFirst = new Cartesian3();
+    var scaleLast = new Cartesian3();
     var ellipsoidGeodesic = new EllipsoidGeodesic();
     //Returns subdivided line scaled to ellipsoid surface starting at p1 and ending at p2.
     //Result includes p1, but not include p2.  This function is called for a sequence of line segments,
     //and this prevents duplication of end point.
     function generateCartesianArc(p1, p2, granularity, ellipsoid) {
-        var separationAngle = Cartesian3.angleBetween(p1, p2);
+        var first = ellipsoid.scaleToGeodeticSurface(p1, scaleFirst);
+        var last = ellipsoid.scaleToGeodeticSurface(p2, scaleLast);
+        var separationAngle = Cartesian3.angleBetween(first, last);
         var numPoints = Math.ceil(separationAngle/granularity);
         var result = new Array(numPoints*3);
-        var start = ellipsoid.cartesianToCartographic(p1, carto1);
-        var end = ellipsoid.cartesianToCartographic(p2, carto2);
+        var start = ellipsoid.cartesianToCartographic(first, carto1);
+        var end = ellipsoid.cartesianToCartographic(last, carto2);
 
         ellipsoidGeodesic.setEndPoints(start, end);
         var surfaceDistanceBetweenPoints = ellipsoidGeodesic.getSurfaceDistance() / (numPoints);

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

@@ -0,0 +1,239 @@
+/*global define*/
+define(['Core/defined', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/CornerType', 'Core/ComponentDatatype', 'Core/Ellipsoid', 'Core/Geometry', 'Core/GeometryPipeline', 'Core/IndexDatatype', 'Core/Math', 'Core/PolygonPipeline', 'Core/PolylineVolumeGeometryLibrary', 'Core/PrimitiveType', 'Core/defaultValue', 'Core/BoundingSphere', 'Core/BoundingRectangle', 'Core/GeometryAttribute', 'Core/GeometryAttributes', 'Core/VertexFormat', 'Core/WindingOrder'], function(
+        defined,
+        DeveloperError,
+        Cartesian3,
+        CornerType,
+        ComponentDatatype,
+        Ellipsoid,
+        Geometry,
+        GeometryPipeline,
+        IndexDatatype,
+        CesiumMath,
+        PolygonPipeline,
+        PolylineVolumeGeometryLibrary,
+        PrimitiveType,
+        defaultValue,
+        BoundingSphere,
+        BoundingRectangle,
+        GeometryAttribute,
+        GeometryAttributes,
+        VertexFormat,
+        WindingOrder) {
+    "use strict";
+
+    function computeAttributes(combinedPositions, shape, boundingRectangle, vertexFormat, ellipsoid) {
+        var attributes = new GeometryAttributes();
+        if (vertexFormat.position) {
+            attributes.position = new GeometryAttribute({
+                componentDatatype : ComponentDatatype.DOUBLE,
+                componentsPerAttribute : 3,
+                values : combinedPositions
+            });
+        }
+        var shapeLength = shape.length;
+        var vertexCount = combinedPositions.length / 3;
+        var length = (vertexCount - shapeLength * 2) / (shapeLength * 2);
+        var firstEndIndices = PolygonPipeline.triangulate(shape);
+
+        var indicesCount = (length - 1) * (shapeLength) * 6 + firstEndIndices.length * 2;
+        var indices = IndexDatatype.createTypedArray(vertexCount, indicesCount);
+        var i, j;
+        var ll, ul, ur, lr;
+        var offset = shapeLength * 2;
+        var index = 0;
+        for (i = 0; i < length - 1; i++) {
+            for (j = 0; j < shapeLength - 1; j++) {
+                ll = j * 2 + i * shapeLength * 2;
+                lr = ll + offset;
+                ul = ll + 1;
+                ur = ul + offset;
+
+                indices[index++] = ul;
+                indices[index++] = ll;
+                indices[index++] = ur;
+                indices[index++] = ur;
+                indices[index++] = ll;
+                indices[index++] = lr;
+            }
+            ll = shapeLength * 2 - 2 + i * shapeLength * 2;
+            ul = ll + 1;
+            ur = ul + offset;
+            lr = ll + offset;
+
+            indices[index++] = ul;
+            indices[index++] = ll;
+            indices[index++] = ur;
+            indices[index++] = ur;
+            indices[index++] = ll;
+            indices[index++] = lr;
+        }
+
+        if (vertexFormat.st || vertexFormat.tangent || vertexFormat.binormal) { // st required for tangent/binormal calculation
+            var st = new Float32Array(vertexCount * 2);
+            var lengthSt = 1 / (length - 1);
+            var heightSt = 1 / (boundingRectangle.height);
+            var heightOffset = boundingRectangle.height / 2;
+            var s, t;
+            var stindex = 0;
+            for (i = 0; i < length; i++) {
+                s = i * lengthSt;
+                t = heightSt * (shape[0].y + heightOffset);
+                st[stindex++] = s;
+                st[stindex++] = t;
+                for (j = 1; j < shapeLength; j++) {
+                    t = heightSt * (shape[j].y + heightOffset);
+                    st[stindex++] = s;
+                    st[stindex++] = t;
+                    st[stindex++] = s;
+                    st[stindex++] = t;
+                }
+                t = heightSt * (shape[0].y + heightOffset);
+                st[stindex++] = s;
+                st[stindex++] = t;
+            }
+            for (j = 0; j < shapeLength; j++) {
+                s = 0;
+                t = heightSt * (shape[j].y + heightOffset);
+                st[stindex++] = s;
+                st[stindex++] = t;
+            }
+            for (j = 0; j < shapeLength; j++) {
+                s = (length - 1) * lengthSt;
+                t = heightSt * (shape[j].y + heightOffset);
+                st[stindex++] = s;
+                st[stindex++] = t;
+            }
+
+            attributes.st = new GeometryAttribute({
+                componentDatatype : ComponentDatatype.FLOAT,
+                componentsPerAttribute : 2,
+                values : new Float32Array(st)
+            });
+        }
+
+        var endOffset = vertexCount - shapeLength * 2;
+        for (i = 0; i < firstEndIndices.length; i += 3) {
+            var v0 = firstEndIndices[i] + endOffset;
+            var v1 = firstEndIndices[i + 1] + endOffset;
+            var v2 = firstEndIndices[i + 2] + endOffset;
+
+            indices[index++] = v0;
+            indices[index++] = v1;
+            indices[index++] = v2;
+            indices[index++] = v2 + shapeLength;
+            indices[index++] = v1 + shapeLength;
+            indices[index++] = v0 + shapeLength;
+        }
+
+        var geometry = new Geometry({
+            attributes : attributes,
+            indices : indices,
+            boundingSphere : BoundingSphere.fromVertices(combinedPositions),
+            primitiveType : PrimitiveType.TRIANGLES
+        });
+
+        if (vertexFormat.normal) {
+            geometry = GeometryPipeline.computeNormal(geometry);
+        }
+
+        if (vertexFormat.tangent || vertexFormat.binormal) {
+            geometry = GeometryPipeline.computeBinormalAndTangent(geometry);
+            if (!vertexFormat.tangent) {
+                geometry.attributes.tangent = undefined;
+            }
+            if (!vertexFormat.binormal) {
+                geometry.attributes.binormal = undefined;
+            }
+            if (!vertexFormat.st) {
+                geometry.attributes.st = undefined;
+            }
+        }
+
+        return geometry;
+    }
+
+    /**
+     * A description of a polyline with a volume (a 2D shape extruded along a polyline).
+     *
+     * @alias PolylineVolumeGeometry
+     * @constructor
+     *
+     * @param {Array} options.polylinePositions An array of {@link Cartesain3} positions that define the center of the polyline volume.
+     * @param {Number} options.shapePositions An array of {@link Cartesian2} positions that define the shape to be extruded along the polyline
+     * @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.
+     * @param {Number} [options.height=0] The distance between the ellipsoid surface and the positions.
+     * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
+     * @param {Boolean} [options.cornerType = CornerType.ROUNDED] Determines the style of the corners.
+     *
+     * @exception {DeveloperError} options.polylinePositions is required.
+     * @exception {DeveloperError} options.shapePositions is required.
+     *
+     * @see PolylineVolumeGeometry#createGeometry
+     *
+     * @example
+     * var volume = new PolylineVolumeGeometry({
+     *     vertexFormat : VertexFormat.POSITION_ONLY,
+     *     polylinePositions : ellipsoid.cartographicArrayToCartesianArray([
+     *         Cartographic.fromDegrees(-72.0, 40.0),
+     *         Cartographic.fromDegrees(-70.0, 35.0)
+     *     ]),
+     *     shapePositions : Shapes.compute2DCircle(100000.0)
+     * });
+     */
+    var PolylineVolumeGeometry = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+        var positions = options.polylinePositions;
+        if (!defined(positions)) {
+            throw new DeveloperError('options.polylinePositions is required.');
+        }
+        var shape = options.shapePositions;
+        if (!defined(shape)) {
+            throw new DeveloperError('options.shapePositions is required.');
+        }
+
+        this._positions = positions;
+        this._shape = shape;
+        this._ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
+        this._height = defaultValue(options.height, 0.0);
+        this._cornerType = defaultValue(options.cornerType, CornerType.ROUNDED);
+        this._vertexFormat = defaultValue(options.vertexFormat, VertexFormat.DEFAULT);
+        this._granularity = defaultValue(options.granularity, CesiumMath.RADIANS_PER_DEGREE);
+        this._workerName = 'createPolylineVolumeGeometry';
+    };
+
+    /**
+     * Computes the geometric representation of a polyline with a volume, including its vertices, indices, and a bounding sphere.
+     * @memberof PolylineVolumeGeometry
+     *
+     * @param {PolylineVolumeGeometry} polylineVolumeGeometry A description of the polyline volume.
+     *
+     * @returns {Geometry} The computed vertices and indices.
+     *
+     * @exception {DeveloperError} Count of unique polyline positions must be greater than 1.
+     * @exception {DeveloperError} Count of unique shape positions must be at least 3.
+     */
+    var brScratch = new BoundingRectangle();
+    PolylineVolumeGeometry.createGeometry = function(polylineVolumeGeometry) {
+        var positions = polylineVolumeGeometry._positions;
+        var cleanPositions = PolylineVolumeGeometryLibrary.removeDuplicatesFromPositions(positions, polylineVolumeGeometry._ellipsoid);
+        if (cleanPositions.length < 2) {
+            throw new DeveloperError('Count of unique polyline positions must be greater than 1.');
+        }
+        var shape2D = polylineVolumeGeometry._shape;
+        shape2D = PolylineVolumeGeometryLibrary.removeDuplicatesFromShape(shape2D);
+        if (shape2D.length < 3) {
+            throw new DeveloperError('Count of unique shape positions must be at least 3.');
+        }
+        if (PolygonPipeline.computeWindingOrder2D(shape2D).value === WindingOrder.CLOCKWISE.value) {
+            shape2D.reverse();
+        }
+        var boundingRectangle = BoundingRectangle.fromPoints(shape2D, brScratch);
+
+        var computedPositions = PolylineVolumeGeometryLibrary.computePositions(cleanPositions, shape2D, boundingRectangle, polylineVolumeGeometry, true);
+        return computeAttributes(computedPositions, shape2D, boundingRectangle, polylineVolumeGeometry._vertexFormat, polylineVolumeGeometry._ellipsoid);
+    };
+
+    return PolylineVolumeGeometry;
+});