@cesium/engine 26.2.0 → 26.3.0

package/Build/Workers/chunk-7XM5JK5F.js

@@ -1,162 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.144.0
- *
- * 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 {
-  Intersect_default
-} from "./chunk-CQNFIAZU.js";
-import {
-  Cartesian3_default
-} from "./chunk-SA2A2AN5.js";
-import {
-  Check_default
-} from "./chunk-XLQZNQ4Z.js";
-import {
-  defined_default
-} from "./chunk-PCL3Y7H5.js";
-
-// packages/engine/Source/Core/AxisAlignedBoundingBox.js
-function AxisAlignedBoundingBox(minimum, maximum, center) {
-  this.minimum = Cartesian3_default.clone(minimum ?? Cartesian3_default.ZERO);
-  this.maximum = Cartesian3_default.clone(maximum ?? Cartesian3_default.ZERO);
-  if (!defined_default(center)) {
-    center = Cartesian3_default.midpoint(this.minimum, this.maximum, new Cartesian3_default());
-  } else {
-    center = Cartesian3_default.clone(center);
-  }
-  this.center = center;
-}
-AxisAlignedBoundingBox.fromCorners = function(minimum, maximum, result) {
-  Check_default.defined("minimum", minimum);
-  Check_default.defined("maximum", maximum);
-  if (!defined_default(result)) {
-    result = new AxisAlignedBoundingBox();
-  }
-  result.minimum = Cartesian3_default.clone(minimum, result.minimum);
-  result.maximum = Cartesian3_default.clone(maximum, result.maximum);
-  result.center = Cartesian3_default.midpoint(minimum, maximum, result.center);
-  return result;
-};
-AxisAlignedBoundingBox.fromPoints = function(positions, result) {
-  if (!defined_default(result)) {
-    result = new AxisAlignedBoundingBox();
-  }
-  if (!defined_default(positions) || positions.length === 0) {
-    result.minimum = Cartesian3_default.clone(Cartesian3_default.ZERO, result.minimum);
-    result.maximum = Cartesian3_default.clone(Cartesian3_default.ZERO, result.maximum);
-    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
-    return result;
-  }
-  let minimumX = positions[0].x;
-  let minimumY = positions[0].y;
-  let minimumZ = positions[0].z;
-  let maximumX = positions[0].x;
-  let maximumY = positions[0].y;
-  let maximumZ = positions[0].z;
-  const length = positions.length;
-  for (let i = 1; i < length; i++) {
-    const p = positions[i];
-    const x = p.x;
-    const y = p.y;
-    const z = p.z;
-    minimumX = Math.min(x, minimumX);
-    maximumX = Math.max(x, maximumX);
-    minimumY = Math.min(y, minimumY);
-    maximumY = Math.max(y, maximumY);
-    minimumZ = Math.min(z, minimumZ);
-    maximumZ = Math.max(z, maximumZ);
-  }
-  const minimum = result.minimum;
-  minimum.x = minimumX;
-  minimum.y = minimumY;
-  minimum.z = minimumZ;
-  const maximum = result.maximum;
-  maximum.x = maximumX;
-  maximum.y = maximumY;
-  maximum.z = maximumZ;
-  result.center = Cartesian3_default.midpoint(minimum, maximum, result.center);
-  return result;
-};
-AxisAlignedBoundingBox.clone = function(box, result) {
-  if (!defined_default(box)) {
-    return void 0;
-  }
-  if (!defined_default(result)) {
-    return new AxisAlignedBoundingBox(box.minimum, box.maximum, box.center);
-  }
-  result.minimum = Cartesian3_default.clone(box.minimum, result.minimum);
-  result.maximum = Cartesian3_default.clone(box.maximum, result.maximum);
-  result.center = Cartesian3_default.clone(box.center, result.center);
-  return result;
-};
-AxisAlignedBoundingBox.equals = function(left, right) {
-  return left === right || defined_default(left) && defined_default(right) && Cartesian3_default.equals(left.center, right.center) && Cartesian3_default.equals(left.minimum, right.minimum) && Cartesian3_default.equals(left.maximum, right.maximum);
-};
-var intersectScratch = new Cartesian3_default();
-AxisAlignedBoundingBox.intersectPlane = function(box, plane) {
-  Check_default.defined("box", box);
-  Check_default.defined("plane", plane);
-  intersectScratch = Cartesian3_default.subtract(
-    box.maximum,
-    box.minimum,
-    intersectScratch
-  );
-  const h = Cartesian3_default.multiplyByScalar(
-    intersectScratch,
-    0.5,
-    intersectScratch
-  );
-  const normal = plane.normal;
-  const e = h.x * Math.abs(normal.x) + h.y * Math.abs(normal.y) + h.z * Math.abs(normal.z);
-  const s = Cartesian3_default.dot(box.center, normal) + plane.distance;
-  if (s - e > 0) {
-    return Intersect_default.INSIDE;
-  }
-  if (s + e < 0) {
-    return Intersect_default.OUTSIDE;
-  }
-  return Intersect_default.INTERSECTING;
-};
-AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox = function(box, other) {
-  Check_default.defined("box", box);
-  Check_default.defined("other", other);
-  return box.minimum.x <= other.maximum.x && box.maximum.x >= other.minimum.x && box.minimum.y <= other.maximum.y && box.maximum.y >= other.minimum.y && box.minimum.z <= other.maximum.z && box.maximum.z >= other.minimum.z;
-};
-AxisAlignedBoundingBox.prototype.clone = function(result) {
-  return AxisAlignedBoundingBox.clone(this, result);
-};
-AxisAlignedBoundingBox.prototype.intersectPlane = function(plane) {
-  return AxisAlignedBoundingBox.intersectPlane(this, plane);
-};
-AxisAlignedBoundingBox.prototype.intersectAxisAlignedBoundingBox = function(other) {
-  return AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox(this, other);
-};
-AxisAlignedBoundingBox.prototype.equals = function(right) {
-  return AxisAlignedBoundingBox.equals(this, right);
-};
-var AxisAlignedBoundingBox_default = AxisAlignedBoundingBox;
-
-export {
-  AxisAlignedBoundingBox_default
-};

