@vcmap/ui 5.0.0-rc.17 → 5.0.0-rc.20

package/dist/assets/cesium/Workers/combine-ca22a614.js

@@ -0,0 +1,82 @@
+define(['exports', './defaultValue-0a909f67'], (function (exports, defaultValue) { 'use strict';
+
+  /**
+   * Merges two objects, copying their properties onto a new combined object. When two objects have the same
+   * property, the value of the property on the first object is used.  If either object is undefined,
+   * it will be treated as an empty object.
+   *
+   * @example
+   * const object1 = {
+   *     propOne : 1,
+   *     propTwo : {
+   *         value1 : 10
+   *     }
+   * }
+   * const object2 = {
+   *     propTwo : 2
+   * }
+   * const final = Cesium.combine(object1, object2);
+   *
+   * // final === {
+   * //     propOne : 1,
+   * //     propTwo : {
+   * //         value1 : 10
+   * //     }
+   * // }
+   *
+   * @param {Object} [object1] The first object to merge.
+   * @param {Object} [object2] The second object to merge.
+   * @param {Boolean} [deep=false] Perform a recursive merge.
+   * @returns {Object} The combined object containing all properties from both objects.
+   *
+   * @function
+   */
+  function combine(object1, object2, deep) {
+    deep = defaultValue.defaultValue(deep, false);
+
+    const result = {};
+
+    const object1Defined = defaultValue.defined(object1);
+    const object2Defined = defaultValue.defined(object2);
+    let property;
+    let object1Value;
+    let object2Value;
+    if (object1Defined) {
+      for (property in object1) {
+        if (object1.hasOwnProperty(property)) {
+          object1Value = object1[property];
+          if (
+            object2Defined &&
+            deep &&
+            typeof object1Value === "object" &&
+            object2.hasOwnProperty(property)
+          ) {
+            object2Value = object2[property];
+            if (typeof object2Value === "object") {
+              result[property] = combine(object1Value, object2Value, deep);
+            } else {
+              result[property] = object1Value;
+            }
+          } else {
+            result[property] = object1Value;
+          }
+        }
+      }
+    }
+    if (object2Defined) {
+      for (property in object2) {
+        if (
+          object2.hasOwnProperty(property) &&
+          !result.hasOwnProperty(property)
+        ) {
+          object2Value = object2[property];
+          result[property] = object2Value;
+        }
+      }
+    }
+    return result;
+  }
+
+  exports.combine = combine;
+
+}));

package/dist/assets/cesium/Workers/combineGeometry.js

@@ -1,25 +1,17 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./PrimitivePipeline-e2640413","./createTaskProcessorWorker","./Transforms-d2e5867e","./Matrix2-eefef8eb","./defaultValue-0c475b81","./ComponentDatatype-0200bf8c","./WebGLConstants-5b50ced1","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryPipeline-33ca229c","./AttributeCompression-7b0f288d","./EncodedCartesian3-ea0e408f","./IndexDatatype-e713bfd2","./IntersectionTests-eb4db8e0","./Plane-b0299683","./WebMercatorProjection-cd2f30c2"],(function(e,t,i,r,n,o,c,a,b,s,m,f,d,u,P,p,l,y,G){"use strict";return t((function(t,i){const r=e.PrimitivePipeline.unpackCombineGeometryParameters(t),n=e.PrimitivePipeline.combineGeometry(r);return e.PrimitivePipeline.packCombineGeometryResults(n,i)}))}));
+define(['./PrimitivePipeline-ba38434a', './createTaskProcessorWorker', './Transforms-40229881', './Matrix3-315394f6', './Check-666ab1a0', './defaultValue-0a909f67', './Math-2dbd6b93', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryPipeline-ce4339ed', './AttributeCompression-b646d393', './EncodedCartesian3-81f70735', './IndexDatatype-a55ceaa1', './IntersectionTests-f6e6bd8a', './Plane-900aa728', './WebMercatorProjection-13a90d41'], (function (PrimitivePipeline, createTaskProcessorWorker, Transforms, Matrix3, Check, defaultValue, Math, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryPipeline, AttributeCompression, EncodedCartesian3, IndexDatatype, IntersectionTests, Plane, WebMercatorProjection) { 'use strict';
+
+  function combineGeometry(packedParameters, transferableObjects) {
+    const parameters = PrimitivePipeline.PrimitivePipeline.unpackCombineGeometryParameters(
+      packedParameters
+    );
+    const results = PrimitivePipeline.PrimitivePipeline.combineGeometry(parameters);
+    return PrimitivePipeline.PrimitivePipeline.packCombineGeometryResults(
+      results,
+      transferableObjects
+    );
+  }
+  var combineGeometry$1 = createTaskProcessorWorker(combineGeometry);
+
+  return combineGeometry$1;
+
+}));

