function Vector3DTilePolygons(options) {
  // All of the private properties will be released except _primitive after the Vector3DTilePrimitive is created.
  this._batchTable = options.batchTable;

  this._batchIds = options.batchIds;
  this._positions = options.positions;
  this._counts = options.counts;

  this._indices = options.indices;
  this._indexCounts = options.indexCounts;
  this._indexOffsets = undefined;

  this._batchTableColors = undefined;
  this._packedBuffer = undefined;

  this._batchedPositions = undefined;
  this._transferrableBatchIds = undefined;
  this._vertexBatchIds = undefined;

  this._ellipsoid = options.ellipsoid ?? Ellipsoid.WGS84;
  this._minimumHeight = options.minimumHeight;
  this._maximumHeight = options.maximumHeight;
  this._polygonMinimumHeights = options.polygonMinimumHeights;
  this._polygonMaximumHeights = options.polygonMaximumHeights;
  this._center = options.center ?? Cartesian3.ZERO;
  this._rectangle = options.rectangle;

  this._center = undefined;

  this._boundingVolume = options.boundingVolume;
  this._boundingVolumes = undefined;

  this._batchedIndices = undefined;

  this._ready = false;
  this._promise = undefined;
  this._error = undefined;
  this._primitive = undefined;

  /**
   * Draws the wireframe of the classification meshes.
   * @type {boolean}
   * @default false
   */
  this.debugWireframe = false;

  /**
   * Forces a re-batch instead of waiting after a number of frames have been rendered. For testing only.
   * @type {boolean}
   * @default false
   */
  this.forceRebatch = false;

  /**
   * What this tile will classify.
   * @type {ClassificationType}
   * @default ClassificationType.BOTH
   */
  this.classificationType = ClassificationType.BOTH;
}
Creates a batch of pre-triangulated polygons draped on terrain and/or 3D Tiles.

@alias Vector3DTilePolygons
@constructor

@param {object} options An object with following properties:
@param {Float32Array|Uint16Array} options.positions The positions of the polygons. The positions must be contiguous
so that the positions for polygon n are in [c, c + counts[n]] where c = sum{counts[0], counts[n - 1]} and they are the outer ring of
the polygon in counter-clockwise order.
@param {Uint32Array} options.counts The number of positions in the each polygon.
@param {Uint32Array} options.indices The indices of the triangulated polygons. The indices must be contiguous so that
the indices for polygon n are in [i, i + indexCounts[n]] where i = sum{indexCounts[0], indexCounts[n - 1]}.
@param {Uint32Array} options.indexCounts The number of indices for each polygon.
@param {number} options.minimumHeight The minimum height of the terrain covered by the tile.
@param {number} options.maximumHeight The maximum height of the terrain covered by the tile.
@param {Float32Array} [options.polygonMinimumHeights] An array containing the minimum heights for each polygon.
@param {Float32Array} [options.polygonMaximumHeights] An array containing the maximum heights for each polygon.
@param {Rectangle} options.rectangle The rectangle containing the tile.
@param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid.
@param {Cartesian3} [options.center=Cartesian3.ZERO] The RTC center.
@param {Cesium3DTileBatchTable} options.batchTable The batch table for the tile containing the batched polygons.
@param {Uint16Array} options.batchIds The batch ids for each polygon.
@param {BoundingSphere} options.boundingVolume The bounding volume for the entire batch of polygons.

@private