chore(BufferPolygon): Unit tests on new polygon APIs

Author: donmccurdy

packages/engine/Source/Scene/BufferPolygon.js

@@ -8,7 +8,8 @@ import BufferPrimitiveCollection from "./BufferPrimitiveCollection.js";
 
 /** @import BufferPolygonCollection from "./BufferPolygonCollection.js"; */
 
-const { ERR_CAPACITY, ERR_RESIZE } = BufferPrimitiveCollection.Error;
+const { ERR_CAPACITY, ERR_RESIZE, ERR_OUT_OF_RANGE } =
+  BufferPrimitiveCollection.Error;
 
 /**
  * View bound to the underlying buffer data of a {@link BufferPolygonCollection}.
@@ -151,7 +152,7 @@ class BufferPolygon extends BufferPrimitive {
    * return {Float64Array}
    */
   getPositions(result) {
-    return this._getPositionsRange(this.vertexOffset, this.vertexCount, result);
+    return this._getPositionsRange(0, this.vertexCount, result);
   }
 
   /** @param {Float64Array} positions */
@@ -216,11 +217,7 @@ class BufferPolygon extends BufferPrimitive {
    * @returns {Float64Array}
    */
   getOuterPositions(result) {
-    return this._getPositionsRange(
-      this.outerVertexOffset,
-      this.outerVertexCount,
-      result,
-    );
+    return this._getPositionsRange(0, this.outerVertexCount, result);
   }
 
   /**
@@ -350,9 +347,11 @@ class BufferPolygon extends BufferPrimitive {
   }
 
   /**
-   * Internal helper for accessing vertex positions. If 'result' argument is
-   * given, the requested range of vertices are written to the result array
-   * and returned. Otherwise, returns an ArrayView on collection memory.
+   * Internal helper for accessing vertex positions. 'vertexOffset' argument
+   * is relative to the start of the polygon's vertex block, with 0 being
+   * the first vertex in the polygon. If 'result' argument is given, the
+   * requested range of vertices are written to the result array and returned.
+   * Otherwise, returns an ArrayView on collection memory.
    *
    * @param {number} vertexOffset
    * @param {number} vertexCount
@@ -361,19 +360,29 @@ class BufferPolygon extends BufferPrimitive {
    * @private
    */
   _getPositionsRange(vertexOffset, vertexCount, result) {
+    const collection = this._collection;
     const positionF64 = this._collection._positionF64;
 
+    const collectionVertexOffset = this.vertexOffset + vertexOffset;
+
+    //>>includeStart('debug', pragmas.debug);
+    assert(collectionVertexOffset >= 0, ERR_OUT_OF_RANGE);
+    assert(collectionVertexOffset < collection.vertexCount, ERR_OUT_OF_RANGE);
+    assert(vertexCount > 0, ERR_OUT_OF_RANGE);
+    assert(vertexCount <= this.vertexCount, ERR_OUT_OF_RANGE);
+    //>>includeEnd('debug');
+
     if (!defined(result)) {
       const byteOffset =
         positionF64.byteOffset +
-        vertexOffset * 3 * Float64Array.BYTES_PER_ELEMENT;
+        collectionVertexOffset * 3 * Float64Array.BYTES_PER_ELEMENT;
       return new Float64Array(positionF64.buffer, byteOffset, vertexCount * 3);
     }
 
     for (let i = 0; i < vertexCount; i++) {
-      result[i * 3] = positionF64[(vertexOffset + i) * 3];
-      result[i * 3 + 1] = positionF64[(vertexOffset + i) * 3 + 1];
-      result[i * 3 + 2] = positionF64[(vertexOffset + i) * 3 + 2];
+      result[i * 3] = positionF64[(collectionVertexOffset + i) * 3];
+      result[i * 3 + 1] = positionF64[(collectionVertexOffset + i) * 3 + 1];
+      result[i * 3 + 2] = positionF64[(collectionVertexOffset + i) * 3 + 2];
     }
     return result;
   }

packages/engine/Source/Scene/BufferPrimitiveCollection.js

@@ -54,6 +54,7 @@ class BufferPrimitiveCollection {
     ERR_CAPACITY: "BufferPrimitiveCollection capacity exceeded.",
     ERR_MULTIPLE_OF_FOUR:
       "BufferPrimitive byte length must be a multiple of 4.",
+    ERR_OUT_OF_RANGE: "BufferPrimitive buffer access out of range.",
   };
 
   /**

packages/engine/Specs/Scene/BufferPolygonCollectionSpec.js

@@ -32,15 +32,34 @@ describe("BufferPolygonCollection", () => {
 
     collection.get(0, polygon);
     expect(polygon.vertexCount, 3);
-    expect(polygon.getPositions(new Float64Array(9))).toEqual(positions1);
+    expect(polygon.getPositions()).toEqual(positions1);
 
     collection.get(1, polygon);
     expect(polygon.vertexCount, 3);
-    expect(polygon.getPositions(new Float64Array(9))).toEqual(positions2);
+    expect(polygon.getPositions()).toEqual(positions2);
 
     collection.get(2, polygon);
     expect(polygon.vertexCount, 4);
-    expect(polygon.getPositions(new Float64Array(12))).toEqual(positions3);
+    expect(polygon.getPositions()).toEqual(positions3);
+  });
+
+  it("outerPositions", () => {
+    const collection = new BufferPolygonCollection();
+    const polygon = new BufferPolygon();
+
+    const positions = new Float64Array([
+      ...createBoxPositions(2), // outer loop
+      ...createBoxPositions(1), // hole
+    ]);
+    const holes = new Uint32Array([3]);
+
+    collection.add({ positions, holes }, polygon);
+
+    expect(polygon.vertexCount, 6);
+    expect(polygon.holeCount, 1);
+    expect(polygon.outerVertexCount, 3);
+    expect(polygon.getPositions()).toEqual(positions);
+    expect(polygon.getOuterPositions()).toEqual(createBoxPositions(2));
   });
 
   it("holes", () => {
@@ -71,7 +90,8 @@ describe("BufferPolygonCollection", () => {
 
     collection.get(2, polygon);
     expect(polygon.holeCount, 1);
-    expect(polygon.getHoles(new Uint32Array(1))).toEqual(holes3);
+    expect(polygon.getHoles()).toEqual(holes3);
+    expect(polygon.getHolePositions(0)).toEqual(createBoxPositions(1));
   });
 
   it("triangles", () => {
@@ -96,15 +116,15 @@ describe("BufferPolygonCollection", () => {
 
     collection.get(0, polygon);
     expect(polygon.triangleCount, 2);
-    expect(polygon.getTriangles(new Uint32Array(6))).toEqual(triangles1);
+    expect(polygon.getTriangles()).toEqual(triangles1);
 
     collection.get(1, polygon);
     expect(polygon.triangleCount, 1);
-    expect(polygon.getTriangles(new Uint32Array(3))).toEqual(triangles2);
+    expect(polygon.getTriangles()).toEqual(triangles2);
 
     collection.get(2, polygon);
     expect(polygon.triangleCount, 1);
-    expect(polygon.getTriangles(new Uint32Array(3))).toEqual(triangles3);
+    expect(polygon.getTriangles()).toEqual(triangles3);
   });
 
   it("show", () => {
@@ -219,25 +239,19 @@ describe("BufferPolygonCollection", () => {
 
     dst.get(0, polygon);
     expect(polygon.getColor(color)).toEqual(Color.RED);
-    expect(polygon.getPositions(new Float64Array(positions1.length))).toEqual(
-      positions1,
-    );
+    expect(polygon.getPositions()).toEqual(positions1);
     expect(polygon.holeCount).toBe(0);
     expect(polygon.triangleCount).toBe(2);
 
     dst.get(1, polygon);
     expect(polygon.getColor(color)).toEqual(Color.GREEN);
-    expect(polygon.getPositions(new Float64Array(positions2.length))).toEqual(
-      positions2,
-    );
+    expect(polygon.getPositions()).toEqual(positions2);
     expect(polygon.holeCount).toBe(0);
     expect(polygon.triangleCount).toBe(2);
 
     dst.get(2, polygon);
     expect(polygon.getColor(color)).toEqual(Color.BLUE);
-    expect(polygon.getPositions(new Float64Array(positions3.length))).toEqual(
-      positions3,
-    );
+    expect(polygon.getPositions()).toEqual(positions3);
     expect(polygon.holeCount).toBe(1);
     expect(polygon.triangleCount).toBe(2);
   });