@rtzh/engine 0.0.3 → 0.0.4

package/Build/Workers/chunk-Z356SW7E.js

@@ -0,0 +1,256 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.4
+ *
+ * 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 {
+  WebGLConstants_default
+} from "./chunk-DEIMB3B5.js";
+import {
+  DeveloperError_default
+} from "./chunk-HGIGANIQ.js";
+import {
+  defined_default
+} from "./chunk-BN4WA7LX.js";
+
+// packages/engine/Source/Core/ComponentDatatype.js
+var ComponentDatatype = {
+  /**
+   * 8-bit signed byte corresponding to <code>gl.BYTE</code> and the type
+   * of an element in <code>Int8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  BYTE: WebGLConstants_default.BYTE,
+  /**
+   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+   * of an element in <code>Uint8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
+  /**
+   * 16-bit signed short corresponding to <code>SHORT</code> and the type
+   * of an element in <code>Int16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  SHORT: WebGLConstants_default.SHORT,
+  /**
+   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+   * of an element in <code>Uint16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
+  /**
+   * 32-bit signed int corresponding to <code>INT</code> and the type
+   * of an element in <code>Int32Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   */
+  INT: WebGLConstants_default.INT,
+  /**
+   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT,
+  /**
+   * 32-bit floating-point corresponding to <code>FLOAT</code> and the type
+   * of an element in <code>Float32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  FLOAT: WebGLConstants_default.FLOAT,
+  /**
+   * 64-bit floating-point corresponding to <code>gl.DOUBLE</code> (in Desktop OpenGL;
+   * this is not supported in WebGL, and is emulated in Cesium via {@link GeometryPipeline.encodeAttribute})
+   * and the type of an element in <code>Float64Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   * @default 0x140A
+   */
+  DOUBLE: WebGLConstants_default.DOUBLE
+};
+ComponentDatatype.getSizeInBytes = function(componentDatatype) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("value is required.");
+  }
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return Int8Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.SHORT:
+      return Int16Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.INT:
+      return Int32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.FLOAT:
+      return Float32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.DOUBLE:
+      return Float64Array.BYTES_PER_ELEMENT;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.fromTypedArray = function(array) {
+  if (array instanceof Int8Array) {
+    return ComponentDatatype.BYTE;
+  }
+  if (array instanceof Uint8Array) {
+    return ComponentDatatype.UNSIGNED_BYTE;
+  }
+  if (array instanceof Int16Array) {
+    return ComponentDatatype.SHORT;
+  }
+  if (array instanceof Uint16Array) {
+    return ComponentDatatype.UNSIGNED_SHORT;
+  }
+  if (array instanceof Int32Array) {
+    return ComponentDatatype.INT;
+  }
+  if (array instanceof Uint32Array) {
+    return ComponentDatatype.UNSIGNED_INT;
+  }
+  if (array instanceof Float32Array) {
+    return ComponentDatatype.FLOAT;
+  }
+  if (array instanceof Float64Array) {
+    return ComponentDatatype.DOUBLE;
+  }
+  throw new DeveloperError_default(
+    "array must be an Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, or Float64Array."
+  );
+};
+ComponentDatatype.validate = function(componentDatatype) {
+  return defined_default(componentDatatype) && (componentDatatype === ComponentDatatype.BYTE || componentDatatype === ComponentDatatype.UNSIGNED_BYTE || componentDatatype === ComponentDatatype.SHORT || componentDatatype === ComponentDatatype.UNSIGNED_SHORT || componentDatatype === ComponentDatatype.INT || componentDatatype === ComponentDatatype.UNSIGNED_INT || componentDatatype === ComponentDatatype.FLOAT || componentDatatype === ComponentDatatype.DOUBLE);
+};
+ComponentDatatype.createTypedArray = function(componentDatatype, valuesOrLength) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("componentDatatype is required.");
+  }
+  if (!defined_default(valuesOrLength)) {
+    throw new DeveloperError_default("valuesOrLength is required.");
+  }
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return new Int8Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return new Uint8Array(valuesOrLength);
+    case ComponentDatatype.SHORT:
+      return new Int16Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return new Uint16Array(valuesOrLength);
+    case ComponentDatatype.INT:
+      return new Int32Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_INT:
+      return new Uint32Array(valuesOrLength);
+    case ComponentDatatype.FLOAT:
+      return new Float32Array(valuesOrLength);
+    case ComponentDatatype.DOUBLE:
+      return new Float64Array(valuesOrLength);
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.createArrayBufferView = function(componentDatatype, buffer, byteOffset, length) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("componentDatatype is required.");
+  }
+  if (!defined_default(buffer)) {
+    throw new DeveloperError_default("buffer is required.");
+  }
+  byteOffset = byteOffset ?? 0;
+  length = length ?? (buffer.byteLength - byteOffset) / ComponentDatatype.getSizeInBytes(componentDatatype);
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return new Int8Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return new Uint8Array(buffer, byteOffset, length);
+    case ComponentDatatype.SHORT:
+      return new Int16Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return new Uint16Array(buffer, byteOffset, length);
+    case ComponentDatatype.INT:
+      return new Int32Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_INT:
+      return new Uint32Array(buffer, byteOffset, length);
+    case ComponentDatatype.FLOAT:
+      return new Float32Array(buffer, byteOffset, length);
+    case ComponentDatatype.DOUBLE:
+      return new Float64Array(buffer, byteOffset, length);
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.fromName = function(name) {
+  switch (name) {
+    case "BYTE":
+      return ComponentDatatype.BYTE;
+    case "UNSIGNED_BYTE":
+      return ComponentDatatype.UNSIGNED_BYTE;
+    case "SHORT":
+      return ComponentDatatype.SHORT;
+    case "UNSIGNED_SHORT":
+      return ComponentDatatype.UNSIGNED_SHORT;
+    case "INT":
+      return ComponentDatatype.INT;
+    case "UNSIGNED_INT":
+      return ComponentDatatype.UNSIGNED_INT;
+    case "FLOAT":
+      return ComponentDatatype.FLOAT;
+    case "DOUBLE":
+      return ComponentDatatype.DOUBLE;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("name is not a valid value.");
+  }
+};
+var ComponentDatatype_default = Object.freeze(ComponentDatatype);
+
+export {
+  ComponentDatatype_default
+};

