@loaders.gl/tiles 5.0.0-alpha.6 → 5.0.0-alpha.7

package/src/tileset-3d/helpers/bounding-volume.ts

@@ -4,7 +4,7 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 /* eslint-disable */
-import {Quaternion, Vector3, Matrix3, degrees} from '@math.gl/core';
+import {Quaternion, Vector3, Matrix3, Matrix4, degrees} from '@math.gl/core';
 import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
 import {Ellipsoid, makeOBBFromRegion} from '@math.gl/geospatial';
 import {assert} from '@loaders.gl/loader-utils';
@@ -18,6 +18,7 @@ function defined(x) {
 // const scratchMatrix = new Matrix3();
 const scratchPoint = new Vector3();
 const scratchScale = new Vector3();
+const identityTransform = new Matrix4();
 // const scratchRectangle = new Rectangle();
 // const scratchOrientedBoundingBox = new OrientedBoundingBox();
 // const scratchTransform = new Matrix4();
@@ -25,20 +26,39 @@ const scratchScale = new Vector3();
 /**
  * Create a bounding volume from the tile's bounding volume header.
  * @param {Object} boundingVolumeHeader The tile's bounding volume header.
- * @param {Matrix4} transform The transform to apply to the bounding volume.
+ * @param {Matrix4} transform The current computed tile transform, including application transforms.
  * @param [result] The object onto which to store the result.
+ * @param initialTransform The accumulated JSON tile transform, excluded from region transforms.
+ * Defaults to transform so callers without application transforms keep geospatial regions fixed.
  * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.
  */
-export function createBoundingVolume(boundingVolumeHeader, transform, result?) {
+export function createBoundingVolume(
+  boundingVolumeHeader,
+  transform: Matrix4,
+  result?,
+  initialTransform: Matrix4 = transform
+) {
   assert(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');
 
   // boundingVolume schema:
   // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
   if (boundingVolumeHeader.box) {
-    return createBox(boundingVolumeHeader.box, transform, result);
+    // S2 cells and regions are geospatially anchored. Their conservative ECEF boxes are already
+    // world-space volumes and must not receive the tile/node transform a second time.
+    const boxTransform = boundingVolumeHeader.s2VolumeInfo ? identityTransform : transform;
+    return createBox(boundingVolumeHeader.box, boxTransform, result);
   }
   if (boundingVolumeHeader.region) {
-    return makeOBBFromRegion(boundingVolumeHeader.region);
+    const boundingVolume = makeOBBFromRegion(boundingVolumeHeader.region);
+    // Regions are already in world coordinates. Apply only the change from the JSON transform.
+    const regionTransform = transform.equals(initialTransform)
+      ? identityTransform
+      : transform.clone().multiplyRight(initialTransform.clone().invert());
+    return createBox(
+      [...boundingVolume.center, ...boundingVolume.halfAxes],
+      regionTransform,
+      result
+    );
   }
 
   if (boundingVolumeHeader.sphere) {
@@ -55,15 +75,17 @@ export type CartographicBounds = [min: number[], max: number[]];
  * Calculate the cartographic bounding box the tile's bounding volume.
  * @param {Object} boundingVolumeHeader The tile's bounding volume header.
  * @param {BoundingVolume} boundingVolume The bounding volume.
+ * @param isRegionTransformed Whether application transforms moved the region from its JSON bounds.
  * @returns {CartographicBounds}
  */
 export function getCartographicBounds(
   boundingVolumeHeader,
-  boundingVolume: OrientedBoundingBox | BoundingSphere
+  boundingVolume: OrientedBoundingBox | BoundingSphere,
+  isRegionTransformed = false
 ): CartographicBounds {
   // boundingVolume schema:
   // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
-  if (boundingVolumeHeader.box) {
+  if (boundingVolumeHeader.box || (boundingVolumeHeader.region && isRegionTransformed)) {
     return orientedBoundingBoxToCartographicBounds(boundingVolume as OrientedBoundingBox);
   }
   if (boundingVolumeHeader.region) {
@@ -142,61 +164,6 @@ function createBox(box, transform, result?) {
   return new OrientedBoundingBox(center, halfAxes);
 }
 
-/*
-function createBoxFromTransformedRegion(region, transform, initialTransform, result) {
-  const rectangle = Rectangle.unpack(region, 0, scratchRectangle);
-  const minimumHeight = region[4];
-  const maximumHeight = region[5];
-
-  const orientedBoundingBox = OrientedBoundingBox.fromRectangle(
-    rectangle,
-    minimumHeight,
-    maximumHeight,
-    Ellipsoid.WGS84,
-    scratchOrientedBoundingBox
-  );
-  const center = orientedBoundingBox.center;
-  const halfAxes = orientedBoundingBox.halfAxes;
-
-  // A region bounding volume is not transformed by the transform in the tileset JSON,
-  // but may be transformed by additional transforms applied in Cesium.
-  // This is why the transform is calculated as the difference between the initial transform and the current transform.
-  transform = Matrix4.multiplyTransformation(
-    transform,
-    Matrix4.inverseTransformation(initialTransform, scratchTransform),
-    scratchTransform
-  );
-  center = Matrix4.multiplyByPoint(transform, center, center);
-  const rotationScale = Matrix4.getRotation(transform, scratchMatrix);
-  halfAxes = Matrix3.multiply(rotationScale, halfAxes, halfAxes);
-
-  if (defined(result) && result instanceof TileOrientedBoundingBox) {
-    result.update(center, halfAxes);
-    return result;
-  }
-
-  return new TileOrientedBoundingBox(center, halfAxes);
-}
-
-function createRegion(region, transform, initialTransform, result) {
-  if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {
-    return createBoxFromTransformedRegion(region, transform, initialTransform, result);
-  }
-
-  if (defined(result)) {
-    return result;
-  }
-
-  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);
-
-  return new TileBoundingRegion({
-    rectangle: rectangleRegion,
-    minimumHeight: region[4],
-    maximumHeight: region[5]
-  });
-}
-*/
-
 function createSphere(sphere, transform, result?) {
   // Find the transformed center
   const center = new Vector3(sphere[0], sphere[1], sphere[2]);

package/src/tileset-3d/helpers/frame-state.ts

@@ -75,6 +75,10 @@ const cullingVolume = new CullingVolume([
 /**
  * Extracts a frame state appropriate for tile culling from a structural deck.gl viewport.
  *
+ * The viewport must describe the render camera, including its elevation. Geographic heights
+ * returned by `unprojectPosition` are used directly; adding a terrain offset only to traversal
+ * would make visibility, camera distances, and screen-space error disagree with rendering.
+ *
  * `options.timeSinceCameraMovement` can be supplied by a caller that retains camera pose across
  * calls. It defaults to a stationary camera so standalone callers do not defer requests.
  *
@@ -134,7 +138,7 @@ export function getFrameState(
   commonSpacePlanesToWGS84(viewport);
 
   const ViewportClass = viewport.constructor;
-  const {longitude, latitude, width, bearing, zoom} = viewport;
+  const {longitude, latitude, width, bearing, zoom, position} = viewport;
   // @ts-ignore
   const topDownViewport = new ViewportClass({
     longitude,
@@ -143,6 +147,7 @@ export function getFrameState(
     width,
     bearing,
     zoom,
+    position,
     pitch: 0
   });
 

package/src/tileset-3d/helpers/s2-bounding-volume.ts

@@ -0,0 +1,35 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+// TypeScript's legacy `node` resolution does not inspect package `exports`, but this public
+// subpath is resolved by the package at runtime and avoids loading unrelated DGGS decoders.
+// @ts-expect-error Conditional package subpath exports require a modern module resolver.
+import {getS2Bounds} from '@math.gl/dggs/s2';
+import {Ellipsoid, makeOBBFromRegion} from '@math.gl/geospatial';
+
+/** Serialized S2 cell metadata used by 3D Tiles bounding-volume extensions. */
+export type S2VolumeInfo = {
+  /** S2 key or token. */
+  token: string;
+  /** Minimum height in meters. */
+  minimumHeight: number;
+  /** Maximum height in meters. */
+  maximumHeight: number;
+};
+
+/**
+ * Converts an S2 cell and its vertical range to the runtime oriented-box representation.
+ *
+ * @param s2VolumeInfo - S2 cell token and height range.
+ * @returns A twelve-component center/half-axis oriented bounding box.
+ */
+export function convertS2BoundingVolumeToOBB(s2VolumeInfo: S2VolumeInfo): number[] {
+  const [[west, south], [east, north]] = getS2Bounds(s2VolumeInfo.token);
+  const orientedBoundingBox = makeOBBFromRegion(
+    [west, south, east, north, s2VolumeInfo.minimumHeight, s2VolumeInfo.maximumHeight],
+    Ellipsoid.WGS84,
+    {units: 'degrees'}
+  );
+  return [...orientedBoundingBox.center, ...orientedBoundingBox.halfAxes];
+}

package/src/types.ts

@@ -46,6 +46,8 @@ export type GeospatialViewport = Viewport & {
   cameraDirection: [number, number, number];
   /** @todo This field is not represented in Deck.gl viewports. Can be removed in the next version */
   cameraUp: [number, number, number];
+  /** Camera target offset in meters from longitude/latitude, including elevation. */
+  position?: number[];
   longitude: number;
   latitude: number;
   bearing: number;