package/dist/assets/cesium/Workers/createBoxGeometry.js

@@ -1,25 +1,12 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./BoxGeometry-4985457c","./defaultValue-0c475b81","./Transforms-d2e5867e","./Matrix2-eefef8eb","./ComponentDatatype-0200bf8c","./WebGLConstants-5b50ced1","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryOffsetAttribute-08ae0c50","./VertexFormat-5ec0d9ff"],(function(e,t,r,o,c,n,f,a,m,b,u,i,s){"use strict";return function(r,o){return t.defined(o)&&(r=e.BoxGeometry.unpack(r,o)),e.BoxGeometry.createGeometry(r)}}));
+define(['./BoxGeometry-12eeccaf', './defaultValue-0a909f67', './Transforms-40229881', './Matrix3-315394f6', './Check-666ab1a0', './Math-2dbd6b93', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryOffsetAttribute-04332ce7', './VertexFormat-6b480673'], (function (BoxGeometry, defaultValue, Transforms, Matrix3, Check, Math, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, VertexFormat) { 'use strict';
+
+  function createBoxGeometry(boxGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      boxGeometry = BoxGeometry.BoxGeometry.unpack(boxGeometry, offset);
+    }
+    return BoxGeometry.BoxGeometry.createGeometry(boxGeometry);
+  }
+
+  return createBoxGeometry;
+
+}));

package/dist/assets/cesium/Workers/createBoxOutlineGeometry.js

