@itwin/core-frontend 3.4.0-dev.9 → 3.5.0-dev.5

package/lib/esm/tile/map/MapTile.js

@@ -9,6 +9,8 @@ import { assert, dispose } from "@itwin/core-bentley";
 import { ColorByName, ColorDef, FrustumPlanes, GlobeMode, PackedFeatureTable } from "@itwin/core-common";
 import { AxisOrder, BilinearPatch, ClipPlane, ClipPrimitive, ClipShape, ClipVector, Constant, ConvexClipPlaneSet, EllipsoidPatch, LongitudeLatitudeNumber, Matrix3d, Point3d, PolygonOps, Range1d, Range2d, Range3d, Ray3d, Transform, Vector2d, Vector3d } from "@itwin/core-geometry";
 import { IModelApp } from "../../IModelApp";
+import { RealityMeshParams } from "../../render/RealityMeshParams";
+import { upsampleRealityMeshParams } from "../../render/UpsampleRealityMeshParams";
 import { TerrainTexture } from "../../render/RenderSystem";
 import { MapCartoRectangle, MapTileTree, QuadId, RealityTile, TileGraphicType, TileLoadStatus, TileTreeLoadStatus, } from "../internal";
 /** @internal */
@@ -30,15 +32,20 @@ export class PlanarTilePatch {
         return [this.corners[0], this.corners[1], this.corners[3], this.corners[2]];
     }
 }
-/** @internal */
+/** Projects points within the rectangular region of a [[MapTile]] into 3d space.
+ * @see [[MapTile.getProjection]] to obtain the projection for a [[MapTile]].
+ * @beta
+ */
 export class MapTileProjection {
+    /** @alpha */
     get ellipsoidPatch() { return undefined; }
+    /** @alpha */
     getGlobalPoint(u, v, z, result) {
         const point = this.getPoint(u, v, z, result);
         return this.transformFromLocal.multiplyPoint3d(point, point);
     }
 }
