import AttributeCompression from "../Core/AttributeCompression.js";
import binarySearch from "../Core/binarySearch.js";
import BoundingSphere from "../Core/BoundingSphere.js";
import Cartesian2 from "../Core/Cartesian2.js";
import Cartesian3 from "../Core/Cartesian3.js";
import Cartesian4 from "../Core/Cartesian4.js";
import Cartographic from "../Core/Cartographic.js";
import defined from "../Core/defined.js";
import DeveloperError from "../Core/DeveloperError.js";
import HeightmapTerrainData from "../Core/HeightmapTerrainData.js";
import CesiumMath from "../Core/Math.js";
import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
import Queue from "../Core/Queue.js";
import Rectangle from "../Core/Rectangle.js";
import TerrainEncoding from "../Core/TerrainEncoding.js";
import TerrainMesh from "../Core/TerrainMesh.js";
import TileEdge from "../Core/TileEdge.js";
import WebMercatorProjection from "../Core/WebMercatorProjection.js";
import GlobeSurfaceTile from "./GlobeSurfaceTile.js";
import TileSelectionResult from "./TileSelectionResult.js";
function TerrainFillMesh(tile) {
this.tile = tile;
this.frameLastUpdated = undefined;
this.westMeshes = []; // north to south (CCW)
this.westTiles = [];
this.southMeshes = []; // west to east (CCW)
this.southTiles = [];
this.eastMeshes = []; // south to north (CCW)
this.eastTiles = [];
this.northMeshes = []; // east to west (CCW)
this.northTiles = [];
this.southwestMesh = undefined;
this.southwestTile = undefined;
this.southeastMesh = undefined;
this.southeastTile = undefined;
this.northwestMesh = undefined;
this.northwestTile = undefined;
this.northeastMesh = undefined;
this.northeastTile = undefined;
this.changedThisFrame = true;
this.visitedFrame = undefined;
this.enqueuedFrame = undefined;
this.mesh = undefined;
this.vertexArray = undefined;
this.waterMaskTexture = undefined;
this.waterMaskTranslationAndScale = new Cartesian4();
}
TerrainFillMesh.prototype.update = function (
tileProvider,
frameState,
vertexArraysToDestroy
) {
if (this.changedThisFrame) {
createFillMesh(tileProvider, frameState, this.tile, vertexArraysToDestroy);
this.changedThisFrame = false;
}
};
TerrainFillMesh.prototype.destroy = function (vertexArraysToDestroy) {
if (defined(this.vertexArray)) {
if (defined(vertexArraysToDestroy)) {
vertexArraysToDestroy.push(this.vertexArray);
} else {
GlobeSurfaceTile._freeVertexArray(
this.vertexArray,
vertexArraysToDestroy
);
}
this.vertexArray = undefined;
}
if (defined(this.waterMaskTexture)) {
--this.waterMaskTexture.referenceCount;
if (this.waterMaskTexture.referenceCount === 0) {
this.waterMaskTexture.destroy();
}
this.waterMaskTexture = undefined;
}
return undefined;
};
var traversalQueueScratch = new Queue();
TerrainFillMesh.updateFillTiles = function (
tileProvider,
renderedTiles,
frameState,
vertexArraysToDestroy
) {
// We want our fill tiles to look natural, which means they should align perfectly with
// adjacent loaded tiles, and their edges that are not adjacent to loaded tiles should have
// sensible heights (e.g. the average of the heights of loaded edges). Some fill tiles may
// be adjacent only to other fill tiles, and in that case heights should be assigned fanning
// outward from the loaded tiles so that there are no sudden changes in height.
// We do this with a breadth-first traversal of the rendered tiles, starting with the loaded
// ones. Graph nodes are tiles and graph edges connect to other rendered tiles that are spatially adjacent
// to those tiles. As we visit each node, we propagate tile edges to adjacent tiles. If there's no data
// for a tile edge, we create an edge with an average height and then propagate it. If an edge is partially defined
// (e.g. an edge is adjacent to multiple more-detailed tiles and only some of them are loaded), we
// fill in the rest of the edge with the same height.
var quadtree = tileProvider._quadtree;
var levelZeroTiles = quadtree._levelZeroTiles;
var lastSelectionFrameNumber = quadtree._lastSelectionFrameNumber;
var traversalQueue = traversalQueueScratch;
traversalQueue.clear();
// Add the tiles with real geometry to the traversal queue.
for (var i = 0; i < renderedTiles.length; ++i) {
var renderedTile = renderedTiles[i];
if (defined(renderedTile.data.vertexArray)) {
traversalQueue.enqueue(renderedTiles[i]);
}
}
var tile = traversalQueue.dequeue();
while (tile !== undefined) {
var tileToWest = tile.findTileToWest(levelZeroTiles);
var tileToSouth = tile.findTileToSouth(levelZeroTiles);
var tileToEast = tile.findTileToEast(levelZeroTiles);
var tileToNorth = tile.findTileToNorth(levelZeroTiles);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToWest,
lastSelectionFrameNumber,
TileEdge.EAST,
false,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToSouth,
lastSelectionFrameNumber,
TileEdge.NORTH,
false,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToEast,
lastSelectionFrameNumber,
TileEdge.WEST,
false,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToNorth,
lastSelectionFrameNumber,
TileEdge.SOUTH,
false,
traversalQueue,
vertexArraysToDestroy
);
var tileToNorthwest = tileToWest.findTileToNorth(levelZeroTiles);
var tileToSouthwest = tileToWest.findTileToSouth(levelZeroTiles);
var tileToNortheast = tileToEast.findTileToNorth(levelZeroTiles);
var tileToSoutheast = tileToEast.findTileToSouth(levelZeroTiles);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToNorthwest,
lastSelectionFrameNumber,
TileEdge.SOUTHEAST,
false,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToNortheast,
lastSelectionFrameNumber,
TileEdge.SOUTHWEST,
false,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToSouthwest,
lastSelectionFrameNumber,
TileEdge.NORTHEAST,
false,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
tile,
tileToSoutheast,
lastSelectionFrameNumber,
TileEdge.NORTHWEST,
false,
traversalQueue,
vertexArraysToDestroy
);
tile = traversalQueue.dequeue();
}
};
function visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile,
currentFrameNumber,
tileEdge,
downOnly,
traversalQueue,
vertexArraysToDestroy
) {
if (startTile === undefined) {
// There are no tiles North or South of the poles.
return;
}
var tile = startTile;
while (
tile &&
(tile._lastSelectionResultFrame !== currentFrameNumber ||
TileSelectionResult.wasKicked(tile._lastSelectionResult) ||
TileSelectionResult.originalResult(tile._lastSelectionResult) ===
TileSelectionResult.CULLED)
) {
// This tile wasn't visited or it was visited and then kicked, so walk up to find the closest ancestor that was rendered.
// We also walk up if the tile was culled, because if siblings were kicked an ancestor may have been rendered.
if (downOnly) {
return;
}
var parent = tile.parent;
if (tileEdge >= TileEdge.NORTHWEST && parent !== undefined) {
// When we're looking for a corner, verify that the parent tile is still relevant.
// That is, the parent and child must share the corner in question.
switch (tileEdge) {
case TileEdge.NORTHWEST:
tile = tile === parent.northwestChild ? parent : undefined;
break;
case TileEdge.NORTHEAST:
tile = tile === parent.northeastChild ? parent : undefined;
break;
case TileEdge.SOUTHWEST:
tile = tile === parent.southwestChild ? parent : undefined;
break;
case TileEdge.SOUTHEAST:
tile = tile === parent.southeastChild ? parent : undefined;
break;
}
} else {
tile = parent;
}
}
if (tile === undefined) {
return;
}
if (tile._lastSelectionResult === TileSelectionResult.RENDERED) {
if (defined(tile.data.vertexArray)) {
// No further processing necessary for renderable tiles.
return;
}
visitTile(
tileProvider,
frameState,
sourceTile,
tile,
tileEdge,
currentFrameNumber,
traversalQueue,
vertexArraysToDestroy
);
return;
}
if (
TileSelectionResult.originalResult(startTile._lastSelectionResult) ===
TileSelectionResult.CULLED
) {
return;
}
// This tile was refined, so find rendered children, if any.
// Visit the tiles in counter-clockwise order.
switch (tileEdge) {
case TileEdge.WEST:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.northwestChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.southwestChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
case TileEdge.EAST:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.southeastChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.northeastChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
case TileEdge.SOUTH:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.southwestChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.southeastChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
case TileEdge.NORTH:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.northeastChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.northwestChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
case TileEdge.NORTHWEST:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.northwestChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
case TileEdge.NORTHEAST:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.northeastChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
case TileEdge.SOUTHWEST:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.southwestChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
case TileEdge.SOUTHEAST:
visitRenderedTiles(
tileProvider,
frameState,
sourceTile,
startTile.southeastChild,
currentFrameNumber,
tileEdge,
true,
traversalQueue,
vertexArraysToDestroy
);
break;
default:
throw new DeveloperError("Invalid edge");
}
}
function visitTile(
tileProvider,
frameState,
sourceTile,
destinationTile,
tileEdge,
frameNumber,
traversalQueue,
vertexArraysToDestroy
) {
var destinationSurfaceTile = destinationTile.data;
if (destinationSurfaceTile.fill === undefined) {
destinationSurfaceTile.fill = new TerrainFillMesh(destinationTile);
} else if (destinationSurfaceTile.fill.visitedFrame === frameNumber) {
// Don't propagate edges to tiles that have already been visited this frame.
return;
}
if (destinationSurfaceTile.fill.enqueuedFrame !== frameNumber) {
// First time visiting this tile this frame, add it to the traversal queue.
destinationSurfaceTile.fill.enqueuedFrame = frameNumber;
destinationSurfaceTile.fill.changedThisFrame = false;
traversalQueue.enqueue(destinationTile);
}
propagateEdge(
tileProvider,
frameState,
sourceTile,
destinationTile,
tileEdge,
vertexArraysToDestroy
);
}
function propagateEdge(
tileProvider,
frameState,
sourceTile,
destinationTile,
tileEdge,
vertexArraysToDestroy
) {
var destinationFill = destinationTile.data.fill;
var sourceMesh;
var sourceFill = sourceTile.data.fill;
if (defined(sourceFill)) {
sourceFill.visitedFrame = frameState.frameNumber;
// Source is a fill, create/update it if necessary.
if (sourceFill.changedThisFrame) {
createFillMesh(
tileProvider,
frameState,
sourceTile,
vertexArraysToDestroy
);
sourceFill.changedThisFrame = false;
}
sourceMesh = sourceTile.data.fill.mesh;
} else {
sourceMesh = sourceTile.data.mesh;
}
var edgeMeshes;
var edgeTiles;
switch (tileEdge) {
case TileEdge.WEST:
edgeMeshes = destinationFill.westMeshes;
edgeTiles = destinationFill.westTiles;
break;
case TileEdge.SOUTH:
edgeMeshes = destinationFill.southMeshes;
edgeTiles = destinationFill.southTiles;
break;
case TileEdge.EAST:
edgeMeshes = destinationFill.eastMeshes;
edgeTiles = destinationFill.eastTiles;
break;
case TileEdge.NORTH:
edgeMeshes = destinationFill.northMeshes;
edgeTiles = destinationFill.northTiles;
break;
// Corners are simpler.
case TileEdge.NORTHWEST:
destinationFill.changedThisFrame =
destinationFill.changedThisFrame ||
destinationFill.northwestMesh !== sourceMesh;
destinationFill.northwestMesh = sourceMesh;
destinationFill.northwestTile = sourceTile;
return;
case TileEdge.NORTHEAST:
destinationFill.changedThisFrame =
destinationFill.changedThisFrame ||
destinationFill.northeastMesh !== sourceMesh;
destinationFill.northeastMesh = sourceMesh;
destinationFill.northeastTile = sourceTile;
return;
case TileEdge.SOUTHWEST:
destinationFill.changedThisFrame =
destinationFill.changedThisFrame ||
destinationFill.southwestMesh !== sourceMesh;
destinationFill.southwestMesh = sourceMesh;
destinationFill.southwestTile = sourceTile;
return;
case TileEdge.SOUTHEAST:
destinationFill.changedThisFrame =
destinationFill.changedThisFrame ||
destinationFill.southeastMesh !== sourceMesh;
destinationFill.southeastMesh = sourceMesh;
destinationFill.southeastTile = sourceTile;
return;
}
if (sourceTile.level <= destinationTile.level) {
// Source edge completely spans the destination edge.
destinationFill.changedThisFrame =
destinationFill.changedThisFrame ||
edgeMeshes[0] !== sourceMesh ||
edgeMeshes.length !== 1;
edgeMeshes[0] = sourceMesh;
edgeTiles[0] = sourceTile;
edgeMeshes.length = 1;
edgeTiles.length = 1;
return;
}
// Source edge is a subset of the destination edge.
// Figure out the range of meshes we're replacing.
var startIndex, endIndex, existingTile, existingRectangle;
var sourceRectangle = sourceTile.rectangle;
var epsilon;
var destinationRectangle = destinationTile.rectangle;
switch (tileEdge) {
case TileEdge.WEST:
epsilon =
(destinationRectangle.north - destinationRectangle.south) *
CesiumMath.EPSILON5;
for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
existingTile = edgeTiles[startIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.greaterThan(
sourceRectangle.north,
existingRectangle.south,
epsilon
)
) {
break;
}
}
for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
existingTile = edgeTiles[endIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.greaterThanOrEquals(
sourceRectangle.south,
existingRectangle.north,
epsilon
)
) {
break;
}
}
break;
case TileEdge.SOUTH:
epsilon =
(destinationRectangle.east - destinationRectangle.west) *
CesiumMath.EPSILON5;
for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
existingTile = edgeTiles[startIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.lessThan(
sourceRectangle.west,
existingRectangle.east,
epsilon
)
) {
break;
}
}
for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
existingTile = edgeTiles[endIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.lessThanOrEquals(
sourceRectangle.east,
existingRectangle.west,
epsilon
)
) {
break;
}
}
break;
case TileEdge.EAST:
epsilon =
(destinationRectangle.north - destinationRectangle.south) *
CesiumMath.EPSILON5;
for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
existingTile = edgeTiles[startIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.lessThan(
sourceRectangle.south,
existingRectangle.north,
epsilon
)
) {
break;
}
}
for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
existingTile = edgeTiles[endIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.lessThanOrEquals(
sourceRectangle.north,
existingRectangle.south,
epsilon
)
) {
break;
}
}
break;
case TileEdge.NORTH:
epsilon =
(destinationRectangle.east - destinationRectangle.west) *
CesiumMath.EPSILON5;
for (startIndex = 0; startIndex < edgeTiles.length; ++startIndex) {
existingTile = edgeTiles[startIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.greaterThan(
sourceRectangle.east,
existingRectangle.west,
epsilon
)
) {
break;
}
}
for (endIndex = startIndex; endIndex < edgeTiles.length; ++endIndex) {
existingTile = edgeTiles[endIndex];
existingRectangle = existingTile.rectangle;
if (
CesiumMath.greaterThanOrEquals(
sourceRectangle.west,
existingRectangle.east,
epsilon
)
) {
break;
}
}
break;
}
if (endIndex - startIndex === 1) {
destinationFill.changedThisFrame =
destinationFill.changedThisFrame || edgeMeshes[startIndex] !== sourceMesh;
edgeMeshes[startIndex] = sourceMesh;
edgeTiles[startIndex] = sourceTile;
} else {
destinationFill.changedThisFrame = true;
edgeMeshes.splice(startIndex, endIndex - startIndex, sourceMesh);
edgeTiles.splice(startIndex, endIndex - startIndex, sourceTile);
}
}
var cartographicScratch = new Cartographic();
var centerCartographicScratch = new Cartographic();
var cartesianScratch = new Cartesian3();
var normalScratch = new Cartesian3();
var octEncodedNormalScratch = new Cartesian2();
var uvScratch2 = new Cartesian2();
var uvScratch = new Cartesian2();
function HeightAndNormal() {
this.height = 0.0;
this.encodedNormal = new Cartesian2();
}
function fillMissingCorner(
fill,
ellipsoid,
u,
v,
corner,
adjacentCorner1,
adjacentCorner2,
oppositeCorner,
vertex
) {
if (defined(corner)) {
return corner;
}
var height;
if (defined(adjacentCorner1) && defined(adjacentCorner2)) {
height = (adjacentCorner1.height + adjacentCorner2.height) * 0.5;
} else if (defined(adjacentCorner1)) {
height = adjacentCorner1.height;
} else if (defined(adjacentCorner2)) {
height = adjacentCorner2.height;
} else if (defined(oppositeCorner)) {
height = oppositeCorner.height;
} else {
var surfaceTile = fill.tile.data;
var tileBoundingRegion = surfaceTile.tileBoundingRegion;
var minimumHeight = 0.0;
var maximumHeight = 0.0;
if (defined(tileBoundingRegion)) {
minimumHeight = tileBoundingRegion.minimumHeight;
maximumHeight = tileBoundingRegion.maximumHeight;
}
height = (minimumHeight + maximumHeight) * 0.5;
}
getVertexWithHeightAtCorner(fill, ellipsoid, u, v, height, vertex);
return vertex;
}
var heightRangeScratch = {
minimumHeight: 0.0,
maximumHeight: 0.0,
};
var swVertexScratch = new HeightAndNormal();
var seVertexScratch = new HeightAndNormal();
var nwVertexScratch = new HeightAndNormal();
var neVertexScratch = new HeightAndNormal();
var heightmapBuffer =
typeof Uint8Array !== "undefined" ? new Uint8Array(9 * 9) : undefined;
var scratchCreateMeshSyncOptions = {
tilingScheme: undefined,
x: 0,
y: 0,
level: 0,
exaggeration: 1.0,
};
function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
GlobeSurfaceTile.initialize(
tile,
tileProvider.terrainProvider,
tileProvider._imageryLayers
);
var surfaceTile = tile.data;
var fill = surfaceTile.fill;
var rectangle = tile.rectangle;
var ellipsoid = tile.tilingScheme.ellipsoid;
var nwCorner = getCorner(
fill,
ellipsoid,
0.0,
1.0,
fill.northwestTile,
fill.northwestMesh,
fill.northTiles,
fill.northMeshes,
fill.westTiles,
fill.westMeshes,
nwVertexScratch
);
var swCorner = getCorner(
fill,
ellipsoid,
0.0,
0.0,
fill.southwestTile,
fill.southwestMesh,
fill.westTiles,
fill.westMeshes,
fill.southTiles,
fill.southMeshes,
swVertexScratch
);
var seCorner = getCorner(
fill,
ellipsoid,
1.0,
0.0,
fill.southeastTile,
fill.southeastMesh,
fill.southTiles,
fill.southMeshes,
fill.eastTiles,
fill.eastMeshes,
seVertexScratch
);
var neCorner = getCorner(
fill,
ellipsoid,
1.0,
1.0,
fill.northeastTile,
fill.northeastMesh,
fill.eastTiles,
fill.eastMeshes,
fill.northTiles,
fill.northMeshes,
neVertexScratch
);
nwCorner = fillMissingCorner(
fill,
ellipsoid,
0.0,
1.0,
nwCorner,
swCorner,
neCorner,
seCorner,
nwVertexScratch
);
swCorner = fillMissingCorner(
fill,
ellipsoid,
0.0,
0.0,
swCorner,
nwCorner,
seCorner,
neCorner,
swVertexScratch
);
seCorner = fillMissingCorner(
fill,
ellipsoid,
1.0,
1.0,
seCorner,
swCorner,
neCorner,
nwCorner,
seVertexScratch
);
neCorner = fillMissingCorner(
fill,
ellipsoid,
1.0,
1.0,
neCorner,
seCorner,
nwCorner,
swCorner,
neVertexScratch
);
var southwestHeight = swCorner.height;
var southeastHeight = seCorner.height;
var northwestHeight = nwCorner.height;
var northeastHeight = neCorner.height;
var minimumHeight = Math.min(
southwestHeight,
southeastHeight,
northwestHeight,
northeastHeight
);
var maximumHeight = Math.max(
southwestHeight,
southeastHeight,
northwestHeight,
northeastHeight
);
var middleHeight = (minimumHeight + maximumHeight) * 0.5;
var i;
var len;
// For low-detail tiles, our usual fill tile approach will create tiles that
// look really blocky because they don't have enough vertices to account for the
// Earth's curvature. But the height range will also typically be well within
// the allowed geometric error for those levels. So fill such tiles with a
// constant-height heightmap.
var geometricError = tileProvider.getLevelMaximumGeometricError(tile.level);
var minCutThroughRadius = ellipsoid.maximumRadius - geometricError;
var maxTileWidth =
Math.acos(minCutThroughRadius / ellipsoid.maximumRadius) * 4.0;
// When the tile width is greater than maxTileWidth as computed above, the error
// of a normal fill tile from globe curvature alone will exceed the allowed geometric
// error. Terrain won't change that much. However, we can allow more error than that.
// A little blockiness during load is acceptable. For the WGS84 ellipsoid and
// standard geometric error setup, the value here will have us use a heightmap
// at levels 1, 2, and 3.
maxTileWidth *= 1.5;
if (
rectangle.width > maxTileWidth &&
maximumHeight - minimumHeight <= geometricError
) {
var terrainData = new HeightmapTerrainData({
width: 9,
height: 9,
buffer: heightmapBuffer,
structure: {
// Use the maximum as the constant height so that this tile's skirt
// covers any cracks with adjacent tiles.
heightOffset: maximumHeight,
},
});
var createMeshSyncOptions = scratchCreateMeshSyncOptions;
createMeshSyncOptions.tilingScheme = tile.tilingScheme;
createMeshSyncOptions.x = tile.x;
createMeshSyncOptions.y = tile.y;
createMeshSyncOptions.level = tile.level;
fill.mesh = terrainData._createMeshSync(createMeshSyncOptions);
} else {
var encoding = new TerrainEncoding(
undefined,
undefined,
undefined,
undefined,
true,
true
);
var centerCartographic = centerCartographicScratch;
centerCartographic.longitude = (rectangle.east + rectangle.west) * 0.5;
centerCartographic.latitude = (rectangle.north + rectangle.south) * 0.5;
centerCartographic.height = middleHeight;
encoding.center = ellipsoid.cartographicToCartesian(
centerCartographic,
encoding.center
);
// At _most_, we have vertices for the 4 corners, plus 1 center, plus every adjacent edge vertex.
// In reality there will be less most of the time, but close enough; better
// to overestimate than to re-allocate/copy/traverse the vertices twice.
// Also, we'll often be able to squeeze the index data into the extra space in the buffer.
var maxVertexCount = 5;
var meshes;
meshes = fill.westMeshes;
for (i = 0, len = meshes.length; i < len; ++i) {
maxVertexCount += meshes[i].eastIndicesNorthToSouth.length;
}
meshes = fill.southMeshes;
for (i = 0, len = meshes.length; i < len; ++i) {
maxVertexCount += meshes[i].northIndicesWestToEast.length;
}
meshes = fill.eastMeshes;
for (i = 0, len = meshes.length; i < len; ++i) {
maxVertexCount += meshes[i].westIndicesSouthToNorth.length;
}
meshes = fill.northMeshes;
for (i = 0, len = meshes.length; i < len; ++i) {
maxVertexCount += meshes[i].southIndicesEastToWest.length;
}
var heightRange = heightRangeScratch;
heightRange.minimumHeight = minimumHeight;
heightRange.maximumHeight = maximumHeight;
var stride = encoding.getStride();
var typedArray = new Float32Array(maxVertexCount * stride);
var nextIndex = 0;
var northwestIndex = nextIndex;
nextIndex = addVertexWithComputedPosition(
ellipsoid,
rectangle,
encoding,
typedArray,
nextIndex,
0.0,
1.0,
nwCorner.height,
nwCorner.encodedNormal,
1.0,
heightRange
);
nextIndex = addEdge(
fill,
ellipsoid,
encoding,
typedArray,
nextIndex,
fill.westTiles,
fill.westMeshes,
TileEdge.EAST,
heightRange
);
var southwestIndex = nextIndex;
nextIndex = addVertexWithComputedPosition(
ellipsoid,
rectangle,
encoding,
typedArray,
nextIndex,
0.0,
0.0,
swCorner.height,
swCorner.encodedNormal,
0.0,
heightRange
);
nextIndex = addEdge(
fill,
ellipsoid,
encoding,
typedArray,
nextIndex,
fill.southTiles,
fill.southMeshes,
TileEdge.NORTH,
heightRange
);
var southeastIndex = nextIndex;
nextIndex = addVertexWithComputedPosition(
ellipsoid,
rectangle,
encoding,
typedArray,
nextIndex,
1.0,
0.0,
seCorner.height,
seCorner.encodedNormal,
0.0,
heightRange
);
nextIndex = addEdge(
fill,
ellipsoid,
encoding,
typedArray,
nextIndex,
fill.eastTiles,
fill.eastMeshes,
TileEdge.WEST,
heightRange
);
var northeastIndex = nextIndex;
nextIndex = addVertexWithComputedPosition(
ellipsoid,
rectangle,
encoding,
typedArray,
nextIndex,
1.0,
1.0,
neCorner.height,
neCorner.encodedNormal,
1.0,
heightRange
);
nextIndex = addEdge(
fill,
ellipsoid,
encoding,
typedArray,
nextIndex,
fill.northTiles,
fill.northMeshes,
TileEdge.SOUTH,
heightRange
);
minimumHeight = heightRange.minimumHeight;
maximumHeight = heightRange.maximumHeight;
var obb = OrientedBoundingBox.fromRectangle(
rectangle,
minimumHeight,
maximumHeight,
tile.tilingScheme.ellipsoid
);
// Add a single vertex at the center of the tile.
var southMercatorY = WebMercatorProjection.geodeticLatitudeToMercatorAngle(
rectangle.south
);
var oneOverMercatorHeight =
1.0 /
(WebMercatorProjection.geodeticLatitudeToMercatorAngle(rectangle.north) -
southMercatorY);
var centerWebMercatorT =
(WebMercatorProjection.geodeticLatitudeToMercatorAngle(
centerCartographic.latitude
) -
southMercatorY) *
oneOverMercatorHeight;
ellipsoid.geodeticSurfaceNormalCartographic(
cartographicScratch,
normalScratch
);
var centerEncodedNormal = AttributeCompression.octEncode(
normalScratch,
octEncodedNormalScratch
);
var centerIndex = nextIndex;
encoding.encode(
typedArray,
nextIndex * stride,
obb.center,
Cartesian2.fromElements(0.5, 0.5, uvScratch),
middleHeight,
centerEncodedNormal,
centerWebMercatorT
);
++nextIndex;
var vertexCount = nextIndex;
var bytesPerIndex = vertexCount < 256 ? 1 : 2;
var indexCount = (vertexCount - 1) * 3; // one triangle per edge vertex
var indexDataBytes = indexCount * bytesPerIndex;
var availableBytesInBuffer =
(typedArray.length - vertexCount * stride) *
Float32Array.BYTES_PER_ELEMENT;
var indices;
if (availableBytesInBuffer >= indexDataBytes) {
// Store the index data in the same buffer as the vertex data.
var startIndex = vertexCount * stride * Float32Array.BYTES_PER_ELEMENT;
indices =
vertexCount < 256
? new Uint8Array(typedArray.buffer, startIndex, indexCount)
: new Uint16Array(typedArray.buffer, startIndex, indexCount);
} else {
// Allocate a new buffer for the index data.
indices =
vertexCount < 256
? new Uint8Array(indexCount)
: new Uint16Array(indexCount);
}
typedArray = new Float32Array(typedArray.buffer, 0, vertexCount * stride);
var indexOut = 0;
for (i = 0; i < vertexCount - 2; ++i) {
indices[indexOut++] = centerIndex;
indices[indexOut++] = i;
indices[indexOut++] = i + 1;
}
indices[indexOut++] = centerIndex;
indices[indexOut++] = i;
indices[indexOut++] = 0;
var westIndicesSouthToNorth = [];
for (i = southwestIndex; i >= northwestIndex; --i) {
westIndicesSouthToNorth.push(i);
}
var southIndicesEastToWest = [];
for (i = southeastIndex; i >= southwestIndex; --i) {
southIndicesEastToWest.push(i);
}
var eastIndicesNorthToSouth = [];
for (i = northeastIndex; i >= southeastIndex; --i) {
eastIndicesNorthToSouth.push(i);
}
var northIndicesWestToEast = [];
northIndicesWestToEast.push(0);
for (i = centerIndex - 1; i >= northeastIndex; --i) {
northIndicesWestToEast.push(i);
}
fill.mesh = new TerrainMesh(
encoding.center,
typedArray,
indices,
indexCount,
vertexCount,
minimumHeight,
maximumHeight,
BoundingSphere.fromOrientedBoundingBox(obb),
computeOccludeePoint(
tileProvider,
obb.center,
rectangle,
minimumHeight,
maximumHeight
),
encoding.getStride(),
obb,
encoding,
frameState.terrainExaggeration,
westIndicesSouthToNorth,
southIndicesEastToWest,
eastIndicesNorthToSouth,
northIndicesWestToEast
);
}
var context = frameState.context;
if (defined(fill.vertexArray)) {
if (defined(vertexArraysToDestroy)) {
vertexArraysToDestroy.push(fill.vertexArray);
} else {
GlobeSurfaceTile._freeVertexArray(fill.vertexArray);
}
}
fill.vertexArray = GlobeSurfaceTile._createVertexArrayForMesh(
context,
fill.mesh
);
surfaceTile.processImagery(
tile,
tileProvider.terrainProvider,
frameState,
true
);
var oldTexture = fill.waterMaskTexture;
fill.waterMaskTexture = undefined;
if (tileProvider.terrainProvider.hasWaterMask) {
var waterSourceTile = surfaceTile._findAncestorTileWithTerrainData(tile);
if (
defined(waterSourceTile) &&
defined(waterSourceTile.data.waterMaskTexture)
) {
fill.waterMaskTexture = waterSourceTile.data.waterMaskTexture;
++fill.waterMaskTexture.referenceCount;
surfaceTile._computeWaterMaskTranslationAndScale(
tile,
waterSourceTile,
fill.waterMaskTranslationAndScale
);
}
}
if (defined(oldTexture)) {
--oldTexture.referenceCount;
if (oldTexture.referenceCount === 0) {
oldTexture.destroy();
}
}
}
function addVertexWithComputedPosition(
ellipsoid,
rectangle,
encoding,
buffer,
index,
u,
v,
height,
encodedNormal,
webMercatorT,
heightRange
) {
var cartographic = cartographicScratch;
cartographic.longitude = CesiumMath.lerp(rectangle.west, rectangle.east, u);
cartographic.latitude = CesiumMath.lerp(rectangle.south, rectangle.north, v);
cartographic.height = height;
var position = ellipsoid.cartographicToCartesian(
cartographic,
cartesianScratch
);
var uv = uvScratch2;
uv.x = u;
uv.y = v;
encoding.encode(
buffer,
index * encoding.getStride(),
position,
uv,
height,
encodedNormal,
webMercatorT
);
heightRange.minimumHeight = Math.min(heightRange.minimumHeight, height);
heightRange.maximumHeight = Math.max(heightRange.maximumHeight, height);
return index + 1;
}
var sourceRectangleScratch = new Rectangle();
function transformTextureCoordinates(
sourceTile,
targetTile,
coordinates,
result
) {
var sourceRectangle = sourceTile.rectangle;
var targetRectangle = targetTile.rectangle;
// Handle transforming across the anti-meridian.
if (
targetTile.x === 0 &&
coordinates.x === 1.0 &&
sourceTile.x ===
sourceTile.tilingScheme.getNumberOfXTilesAtLevel(sourceTile.level) - 1
) {
sourceRectangle = Rectangle.clone(
sourceTile.rectangle,
sourceRectangleScratch
);
sourceRectangle.west -= CesiumMath.TWO_PI;
sourceRectangle.east -= CesiumMath.TWO_PI;
} else if (
sourceTile.x === 0 &&
coordinates.x === 0.0 &&
targetTile.x ===
targetTile.tilingScheme.getNumberOfXTilesAtLevel(targetTile.level) - 1
) {
sourceRectangle = Rectangle.clone(
sourceTile.rectangle,
sourceRectangleScratch
);
sourceRectangle.west += CesiumMath.TWO_PI;
sourceRectangle.east += CesiumMath.TWO_PI;
}
var sourceWidth = sourceRectangle.east - sourceRectangle.west;
var umin = (targetRectangle.west - sourceRectangle.west) / sourceWidth;
var umax = (targetRectangle.east - sourceRectangle.west) / sourceWidth;
var sourceHeight = sourceRectangle.north - sourceRectangle.south;
var vmin = (targetRectangle.south - sourceRectangle.south) / sourceHeight;
var vmax = (targetRectangle.north - sourceRectangle.south) / sourceHeight;
var u = (coordinates.x - umin) / (umax - umin);
var v = (coordinates.y - vmin) / (vmax - vmin);
// Ensure that coordinates very near the corners are at the corners.
if (Math.abs(u) < Math.EPSILON5) {
u = 0.0;
} else if (Math.abs(u - 1.0) < Math.EPSILON5) {
u = 1.0;
}
if (Math.abs(v) < Math.EPSILON5) {
v = 0.0;
} else if (Math.abs(v - 1.0) < Math.EPSILON5) {
v = 1.0;
}
result.x = u;
result.y = v;
return result;
}
var encodedNormalScratch = new Cartesian2();
function getVertexFromTileAtCorner(sourceMesh, sourceIndex, u, v, vertex) {
var sourceEncoding = sourceMesh.encoding;
var sourceVertices = sourceMesh.vertices;
vertex.height = sourceEncoding.decodeHeight(sourceVertices, sourceIndex);
if (sourceEncoding.hasVertexNormals) {
sourceEncoding.getOctEncodedNormal(
sourceVertices,
sourceIndex,
vertex.encodedNormal
);
} else {
var normal = vertex.encodedNormal;
normal.x = 0.0;
normal.y = 0.0;
}
}
var encodedNormalScratch2 = new Cartesian2();
var cartesianScratch2 = new Cartesian3();
function getInterpolatedVertexAtCorner(
ellipsoid,
sourceTile,
targetTile,
sourceMesh,
previousIndex,
nextIndex,
u,
v,
interpolateU,
vertex
) {
var sourceEncoding = sourceMesh.encoding;
var sourceVertices = sourceMesh.vertices;
var previousUv = transformTextureCoordinates(
sourceTile,
targetTile,
sourceEncoding.decodeTextureCoordinates(
sourceVertices,
previousIndex,
uvScratch
),
uvScratch
);
var nextUv = transformTextureCoordinates(
sourceTile,
targetTile,
sourceEncoding.decodeTextureCoordinates(
sourceVertices,
nextIndex,
uvScratch2
),
uvScratch2
);
var ratio;
if (interpolateU) {
ratio = (u - previousUv.x) / (nextUv.x - previousUv.x);
} else {
ratio = (v - previousUv.y) / (nextUv.y - previousUv.y);
}
var height1 = sourceEncoding.decodeHeight(sourceVertices, previousIndex);
var height2 = sourceEncoding.decodeHeight(sourceVertices, nextIndex);
var targetRectangle = targetTile.rectangle;
cartographicScratch.longitude = CesiumMath.lerp(
targetRectangle.west,
targetRectangle.east,
u
);
cartographicScratch.latitude = CesiumMath.lerp(
targetRectangle.south,
targetRectangle.north,
v
);
vertex.height = cartographicScratch.height = CesiumMath.lerp(
height1,
height2,
ratio
);
var normal;
if (sourceEncoding.hasVertexNormals) {
var encodedNormal1 = sourceEncoding.getOctEncodedNormal(
sourceVertices,
previousIndex,
encodedNormalScratch
);
var encodedNormal2 = sourceEncoding.getOctEncodedNormal(
sourceVertices,
nextIndex,
encodedNormalScratch2
);
var normal1 = AttributeCompression.octDecode(
encodedNormal1.x,
encodedNormal1.y,
cartesianScratch
);
var normal2 = AttributeCompression.octDecode(
encodedNormal2.x,
encodedNormal2.y,
cartesianScratch2
);
normal = Cartesian3.lerp(normal1, normal2, ratio, cartesianScratch);
Cartesian3.normalize(normal, normal);
AttributeCompression.octEncode(normal, vertex.encodedNormal);
} else {
normal = ellipsoid.geodeticSurfaceNormalCartographic(
cartographicScratch,
cartesianScratch
);
AttributeCompression.octEncode(normal, vertex.encodedNormal);
}
}
function getVertexWithHeightAtCorner(
terrainFillMesh,
ellipsoid,
u,
v,
height,
vertex
) {
vertex.height = height;
var normal = ellipsoid.geodeticSurfaceNormalCartographic(
cartographicScratch,
cartesianScratch
);
AttributeCompression.octEncode(normal, vertex.encodedNormal);
}
function getCorner(
terrainFillMesh,
ellipsoid,
u,
v,
cornerTile,
cornerMesh,
previousEdgeTiles,
previousEdgeMeshes,
nextEdgeTiles,
nextEdgeMeshes,
vertex
) {
var gotCorner =
getCornerFromEdge(
terrainFillMesh,
ellipsoid,
previousEdgeMeshes,
previousEdgeTiles,
false,
u,
v,
vertex
) ||
getCornerFromEdge(
terrainFillMesh,
ellipsoid,
nextEdgeMeshes,
nextEdgeTiles,
true,
u,
v,
vertex
);
if (gotCorner) {
return vertex;
}
var vertexIndex;
if (meshIsUsable(cornerTile, cornerMesh)) {
// Corner mesh is valid, copy its corner vertex to this mesh.
if (u === 0.0) {
if (v === 0.0) {
// southwest destination, northeast source
vertexIndex = cornerMesh.eastIndicesNorthToSouth[0];
} else {
// northwest destination, southeast source
vertexIndex = cornerMesh.southIndicesEastToWest[0];
}
} else if (v === 0.0) {
// southeast destination, northwest source
vertexIndex = cornerMesh.northIndicesWestToEast[0];
} else {
// northeast destination, southwest source
vertexIndex = cornerMesh.westIndicesSouthToNorth[0];
}
getVertexFromTileAtCorner(cornerMesh, vertexIndex, u, v, vertex);
return vertex;
}
// There is no precise vertex available from the corner or from either adjacent edge.
// This is either because there are no tiles at all at the edges and corner, or
// because the tiles at the edge are higher-level-number and don't extend all the way
// to the corner.
// Try to grab a height from the adjacent edges.
var height;
if (u === 0.0) {
if (v === 0.0) {
// southwest
height = getClosestHeightToCorner(
terrainFillMesh.westMeshes,
terrainFillMesh.westTiles,
TileEdge.EAST,
terrainFillMesh.southMeshes,
terrainFillMesh.southTiles,
TileEdge.NORTH,
u,
v
);
} else {
// northwest
height = getClosestHeightToCorner(
terrainFillMesh.northMeshes,
terrainFillMesh.northTiles,
TileEdge.SOUTH,
terrainFillMesh.westMeshes,
terrainFillMesh.westTiles,
TileEdge.EAST,
u,
v
);
}
} else if (v === 0.0) {
// southeast
height = getClosestHeightToCorner(
terrainFillMesh.southMeshes,
terrainFillMesh.southTiles,
TileEdge.NORTH,
terrainFillMesh.eastMeshes,
terrainFillMesh.eastTiles,
TileEdge.WEST,
u,
v
);
} else {
// northeast
height = getClosestHeightToCorner(
terrainFillMesh.eastMeshes,
terrainFillMesh.eastTiles,
TileEdge.WEST,
terrainFillMesh.northMeshes,
terrainFillMesh.northTiles,
TileEdge.SOUTH,
u,
v
);
}
if (defined(height)) {
getVertexWithHeightAtCorner(
terrainFillMesh,
ellipsoid,
u,
v,
height,
vertex
);
return vertex;
}
// No heights available that are closer than the adjacent corners.
return undefined;
}
function getClosestHeightToCorner(
previousMeshes,
previousTiles,
previousEdge,
nextMeshes,
nextTiles,
nextEdge,
u,
v
) {
var height1 = getNearestHeightOnEdge(
previousMeshes,
previousTiles,
false,
previousEdge,
u,
v
);
var height2 = getNearestHeightOnEdge(
nextMeshes,
nextTiles,
true,
nextEdge,
u,
v
);
if (defined(height1) && defined(height2)) {
// It would be slightly better to do a weighted average of the two heights
// based on their distance from the corner, but it shouldn't matter much in practice.
return (height1 + height2) * 0.5;
} else if (defined(height1)) {
return height1;
}
return height2;
}
function addEdge(
terrainFillMesh,
ellipsoid,
encoding,
typedArray,
nextIndex,
edgeTiles,
edgeMeshes,
tileEdge,
heightRange
) {
for (var i = 0; i < edgeTiles.length; ++i) {
nextIndex = addEdgeMesh(
terrainFillMesh,
ellipsoid,
encoding,
typedArray,
nextIndex,
edgeTiles[i],
edgeMeshes[i],
tileEdge,
heightRange
);
}
return nextIndex;
}
function addEdgeMesh(
terrainFillMesh,
ellipsoid,
encoding,
typedArray,
nextIndex,
edgeTile,
edgeMesh,
tileEdge,
heightRange
) {
// Handle copying edges across the anti-meridian.
var sourceRectangle = edgeTile.rectangle;
if (tileEdge === TileEdge.EAST && terrainFillMesh.tile.x === 0) {
sourceRectangle = Rectangle.clone(
edgeTile.rectangle,
sourceRectangleScratch
);
sourceRectangle.west -= CesiumMath.TWO_PI;
sourceRectangle.east -= CesiumMath.TWO_PI;
} else if (tileEdge === TileEdge.WEST && edgeTile.x === 0) {
sourceRectangle = Rectangle.clone(
edgeTile.rectangle,
sourceRectangleScratch
);
sourceRectangle.west += CesiumMath.TWO_PI;
sourceRectangle.east += CesiumMath.TWO_PI;
}
var targetRectangle = terrainFillMesh.tile.rectangle;
var lastU;
var lastV;
if (nextIndex > 0) {
encoding.decodeTextureCoordinates(typedArray, nextIndex - 1, uvScratch);
lastU = uvScratch.x;
lastV = uvScratch.y;
}
var indices;
var compareU;
switch (tileEdge) {
case TileEdge.WEST:
indices = edgeMesh.westIndicesSouthToNorth;
compareU = false;
break;
case TileEdge.NORTH:
indices = edgeMesh.northIndicesWestToEast;
compareU = true;
break;
case TileEdge.EAST:
indices = edgeMesh.eastIndicesNorthToSouth;
compareU = false;
break;
case TileEdge.SOUTH:
indices = edgeMesh.southIndicesEastToWest;
compareU = true;
break;
}
var sourceTile = edgeTile;
var targetTile = terrainFillMesh.tile;
var sourceEncoding = edgeMesh.encoding;
var sourceVertices = edgeMesh.vertices;
var targetStride = encoding.getStride();
var southMercatorY;
var oneOverMercatorHeight;
if (sourceEncoding.hasWebMercatorT) {
southMercatorY = WebMercatorProjection.geodeticLatitudeToMercatorAngle(
targetRectangle.south
);
oneOverMercatorHeight =
1.0 /
(WebMercatorProjection.geodeticLatitudeToMercatorAngle(
targetRectangle.north
) -
southMercatorY);
}
for (var i = 0; i < indices.length; ++i) {
var index = indices[i];
var uv = sourceEncoding.decodeTextureCoordinates(
sourceVertices,
index,
uvScratch
);
transformTextureCoordinates(sourceTile, targetTile, uv, uv);
var u = uv.x;
var v = uv.y;
var uOrV = compareU ? u : v;
if (uOrV < 0.0 || uOrV > 1.0) {
// Vertex is outside the target tile - skip it.
continue;
}
if (
Math.abs(u - lastU) < CesiumMath.EPSILON5 &&
Math.abs(v - lastV) < CesiumMath.EPSILON5
) {
// Vertex is very close to the previous one - skip it.
continue;
}
var nearlyEdgeU =
Math.abs(u) < CesiumMath.EPSILON5 ||
Math.abs(u - 1.0) < CesiumMath.EPSILON5;
var nearlyEdgeV =
Math.abs(v) < CesiumMath.EPSILON5 ||
Math.abs(v - 1.0) < CesiumMath.EPSILON5;
if (nearlyEdgeU && nearlyEdgeV) {
// Corner vertex - skip it.
continue;
}
var position = sourceEncoding.decodePosition(
sourceVertices,
index,
cartesianScratch
);
var height = sourceEncoding.decodeHeight(sourceVertices, index);
var normal;
if (sourceEncoding.hasVertexNormals) {
normal = sourceEncoding.getOctEncodedNormal(
sourceVertices,
index,
octEncodedNormalScratch
);
} else {
normal = octEncodedNormalScratch;
normal.x = 0.0;
normal.y = 0.0;
}
var webMercatorT = v;
if (sourceEncoding.hasWebMercatorT) {
var latitude = CesiumMath.lerp(
targetRectangle.south,
targetRectangle.north,
v
);
webMercatorT =
(WebMercatorProjection.geodeticLatitudeToMercatorAngle(latitude) -
southMercatorY) *
oneOverMercatorHeight;
}
encoding.encode(
typedArray,
nextIndex * targetStride,
position,
uv,
height,
normal,
webMercatorT
);
heightRange.minimumHeight = Math.min(heightRange.minimumHeight, height);
heightRange.maximumHeight = Math.max(heightRange.maximumHeight, height);
++nextIndex;
}
return nextIndex;
}
function getNearestHeightOnEdge(meshes, tiles, isNext, edge, u, v) {
var meshStart;
var meshEnd;
var meshStep;
if (isNext) {
meshStart = 0;
meshEnd = meshes.length;
meshStep = 1;
} else {
meshStart = meshes.length - 1;
meshEnd = -1;
meshStep = -1;
}
for (
var meshIndex = meshStart;
meshIndex !== meshEnd;
meshIndex += meshStep
) {
var mesh = meshes[meshIndex];
var tile = tiles[meshIndex];
if (!meshIsUsable(tile, mesh)) {
continue;
}
var indices;
switch (edge) {
case TileEdge.WEST:
indices = mesh.westIndicesSouthToNorth;
break;
case TileEdge.SOUTH:
indices = mesh.southIndicesEastToWest;
break;
case TileEdge.EAST:
indices = mesh.eastIndicesNorthToSouth;
break;
case TileEdge.NORTH:
indices = mesh.northIndicesWestToEast;
break;
}
var index = indices[isNext ? 0 : indices.length - 1];
if (defined(index)) {
return mesh.encoding.decodeHeight(mesh.vertices, index);
}
}
return undefined;
}
function meshIsUsable(tile, mesh) {
return (
defined(mesh) &&
(!defined(tile.data.fill) || !tile.data.fill.changedThisFrame)
);
}
function getCornerFromEdge(
terrainFillMesh,
ellipsoid,
edgeMeshes,
edgeTiles,
isNext,
u,
v,
vertex
) {
var edgeVertices;
var compareU;
var increasing;
var vertexIndexIndex;
var vertexIndex;
var sourceTile = edgeTiles[isNext ? 0 : edgeMeshes.length - 1];
var sourceMesh = edgeMeshes[isNext ? 0 : edgeMeshes.length - 1];
if (meshIsUsable(sourceTile, sourceMesh)) {
// Previous mesh is valid, but we don't know yet if it covers this corner.
if (u === 0.0) {
if (v === 0.0) {
// southwest
edgeVertices = isNext
? sourceMesh.northIndicesWestToEast
: sourceMesh.eastIndicesNorthToSouth;
compareU = isNext;
increasing = isNext;
} else {
// northwest
edgeVertices = isNext
? sourceMesh.eastIndicesNorthToSouth
: sourceMesh.southIndicesEastToWest;
compareU = !isNext;
increasing = false;
}
} else if (v === 0.0) {
// southeast
edgeVertices = isNext
? sourceMesh.westIndicesSouthToNorth
: sourceMesh.northIndicesWestToEast;
compareU = !isNext;
increasing = true;
} else {
// northeast
edgeVertices = isNext
? sourceMesh.southIndicesEastToWest
: sourceMesh.westIndicesSouthToNorth;
compareU = isNext;
increasing = !isNext;
}
if (edgeVertices.length > 0) {
// The vertex we want will very often be the first/last vertex so check that first.
vertexIndexIndex = isNext ? 0 : edgeVertices.length - 1;
vertexIndex = edgeVertices[vertexIndexIndex];
sourceMesh.encoding.decodeTextureCoordinates(
sourceMesh.vertices,
vertexIndex,
uvScratch
);
var targetUv = transformTextureCoordinates(
sourceTile,
terrainFillMesh.tile,
uvScratch,
uvScratch
);
if (targetUv.x === u && targetUv.y === v) {
// Vertex is good!
getVertexFromTileAtCorner(sourceMesh, vertexIndex, u, v, vertex);
return true;
}
// The last vertex is not the one we need, try binary searching for the right one.
vertexIndexIndex = binarySearch(edgeVertices, compareU ? u : v, function (
vertexIndex,
textureCoordinate
) {
sourceMesh.encoding.decodeTextureCoordinates(
sourceMesh.vertices,
vertexIndex,
uvScratch
);
var targetUv = transformTextureCoordinates(
sourceTile,
terrainFillMesh.tile,
uvScratch,
uvScratch
);
if (increasing) {
if (compareU) {
return targetUv.x - u;
}
return targetUv.y - v;
} else if (compareU) {
return u - targetUv.x;
}
return v - targetUv.y;
});
if (vertexIndexIndex < 0) {
vertexIndexIndex = ~vertexIndexIndex;
if (vertexIndexIndex > 0 && vertexIndexIndex < edgeVertices.length) {
// The corner falls between two vertices, so interpolate between them.
getInterpolatedVertexAtCorner(
ellipsoid,
sourceTile,
terrainFillMesh.tile,
sourceMesh,
edgeVertices[vertexIndexIndex - 1],
edgeVertices[vertexIndexIndex],
u,
v,
compareU,
vertex
);
return true;
}
} else {
// Found a vertex that fits in the corner exactly.
getVertexFromTileAtCorner(
sourceMesh,
edgeVertices[vertexIndexIndex],
u,
v,
vertex
);
return true;
}
}
}
return false;
}
var cornerPositionsScratch = [
new Cartesian3(),
new Cartesian3(),
new Cartesian3(),
new Cartesian3(),
];
function computeOccludeePoint(
tileProvider,
center,
rectangle,
minimumHeight,
maximumHeight,
result
) {
var ellipsoidalOccluder = tileProvider.quadtree._occluders.ellipsoid;
var ellipsoid = ellipsoidalOccluder.ellipsoid;
var cornerPositions = cornerPositionsScratch;
Cartesian3.fromRadians(
rectangle.west,
rectangle.south,
maximumHeight,
ellipsoid,
cornerPositions[0]
);
Cartesian3.fromRadians(
rectangle.east,
rectangle.south,
maximumHeight,
ellipsoid,
cornerPositions[1]
);
Cartesian3.fromRadians(
rectangle.west,
rectangle.north,
maximumHeight,
ellipsoid,
cornerPositions[2]
);
Cartesian3.fromRadians(
rectangle.east,
rectangle.north,
maximumHeight,
ellipsoid,
cornerPositions[3]
);
return ellipsoidalOccluder.computeHorizonCullingPointPossiblyUnderEllipsoid(
center,
cornerPositions,
minimumHeight,
result
);
}
export default TerrainFillMesh;