package/Build/Workers/chunk-7YG3ND3P.js

@@ -1,454 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.143.0
- *
- * 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 {
-  Matrix2_default
-} from "./chunk-ADX3CBKD.js";
-import {
-  Cartesian4_default,
-  Matrix4_default
-} from "./chunk-WN3F4CVG.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-VAL7DYNR.js";
-import {
-  Cartesian2_default
-} from "./chunk-UTB7U3O6.js";
-import {
-  Cartesian3_default,
-  Matrix3_default
-} from "./chunk-ZQLZG4IN.js";
-import {
-  Math_default
-} from "./chunk-5YPQBFRD.js";
-import {
-  Check_default,
-  DeveloperError_default
-} from "./chunk-6YR6JBMY.js";
-import {
-  defined_default
-} from "./chunk-AHWAZRBV.js";
-
-// packages/engine/Source/Scene/AttributeType.js
-var AttributeType = {
-  /**
-   * The attribute is a single component.
-   *
-   * @type {string}
-   * @constant
-   */
-  SCALAR: "SCALAR",
-  /**
-   * The attribute is a two-component vector.
-   *
-   * @type {string}
-   * @constant
-   */
-  VEC2: "VEC2",
-  /**
-   * The attribute is a three-component vector.
-   *
-   * @type {string}
-   * @constant
-   */
-  VEC3: "VEC3",
-  /**
-   * The attribute is a four-component vector.
-   *
-   * @type {string}
-   * @constant
-   */
-  VEC4: "VEC4",
-  /**
-   * The attribute is a 2x2 matrix.
-   *
-   * @type {string}
-   * @constant
-   */
-  MAT2: "MAT2",
-  /**
-   * The attribute is a 3x3 matrix.
-   *
-   * @type {string}
-   * @constant
-   */
-  MAT3: "MAT3",
-  /**
-   * The attribute is a 4x4 matrix.
-   *
-   * @type {string}
-   * @constant
-   */
-  MAT4: "MAT4"
-};
-AttributeType.getMathType = function(attributeType) {
-  switch (attributeType) {
-    case AttributeType.SCALAR:
-      return Number;
-    case AttributeType.VEC2:
-      return Cartesian2_default;
-    case AttributeType.VEC3:
-      return Cartesian3_default;
-    case AttributeType.VEC4:
-      return Cartesian4_default;
-    case AttributeType.MAT2:
-      return Matrix2_default;
-    case AttributeType.MAT3:
-      return Matrix3_default;
-    case AttributeType.MAT4:
-      return Matrix4_default;
-    //>>includeStart('debug', pragmas.debug);
-    default:
-      throw new DeveloperError_default("attributeType is not a valid value.");
-  }
-};
-AttributeType.getNumberOfComponents = function(attributeType) {
-  switch (attributeType) {
-    case AttributeType.SCALAR:
-      return 1;
-    case AttributeType.VEC2:
-      return 2;
-    case AttributeType.VEC3:
-      return 3;
-    case AttributeType.VEC4:
-    case AttributeType.MAT2:
-      return 4;
-    case AttributeType.MAT3:
-      return 9;
-    case AttributeType.MAT4:
-      return 16;
-    //>>includeStart('debug', pragmas.debug);
-    default:
-      throw new DeveloperError_default("attributeType is not a valid value.");
-  }
-};
-AttributeType.getAttributeLocationCount = function(attributeType) {
-  switch (attributeType) {
-    case AttributeType.SCALAR:
-    case AttributeType.VEC2:
-    case AttributeType.VEC3:
-    case AttributeType.VEC4:
-      return 1;
-    case AttributeType.MAT2:
-      return 2;
-    case AttributeType.MAT3:
-      return 3;
-    case AttributeType.MAT4:
-      return 4;
-    //>>includeStart('debug', pragmas.debug);
-    default:
-      throw new DeveloperError_default("attributeType is not a valid value.");
-  }
-};
-AttributeType.getGlslType = function(attributeType) {
-  Check_default.typeOf.string("attributeType", attributeType);
-  switch (attributeType) {
-    case AttributeType.SCALAR:
-      return "float";
-    case AttributeType.VEC2:
-      return "vec2";
-    case AttributeType.VEC3:
-      return "vec3";
-    case AttributeType.VEC4:
-      return "vec4";
-    case AttributeType.MAT2:
-      return "mat2";
-    case AttributeType.MAT3:
-      return "mat3";
-    case AttributeType.MAT4:
-      return "mat4";
-    //>>includeStart('debug', pragmas.debug);
-    default:
-      throw new DeveloperError_default("attributeType is not a valid value.");
-  }
-};
-Object.freeze(AttributeType);
-var AttributeType_default = AttributeType;
-
-// packages/engine/Source/Core/AttributeCompression.js
-var RIGHT_SHIFT8 = 1 / 256;
-var LEFT_SHIFT16 = 65536;
-var LEFT_SHIFT8 = 256;
-var AttributeCompression = {};
-AttributeCompression.octEncodeInRange = function(vector, rangeMax, result) {
-  Check_default.defined("vector", vector);
-  Check_default.defined("result", result);
-  const magSquared = Cartesian3_default.magnitudeSquared(vector);
-  if (Math.abs(magSquared - 1) > Math_default.EPSILON6) {
-    throw new DeveloperError_default("vector must be normalized.");
-  }
-  result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
-  result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
-  if (vector.z < 0) {
-    const x = result.x;
-    const y = result.y;
-    result.x = (1 - Math.abs(y)) * Math_default.signNotZero(x);
-    result.y = (1 - Math.abs(x)) * Math_default.signNotZero(y);
-  }
-  result.x = Math_default.toSNorm(result.x, rangeMax);
-  result.y = Math_default.toSNorm(result.y, rangeMax);
-  return result;
-};
-AttributeCompression.octEncode = function(vector, result) {
-  return AttributeCompression.octEncodeInRange(vector, 255, result);
-};
-var octEncodeScratch = new Cartesian2_default();
-var uint8ForceArray = new Uint8Array(1);
-function forceUint8(value) {
-  uint8ForceArray[0] = value;
-  return uint8ForceArray[0];
-}
-AttributeCompression.octEncodeToCartesian4 = function(vector, result) {
-  AttributeCompression.octEncodeInRange(vector, 65535, octEncodeScratch);
-  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT8);
-  result.y = forceUint8(octEncodeScratch.x);
-  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT8);
-  result.w = forceUint8(octEncodeScratch.y);
-  return result;
-};
-AttributeCompression.octDecodeInRange = function(x, y, rangeMax, result) {
-  Check_default.defined("result", result);
-  if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
-    throw new DeveloperError_default(
-      `x and y must be unsigned normalized integers between 0 and ${rangeMax}`
-    );
-  }
-  result.x = Math_default.fromSNorm(x, rangeMax);
-  result.y = Math_default.fromSNorm(y, rangeMax);
-  result.z = 1 - (Math.abs(result.x) + Math.abs(result.y));
-  if (result.z < 0) {
-    const oldVX = result.x;
-    result.x = (1 - Math.abs(result.y)) * Math_default.signNotZero(oldVX);
-    result.y = (1 - Math.abs(oldVX)) * Math_default.signNotZero(result.y);
-  }
-  return Cartesian3_default.normalize(result, result);
-};
-AttributeCompression.octDecode = function(x, y, result) {
-  return AttributeCompression.octDecodeInRange(x, y, 255, result);
-};
-AttributeCompression.octDecodeFromCartesian4 = function(encoded, result) {
-  Check_default.typeOf.object("encoded", encoded);
-  Check_default.typeOf.object("result", result);
-  const x = encoded.x;
-  const y = encoded.y;
-  const z = encoded.z;
-  const w = encoded.w;
-  if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {
-    throw new DeveloperError_default(
-      "x, y, z, and w must be unsigned normalized integers between 0 and 255"
-    );
-  }
-  const xOct16 = x * LEFT_SHIFT8 + y;
-  const yOct16 = z * LEFT_SHIFT8 + w;
-  return AttributeCompression.octDecodeInRange(xOct16, yOct16, 65535, result);
-};
-AttributeCompression.octPackFloat = function(encoded) {
-  Check_default.defined("encoded", encoded);
-  return 256 * encoded.x + encoded.y;
-};
-var scratchEncodeCart2 = new Cartesian2_default();
-AttributeCompression.octEncodeFloat = function(vector) {
-  AttributeCompression.octEncode(vector, scratchEncodeCart2);
-  return AttributeCompression.octPackFloat(scratchEncodeCart2);
-};
-AttributeCompression.octDecodeFloat = function(value, result) {
-  Check_default.defined("value", value);
-  const temp = value / 256;
-  const x = Math.floor(temp);
-  const y = (temp - x) * 256;
-  return AttributeCompression.octDecode(x, y, result);
-};
-AttributeCompression.octPack = function(v1, v2, v3, result) {
-  Check_default.defined("v1", v1);
-  Check_default.defined("v2", v2);
-  Check_default.defined("v3", v3);
-  Check_default.defined("result", result);
-  const encoded1 = AttributeCompression.octEncodeFloat(v1);
-  const encoded2 = AttributeCompression.octEncodeFloat(v2);
-  const encoded3 = AttributeCompression.octEncode(v3, scratchEncodeCart2);
-  result.x = 65536 * encoded3.x + encoded1;
-  result.y = 65536 * encoded3.y + encoded2;
-  return result;
-};
-AttributeCompression.octUnpack = function(packed, v1, v2, v3) {
-  Check_default.defined("packed", packed);
-  Check_default.defined("v1", v1);
-  Check_default.defined("v2", v2);
-  Check_default.defined("v3", v3);
-  let temp = packed.x / 65536;
-  const x = Math.floor(temp);
-  const encodedFloat1 = (temp - x) * 65536;
-  temp = packed.y / 65536;
-  const y = Math.floor(temp);
-  const encodedFloat2 = (temp - y) * 65536;
-  AttributeCompression.octDecodeFloat(encodedFloat1, v1);
-  AttributeCompression.octDecodeFloat(encodedFloat2, v2);
-  AttributeCompression.octDecode(x, y, v3);
-};
-AttributeCompression.compressTextureCoordinates = function(textureCoordinates) {
-  Check_default.defined("textureCoordinates", textureCoordinates);
-  const x = textureCoordinates.x * 4095 | 0;
-  const y = textureCoordinates.y * 4095 | 0;
-  return 4096 * x + y;
-};
-AttributeCompression.decompressTextureCoordinates = function(compressed, result) {
-  Check_default.defined("compressed", compressed);
-  Check_default.defined("result", result);
-  const temp = compressed / 4096;
-  const xZeroTo4095 = Math.floor(temp);
-  result.x = xZeroTo4095 / 4095;
-  result.y = (compressed - xZeroTo4095 * 4096) / 4095;
-  return result;
-};
-function zigZagDecode(value) {
-  return value >> 1 ^ -(value & 1);
-}
-AttributeCompression.zigZagDeltaDecode = function(uBuffer, vBuffer, heightBuffer) {
-  Check_default.defined("uBuffer", uBuffer);
-  Check_default.defined("vBuffer", vBuffer);
-  Check_default.typeOf.number.equals(
-    "uBuffer.length",
-    "vBuffer.length",
-    uBuffer.length,
-    vBuffer.length
-  );
-  if (defined_default(heightBuffer)) {
-    Check_default.typeOf.number.equals(
-      "uBuffer.length",
-      "heightBuffer.length",
-      uBuffer.length,
-      heightBuffer.length
-    );
-  }
-  const count = uBuffer.length;
-  let u = 0;
-  let v = 0;
-  let height = 0;
-  for (let i = 0; i < count; ++i) {
-    u += zigZagDecode(uBuffer[i]);
-    v += zigZagDecode(vBuffer[i]);
-    uBuffer[i] = u;
-    vBuffer[i] = v;
-    if (defined_default(heightBuffer)) {
-      height += zigZagDecode(heightBuffer[i]);
-      heightBuffer[i] = height;
-    }
-  }
-};
-AttributeCompression.dequantize = function(typedArray, componentDatatype, type, count) {
-  Check_default.defined("typedArray", typedArray);
-  Check_default.defined("componentDatatype", componentDatatype);
-  Check_default.defined("type", type);
-  Check_default.defined("count", count);
-  const componentsPerAttribute = AttributeType_default.getNumberOfComponents(type);
-  let divisor;
-  switch (componentDatatype) {
-    case ComponentDatatype_default.BYTE:
-      divisor = 127;
-      break;
-    case ComponentDatatype_default.UNSIGNED_BYTE:
-      divisor = 255;
-      break;
-    case ComponentDatatype_default.SHORT:
-      divisor = 32767;
-      break;
-    case ComponentDatatype_default.UNSIGNED_SHORT:
-      divisor = 65535;
-      break;
-    case ComponentDatatype_default.INT:
-      divisor = 2147483647;
-      break;
-    case ComponentDatatype_default.UNSIGNED_INT:
-      divisor = 4294967295;
-      break;
-    //>>includeStart('debug', pragmas.debug);
-    default:
-      throw new DeveloperError_default(
-        `Cannot dequantize component datatype: ${componentDatatype}`
-      );
-  }
-  const dequantizedTypedArray = new Float32Array(
-    count * componentsPerAttribute
-  );
-  for (let i = 0; i < count; i++) {
-    for (let j = 0; j < componentsPerAttribute; j++) {
-      const index = i * componentsPerAttribute + j;
-      dequantizedTypedArray[index] = Math.max(
-        typedArray[index] / divisor,
-        -1
-      );
-    }
-  }
-  return dequantizedTypedArray;
-};
-AttributeCompression.encodeRGB8 = function(color) {
-  Check_default.typeOf.object("color", color);
-  return Math.round(Math_default.clamp(color.red * 255, 0, 255)) * LEFT_SHIFT16 + Math.round(Math_default.clamp(color.green * 255, 0, 255)) * LEFT_SHIFT8 + Math.round(Math_default.clamp(color.blue * 255, 0, 255));
-};
-AttributeCompression.decodeRGB8 = function(encoded, result) {
-  Check_default.typeOf.number("encoded", encoded);
-  Check_default.typeOf.object("result", result);
-  encoded = Math.floor(encoded);
-  result.red = (encoded >> 16 & 255) / 255;
-  result.green = (encoded >> 8 & 255) / 255;
-  result.blue = (encoded & 255) / 255;
-  return result;
-};
-AttributeCompression.decodeRGB565 = function(typedArray, result) {
-  Check_default.defined("typedArray", typedArray);
-  const expectedLength = typedArray.length * 3;
-  if (defined_default(result)) {
-    Check_default.typeOf.number.equals(
-      "result.length",
-      "typedArray.length * 3",
-      result.length,
-      expectedLength
-    );
-  }
-  const count = typedArray.length;
-  if (!defined_default(result)) {
-    result = new Float32Array(count * 3);
-  }
-  const mask5 = (1 << 5) - 1;
-  const mask6 = (1 << 6) - 1;
-  const normalize5 = 1 / 31;
-  const normalize6 = 1 / 63;
-  for (let i = 0; i < count; i++) {
-    const value = typedArray[i];
-    const red = value >> 11;
-    const green = value >> 5 & mask6;
-    const blue = value & mask5;
-    const offset = 3 * i;
-    result[offset] = red * normalize5;
-    result[offset + 1] = green * normalize6;
-    result[offset + 2] = blue * normalize5;
-  }
-  return result;
-};
-var AttributeCompression_default = AttributeCompression;
-
-export {
-  AttributeCompression_default
-};

