@hztxi/cesium-engine 25.0.4 → 25.0.7

package/Build/Workers/chunk-5FYUSABU.js

@@ -0,0 +1,945 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.7
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  WebMercatorProjection_default
+} from "./chunk-KW2QZDUS.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-DQEUGBGA.js";
+import {
+  IntersectionTests_default
+} from "./chunk-2GJAWJJT.js";
+import {
+  IndexDatatype_default
+} from "./chunk-NCPJBP24.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-375SHKGW.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default
+} from "./chunk-75HIWCEV.js";
+import {
+  BoundingSphere_default,
+  GeographicProjection_default
+} from "./chunk-CDLPLYLV.js";
+import {
+  Rectangle_default
+} from "./chunk-FV4OWDV4.js";
+import {
+  Cartesian4_default,
+  Matrix4_default
+} from "./chunk-RBEVHHXK.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-CWGB3D4Z.js";
+import {
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-7AMVPXZY.js";
+import {
+  Cartesian3_default
+} from "./chunk-CHMDKP5L.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-ESQGFRLZ.js";
+import {
+  defined_default
+} from "./chunk-KEJKMITY.js";
+
+// packages/engine/Source/Core/OffsetGeometryInstanceAttribute.js
+function OffsetGeometryInstanceAttribute(x, y, z) {
+  x = x ?? 0;
+  y = y ?? 0;
+  z = z ?? 0;
+  this.value = new Float32Array([x, y, z]);
+}
+Object.defineProperties(OffsetGeometryInstanceAttribute.prototype, {
+  /**
+   * The datatype of each component in the attribute, e.g., individual elements in
+   * {@link OffsetGeometryInstanceAttribute#value}.
+   *
+   * @memberof OffsetGeometryInstanceAttribute.prototype
+   *
+   * @type {ComponentDatatype}
+   * @readonly
+   *
+   * @default {@link ComponentDatatype.FLOAT}
+   */
+  componentDatatype: {
+    get: function() {
+      return ComponentDatatype_default.FLOAT;
+    }
+  },
+  /**
+   * The number of components in the attributes, i.e., {@link OffsetGeometryInstanceAttribute#value}.
+   *
+   * @memberof OffsetGeometryInstanceAttribute.prototype
+   *
+   * @type {number}
+   * @readonly
+   *
+   * @default 3
+   */
+  componentsPerAttribute: {
+    get: function() {
+      return 3;
+    }
+  },
+  /**
+   * When <code>true</code> and <code>componentDatatype</code> is an integer format,
+   * indicate that the components should be mapped to the range [0, 1] (unsigned)
+   * or [-1, 1] (signed) when they are accessed as floating-point for rendering.
+   *
+   * @memberof OffsetGeometryInstanceAttribute.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   *
+   * @default false
+   */
+  normalize: {
+    get: function() {
+      return false;
+    }
+  }
+});
+OffsetGeometryInstanceAttribute.fromCartesian3 = function(offset) {
+  Check_default.defined("offset", offset);
+  return new OffsetGeometryInstanceAttribute(offset.x, offset.y, offset.z);
+};
+OffsetGeometryInstanceAttribute.toValue = function(offset, result) {
+  Check_default.defined("offset", offset);
+  if (!defined_default(result)) {
+    result = new Float32Array([offset.x, offset.y, offset.z]);
+  }
+  result[0] = offset.x;
+  result[1] = offset.y;
+  result[2] = offset.z;
+  return result;
+};
+var OffsetGeometryInstanceAttribute_default = OffsetGeometryInstanceAttribute;
+
+// packages/engine/Source/Scene/ColumbusWorlds.js
+var ColumbusWorlds = {};
+var worldWidthCartographic = new Cartographic_default();
+var worldWidthCartesian = new Cartesian3_default();
+var worldWidthCache = {
+  projection: void 0,
+  width: 0
+};
+ColumbusWorlds.getWorldWidth = function(projection) {
+  if (worldWidthCache.projection !== projection) {
+    const northeast = projection.project(
+      Rectangle_default.northeast(Rectangle_default.MAX_VALUE, worldWidthCartographic),
+      worldWidthCartesian
+    );
+    worldWidthCache.projection = projection;
+    worldWidthCache.width = Math.abs(northeast.x) * 2;
+  }
+  return worldWidthCache.width;
+};
+ColumbusWorlds.nearestWorldU = function(cameraU, u, projection) {
+  const worldWidth = ColumbusWorlds.getWorldWidth(projection);
+  return u + Math.round((cameraU - u) / worldWidth) * worldWidth;
+};
+var cameraOffsetDelta = new Cartesian3_default();
+var cameraOffsetTranslation = new Matrix4_default();
+ColumbusWorlds.applyCameraWorldOffset = function(camera, worldOffset) {
+  Cartesian3_default.fromElements(0, worldOffset, 0, cameraOffsetDelta);
+  Matrix4_default.fromTranslation(cameraOffsetDelta, cameraOffsetTranslation);
+  Matrix4_default.multiply(
+    camera._viewMatrix,
+    cameraOffsetTranslation,
+    camera._viewMatrix
+  );
+  Matrix4_default.inverseTransformation(camera._viewMatrix, camera._invViewMatrix);
+  camera._positionWC.y -= worldOffset;
+};
+ColumbusWorlds.translateCullingVolume = function(cullingVolume, worldOffset, result) {
+  const planes = cullingVolume.planes;
+  const resultPlanes = result.planes;
+  for (let i = 0; i < planes.length; ++i) {
+    const plane = planes[i];
+    let resultPlane = resultPlanes[i];
+    if (!defined_default(resultPlane)) {
+      resultPlane = resultPlanes[i] = new Cartesian4_default();
+    }
+    resultPlane.x = plane.x;
+    resultPlane.y = plane.y;
+    resultPlane.z = plane.z;
+    resultPlane.w = plane.w + plane.y * worldOffset;
+  }
+  return result;
+};
+var worldStripSphere = new BoundingSphere_default();
+ColumbusWorlds.getVisibleWorldIndices = function(cameraU, worldWidth, cullingVolume, maxExtraWorlds, result) {
+  result.length = 0;
+  if (!(worldWidth > 0) || !Number.isFinite(cameraU)) {
+    return result;
+  }
+  const sphere = worldStripSphere;
+  sphere.center.x = 0;
+  sphere.center.z = 0;
+  sphere.radius = worldWidth * 0.75;
+  const centerWorld = Math.round(cameraU / worldWidth);
+  for (let i = -maxExtraWorlds; i <= maxExtraWorlds; ++i) {
+    const worldIndex = centerWorld + i;
+    if (worldIndex === 0) {
+      continue;
+    }
+    sphere.center.y = worldIndex * worldWidth;
+    if (cullingVolume.computeVisibility(sphere) === IntersectionTests_default.OUTSIDE) {
+      continue;
+    }
+    result.push(worldIndex);
+  }
+  return result;
+};
+var ColumbusWorlds_default = ColumbusWorlds;
+
+// packages/engine/Source/Scene/PrimitivePipeline.js
+function transformToWorldCoordinates(instances, primitiveModelMatrix, scene3DOnly) {
+  let toWorld = !scene3DOnly;
+  const length = instances.length;
+  let i;
+  if (!toWorld && length > 1) {
+    const modelMatrix = instances[0].modelMatrix;
+    for (i = 1; i < length; ++i) {
+      if (!Matrix4_default.equals(modelMatrix, instances[i].modelMatrix)) {
+        toWorld = true;
+        break;
+      }
+    }
+  }
+  if (toWorld) {
+    for (i = 0; i < length; ++i) {
+      if (defined_default(instances[i].geometry)) {
+        GeometryPipeline_default.transformToWorldCoordinates(instances[i]);
+      }
+    }
+  } else {
+    Matrix4_default.multiplyTransformation(
+      primitiveModelMatrix,
+      instances[0].modelMatrix,
+      primitiveModelMatrix
+    );
+  }
+}
+function addGeometryBatchId(geometry, batchId) {
+  const attributes = geometry.attributes;
+  const positionAttr = attributes.position;
+  const numberOfComponents = positionAttr.values.length / positionAttr.componentsPerAttribute;
+  attributes.batchId = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.FLOAT,
+    componentsPerAttribute: 1,
+    values: new Float32Array(numberOfComponents)
+  });
+  const values = attributes.batchId.values;
+  for (let j = 0; j < numberOfComponents; ++j) {
+    values[j] = batchId;
+  }
+}
+function addBatchIds(instances) {
+  const length = instances.length;
+  for (let i = 0; i < length; ++i) {
+    const instance = instances[i];
+    if (defined_default(instance.geometry)) {
+      addGeometryBatchId(instance.geometry, i);
+    } else if (defined_default(instance.westHemisphereGeometry) && defined_default(instance.eastHemisphereGeometry)) {
+      addGeometryBatchId(instance.westHemisphereGeometry, i);
+      addGeometryBatchId(instance.eastHemisphereGeometry, i);
+    }
+  }
+}
+function liftPolyline2DToWorldCopy(geometry, projection) {
+  const attributes = geometry.attributes;
+  const position2D = attributes.position2D;
+  const prevPosition2D = attributes.prevPosition2D;
+  const nextPosition2D = attributes.nextPosition2D;
+  if (!defined_default(position2D) || !defined_default(prevPosition2D) || !defined_default(nextPosition2D)) {
+    return;
+  }
+  const worldWidth = ColumbusWorlds_default.getWorldWidth(projection);
+  const halfWorldWidth = worldWidth * 0.5;
+  const positions = position2D.values;
+  const vertexCount = positions.length / 3;
+  const lifts = new Float64Array(vertexCount);
+  let lift = 0;
+  let lifted = false;
+  for (let i = 1; i < vertexCount; ++i) {
+    const du = positions[i * 3] - (positions[(i - 1) * 3] + lift);
+    if (du > halfWorldWidth) {
+      lift -= worldWidth;
+      lifted = true;
+    } else if (du < -halfWorldWidth) {
+      lift += worldWidth;
+      lifted = true;
+    }
+    lifts[i] = lift;
+  }
+  if (!lifted) {
+    return;
+  }
+  const prevPositions = prevPosition2D.values;
+  const nextPositions = nextPosition2D.values;
+  for (let i = 0; i < vertexCount; ++i) {
+    const vertexLift = lifts[i];
+    if (vertexLift !== 0) {
+      positions[i * 3] += vertexLift;
+      prevPositions[i * 3] += vertexLift;
+      nextPositions[i * 3] += vertexLift;
+    }
+  }
+}
+function liftGroundPolyline2DToWorldCopy(geometry, projection) {
+  const attributes = geometry.attributes;
+  const startHiLo2D = attributes.startHiLo2D;
+  const position2D = attributes.position2D;
+  if (!defined_default(startHiLo2D) || !defined_default(position2D)) {
+    return;
+  }
+  const worldWidth = ColumbusWorlds_default.getWorldWidth(projection);
+  const halfWorldWidth = worldWidth * 0.5;
+  if (!(halfWorldWidth > 0)) {
+    return;
+  }
+  const starts = startHiLo2D.values;
+  const positions = position2D.values;
+  const count = Math.min(starts.length / 4, positions.length / 3);
+  for (let i = 0; i < count; ++i) {
+    const startU = starts[i * 4] + starts[i * 4 + 2];
+    const u = positions[i * 3];
+    const delta = startU - u;
+    if (delta > halfWorldWidth || delta < -halfWorldWidth) {
+      positions[i * 3] = u + Math.round(delta / worldWidth) * worldWidth;
+    }
+  }
+}
+function geometryPipeline(parameters) {
+  const instances = parameters.instances;
+  const projection = parameters.projection;
+  const uintIndexSupport = parameters.elementIndexUintSupported;
+  const scene3DOnly = parameters.scene3DOnly;
+  const columbusRepeatWorlds = parameters.columbusRepeatWorlds === true;
+  const vertexCacheOptimize = parameters.vertexCacheOptimize;
+  const compressVertices = parameters.compressVertices;
+  const modelMatrix = parameters.modelMatrix;
+  let i;
+  let geometry;
+  let primitiveType;
+  let length = instances.length;
+  for (i = 0; i < length; ++i) {
+    if (defined_default(instances[i].geometry)) {
+      primitiveType = instances[i].geometry.primitiveType;
+      break;
+    }
+  }
+  for (i = 1; i < length; ++i) {
+    if (defined_default(instances[i].geometry) && instances[i].geometry.primitiveType !== primitiveType) {
+      throw new DeveloperError_default(
+        "All instance geometries must have the same primitiveType."
+      );
+    }
+  }
+  transformToWorldCoordinates(instances, modelMatrix, scene3DOnly);
+  if (!scene3DOnly) {
+    for (i = 0; i < length; ++i) {
+      if (defined_default(instances[i].geometry)) {
+        GeometryPipeline_default.splitLongitude(instances[i]);
+      }
+    }
+  }
+  addBatchIds(instances);
+  if (vertexCacheOptimize) {
+    for (i = 0; i < length; ++i) {
+      const instance = instances[i];
+      if (defined_default(instance.geometry)) {
+        GeometryPipeline_default.reorderForPostVertexCache(instance.geometry);
+        GeometryPipeline_default.reorderForPreVertexCache(instance.geometry);
+      } else if (defined_default(instance.westHemisphereGeometry) && defined_default(instance.eastHemisphereGeometry)) {
+        GeometryPipeline_default.reorderForPostVertexCache(
+          instance.westHemisphereGeometry
+        );
+        GeometryPipeline_default.reorderForPreVertexCache(
+          instance.westHemisphereGeometry
+        );
+        GeometryPipeline_default.reorderForPostVertexCache(
+          instance.eastHemisphereGeometry
+        );
+        GeometryPipeline_default.reorderForPreVertexCache(
+          instance.eastHemisphereGeometry
+        );
+      }
+    }
+  }
+  let geometries = GeometryPipeline_default.combineInstances(instances);
+  length = geometries.length;
+  for (i = 0; i < length; ++i) {
+    geometry = geometries[i];
+    const attributes = geometry.attributes;
+    if (!scene3DOnly) {
+      const doubleAttributeNames = [];
+      for (const name in attributes) {
+        if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype_default.DOUBLE) {
+          doubleAttributeNames.push(name);
+        }
+      }
+      for (let a = 0; a < doubleAttributeNames.length; ++a) {
+        const name = doubleAttributeNames[a];
+        GeometryPipeline_default.projectTo2D(
+          geometry,
+          name,
+          `${name}3D`,
+          `${name}2D`,
+          projection
+        );
+      }
+      if (columbusRepeatWorlds) {
+        liftPolyline2DToWorldCopy(geometry, projection);
+        liftGroundPolyline2DToWorldCopy(geometry, projection);
+      }
+      if (defined_default(geometry.boundingSphere) && defined_default(attributes.position2D)) {
+        geometry.boundingSphereCV = BoundingSphere_default.fromVertices(
+          attributes.position2D.values
+        );
+      }
+      for (let a = 0; a < doubleAttributeNames.length; ++a) {
+        const name3D = `${doubleAttributeNames[a]}3D`;
+        const name2D = `${doubleAttributeNames[a]}2D`;
+        GeometryPipeline_default.encodeAttribute(
+          geometry,
+          name3D,
+          `${name3D}High`,
+          `${name3D}Low`
+        );
+        GeometryPipeline_default.encodeAttribute(
+          geometry,
+          name2D,
+          `${name2D}High`,
+          `${name2D}Low`
+        );
+      }
+    } else {
+      for (const name in attributes) {
+        if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype_default.DOUBLE) {
+          GeometryPipeline_default.encodeAttribute(
+            geometry,
+            name,
+            `${name}3DHigh`,
+            `${name}3DLow`
+          );
+        }
+      }
+    }
+    if (compressVertices) {
+      GeometryPipeline_default.compressVertices(geometry);
+    }
+  }
+  if (!uintIndexSupport) {
+    let splitGeometries = [];
+    length = geometries.length;
+    for (i = 0; i < length; ++i) {
+      geometry = geometries[i];
+      splitGeometries = splitGeometries.concat(
+        GeometryPipeline_default.fitToUnsignedShortIndices(geometry)
+      );
+    }
+    geometries = splitGeometries;
+  }
+  return geometries;
+}
+function createPickOffsets(instances, geometryName, geometries, pickOffsets) {
+  let offset;
+  let indexCount;
+  let geometryIndex;
+  const offsetIndex = pickOffsets.length - 1;
+  if (offsetIndex >= 0) {
+    const pickOffset = pickOffsets[offsetIndex];
+    offset = pickOffset.offset + pickOffset.count;
+    geometryIndex = pickOffset.index;
+    indexCount = geometries[geometryIndex].indices.length;
+  } else {
+    offset = 0;
+    geometryIndex = 0;
+    indexCount = geometries[geometryIndex].indices.length;
+  }
+  const length = instances.length;
+  for (let i = 0; i < length; ++i) {
+    const instance = instances[i];
+    const geometry = instance[geometryName];
+    if (!defined_default(geometry)) {
+      continue;
+    }
+    const count = geometry.indices.length;
+    if (offset + count > indexCount) {
+      offset = 0;
+      indexCount = geometries[++geometryIndex].indices.length;
+    }
+    pickOffsets.push({
+      index: geometryIndex,
+      offset,
+      count
+    });
+    offset += count;
+  }
+}
+function createInstancePickOffsets(instances, geometries) {
+  const pickOffsets = [];
+  createPickOffsets(instances, "geometry", geometries, pickOffsets);
+  createPickOffsets(
+    instances,
+    "westHemisphereGeometry",
+    geometries,
+    pickOffsets
+  );
+  createPickOffsets(
+    instances,
+    "eastHemisphereGeometry",
+    geometries,
+    pickOffsets
+  );
+  return pickOffsets;
+}
+var PrimitivePipeline = {};
+PrimitivePipeline.combineGeometry = function(parameters) {
+  let geometries;
+  let attributeLocations;
+  const instances = parameters.instances;
+  const length = instances.length;
+  let pickOffsets;
+  let offsetInstanceExtend;
+  let hasOffset = false;
+  if (length > 0) {
+    geometries = geometryPipeline(parameters);
+    if (geometries.length > 0) {
+      attributeLocations = GeometryPipeline_default.createAttributeLocations(
+        geometries[0]
+      );
+      if (parameters.createPickOffsets) {
+        pickOffsets = createInstancePickOffsets(instances, geometries);
+      }
+    }
+    if (defined_default(instances[0].attributes) && defined_default(instances[0].attributes.offset)) {
+      offsetInstanceExtend = new Array(length);
+      hasOffset = true;
+    }
+  }
+  const boundingSpheres = new Array(length);
+  const boundingSpheresCV = new Array(length);
+  for (let i = 0; i < length; ++i) {
+    const instance = instances[i];
+    const geometry = instance.geometry;
+    if (defined_default(geometry)) {
+      boundingSpheres[i] = geometry.boundingSphere;
+      boundingSpheresCV[i] = geometry.boundingSphereCV;
+      if (hasOffset) {
+        offsetInstanceExtend[i] = instance.geometry.offsetAttribute;
+      }
+    }
+    const eastHemisphereGeometry = instance.eastHemisphereGeometry;
+    const westHemisphereGeometry = instance.westHemisphereGeometry;
+    if (defined_default(eastHemisphereGeometry) && defined_default(westHemisphereGeometry)) {
+      if (defined_default(eastHemisphereGeometry.boundingSphere) && defined_default(westHemisphereGeometry.boundingSphere)) {
+        boundingSpheres[i] = BoundingSphere_default.union(
+          eastHemisphereGeometry.boundingSphere,
+          westHemisphereGeometry.boundingSphere
+        );
+      }
+      if (defined_default(eastHemisphereGeometry.boundingSphereCV) && defined_default(westHemisphereGeometry.boundingSphereCV)) {
+        boundingSpheresCV[i] = BoundingSphere_default.union(
+          eastHemisphereGeometry.boundingSphereCV,
+          westHemisphereGeometry.boundingSphereCV
+        );
+      }
+    }
+  }
+  return {
+    geometries,
+    modelMatrix: parameters.modelMatrix,
+    attributeLocations,
+    pickOffsets,
+    offsetInstanceExtend,
+    boundingSpheres,
+    boundingSpheresCV
+  };
+};
+function transferGeometry(geometry, transferableObjects) {
+  const attributes = geometry.attributes;
+  for (const name in attributes) {
+    if (attributes.hasOwnProperty(name)) {
+      const attribute = attributes[name];
+      if (defined_default(attribute) && defined_default(attribute.values)) {
+        transferableObjects.push(attribute.values.buffer);
+      }
+    }
+  }
+  if (defined_default(geometry.indices)) {
+    transferableObjects.push(geometry.indices.buffer);
+  }
+}
+function transferGeometries(geometries, transferableObjects) {
+  const length = geometries.length;
+  for (let i = 0; i < length; ++i) {
+    transferGeometry(geometries[i], transferableObjects);
+  }
+}
+function countCreateGeometryResults(items) {
+  let count = 1;
+  const length = items.length;
+  for (let i = 0; i < length; i++) {
+    const geometry = items[i];
+    ++count;
+    if (!defined_default(geometry)) {
+      continue;
+    }
+    const attributes = geometry.attributes;
+    count += 7 + 2 * BoundingSphere_default.packedLength + (defined_default(geometry.indices) ? geometry.indices.length : 0);
+    for (const property in attributes) {
+      if (attributes.hasOwnProperty(property) && defined_default(attributes[property])) {
+        const attribute = attributes[property];
+        count += 5 + attribute.values.length;
+      }
+    }
+  }
+  return count;
+}
+PrimitivePipeline.packCreateGeometryResults = function(items, transferableObjects) {
+  const packedData = new Float64Array(countCreateGeometryResults(items));
+  const stringTable = [];
+  const stringHash = {};
+  const length = items.length;
+  let count = 0;
+  packedData[count++] = length;
+  for (let i = 0; i < length; i++) {
+    const geometry = items[i];
+    const validGeometry = defined_default(geometry);
+    packedData[count++] = validGeometry ? 1 : 0;
+    if (!validGeometry) {
+      continue;
+    }
+    packedData[count++] = geometry.primitiveType;
+    packedData[count++] = geometry.geometryType;
+    packedData[count++] = geometry.offsetAttribute ?? -1;
+    const validBoundingSphere = defined_default(geometry.boundingSphere) ? 1 : 0;
+    packedData[count++] = validBoundingSphere;
+    if (validBoundingSphere) {
+      BoundingSphere_default.pack(geometry.boundingSphere, packedData, count);
+    }
+    count += BoundingSphere_default.packedLength;
+    const validBoundingSphereCV = defined_default(geometry.boundingSphereCV) ? 1 : 0;
+    packedData[count++] = validBoundingSphereCV;
+    if (validBoundingSphereCV) {
+      BoundingSphere_default.pack(geometry.boundingSphereCV, packedData, count);
+    }
+    count += BoundingSphere_default.packedLength;
+    const attributes = geometry.attributes;
+    const attributesToWrite = [];
+    for (const property in attributes) {
+      if (attributes.hasOwnProperty(property) && defined_default(attributes[property])) {
+        attributesToWrite.push(property);
+        if (!defined_default(stringHash[property])) {
+          stringHash[property] = stringTable.length;
+          stringTable.push(property);
+        }
+      }
+    }
+    packedData[count++] = attributesToWrite.length;
+    for (let q = 0; q < attributesToWrite.length; q++) {
+      const name = attributesToWrite[q];
+      const attribute = attributes[name];
+      packedData[count++] = stringHash[name];
+      packedData[count++] = attribute.componentDatatype;
+      packedData[count++] = attribute.componentsPerAttribute;
+      packedData[count++] = attribute.normalize ? 1 : 0;
+      packedData[count++] = attribute.values.length;
+      packedData.set(attribute.values, count);
+      count += attribute.values.length;
+    }
+    const indicesLength = defined_default(geometry.indices) ? geometry.indices.length : 0;
+    packedData[count++] = indicesLength;
+    if (indicesLength > 0) {
+      packedData.set(geometry.indices, count);
+      count += indicesLength;
+    }
+  }
+  transferableObjects.push(packedData.buffer);
+  return {
+    stringTable,
+    packedData
+  };
+};
+PrimitivePipeline.unpackCreateGeometryResults = function(createGeometryResult) {
+  const stringTable = createGeometryResult.stringTable;
+  const packedGeometry = createGeometryResult.packedData;
+  let i;
+  const result = new Array(packedGeometry[0]);
+  let resultIndex = 0;
+  let packedGeometryIndex = 1;
+  while (packedGeometryIndex < packedGeometry.length) {
+    const valid = packedGeometry[packedGeometryIndex++] === 1;
+    if (!valid) {
+      result[resultIndex++] = void 0;
+      continue;
+    }
+    const primitiveType = packedGeometry[packedGeometryIndex++];
+    const geometryType = packedGeometry[packedGeometryIndex++];
+    let offsetAttribute = packedGeometry[packedGeometryIndex++];
+    if (offsetAttribute === -1) {
+      offsetAttribute = void 0;
+    }
+    let boundingSphere;
+    let boundingSphereCV;
+    const validBoundingSphere = packedGeometry[packedGeometryIndex++] === 1;
+    if (validBoundingSphere) {
+      boundingSphere = BoundingSphere_default.unpack(
+        packedGeometry,
+        packedGeometryIndex
+      );
+    }
+    packedGeometryIndex += BoundingSphere_default.packedLength;
+    const validBoundingSphereCV = packedGeometry[packedGeometryIndex++] === 1;
+    if (validBoundingSphereCV) {
+      boundingSphereCV = BoundingSphere_default.unpack(
+        packedGeometry,
+        packedGeometryIndex
+      );
+    }
+    packedGeometryIndex += BoundingSphere_default.packedLength;
+    let length;
+    let values;
+    let componentsPerAttribute;
+    const attributes = new GeometryAttributes_default();
+    const numAttributes = packedGeometry[packedGeometryIndex++];
+    for (i = 0; i < numAttributes; i++) {
+      const name = stringTable[packedGeometry[packedGeometryIndex++]];
+      const componentDatatype = packedGeometry[packedGeometryIndex++];
+      componentsPerAttribute = packedGeometry[packedGeometryIndex++];
+      const normalize = packedGeometry[packedGeometryIndex++] !== 0;
+      length = packedGeometry[packedGeometryIndex++];
+      values = ComponentDatatype_default.createTypedArray(componentDatatype, length);
+      for (let valuesIndex = 0; valuesIndex < length; valuesIndex++) {
+        values[valuesIndex] = packedGeometry[packedGeometryIndex++];
+      }
+      attributes[name] = new GeometryAttribute_default({
+        componentDatatype,
+        componentsPerAttribute,
+        normalize,
+        values
+      });
+    }
+    let indices;
+    length = packedGeometry[packedGeometryIndex++];
+    if (length > 0) {
+      const numberOfVertices = values.length / componentsPerAttribute;
+      indices = IndexDatatype_default.createTypedArray(numberOfVertices, length);
+      for (i = 0; i < length; i++) {
+        indices[i] = packedGeometry[packedGeometryIndex++];
+      }
+    }
+    result[resultIndex++] = new Geometry_default({
+      primitiveType,
+      geometryType,
+      boundingSphere,
+      boundingSphereCV,
+      indices,
+      attributes,
+      offsetAttribute
+    });
+  }
+  return result;
+};
+function packInstancesForCombine(instances, transferableObjects) {
+  const length = instances.length;
+  const packedData = new Float64Array(1 + length * 19);
+  let count = 0;
+  packedData[count++] = length;
+  for (let i = 0; i < length; i++) {
+    const instance = instances[i];
+    Matrix4_default.pack(instance.modelMatrix, packedData, count);
+    count += Matrix4_default.packedLength;
+    if (defined_default(instance.attributes) && defined_default(instance.attributes.offset)) {
+      const values = instance.attributes.offset.value;
+      packedData[count] = values[0];
+      packedData[count + 1] = values[1];
+      packedData[count + 2] = values[2];
+    }
+    count += 3;
+  }
+  transferableObjects.push(packedData.buffer);
+  return packedData;
+}
+function unpackInstancesForCombine(data) {
+  const packedInstances = data;
+  const result = new Array(packedInstances[0]);
+  let count = 0;
+  let i = 1;
+  while (i < packedInstances.length) {
+    const modelMatrix = Matrix4_default.unpack(packedInstances, i);
+    let attributes;
+    i += Matrix4_default.packedLength;
+    if (defined_default(packedInstances[i])) {
+      attributes = {
+        offset: new OffsetGeometryInstanceAttribute_default(
+          packedInstances[i],
+          packedInstances[i + 1],
+          packedInstances[i + 2]
+        )
+      };
+    }
+    i += 3;
+    result[count++] = {
+      modelMatrix,
+      attributes
+    };
+  }
+  return result;
+}
+PrimitivePipeline.packCombineGeometryParameters = function(parameters, transferableObjects) {
+  const createGeometryResults = parameters.createGeometryResults;
+  const length = createGeometryResults.length;
+  for (let i = 0; i < length; i++) {
+    transferableObjects.push(createGeometryResults[i].packedData.buffer);
+  }
+  return {
+    createGeometryResults: parameters.createGeometryResults,
+    packedInstances: packInstancesForCombine(
+      parameters.instances,
+      transferableObjects
+    ),
+    ellipsoid: parameters.ellipsoid,
+    isGeographic: parameters.projection instanceof GeographicProjection_default,
+    elementIndexUintSupported: parameters.elementIndexUintSupported,
+    scene3DOnly: parameters.scene3DOnly,
+    columbusRepeatWorlds: parameters.columbusRepeatWorlds === true,
+    vertexCacheOptimize: parameters.vertexCacheOptimize,
+    compressVertices: parameters.compressVertices,
+    modelMatrix: parameters.modelMatrix,
+    createPickOffsets: parameters.createPickOffsets
+  };
+};
+PrimitivePipeline.unpackCombineGeometryParameters = function(packedParameters) {
+  const instances = unpackInstancesForCombine(packedParameters.packedInstances);
+  const createGeometryResults = packedParameters.createGeometryResults;
+  const length = createGeometryResults.length;
+  let instanceIndex = 0;
+  for (let resultIndex = 0; resultIndex < length; resultIndex++) {
+    const geometries = PrimitivePipeline.unpackCreateGeometryResults(
+      createGeometryResults[resultIndex]
+    );
+    const geometriesLength = geometries.length;
+    for (let geometryIndex = 0; geometryIndex < geometriesLength; geometryIndex++) {
+      const geometry = geometries[geometryIndex];
+      const instance = instances[instanceIndex];
+      instance.geometry = geometry;
+      ++instanceIndex;
+    }
+  }
+  const ellipsoid = Ellipsoid_default.clone(packedParameters.ellipsoid);
+  const projection = packedParameters.isGeographic ? new GeographicProjection_default(ellipsoid) : new WebMercatorProjection_default(ellipsoid);
+  return {
+    instances,
+    ellipsoid,
+    projection,
+    elementIndexUintSupported: packedParameters.elementIndexUintSupported,
+    scene3DOnly: packedParameters.scene3DOnly,
+    columbusRepeatWorlds: packedParameters.columbusRepeatWorlds === true,
+    vertexCacheOptimize: packedParameters.vertexCacheOptimize,
+    compressVertices: packedParameters.compressVertices,
+    modelMatrix: Matrix4_default.clone(packedParameters.modelMatrix),
+    createPickOffsets: packedParameters.createPickOffsets
+  };
+};
+function packBoundingSpheres(boundingSpheres) {
+  const length = boundingSpheres.length;
+  const bufferLength = 1 + (BoundingSphere_default.packedLength + 1) * length;
+  const buffer = new Float32Array(bufferLength);
+  let bufferIndex = 0;
+  buffer[bufferIndex++] = length;
+  for (let i = 0; i < length; ++i) {
+    const bs = boundingSpheres[i];
+    if (!defined_default(bs)) {
+      buffer[bufferIndex++] = 0;
+    } else {
+      buffer[bufferIndex++] = 1;
+      BoundingSphere_default.pack(boundingSpheres[i], buffer, bufferIndex);
+    }
+    bufferIndex += BoundingSphere_default.packedLength;
+  }
+  return buffer;
+}
+function unpackBoundingSpheres(buffer) {
+  const result = new Array(buffer[0]);
+  let count = 0;
+  let i = 1;
+  while (i < buffer.length) {
+    if (buffer[i++] === 1) {
+      result[count] = BoundingSphere_default.unpack(buffer, i);
+    }
+    ++count;
+    i += BoundingSphere_default.packedLength;
+  }
+  return result;
+}
+PrimitivePipeline.packCombineGeometryResults = function(results, transferableObjects) {
+  if (defined_default(results.geometries)) {
+    transferGeometries(results.geometries, transferableObjects);
+  }
+  const packedBoundingSpheres = packBoundingSpheres(results.boundingSpheres);
+  const packedBoundingSpheresCV = packBoundingSpheres(
+    results.boundingSpheresCV
+  );
+  transferableObjects.push(
+    packedBoundingSpheres.buffer,
+    packedBoundingSpheresCV.buffer
+  );
+  return {
+    geometries: results.geometries,
+    attributeLocations: results.attributeLocations,
+    modelMatrix: results.modelMatrix,
+    pickOffsets: results.pickOffsets,
+    offsetInstanceExtend: results.offsetInstanceExtend,
+    boundingSpheres: packedBoundingSpheres,
+    boundingSpheresCV: packedBoundingSpheresCV
+  };
+};
+PrimitivePipeline.unpackCombineGeometryResults = function(packedResult) {
+  return {
+    geometries: packedResult.geometries,
+    attributeLocations: packedResult.attributeLocations,
+    modelMatrix: packedResult.modelMatrix,
+    pickOffsets: packedResult.pickOffsets,
+    offsetInstanceExtend: packedResult.offsetInstanceExtend,
+    boundingSpheres: unpackBoundingSpheres(packedResult.boundingSpheres),
+    boundingSpheresCV: unpackBoundingSpheres(packedResult.boundingSpheresCV)
+  };
+};
+var PrimitivePipeline_default = PrimitivePipeline;
+
+export {
+  PrimitivePipeline_default
+};