cesium 0.22.0 → 0.23.0

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

@@ -25,8 +25,8 @@ define(['Core/defaultValue', 'Core/defined', 'Core/Cartesian3', 'Core/Ellipsoid'
     PolygonGeometryLibrary.subdivideLine = function(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));
+        var n = angleBetween / granularity;
+        var countDivide = Math.ceil(Math.log(n) / Math.log(2));
         if (countDivide < 1) {
             countDivide = 0;
         }
@@ -39,8 +39,8 @@ define(['Core/defaultValue', 'Core/defined', 'Core/Cartesian3', 'Core/Ellipsoid'
         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);
+        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];
@@ -49,19 +49,20 @@ define(['Core/defaultValue', 'Core/defined', 'Core/Cartesian3', 'Core/Ellipsoid'
         return positions;
     };
 
-
     var scaleToGeodeticHeightN1 = new Cartesian3();
     var scaleToGeodeticHeightN2 = new Cartesian3();
-    var scaleToGeodeticHeightP = new Cartesian3();
+    var scaleToGeodeticHeightP1 = new Cartesian3();
+    var scaleToGeodeticHeightP2 = new Cartesian3();
     /**
      * @private
      */
-    PolygonGeometryLibrary.scaleToGeodeticHeightExtruded = function(geometry, maxHeight, minHeight, ellipsoid) {
+    PolygonGeometryLibrary.scaleToGeodeticHeightExtruded = function(geometry, maxHeight, minHeight, ellipsoid, perPositionHeight) {
         ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
 
         var n1 = scaleToGeodeticHeightN1;
         var n2 = scaleToGeodeticHeightN2;
-        var p = scaleToGeodeticHeightP;
+        var p = scaleToGeodeticHeightP1;
+        var p2 = scaleToGeodeticHeightP2;
 
         if (defined(geometry) && defined(geometry.attributes) && defined(geometry.attributes.position)) {
             var positions = geometry.attributes.position.values;
@@ -70,20 +71,22 @@ define(['Core/defaultValue', 'Core/defined', 'Core/Cartesian3', 'Core/Ellipsoid'
             for ( var i = 0; i < length; i += 3) {
                 Cartesian3.fromArray(positions, i, p);
 
-                ellipsoid.scaleToGeodeticSurface(p, p);
                 ellipsoid.geodeticSurfaceNormal(p, n1);
+                p2 = ellipsoid.scaleToGeodeticSurface(p, p2);
+                n2 = Cartesian3.multiplyByScalar(n1, minHeight, n2);
+                n2 = Cartesian3.add(p2, n2, n2);
+                positions[i + length] = n2.x;
+                positions[i + 1 + length] = n2.y;
+                positions[i + 2 + length] = n2.z;
 
-                Cartesian3.multiplyByScalar(n1, maxHeight, n2);
-                Cartesian3.add(p, n2, n2);
+                if (perPositionHeight) {
+                    p2 = Cartesian3.clone(p, p2);
+                }
+                n2 = Cartesian3.multiplyByScalar(n1, maxHeight, n2);
+                n2 = Cartesian3.add(p2, 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;

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

@@ -23,7 +23,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
     "use strict";
     var createGeometryFromPositionsPositions = [];
 
-    function createGeometryFromPositions(ellipsoid, positions, granularity) {
+    function createGeometryFromPositions(ellipsoid, positions, granularity, perPositionHeight) {
         var cleanedPositions = PolygonPipeline.removeDuplicates(positions);
         if (cleanedPositions.length < 3) {
             throw new DeveloperError('Duplicate positions result in not enough positions to form a polygon.');
@@ -37,36 +37,44 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
             positions2D.reverse();
             cleanedPositions.reverse();
         }
+
         var subdividedPositions = [];
         var length = cleanedPositions.length;
         var i;
-        for (i = 0; i < length-1; i++) {
-            subdividedPositions = subdividedPositions.concat(PolygonGeometryLibrary.subdivideLine(cleanedPositions[i], cleanedPositions[i+1], granularity));
+        if (!perPositionHeight) {
+            for (i = 0; i < length; i++) {
+                subdividedPositions = subdividedPositions.concat(PolygonGeometryLibrary.subdivideLine(cleanedPositions[i], cleanedPositions[(i + 1) % length], granularity));
+            }
+        } else {
+            for (i = 0; i < length; i++) {
+                var p0 = cleanedPositions[i];
+                var p1 = cleanedPositions[(i + 1) % length];
+                subdividedPositions.push(p0.x, p0.y, p0.z, p1.x, p1.y, p1.z);
+            }
         }
-        subdividedPositions = subdividedPositions.concat(PolygonGeometryLibrary.subdivideLine(cleanedPositions[length-1], cleanedPositions[0], granularity));
 
-        length = subdividedPositions.length/3;
-        var indicesSize = length*2;
-        var indices = IndexDatatype.createTypedArray(subdividedPositions.length/3, indicesSize);
+        length = subdividedPositions.length / 3;
+        var indicesSize = length * 2;
+        var indices = IndexDatatype.createTypedArray(subdividedPositions.length / 3, indicesSize);
         var index = 0;
-        for (i = 0; i < length-1; i++) {
+        for (i = 0; i < length - 1; i++) {
             indices[index++] = i;
-            indices[index++] = i+1;
+            indices[index++] = i + 1;
         }
-        indices[index++] = length-1;
+        indices[index++] = length - 1;
         indices[index++] = 0;
 
         return new GeometryInstance({
             geometry : new Geometry({
-                attributes: new GeometryAttributes({
-                    position: new GeometryAttribute({
+                attributes : new GeometryAttributes({
+                    position : new GeometryAttribute({
                         componentDatatype : ComponentDatatype.DOUBLE,
                         componentsPerAttribute : 3,
                         values : new Float64Array(subdividedPositions)
                     })
                 }),
-                indices: indices,
-                primitiveType: PrimitiveType.LINES
+                indices : indices,
+                primitiveType : PrimitiveType.LINES
             })
         });
     }
@@ -75,7 +83,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
     var scratchNormal = new Cartesian3();
     var scratchBoundingSphere = new BoundingSphere();
 
-    function createGeometryFromPositionsExtruded(ellipsoid, positions, granularity) {
+    function createGeometryFromPositionsExtruded(ellipsoid, positions, granularity, perPositionHeight) {
         var cleanedPositions = PolygonPipeline.removeDuplicates(positions);
         if (cleanedPositions.length < 3) {
             throw new DeveloperError('Duplicate positions result in not enough positions to form a polygon.');
@@ -94,25 +102,39 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
         var i;
         var corners = new Array(length);
         corners[0] = 0;
-        for (i = 0; i < length-1; i++) {
-            subdividedPositions = subdividedPositions.concat(PolygonGeometryLibrary.subdivideLine(cleanedPositions[i], cleanedPositions[i+1], granularity));
-            corners[i+1] = subdividedPositions.length/3;
+        if (!perPositionHeight) {
+            for (i = 0; i < length - 1; i++) {
+                subdividedPositions = subdividedPositions.concat(PolygonGeometryLibrary.subdivideLine(cleanedPositions[i], cleanedPositions[i + 1], granularity));
+                corners[i + 1] = subdividedPositions.length / 3;
+            }
+            subdividedPositions = subdividedPositions.concat(PolygonGeometryLibrary.subdivideLine(cleanedPositions[length - 1], cleanedPositions[0], granularity));
+        } else {
+            var p0;
+            var p1;
+            for (i = 0; i < length - 1; i++) {
+                p0 = cleanedPositions[i];
+                p1 = cleanedPositions[(i + 1) % length];
+                subdividedPositions.push(p0.x, p0.y, p0.z, p1.x, p1.y, p1.z);
+                corners[i + 1] = subdividedPositions.length / 3;
+            }
+            p0 = cleanedPositions[length - 1];
+            p1 = cleanedPositions[0];
+            subdividedPositions.push(p0.x, p0.y, p0.z, p1.x, p1.y, p1.z);
         }
-        subdividedPositions = subdividedPositions.concat(PolygonGeometryLibrary.subdivideLine(cleanedPositions[length-1], cleanedPositions[0], granularity));
 
-        length = subdividedPositions.length/3;
-        var indicesSize = ((length * 2) + corners.length)*2;
-        var indices = IndexDatatype.createTypedArray(subdividedPositions.length/3, indicesSize);
+        length = subdividedPositions.length / 3;
+        var indicesSize = ((length * 2) + corners.length) * 2;
+        var indices = IndexDatatype.createTypedArray(subdividedPositions.length / 3, indicesSize);
         var index = 0;
-        for (i = 0; i < length-1; i++) {
+        for (i = 0; i < length - 1; i++) {
             indices[index++] = i;
-            indices[index++] = i+1;
+            indices[index++] = i + 1;
             indices[index++] = i + length;
-            indices[index++] = i+1 + length;
+            indices[index++] = i + 1 + length;
         }
-        indices[index++] = length-1;
+        indices[index++] = length - 1;
         indices[index++] = 0;
-        indices[index++] = length + length-1;
+        indices[index++] = length + length - 1;
         indices[index++] = length;
 
         for (i = 0; i < corners.length; i++) {
@@ -125,15 +147,15 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
 
         return new GeometryInstance({
             geometry : new Geometry({
-                attributes: new GeometryAttributes({
-                    position: new GeometryAttribute({
+                attributes : new GeometryAttributes({
+                    position : new GeometryAttribute({
                         componentDatatype : ComponentDatatype.DOUBLE,
                         componentsPerAttribute : 3,
                         values : new Float64Array(subdividedPositions)
                     })
                 }),
-                indices: indices,
-                primitiveType: PrimitiveType.LINES
+                indices : indices,
+                primitiveType : PrimitiveType.LINES
             })
         });
     }
@@ -150,6 +172,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
      * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
      * @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 {Boolean} [options.perPositionHeight=false] Use the height of options.positions for each position instead of using options.height to determine the height.
      *
      * @exception {DeveloperError} polygonHierarchy is required.
      *
@@ -228,9 +251,10 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
         var ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
         var granularity = defaultValue(options.granularity, CesiumMath.RADIANS_PER_DEGREE);
         var height = defaultValue(options.height, 0.0);
+        var perPositionHeight = defaultValue(options.perPositionHeight, false);
 
-        var extrudedHeight = defaultValue(options.extrudedHeight, undefined);
-        var extrude = (defined(extrudedHeight) && !CesiumMath.equalsEpsilon(height, extrudedHeight, CesiumMath.EPSILON6));
+        var extrudedHeight = options.extrudedHeight;
+        var extrude = (defined(extrudedHeight) && (!CesiumMath.equalsEpsilon(height, extrudedHeight, CesiumMath.EPSILON6) || perPositionHeight));
         if (extrude) {
             var h = extrudedHeight;
             extrudedHeight = Math.min(h, height);
@@ -248,6 +272,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
         this._extrudedHeight = extrudedHeight;
         this._extrude = extrude;
         this._polygonHierarchy = polygonHierarchy;
+        this._perPositionHeight = perPositionHeight;
         this._workerName = 'createPolygonOutlineGeometry';
     };
 
@@ -261,6 +286,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
      * @param {Number} [options.extrudedHeight] The height of the polygon extrusion.
      * @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 {Boolean} [options.perPositionHeight=false] Use the height of options.positions for each position instead of using options.height to determine the height.
      *
      * @exception {DeveloperError} options.positions is required.
      *
@@ -293,7 +319,8 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
             height : options.height,
             extrudedHeight : options.extrudedHeight,
             ellipsoid : options.ellipsoid,
-            granularity : options.granularity
+            granularity : options.granularity,
+            perPositionHeight : options.perPositionHeight
         };
         return new PolygonOutlineGeometry(newOptions);
     };
@@ -315,6 +342,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
         var extrudedHeight = polygonGeometry._extrudedHeight;
         var extrude = polygonGeometry._extrude;
         var polygonHierarchy = polygonGeometry._polygonHierarchy;
+        var perPositionHeight = polygonGeometry._perPositionHeight;
 
         var boundingSphere;
         var outerPositions;
@@ -344,7 +372,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
                     numGrandchildren = hole.holes.length;
                 }
 
-                for (var j = 0; j < numGrandchildren; j++) {
+                for ( var j = 0; j < numGrandchildren; j++) {
                     queue.enqueue(hole.holes[j]);
                 }
             }
@@ -352,7 +380,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
             polygons.push(outerRing);
         }
 
-        outerPositions =  polygons[0];
+        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.
@@ -363,17 +391,17 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
 
         if (extrude) {
             for (i = 0; i < polygons.length; i++) {
-                geometry = createGeometryFromPositionsExtruded(ellipsoid, polygons[i], granularity);
+                geometry = createGeometryFromPositionsExtruded(ellipsoid, polygons[i], granularity, perPositionHeight);
                 if (defined(geometry)) {
-                    geometry.geometry = PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(geometry.geometry, height, extrudedHeight, ellipsoid);
+                    geometry.geometry = PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(geometry.geometry, height, extrudedHeight, ellipsoid, perPositionHeight);
                     geometries.push(geometry);
                 }
             }
         } else {
             for (i = 0; i < polygons.length; i++) {
-                geometry = createGeometryFromPositions(ellipsoid, polygons[i], granularity);
+                geometry = createGeometryFromPositions(ellipsoid, polygons[i], granularity, perPositionHeight);
                 if (defined(geometry)) {
-                    geometry.geometry = PolygonPipeline.scaleToGeodeticHeight(geometry.geometry, height, ellipsoid);
+                    geometry.geometry = PolygonPipeline.scaleToGeodeticHeight(geometry.geometry, height, ellipsoid, !perPositionHeight);
                     geometries.push(geometry);
                 }
             }

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

@@ -882,11 +882,11 @@ define(['Core/DeveloperError', 'Core/Math', 'Core/Cartesian2', 'Core/Cartesian3'
         },
 
         /**
-         * DOC_TBA
+         * Subdivides positions and raises points to the surface of the ellipsoid.
          *
-         * @param {DOC_TBA} positions DOC_TBA
-         * @param {DOC_TBA} indices DOC_TBA
-         * @param {Number} [granularity] DOC_TBA
+         * @param {Array} positions An array of {@link Cartesian3} positions of the polygon.
+         * @param {Array} indices An array of indices that determines the triangles in the polygon.
+         * @param {Number} [granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
          *
          * @exception {DeveloperError} positions is required.
          * @exception {DeveloperError} indices is required.
@@ -1053,17 +1053,23 @@ define(['Core/DeveloperError', 'Core/Math', 'Core/Cartesian2', 'Core/Cartesian3'
         },
 
         /**
-         * DOC_TBA
+         * Scales each position of a geometry's position attribute to a height, in place.
+         *
+         * @param {Geometry} geometry The geometry whose positions are to be scaled.
+         * @param {Number} [height=0.0] The desired height to add to the positions of the geometry.
+         * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the positions lie.
+         * @param {Boolean} [scaleToSurface=true] <code>true</code> if the positions need to be scaled to the surface before the height is added.
          *
-         * @exception {DeveloperError} ellipsoid is required.
+         * @returns {Geometry} The same geometry whose positions where scaled.
          */
-        scaleToGeodeticHeight : function(geometry, height, ellipsoid) {
+        scaleToGeodeticHeight : function(geometry, height, ellipsoid, scaleToSurface) {
             ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
 
             var n = scaleToGeodeticHeightN;
             var p = scaleToGeodeticHeightP;
 
             height = defaultValue(height, 0.0);
+            scaleToSurface = defaultValue(scaleToSurface, true);
 
             if (defined(geometry) && defined(geometry.attributes) && defined(geometry.attributes.position)) {
                 var positions = geometry.attributes.position.values;
@@ -1072,8 +1078,12 @@ define(['Core/DeveloperError', 'Core/Math', 'Core/Cartesian2', 'Core/Cartesian3'
                 for ( var i = 0; i < length; i += 3) {
                     Cartesian3.fromArray(positions, i, p);
 
-                    ellipsoid.scaleToGeodeticSurface(p, p);
-                    ellipsoid.geodeticSurfaceNormal(p, n);
+                    if (scaleToSurface) {
+                        p = ellipsoid.scaleToGeodeticSurface(p, p);
+                    }
+
+                    n = ellipsoid.geodeticSurfaceNormal(p, n);
+
                     Cartesian3.multiplyByScalar(n, height, n);
                     Cartesian3.add(p, n, p);
 

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/Enumeration'], function(Enumeration) {
+define(function() {
     "use strict";
 
     /**
@@ -9,61 +9,58 @@ define(['Core/Enumeration'], function(Enumeration) {
      */
     var PrimitiveType = {
         /**
-         * DOC_TBA
+         * 0x0000.  Points primitive where each vertex (or index) is a separate point.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x0000
          */
-        POINTS : new Enumeration(0x0000, 'POINTS'),
+        POINTS : 0x0000,
         /**
-         * DOC_TBA
+         * 0x0001.  Lines primitive where each two vertices (or indices) is a line segment.  Line segments are not necessarily connected.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x0001
          */
-        LINES : new Enumeration(0x0001, 'LINES'),
+        LINES : 0x0001,
         /**
-         * DOC_TBA
+         * 0x0002.  Line loop primitive where each vertex (or index) after the first connects a line to
+         * the previous vertex, and the last vertex implicitly connects to the first.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x0002
          */
-        LINE_LOOP : new Enumeration(0x0002, 'LINE_LOOP'),
+        LINE_LOOP : 0x0002,
         /**
-         * DOC_TBA
+         * 0x0003.  Line strip primitive where each vertex (or index) after the first connects a line to the previous vertex.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x0003
          */
-        LINE_STRIP : new Enumeration(0x0003, 'LINE_STRIP'),
+        LINE_STRIP : 0x0003,
         /**
-         * DOC_TBA
+         * 0x0004.  Triangles primitive where each three vertices (or indices) is a triangle.  Triangles do not necessarily share edges.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x0004
          */
-        TRIANGLES : new Enumeration(0x0004, 'TRIANGLES'),
+        TRIANGLES : 0x0004,
         /**
-         * DOC_TBA
+         * 0x0005.  Triangle strip primitive where each vertex (or index) after the first two connect to
+         * the previous two vertices forming a triangle.  For example, this can be used to model a wall.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x0004
          */
-        TRIANGLE_STRIP : new Enumeration(0x0005, 'TRIANGLE_STRIP'),
+        TRIANGLE_STRIP : 0x0005,
         /**
-         * DOC_TBA
+         * 0x0006.  Triangle fan primitive where each vertex (or index) after the first two connect to
+         * the previous vertex and the first vertex forming a triangle.  For example, this can be used
+         * to model a cone or circle.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x0006
          */
-        TRIANGLE_FAN : new Enumeration(0x0006, 'TRIANGLE_FAN'),
+        TRIANGLE_FAN : 0x0006,
 
         /**
          * DOC_TBA
@@ -73,13 +70,13 @@ define(['Core/Enumeration'], function(Enumeration) {
          * @returns {Boolean}
          */
         validate : function(primitiveType) {
-            return ((primitiveType.value === PrimitiveType.POINTS.value) ||
-                    (primitiveType.value === PrimitiveType.LINES.value) ||
-                    (primitiveType.value === PrimitiveType.LINE_LOOP.value) ||
-                    (primitiveType.value === PrimitiveType.LINE_STRIP.value) ||
-                    (primitiveType.value === PrimitiveType.TRIANGLES.value) ||
-                    (primitiveType.value === PrimitiveType.TRIANGLE_STRIP.value) ||
-                    (primitiveType.value === PrimitiveType.TRIANGLE_FAN.value));
+            return ((primitiveType === PrimitiveType.POINTS) ||
+                    (primitiveType === PrimitiveType.LINES) ||
+                    (primitiveType === PrimitiveType.LINE_LOOP) ||
+                    (primitiveType === PrimitiveType.LINE_STRIP) ||
+                    (primitiveType === PrimitiveType.TRIANGLES) ||
+                    (primitiveType === PrimitiveType.TRIANGLE_STRIP) ||
+                    (primitiveType === PrimitiveType.TRIANGLE_FAN));
         }
     };