@@ -1,25 +1,313 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./Transforms-d2e5867e","./Matrix2-eefef8eb","./ComponentDatatype-0200bf8c","./defaultValue-0c475b81","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryOffsetAttribute-08ae0c50","./_commonjsHelpers-bc29abbc","./combine-7533016d","./RuntimeError-5baf5c66","./WebGLConstants-5b50ced1"],(function(e,t,n,a,i,r,o,u,s,m,f){"use strict";const c=new t.Cartesian3;function d(e){const n=(e=a.defaultValue(e,a.defaultValue.EMPTY_OBJECT)).minimum,i=e.maximum;this._min=t.Cartesian3.clone(n),this._max=t.Cartesian3.clone(i),this._offsetAttribute=e.offsetAttribute,this._workerName="createBoxOutlineGeometry"}d.fromDimensions=function(e){const n=(e=a.defaultValue(e,a.defaultValue.EMPTY_OBJECT)).dimensions,i=t.Cartesian3.multiplyByScalar(n,.5,new t.Cartesian3);return new d({minimum:t.Cartesian3.negate(i,new t.Cartesian3),maximum:i,offsetAttribute:e.offsetAttribute})},d.fromAxisAlignedBoundingBox=function(e){return new d({minimum:e.minimum,maximum:e.maximum})},d.packedLength=2*t.Cartesian3.packedLength+1,d.pack=function(e,n,i){return i=a.defaultValue(i,0),t.Cartesian3.pack(e._min,n,i),t.Cartesian3.pack(e._max,n,i+t.Cartesian3.packedLength),n[i+2*t.Cartesian3.packedLength]=a.defaultValue(e._offsetAttribute,-1),n};const p=new t.Cartesian3,b=new t.Cartesian3,l={minimum:p,maximum:b,offsetAttribute:void 0};return d.unpack=function(e,n,i){n=a.defaultValue(n,0);const r=t.Cartesian3.unpack(e,n,p),o=t.Cartesian3.unpack(e,n+t.Cartesian3.packedLength,b),u=e[n+2*t.Cartesian3.packedLength];return a.defined(i)?(i._min=t.Cartesian3.clone(r,i._min),i._max=t.Cartesian3.clone(o,i._max),i._offsetAttribute=-1===u?void 0:u,i):(l.offsetAttribute=-1===u?void 0:u,new d(l))},d.createGeometry=function(u){const s=u._min,m=u._max;if(t.Cartesian3.equals(s,m))return;const f=new r.GeometryAttributes,d=new Uint16Array(24),p=new Float64Array(24);p[0]=s.x,p[1]=s.y,p[2]=s.z,p[3]=m.x,p[4]=s.y,p[5]=s.z,p[6]=m.x,p[7]=m.y,p[8]=s.z,p[9]=s.x,p[10]=m.y,p[11]=s.z,p[12]=s.x,p[13]=s.y,p[14]=m.z,p[15]=m.x,p[16]=s.y,p[17]=m.z,p[18]=m.x,p[19]=m.y,p[20]=m.z,p[21]=s.x,p[22]=m.y,p[23]=m.z,f.position=new i.GeometryAttribute({componentDatatype:n.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:p}),d[0]=4,d[1]=5,d[2]=5,d[3]=6,d[4]=6,d[5]=7,d[6]=7,d[7]=4,d[8]=0,d[9]=1,d[10]=1,d[11]=2,d[12]=2,d[13]=3,d[14]=3,d[15]=0,d[16]=0,d[17]=4,d[18]=1,d[19]=5,d[20]=2,d[21]=6,d[22]=3,d[23]=7;const b=t.Cartesian3.subtract(m,s,c),l=.5*t.Cartesian3.magnitude(b);if(a.defined(u._offsetAttribute)){const e=p.length,t=u._offsetAttribute===o.GeometryOffsetAttribute.NONE?0:1,a=new Uint8Array(e/3).fill(t);f.applyOffset=new i.GeometryAttribute({componentDatatype:n.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:a})}return new i.Geometry({attributes:f,indices:d,primitiveType:i.PrimitiveType.LINES,boundingSphere:new e.BoundingSphere(t.Cartesian3.ZERO,l),offsetAttribute:u._offsetAttribute})},function(e,t){return a.defined(t)&&(e=d.unpack(e,t)),d.createGeometry(e)}}));
+define(['./Transforms-40229881', './Matrix3-315394f6', './Check-666ab1a0', './ComponentDatatype-f7b11d02', './defaultValue-0a909f67', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryOffsetAttribute-04332ce7', './Math-2dbd6b93', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c'], (function (Transforms, Matrix3, Check, ComponentDatatype, defaultValue, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, Math, Matrix2, RuntimeError, combine, WebGLConstants) { 'use strict';
+
+  const diffScratch = new Matrix3.Cartesian3();
+
+  /**
+   * A description of the outline of a cube centered at the origin.
+   *
+   * @alias BoxOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3} options.minimum The minimum x, y, and z coordinates of the box.
+   * @param {Cartesian3} options.maximum The maximum x, y, and z coordinates of the box.
+   *
+   * @see BoxOutlineGeometry.fromDimensions
+   * @see BoxOutlineGeometry.createGeometry
+   * @see Packable
+   *
+   * @example
+   * const box = new Cesium.BoxOutlineGeometry({
+   *   maximum : new Cesium.Cartesian3(250000.0, 250000.0, 250000.0),
+   *   minimum : new Cesium.Cartesian3(-250000.0, -250000.0, -250000.0)
+   * });
+   * const geometry = Cesium.BoxOutlineGeometry.createGeometry(box);
+   */
+  function BoxOutlineGeometry(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+
+    const min = options.minimum;
+    const max = options.maximum;
+
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("min", min);
+    Check.Check.typeOf.object("max", max);
+    if (
+      defaultValue.defined(options.offsetAttribute) &&
+      options.offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.TOP
+    ) {
+      throw new Check.DeveloperError(
+        "GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
+      );
+    }
+    //>>includeEnd('debug');
+
+    this._min = Matrix3.Cartesian3.clone(min);
+    this._max = Matrix3.Cartesian3.clone(max);
+    this._offsetAttribute = options.offsetAttribute;
+    this._workerName = "createBoxOutlineGeometry";
+  }
+
+  /**
+   * Creates an outline of a cube centered at the origin given its dimensions.
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3} options.dimensions The width, depth, and height of the box stored in the x, y, and z coordinates of the <code>Cartesian3</code>, respectively.
+   * @returns {BoxOutlineGeometry}
+   *
+   * @exception {DeveloperError} All dimensions components must be greater than or equal to zero.
+   *
+   *
+   * @example
+   * const box = Cesium.BoxOutlineGeometry.fromDimensions({
+   *   dimensions : new Cesium.Cartesian3(500000.0, 500000.0, 500000.0)
+   * });
+   * const geometry = Cesium.BoxOutlineGeometry.createGeometry(box);
+   *
+   * @see BoxOutlineGeometry.createGeometry
+   */
+  BoxOutlineGeometry.fromDimensions = function (options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+    const dimensions = options.dimensions;
+
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("dimensions", dimensions);
+    Check.Check.typeOf.number.greaterThanOrEquals("dimensions.x", dimensions.x, 0);
+    Check.Check.typeOf.number.greaterThanOrEquals("dimensions.y", dimensions.y, 0);
+    Check.Check.typeOf.number.greaterThanOrEquals("dimensions.z", dimensions.z, 0);
+    //>>includeEnd('debug');
+
+    const corner = Matrix3.Cartesian3.multiplyByScalar(dimensions, 0.5, new Matrix3.Cartesian3());
+
+    return new BoxOutlineGeometry({
+      minimum: Matrix3.Cartesian3.negate(corner, new Matrix3.Cartesian3()),
+      maximum: corner,
+      offsetAttribute: options.offsetAttribute,
+    });
+  };
+
+  /**
+   * Creates an outline of a cube from the dimensions of an AxisAlignedBoundingBox.
+   *
+   * @param {AxisAlignedBoundingBox} boundingBox A description of the AxisAlignedBoundingBox.
+   * @returns {BoxOutlineGeometry}
+   *
+   *
+   *
+   * @example
+   * const aabb = Cesium.AxisAlignedBoundingBox.fromPoints(Cesium.Cartesian3.fromDegreesArray([
+   *      -72.0, 40.0,
+   *      -70.0, 35.0,
+   *      -75.0, 30.0,
+   *      -70.0, 30.0,
+   *      -68.0, 40.0
+   * ]));
+   * const box = Cesium.BoxOutlineGeometry.fromAxisAlignedBoundingBox(aabb);
+   *
+   *  @see BoxOutlineGeometry.createGeometry
+   */
+  BoxOutlineGeometry.fromAxisAlignedBoundingBox = function (boundingBox) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("boundindBox", boundingBox);
+    //>>includeEnd('debug');
+
+    return new BoxOutlineGeometry({
+      minimum: boundingBox.minimum,
+      maximum: boundingBox.maximum,
+    });
+  };
+
+  /**
+   * The number of elements used to pack the object into an array.
+   * @type {Number}
+   */
+  BoxOutlineGeometry.packedLength = 2 * Matrix3.Cartesian3.packedLength + 1;
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {BoxOutlineGeometry} value The value to pack.
+   * @param {Number[]} array The array to pack into.
+   * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
+   *
+   * @returns {Number[]} The array that was packed into
+   */
+  BoxOutlineGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("value", value);
+    Check.Check.defined("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    Matrix3.Cartesian3.pack(value._min, array, startingIndex);
+    Matrix3.Cartesian3.pack(value._max, array, startingIndex + Matrix3.Cartesian3.packedLength);
+    array[startingIndex + Matrix3.Cartesian3.packedLength * 2] = defaultValue.defaultValue(
+      value._offsetAttribute,
+      -1
+    );
+
+    return array;
+  };
+
+  const scratchMin = new Matrix3.Cartesian3();
+  const scratchMax = new Matrix3.Cartesian3();
+  const scratchOptions = {
+    minimum: scratchMin,
+    maximum: scratchMax,
+    offsetAttribute: undefined,
+  };
+
+  /**
+   * Retrieves an instance from a packed array.
+   *
+   * @param {Number[]} array The packed array.
+   * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
+   * @param {BoxOutlineGeometry} [result] The object into which to store the result.
+   * @returns {BoxOutlineGeometry} The modified result parameter or a new BoxOutlineGeometry instance if one was not provided.
+   */
+  BoxOutlineGeometry.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    const min = Matrix3.Cartesian3.unpack(array, startingIndex, scratchMin);
+    const max = Matrix3.Cartesian3.unpack(
+      array,
+      startingIndex + Matrix3.Cartesian3.packedLength,
+      scratchMax
+    );
+    const offsetAttribute = array[startingIndex + Matrix3.Cartesian3.packedLength * 2];
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.offsetAttribute =
+        offsetAttribute === -1 ? undefined : offsetAttribute;
+      return new BoxOutlineGeometry(scratchOptions);
+    }
+
+    result._min = Matrix3.Cartesian3.clone(min, result._min);
+    result._max = Matrix3.Cartesian3.clone(max, result._max);
+    result._offsetAttribute =
+      offsetAttribute === -1 ? undefined : offsetAttribute;
+
+    return result;
+  };
+
+  /**
+   * Computes the geometric representation of an outline of a box, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {BoxOutlineGeometry} boxGeometry A description of the box outline.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  BoxOutlineGeometry.createGeometry = function (boxGeometry) {
+    const min = boxGeometry._min;
+    const max = boxGeometry._max;
+
+    if (Matrix3.Cartesian3.equals(min, max)) {
+      return;
+    }
+
+    const attributes = new GeometryAttributes.GeometryAttributes();
+    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.GeometryAttribute({
+      componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positions,
+    });
+
+    // top
+    indices[0] = 4;
+    indices[1] = 5;
+    indices[2] = 5;
+    indices[3] = 6;
+    indices[4] = 6;
+    indices[5] = 7;
+    indices[6] = 7;
+    indices[7] = 4;
+
+    // bottom
+    indices[8] = 0;
+    indices[9] = 1;
+    indices[10] = 1;
+    indices[11] = 2;
+    indices[12] = 2;
+    indices[13] = 3;
+    indices[14] = 3;
+    indices[15] = 0;
+
+    // left
+    indices[16] = 0;
+    indices[17] = 4;
+    indices[18] = 1;
+    indices[19] = 5;
+
+    //right
+    indices[20] = 2;
+    indices[21] = 6;
+    indices[22] = 3;
+    indices[23] = 7;
+
+    const diff = Matrix3.Cartesian3.subtract(max, min, diffScratch);
+    const radius = Matrix3.Cartesian3.magnitude(diff) * 0.5;
+
+    if (defaultValue.defined(boxGeometry._offsetAttribute)) {
+      const length = positions.length;
+      const offsetValue =
+        boxGeometry._offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.NONE ? 0 : 1;
+      const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+      attributes.applyOffset = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: applyOffset,
+      });
+    }
+
+    return new GeometryAttribute.Geometry({
+      attributes: attributes,
+      indices: indices,
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      boundingSphere: new Transforms.BoundingSphere(Matrix3.Cartesian3.ZERO, radius),
+      offsetAttribute: boxGeometry._offsetAttribute,
+    });
+  };
+
+  function createBoxOutlineGeometry(boxGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      boxGeometry = BoxOutlineGeometry.unpack(boxGeometry, offset);
+    }
+    return BoxOutlineGeometry.createGeometry(boxGeometry);
+  }
+
+  return createBoxOutlineGeometry;
+
+}));