-/** @internal */
+/** @alpha */
 class EllipsoidProjection extends MapTileProjection {
     constructor(_patch, heightRange) {
         super();
@@ -56,7 +63,7 @@ class EllipsoidProjection extends MapTileProjection {
 }
 EllipsoidProjection._scratchAngles = LongitudeLatitudeNumber.createZero();
 EllipsoidProjection._scratchRay = Ray3d.createZero();
-/** @internal */
+/** @alpha */
 class PlanarProjection extends MapTileProjection {
     constructor(patch, heightRange) {
         super();
@@ -78,53 +85,74 @@ const scratchViewZ = Vector3d.create();
 const scratchPoint = Point3d.create();
 const scratchClipPlanes = [ClipPlane.createNormalAndPoint(scratchNormal, scratchPoint), ClipPlane.createNormalAndPoint(scratchNormal, scratchPoint), ClipPlane.createNormalAndPoint(scratchNormal, scratchPoint), ClipPlane.createNormalAndPoint(scratchNormal, scratchPoint)];
 const scratchCorners = [Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero()];
-/**
- * A specialization of Tile for maps imagery.  Holds the corners (possibly reprojected) as well as the height range.
- * @internal
+/** A [[Tile]] belonging to a [[MapTileTree]] representing a rectangular region of a map of the Earth.
+ * @beta
  */
-/** @internal */
 export class MapTile extends RealityTile {
-    constructor(params, mapTree, quadId, _patch, rectangle, heightRange, _cornerRays) {
+    /** @internal */
+    constructor(params, mapTree, quadId, patch, rectangle, heightRange, cornerRays) {
         super(params, mapTree);
+        /** @internal */
+        this.everLoaded = false; // If the tile is only required for availability metadata, load it once and then allow it to be unloaded.
         this.mapTree = mapTree;
         this.quadId = quadId;
-        this._patch = _patch;
+        this._patch = patch;
         this.rectangle = rectangle;
-        this._cornerRays = _cornerRays;
-        this.everLoaded = false; // If the tile is only required for availability metadata, load it once and then allow it to be unloaded.
-        this._heightRange = heightRange ? heightRange.clone() : undefined;
+        this._cornerRays = cornerRays;
+        this._heightRange = heightRange === null || heightRange === void 0 ? void 0 : heightRange.clone();
     }
-    get isReady() { return super.isReady && this.baseImageryIsReady; }
-    get hasGraphics() { return this._renderGeometry !== undefined; }
+    /** @internal */
+    get isReady() {
+        return super.isReady && this.baseImageryIsReady;
+    }
+    /** @internal */
+    get hasGraphics() {
+        return this._renderGeometry !== undefined;
+    }
+    /** @internal */
     get renderGeometry() { return this._renderGeometry; }
+    /** @internal */
     get mesh() { return this._mesh; }
+    /** @internal */
     get loadableTerrainTile() { return this.loadableTile; }
+    /** @internal */
     get isPlanar() { return this._patch instanceof PlanarTilePatch; }
+    /** @internal */
     get imageryTiles() { return this._imageryTiles; }
-    getRangeCorners(result) { return this._patch instanceof PlanarTilePatch ? this._patch.getRangeCorners(this.heightRange, result) : this.range.corners(result); }
+    /** @internal */
+    getRangeCorners(result) {
+        return this._patch instanceof PlanarTilePatch ? this._patch.getRangeCorners(this.heightRange, result) : this.range.corners(result);
+    }
+    /** @internal */
     getSizeProjectionCorners() {
         // Use only the first 4 corners -- On terrain tiles the height is initially exagerated to world height range which can cause excessive tile loading.
         const rangeCorners = this.getRangeCorners(scratchCorners);
         return rangeCorners.slice(0, 4);
     }
+    /** @internal */
     markUsed(args) {
         super.markUsed(args);
         if (this._imageryTiles)
             for (const imageryTile of this._imageryTiles)
                 imageryTile.markUsed(args);
     }
+    /** @internal */
     get graphicType() {
-        return this.mapTree.isOverlay ? TileGraphicType.Overlay : ((this.mapTree.useDepthBuffer || this._forceDepthBuffer) ? TileGraphicType.Scene : TileGraphicType.BackgroundMap);
+        if (this.mapTree.isOverlay)
+            return TileGraphicType.Overlay;
+        return (this.mapTree.useDepthBuffer || this._forceDepthBuffer) ? TileGraphicType.Scene : TileGraphicType.BackgroundMap;
     }
+    /** @internal */
     get mapLoader() { return this.realityRoot.loader; }
+    /** @internal */
     get isUpsampled() { return false; }
+    /** @internal */
     tileFromQuadId(quadId) {
         if (0 === quadId.compare(this.quadId))
             return this;
-        if (quadId.level <= this.quadId.level) {
-            assert(false);
+        assert(quadId.level > this.quadId.level);
+        if (quadId.level <= this.quadId.level)
             return undefined;
-        }
         if (this.children) {
             const shift = quadId.level - this.quadId.level - 1;
             const childRow = quadId.row >> shift;
@@ -139,8 +167,10 @@ export class MapTile extends RealityTile {
         return undefined;
     }
     get _forceDepthBuffer() {
-        return this.mapTree.globeMode === GlobeMode.Ellipsoid && this.depth < 8; // For large ellipsoidal globe tile force the depth buffer on to avoid anomalies at horizon.  These are large enough that they
+        // For large ellipsoidal globe tile force the depth buffer on to avoid anomalies at horizon.
+        return this.mapTree.globeMode === GlobeMode.Ellipsoid && this.depth < 8;
     }
+    /** @internal */
     addBoundingGraphic(builder, color) {
         if (!this.isDisplayable)
             return;
@@ -185,6 +215,7 @@ export class MapTile extends RealityTile {
         builder.setSymbology(transitionColor, transitionColor, 31);
         builder.addPointString(transitionPoints);
     }
+    /** @internal */
     getContentClip() {
         const points = this.getClipShape();
         if (points.length < 3)
@@ -212,19 +243,24 @@ export class MapTile extends RealityTile {
             return ClipVector.createCapture([ClipShape.createShape(points)]);
         }
     }
+    /** @internal */
     setNotFound() {
         super.setNotFound();
         // For map tiles assume that an unfound tile implies descendants and siblings will also be unfound.
         if (undefined !== this.parent)
             this.parent.setLeaf();
     }
-    getGraphic(_system, _texture) { return undefined; }
+    /** @internal */
+    getGraphic(_system, _texture) {
+        return undefined;
+    }
     /** For globe tiles displaying less then depth 2 appears distorted
      * @internal
      */
     get isDisplayable() {
         return this.mapTree.globeMode === GlobeMode.Ellipsoid ? (this.depth >= MapTileTree.minDisplayableDepth) : super.isDisplayable;
     }
+    /** @internal */
     isOccluded(viewingSpace) {
         if (undefined === this._cornerRays || this.mapTree.globeMode !== GlobeMode.Ellipsoid)
             return false;
@@ -246,6 +282,7 @@ export class MapTile extends RealityTile {
         }
         return true;
     }
+    /** @internal */
     _loadChildren(resolve, _reject) {
         const mapTree = this.mapTree;
         const childLevel = this.quadId.level + 1;
@@ -313,6 +350,7 @@ export class MapTile extends RealityTile {
         resolve(children);
         return children;
     }
+    /** @internal */
     static computeRangeCorners(corners, normal, chordHeight, result, heightRange) {
         if (result === undefined) {
             result = [];
@@ -329,12 +367,15 @@ export class MapTile extends RealityTile {
             corner.plus(deltaHigh, result[index++]);
         return result;
     }
+    /** @internal */
     isRegionCulled(args) {
         return this.isContentCulled(args);
     }
+    /** @internal */
     isContentCulled(args) {
         return FrustumPlanes.Containment.Outside === args.frustumPlanes.computeContainment(this.getRangeCorners(scratchCorners));
     }
+    /** @internal */
     clearLayers() {
         this.clearImageryTiles();
         this._graphic = undefined;
@@ -348,6 +389,7 @@ export class MapTile extends RealityTile {
             this._imageryTiles = undefined;
         }
     }
+    /** @internal */
     produceGraphics() {
         if (undefined !== this._graphic && this.imageryIsReady)
             return this._graphic;
@@ -363,14 +405,21 @@ export class MapTile extends RealityTile {
             this._graphic = graphic;
         return graphic;
     }
+    /** @internal */
     getClipShape() {
         return (this._patch instanceof PlanarTilePatch) ? this._patch.getClipShape() : [this._cornerRays[0].origin, this._cornerRays[1].origin, this._cornerRays[3].origin, this._cornerRays[2].origin];
     }
+    /** @internal */
     _collectStatistics(stats) {
-        var _a, _b;
+        var _a;
         super._collectStatistics(stats);
         (_a = this._renderGeometry) === null || _a === void 0 ? void 0 : _a.collectStatistics(stats);
-        (_b = this._mesh) === null || _b === void 0 ? void 0 : _b.collectStatistics(stats);
+        if (this._mesh) {
+            stats.addTerrain(this._mesh.indices.byteLength
+                + this._mesh.positions.points.byteLength
+                + this._mesh.uvs.points.byteLength
+                + (this._mesh.normals ? this._mesh.normals.byteLength : 0));
+        }
     }
     /** Height range is along with the tile corners to detect if tile intersects view frustum.
      * Range will be single value fo ron-terrain tiles -- if terrain tile is not loaded it will
@@ -388,9 +437,11 @@ export class MapTile extends RealityTile {
         assert(false);
         return Range1d.createNull();
     }
+    /** @internal */
     get mapTilingScheme() {
         return this.mapTree.sourceTilingScheme;
     }
+    /** Adjust the minimum and maximum elevations of the terrain within this tile. */
     adjustHeights(minHeight, maxHeight) {
         if (undefined === this._heightRange)
             this._heightRange = Range1d.createXX(minHeight, maxHeight);
@@ -401,9 +452,11 @@ export class MapTile extends RealityTile {
         if (this.rangeCorners && this._patch instanceof PlanarTilePatch)
             this._patch.getRangeCorners(this.heightRange, this.rangeCorners);
     }
+    /** Obtain a [[MapTileProjection]] to project positions within this tile's area into 3d space. */
     getProjection(heightRange) {
         return this._patch instanceof PlanarTilePatch ? new PlanarProjection(this._patch, heightRange) : new EllipsoidProjection(this._patch, heightRange);
     }
+    /** @internal */
     get baseImageryIsReady() {
         if (undefined !== this.mapTree.baseColor || 0 === this.mapTree.imageryTrees.length)
             return true;
@@ -412,6 +465,7 @@ export class MapTile extends RealityTile {
         const baseTreeId = this.mapTree.imageryTrees[0].modelId;
         return this._imageryTiles.every((imageryTile) => imageryTile.imageryTree.modelId !== baseTreeId || imageryTile.isReady);
     }
+    /** @internal */
     get imageryIsReady() {
         if (undefined === this._imageryTiles)
             return 0 === this.mapTree.imageryTrees.length;
@@ -451,6 +505,7 @@ export class MapTile extends RealityTile {
             parentHeightDepth++;
         return parentHeightDepth > MapTile._maxParentHeightDepth;
     }
+    /** @internal */
     getDrapeTextures() {
         if (undefined === this._imageryTiles)
             return undefined;
@@ -509,28 +564,31 @@ export class MapTile extends RealityTile {
         const imageryModelId = imageryTile.tree.modelId;
         return new TerrainTexture(imageryTile.texture, featureIndex, scale, translate, drapeRectangle, this.mapTree.getLayerIndex(imageryModelId), this.mapTree.getLayerTransparency(imageryModelId), clipRect);
     }
+    /** @internal */
     setContent(content) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         this._mesh = (_a = content.terrain) === null || _a === void 0 ? void 0 : _a.mesh;
         if (this.mapTree.produceGeometry) {
             const iModelTransform = this.mapTree.iModelTransform;
             const geometryTransform = (_c = (_b = content.terrain) === null || _b === void 0 ? void 0 : _b.renderGeometry) === null || _c === void 0 ? void 0 : _c.transform;
             const transform = geometryTransform ? iModelTransform.multiplyTransformTransform(geometryTransform) : iModelTransform;
-            const polyface = (_e = (_d = content.terrain) === null || _d === void 0 ? void 0 : _d.mesh) === null || _e === void 0 ? void 0 : _e.createPolyface(transform);
+            const polyface = ((_d = content.terrain) === null || _d === void 0 ? void 0 : _d.mesh) ? RealityMeshParams.toPolyface(content.terrain.mesh, { transform }) : undefined;
             this._geometry = polyface ? { polyfaces: [polyface] } : undefined;
         }
         else {
             dispose(this._renderGeometry);
-            this._renderGeometry = (_f = content.terrain) === null || _f === void 0 ? void 0 : _f.renderGeometry;
+            this._renderGeometry = (_e = content.terrain) === null || _e === void 0 ? void 0 : _e.renderGeometry;
         }
         this.everLoaded = true;
         if (undefined !== content.contentRange)
             this._contentRange = content.contentRange;
         this.setIsReady();
     }
+    /** @internal */
     freeMemory() {
         // ###TODO MapTiles and ImageryMapTiles share resources and don't currently interact well with TileAdmin.freeMemory(). Opt out for now.
     }
+    /** @internal */
     disposeContents() {
         super.disposeContents();
         this._renderGeometry = dispose(this._renderGeometry);
@@ -539,8 +597,8 @@ export class MapTile extends RealityTile {
     }
 }
 MapTile._maxParentHeightDepth = 4;
-MapTile._scratchRectangle1 = new MapCartoRectangle();
-MapTile._scratchRectangle2 = new MapCartoRectangle();
+MapTile._scratchRectangle1 = MapCartoRectangle.createZero();
+MapTile._scratchRectangle2 = MapCartoRectangle.createZero();
 MapTile._scratchThisDiagonal = Vector2d.create();
 MapTile._scratchDrapeDiagonal = Vector2d.create();
 MapTile._scratchIntersectRange = Range2d.createNull();
@@ -566,7 +624,7 @@ export class UpsampledMapTile extends MapTile {
         const thisRow = thisId.row - (parentId.row << levelDelta);
         const scale = 1.0 / (1 << levelDelta);
         const parentParameterRange = Range2d.createXYXY(scale * thisColumn, scale * thisRow, scale * (thisColumn + 1), scale * (thisRow + 1));
-        const upsample = parentMesh.upsample(parentParameterRange);
+        const upsample = upsampleRealityMeshParams(parentMesh, parentParameterRange);
         this.adjustHeights(upsample.heightRange.low, upsample.heightRange.high);
         return upsample;
     }
@@ -575,7 +633,7 @@ export class UpsampledMapTile extends MapTile {
             const upsample = this.upsampleFromParent();
             const projection = this.loadableTerrainTile.getProjection(this.heightRange);
             if (upsample)
-                this._renderGeometry = IModelApp.renderSystem.createRealityMeshFromTerrain(upsample.mesh, projection.transformFromLocal, true);
+                this._renderGeometry = IModelApp.renderSystem.createTerrainMesh(upsample.mesh, projection.transformFromLocal, true);
         }
         return this._renderGeometry;
     }