package/Build/Workers/chunk-ZV42SJKS.js

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.4
+ *
+ * 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 {
+  Frozen_default
+} from "./chunk-VR2L2Y4Z.js";
+
+// packages/engine/Source/Core/GeometryAttributes.js
+function GeometryAttributes(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  this.position = options.position;
+  this.normal = options.normal;
+  this.st = options.st;
+  this.bitangent = options.bitangent;
+  this.tangent = options.tangent;
+  this.color = options.color;
+}
+var GeometryAttributes_default = GeometryAttributes;
+
+export {
+  GeometryAttributes_default
+};

package/Build/Workers/combineGeometry.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.4
+ *
+ * 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 {
+  PrimitivePipeline_default
+} from "./chunk-KHKSE4WQ.js";
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-2APW7KRS.js";
+import "./chunk-KVDSJXRK.js";
+import "./chunk-UUJXSLQ2.js";
+import "./chunk-PHB5MRHM.js";
+import "./chunk-MLFVICFZ.js";
+import "./chunk-HU5P7PMU.js";
+import "./chunk-BXBGWQ3Z.js";
+import "./chunk-KBAGFNQ4.js";
+import "./chunk-ZV42SJKS.js";
+import "./chunk-2BLQ3B4Q.js";
+import "./chunk-UOD5YNH3.js";
+import "./chunk-5BIQOSBV.js";
+import "./chunk-HAWJ7FMN.js";
+import "./chunk-EISI2CR2.js";
+import "./chunk-Z356SW7E.js";
+import "./chunk-DEIMB3B5.js";
+import "./chunk-HI6X33GO.js";
+import "./chunk-F5LAPCFC.js";
+import "./chunk-VR2L2Y4Z.js";
+import "./chunk-WMGESUDW.js";
+import "./chunk-HGIGANIQ.js";
+import "./chunk-BN4WA7LX.js";
+
+// packages/engine/Source/Workers/combineGeometry.js
+function combineGeometry(packedParameters, transferableObjects) {
+  const parameters = PrimitivePipeline_default.unpackCombineGeometryParameters(packedParameters);
+  const results = PrimitivePipeline_default.combineGeometry(parameters);
+  return PrimitivePipeline_default.packCombineGeometryResults(
+    results,
+    transferableObjects
+  );
+}
+var combineGeometry_default = createTaskProcessorWorker_default(combineGeometry);
+export {
+  combineGeometry_default as default
+};

