@splnlss/3d-story-viewer 0.8.1 → 0.8.3

package/build/{index-DaqGSC4W.js → index-a8PLKOvo.js}

@@ -14837,6 +14837,84 @@ class PlaneGeometry extends BufferGeometry {
     return new PlaneGeometry(data.width, data.height, data.widthSegments, data.heightSegments);
   }
 }
+class RingGeometry extends BufferGeometry {
+  /**
+   * Constructs a new ring geometry.
+   *
+   * @param {number} [innerRadius=0.5] - The inner radius of the ring.
+   * @param {number} [outerRadius=1] - The outer radius of the ring.
+   * @param {number} [thetaSegments=32] - Number of segments. A higher number means the ring will be more round. Minimum is `3`.
+   * @param {number} [phiSegments=1] - Number of segments per ring segment. Minimum is `1`.
+   * @param {number} [thetaStart=0] - Starting angle in radians.
+   * @param {number} [thetaLength=Math.PI*2] - Central angle in radians.
+   */
+  constructor(innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2) {
+    super();
+    this.type = "RingGeometry";
+    this.parameters = {
+      innerRadius,
+      outerRadius,
+      thetaSegments,
+      phiSegments,
+      thetaStart,
+      thetaLength
+    };
+    thetaSegments = Math.max(3, thetaSegments);
+    phiSegments = Math.max(1, phiSegments);
+    const indices = [];
+    const vertices = [];
+    const normals = [];
+    const uvs = [];
+    let radius = innerRadius;
+    const radiusStep = (outerRadius - innerRadius) / phiSegments;
+    const vertex2 = new Vector3$1();
+    const uv = new Vector2();
+    for (let j = 0; j <= phiSegments; j++) {
+      for (let i = 0; i <= thetaSegments; i++) {
+        const segment = thetaStart + i / thetaSegments * thetaLength;
+        vertex2.x = radius * Math.cos(segment);
+        vertex2.y = radius * Math.sin(segment);
+        vertices.push(vertex2.x, vertex2.y, vertex2.z);
+        normals.push(0, 0, 1);
+        uv.x = (vertex2.x / outerRadius + 1) / 2;
+        uv.y = (vertex2.y / outerRadius + 1) / 2;
+        uvs.push(uv.x, uv.y);
+      }
+      radius += radiusStep;
+    }
+    for (let j = 0; j < phiSegments; j++) {
+      const thetaSegmentLevel = j * (thetaSegments + 1);
+      for (let i = 0; i < thetaSegments; i++) {
+        const segment = i + thetaSegmentLevel;
+        const a = segment;
+        const b = segment + thetaSegments + 1;
+        const c = segment + thetaSegments + 2;
+        const d = segment + 1;
+        indices.push(a, b, d);
+        indices.push(b, c, d);
+      }
+    }
+    this.setIndex(indices);
+    this.setAttribute("position", new Float32BufferAttribute(vertices, 3));
+    this.setAttribute("normal", new Float32BufferAttribute(normals, 3));
+    this.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+  }
+  copy(source) {
+    super.copy(source);
+    this.parameters = Object.assign({}, source.parameters);
+    return this;
+  }
+  /**
+   * Factory method for creating an instance of this class from the given
+   * JSON object.
+   *
+   * @param {Object} data - A JSON object representing the serialized geometry.
+   * @return {RingGeometry} A new instance.
+   */
+  static fromJSON(data) {
+    return new RingGeometry(data.innerRadius, data.outerRadius, data.thetaSegments, data.phiSegments, data.thetaStart, data.thetaLength);
+  }
+}
 function cloneUniforms(src) {
   const dst = {};
   for (const u in src) {
@@ -31445,6 +31523,15 @@ function getEnuBasis(longitude, latitude) {
     up: [cosLatitude * cosLongitude, cosLatitude * sinLongitude, sinLatitude]
   };
 }
+function enuToEcefDelta(translation, longitude, latitude) {
+  validateTuple(translation, "ENU translation");
+  const { east, north, up } = getEnuBasis(longitude, latitude);
+  return [
+    east[0] * translation[0] + north[0] * translation[1] + up[0] * translation[2],
+    east[1] * translation[0] + north[1] * translation[1] + up[1] * translation[2],
+    east[2] * translation[0] + north[2] * translation[1] + up[2] * translation[2]
+  ];
+}
 function geodeticOffsetToEcefDelta(position, offset) {
   validateLongitudeLatitude(position.lon, position.lat, "Layer root");
   requireFiniteNumber(position.alt, "Layer root altitude");
@@ -39348,52 +39435,54 @@ export {
   RED_GREEN_RGTC2_Format as ay,
   SIGNED_RED_GREEN_RGTC2_Format as az,
   Mesh as b,
-  Float32BufferAttribute as b0,
-  LinearMipMapLinearFilter as b1,
-  Triangle as b2,
-  CanvasTexture as b3,
-  WebGLRenderer as b4,
-  WebGLRenderTarget as b5,
-  OneFactor as b6,
-  ZeroFactor as b7,
-  CustomBlending as b8,
-  Box2 as b9,
-  RGBAIntegerFormat as bA,
-  WebGLArrayRenderTarget as bB,
-  GLSL3 as bC,
-  Timer as bD,
-  WebGLCubeRenderTarget as bE,
-  CubeCamera as bF,
-  Camera as bG,
-  PMREMGenerator as bH,
-  InstancedBufferGeometry as bI,
-  RawShaderMaterial as bJ,
-  Matrix2 as ba,
-  Vector4 as bb,
-  DataTextureLoader as bc,
-  DataUtils as bd,
-  REVISION as be,
-  TextureSource as bf,
-  ImageUtils as bg,
-  Scene as bh,
-  ecefToGeodeticPosition as bi,
-  getEnuBasis as bj,
-  BackSide as bk,
-  BoxGeometry as bl,
-  normalizeLayerOffset as bm,
-  geodeticOffsetToEcefDelta as bn,
-  validateGeodeticPosition as bo,
-  validateTuple as bp,
-  validateScale as bq,
-  geodeticToEcefPosition as br,
-  AgXToneMapping as bs,
-  EquirectangularReflectionMapping as bt,
-  validateRotation as bu,
-  requireFiniteNumber as bv,
-  computeElevation as bw,
-  DataArrayTexture as bx,
-  RGIntegerFormat as by,
-  UnsignedIntType as bz,
+  REVISION as b0,
+  TextureSource as b1,
+  ImageUtils as b2,
+  Scene as b3,
+  ecefToGeodeticPosition as b4,
+  getEnuBasis as b5,
+  Float32BufferAttribute as b6,
+  LinearMipMapLinearFilter as b7,
+  Triangle as b8,
+  CanvasTexture as b9,
+  RGIntegerFormat as bA,
+  UnsignedIntType as bB,
+  RGBAIntegerFormat as bC,
+  WebGLArrayRenderTarget as bD,
+  GLSL3 as bE,
+  Timer as bF,
+  WebGLCubeRenderTarget as bG,
+  CubeCamera as bH,
+  Camera as bI,
+  PMREMGenerator as bJ,
+  InstancedBufferGeometry as bK,
+  RawShaderMaterial as bL,
+  WebGLRenderer as ba,
+  WebGLRenderTarget as bb,
+  OneFactor as bc,
+  ZeroFactor as bd,
+  CustomBlending as be,
+  Box2 as bf,
+  Matrix2 as bg,
+  Vector4 as bh,
+  validateGeodeticPosition as bi,
+  validateRotation as bj,
+  geodeticToEcefPosition as bk,
+  DataTextureLoader as bl,
+  DataUtils as bm,
+  BackSide as bn,
+  BoxGeometry as bo,
+  normalizeLayerOffset as bp,
+  geodeticOffsetToEcefDelta as bq,
+  validateTuple as br,
+  validateScale as bs,
+  enuToEcefDelta as bt,
+  RingGeometry as bu,
+  AgXToneMapping as bv,
+  EquirectangularReflectionMapping as bw,
+  requireFiniteNumber as bx,
+  computeElevation as by,
+  DataArrayTexture as bz,
   ShaderMaterial as c,
   Plane as d,
   Raycaster as e,