package/Build/Workers/chunk-A3O6EDBK.js

@@ -1,73 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.143.0
- *
- * 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 {
-  Math_default
-} from "./chunk-C7JQVRLM.js";
-
-// packages/engine/Source/Core/CylinderGeometryLibrary.js
-var CylinderGeometryLibrary = {};
-CylinderGeometryLibrary.computePositions = function(length, topRadius, bottomRadius, slices, fill) {
-  const topZ = length * 0.5;
-  const bottomZ = -topZ;
-  const twoSlice = slices + slices;
-  const size = fill ? 2 * twoSlice : twoSlice;
-  const positions = new Float64Array(size * 3);
-  let i;
-  let index = 0;
-  let tbIndex = 0;
-  const bottomOffset = fill ? twoSlice * 3 : 0;
-  const topOffset = fill ? (twoSlice + slices) * 3 : slices * 3;
-  for (i = 0; i < slices; i++) {
-    const angle = i / slices * Math_default.TWO_PI;
-    const x = Math.cos(angle);
-    const y = Math.sin(angle);
-    const bottomX = x * bottomRadius;
-    const bottomY = y * bottomRadius;
-    const topX = x * topRadius;
-    const topY = y * topRadius;
-    positions[tbIndex + bottomOffset] = bottomX;
-    positions[tbIndex + bottomOffset + 1] = bottomY;
-    positions[tbIndex + bottomOffset + 2] = bottomZ;
-    positions[tbIndex + topOffset] = topX;
-    positions[tbIndex + topOffset + 1] = topY;
-    positions[tbIndex + topOffset + 2] = topZ;
-    tbIndex += 3;
-    if (fill) {
-      positions[index++] = bottomX;
-      positions[index++] = bottomY;
-      positions[index++] = bottomZ;
-      positions[index++] = topX;
-      positions[index++] = topY;
-      positions[index++] = topZ;
-    }
-  }
-  return positions;
-};
-var CylinderGeometryLibrary_default = CylinderGeometryLibrary;
-
-export {
-  CylinderGeometryLibrary_default
-};