package/Build/Workers/createBoxGeometry.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.4
+ *
+ * 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 {
+  BoxGeometry_default
+} from "./chunk-U364CIW4.js";
+import "./chunk-J3FBVUY4.js";
+import "./chunk-FJREGHFG.js";
+import "./chunk-ZV42SJKS.js";
+import "./chunk-2BLQ3B4Q.js";
+import "./chunk-UOD5YNH3.js";
+import "./chunk-5BIQOSBV.js";
+import "./chunk-HAWJ7FMN.js";
+import "./chunk-EISI2CR2.js";
+import "./chunk-Z356SW7E.js";
+import "./chunk-DEIMB3B5.js";
+import "./chunk-HI6X33GO.js";
+import "./chunk-F5LAPCFC.js";
+import "./chunk-VR2L2Y4Z.js";
+import "./chunk-WMGESUDW.js";
+import "./chunk-HGIGANIQ.js";
+import {
+  defined_default
+} from "./chunk-BN4WA7LX.js";
+
+// packages/engine/Source/Workers/createBoxGeometry.js
+function createBoxGeometry(boxGeometry, offset) {
+  if (defined_default(offset)) {
+    boxGeometry = BoxGeometry_default.unpack(boxGeometry, offset);
+  }
+  return BoxGeometry_default.createGeometry(boxGeometry);
+}
+var createBoxGeometry_default = createBoxGeometry;
+export {
+  createBoxGeometry_default as default
+};

package/Build/Workers/createBoxOutlineGeometry.js

