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

package/build/computeElevation.cjs

@@ -1 +1 @@
-"use strict";const e=require("./index-D87IZDc6.cjs");module.exports=e.computeElevation;
+"use strict";const e=require("./index-XZNzHig1.cjs");module.exports=e.computeElevation;

package/build/computeElevation.js

@@ -1,4 +1,4 @@
-import { bw } from "./index-DaqGSC4W.js";
+import { by } from "./index-BgprA821.js";
 export {
-  bw as default
+  by as default
 };

package/build/{index-DaqGSC4W.js → index-BgprA821.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");
@@ -39358,16 +39445,18 @@ export {
   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,
+  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,
   Matrix2 as ba,
   Vector4 as bb,
   DataTextureLoader as bc,
@@ -39386,14 +39475,14 @@ export {
   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,
+  enuToEcefDelta as bs,
+  RingGeometry as bt,
+  AgXToneMapping as bu,
+  EquirectangularReflectionMapping as bv,
+  validateRotation as bw,
+  requireFiniteNumber as bx,
+  computeElevation as by,
+  DataArrayTexture as bz,
   ShaderMaterial as c,
   Plane as d,
   Raycaster as e,