@@ -0,0 +1,231 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.4
+ *
+ * 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 {
+  GeometryOffsetAttribute_default
+} from "./chunk-J3FBVUY4.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-ZV42SJKS.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-2BLQ3B4Q.js";
+import {
+  BoundingSphere_default
+} from "./chunk-UOD5YNH3.js";
+import "./chunk-5BIQOSBV.js";
+import "./chunk-HAWJ7FMN.js";
+import "./chunk-EISI2CR2.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-Z356SW7E.js";
+import "./chunk-DEIMB3B5.js";
+import "./chunk-HI6X33GO.js";
+import "./chunk-F5LAPCFC.js";
+import {
+  Cartesian3_default,
+  Frozen_default
+} from "./chunk-VR2L2Y4Z.js";
+import "./chunk-WMGESUDW.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-HGIGANIQ.js";
+import {
+  defined_default
+} from "./chunk-BN4WA7LX.js";
+
+// packages/engine/Source/Core/BoxOutlineGeometry.js
+var diffScratch = new Cartesian3_default();
+function BoxOutlineGeometry(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  const min = options.minimum;
+  const max = options.maximum;
+  Check_default.typeOf.object("min", min);
+  Check_default.typeOf.object("max", max);
+  if (defined_default(options.offsetAttribute) && options.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+    throw new DeveloperError_default(
+      "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
+    );
+  }
+  this._min = Cartesian3_default.clone(min);
+  this._max = Cartesian3_default.clone(max);
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createBoxOutlineGeometry";
+}
+BoxOutlineGeometry.fromDimensions = function(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  const dimensions = options.dimensions;
+  Check_default.typeOf.object("dimensions", dimensions);
+  Check_default.typeOf.number.greaterThanOrEquals("dimensions.x", dimensions.x, 0);
+  Check_default.typeOf.number.greaterThanOrEquals("dimensions.y", dimensions.y, 0);
+  Check_default.typeOf.number.greaterThanOrEquals("dimensions.z", dimensions.z, 0);
+  const corner = Cartesian3_default.multiplyByScalar(dimensions, 0.5, new Cartesian3_default());
+  return new BoxOutlineGeometry({
+    minimum: Cartesian3_default.negate(corner, new Cartesian3_default()),
+    maximum: corner,
+    offsetAttribute: options.offsetAttribute
+  });
+};
+BoxOutlineGeometry.fromAxisAlignedBoundingBox = function(boundingBox) {
+  Check_default.typeOf.object("boundindBox", boundingBox);
+  return new BoxOutlineGeometry({
+    minimum: boundingBox.minimum,
+    maximum: boundingBox.maximum
+  });
+};
+BoxOutlineGeometry.packedLength = 2 * Cartesian3_default.packedLength + 1;
+BoxOutlineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = startingIndex ?? 0;
+  Cartesian3_default.pack(value._min, array, startingIndex);
+  Cartesian3_default.pack(value._max, array, startingIndex + Cartesian3_default.packedLength);
+  array[startingIndex + Cartesian3_default.packedLength * 2] = value._offsetAttribute ?? -1;
+  return array;
+};
+var scratchMin = new Cartesian3_default();
+var scratchMax = new Cartesian3_default();
+var scratchOptions = {
+  minimum: scratchMin,
+  maximum: scratchMax,
+  offsetAttribute: void 0
+};
+BoxOutlineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = startingIndex ?? 0;
+  const min = Cartesian3_default.unpack(array, startingIndex, scratchMin);
+  const max = Cartesian3_default.unpack(
+    array,
+    startingIndex + Cartesian3_default.packedLength,
+    scratchMax
+  );
+  const offsetAttribute = array[startingIndex + Cartesian3_default.packedLength * 2];
+  if (!defined_default(result)) {
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new BoxOutlineGeometry(scratchOptions);
+  }
+  result._min = Cartesian3_default.clone(min, result._min);
+  result._max = Cartesian3_default.clone(max, result._max);
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+BoxOutlineGeometry.createGeometry = function(boxGeometry) {
+  const min = boxGeometry._min;
+  const max = boxGeometry._max;
+  if (Cartesian3_default.equals(min, max)) {
+    return;
+  }
+  const attributes = new GeometryAttributes_default();
+  const indices = new Uint16Array(12 * 2);
+  const positions = new Float64Array(8 * 3);
+  positions[0] = min.x;
+  positions[1] = min.y;
+  positions[2] = min.z;
+  positions[3] = max.x;
+  positions[4] = min.y;
+  positions[5] = min.z;
+  positions[6] = max.x;
+  positions[7] = max.y;
+  positions[8] = min.z;
+  positions[9] = min.x;
+  positions[10] = max.y;
+  positions[11] = min.z;
+  positions[12] = min.x;
+  positions[13] = min.y;
+  positions[14] = max.z;
+  positions[15] = max.x;
+  positions[16] = min.y;
+  positions[17] = max.z;
+  positions[18] = max.x;
+  positions[19] = max.y;
+  positions[20] = max.z;
+  positions[21] = min.x;
+  positions[22] = max.y;
+  positions[23] = max.z;
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: positions
+  });
+  indices[0] = 4;
+  indices[1] = 5;
+  indices[2] = 5;
+  indices[3] = 6;
+  indices[4] = 6;
+  indices[5] = 7;
+  indices[6] = 7;
+  indices[7] = 4;
+  indices[8] = 0;
+  indices[9] = 1;
+  indices[10] = 1;
+  indices[11] = 2;
+  indices[12] = 2;
+  indices[13] = 3;
+  indices[14] = 3;
+  indices[15] = 0;
+  indices[16] = 0;
+  indices[17] = 4;
+  indices[18] = 1;
+  indices[19] = 5;
+  indices[20] = 2;
+  indices[21] = 6;
+  indices[22] = 3;
+  indices[23] = 7;
+  const diff = Cartesian3_default.subtract(max, min, diffScratch);
+  const radius = Cartesian3_default.magnitude(diff) * 0.5;
+  if (defined_default(boxGeometry._offsetAttribute)) {
+    const length = positions.length;
+    const offsetValue = boxGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+    const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  return new Geometry_default({
+    attributes,
+    indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere: new BoundingSphere_default(Cartesian3_default.ZERO, radius),
+    offsetAttribute: boxGeometry._offsetAttribute
+  });
+};
+var BoxOutlineGeometry_default = BoxOutlineGeometry;
+
+// packages/engine/Source/Workers/createBoxOutlineGeometry.js
+function createBoxOutlineGeometry(boxGeometry, offset) {
+  if (defined_default(offset)) {
+    boxGeometry = BoxOutlineGeometry_default.unpack(boxGeometry, offset);
+  }
+  return BoxOutlineGeometry_default.createGeometry(boxGeometry);
+}
+var createBoxOutlineGeometry_default = createBoxOutlineGeometry;
+export {
+  createBoxOutlineGeometry_default as default
+};