@openglobus/og
Version:
[openglobus](https://www.openglobus.org/) is a javascript/typescript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers, and 3D objects. It uses the WebGL technology, open source, and completely fr
291 lines (290 loc) • 9.73 kB
TypeScript
import { Box } from "../bv/Box";
import { Extent } from "../Extent";
import { Entity } from "../entity/Entity";
import type { TypedArray } from "../utils/shared";
import { Handler } from "../webgl/Handler";
import type { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
import type { ITerrainWorkerData } from "../utils/TerrainWorker";
import { Layer } from "../layer/Layer";
import { LonLat } from "../LonLat";
import { Material } from "../layer/Material";
import { Node } from "../quadTree/Node";
import { Planet } from "../scene/Planet";
import { PlanetCamera } from "../camera/PlanetCamera";
import { Program } from "../webgl/Program";
import { Proj } from "../proj/Proj";
import { Sphere } from "../bv/Sphere";
import type { NumberArray6 } from "../bv/Sphere";
import { Slice } from "./Slice";
import { Vec3 } from "../math/Vec3";
import type { IPlainSegmentWorkerData } from "../utils/PlainSegmentWorker";
import { QuadTreeStrategy } from "../quadTree";
export declare function getTileCellIndex(coordinate: number, tileSize: number, worldEdge: number): number;
export declare function getTileCellExtent(x: number, y: number, z: number, worldExtent: Extent): Extent;
export declare const TILEGROUP_COMMON = 0;
export declare const TILEGROUP_NORTH = 20;
export declare const TILEGROUP_SOUTH = 300;
export declare function getTileGroupByLat(lat: number, maxLat?: number): number;
/**
* Planet segment Web Mercator tile class that stored and rendered with a quad-tree.
* @class
* @param {Node} node - Segment node.
* @param {Planet} planet - Planet scene.
* @param {number} tileZoom - Zoom index.
* @param {Extent} extent - Segment extent.
*/
declare class Segment {
_isNorth?: boolean;
isPole: boolean;
_tileGroup: number;
_projection: Proj;
elevationData: TypedArray | null;
/**
* Quad tree node of the segment.
* @type {Node}
*/
node: Node;
/**
* Planet pointer.
* @type {Planet}
*/
planet: Planet;
/**
* WebGl handler pointer.
* @type {Handler}
*/
handler: Handler;
/**
* Segment bounding sphere
* @type {Sphere}
*/
bsphere: Sphere;
_plainRadius: number;
/**
* Segment bounding box.
* @type {Box}
*/
bbox: Box;
_sw: Vec3;
_nw: Vec3;
_se: Vec3;
_ne: Vec3;
centerNormal: Vec3;
/**
* Geographical extent.
* @type {Extent}
*/
_extent: Extent;
_extentMerc: Extent;
_extentLonLat: Extent;
/**
* Vertices grid size.
* @type {number}
*/
gridSize: number;
fileGridSize: number;
/**
* Tile zoom index.
* @type {number}
*/
tileZoom: number;
/**
* Equals to pow(2, tileZoom).
* @type {number}
*/
powTileZoom: number;
/**
* Horizontal tile index.
* @type {number}
*/
tileX: number;
tileXE: number;
tileXW: number;
tileYN: number;
tileYS: number;
/**
* Vertical tile index.
* @type {number}
*/
tileY: number;
tileIndex: string;
/**
* Texture materials array.
* @type {Array.<Material>}
*
* @toso: Check it should be Map<number, Material> instead of array
*
*/
materials: Material[];
/**
* Plain segment vertices was created.
* @type {boolean}
*/
plainReady: boolean;
/**
* Segment is ready to create plain vertices.
* @type {boolean}
*/
initialized: boolean;
/**
* Normal map is already made.
* @type {boolean}
*/
normalMapReady: boolean;
/**
* Terrain is already applied flag.
* @type {boolean}
*/
terrainReady: boolean;
/**
* Terrain is loading now flag.
* @type {boolean}
*/
terrainIsLoading: boolean;
/**
* Terrain existing flag.
* @type {boolean}
*/
terrainExists: boolean;
/**
* Means that tree passage reach the segment, and the segment terrain is ready.
* @type {boolean}
*/
passReady: boolean;
plainVertices: Float64Array | null;
plainVerticesHigh: Float32Array | null;
plainVerticesLow: Float32Array | null;
plainNormals: Float32Array | null;
terrainVertices: Float64Array | null;
terrainVerticesHigh: Float32Array | null;
terrainVerticesLow: Float32Array | null;
noDataVertices: Uint8Array | null;
tempVertices: Float64Array | null;
tempVerticesHigh: Float32Array | null;
tempVerticesLow: Float32Array | null;
normalMapTexture: WebGLTextureExt | null;
normalMapTextureBias: Float32Array;
normalMapVertices: Float64Array | null;
normalMapVerticesHigh: Float32Array | null;
normalMapVerticesLow: Float32Array | null;
normalMapNormals: Float32Array | null;
vertexNormalBuffer: WebGLBufferExt | null;
vertexPositionBuffer: WebGLBufferExt | null;
vertexPositionBufferHigh: WebGLBufferExt | null;
vertexPositionBufferLow: WebGLBufferExt | null;
vertexTextureCoordBuffer: WebGLBufferExt | null;
_globalTextureCoordinates: Float32Array;
_inTheQueue: boolean;
_appliedNeighborsZoom: [number, number, number, number];
_slices: Slice[];
_indexBuffer: WebGLBufferExt | null;
readyToEngage: boolean;
plainProcessing: boolean;
normalMapTexturePtr: WebGLTextureExt | null;
_transitionOpacity: number;
_transitionTimestamp: number;
quadTreeStrategy: QuadTreeStrategy;
constructor(node: Node, quadTreeStrategy: QuadTreeStrategy, tileZoom: number, extent: Extent);
checkZoom(): boolean;
/**
* Returns entity terrain point.
* @public
* @param {Entity} entity - Entity.
* @param {Vec3} res - Point coordinates.
* @returns {Vec3} -
*/
getEntityTerrainPoint(entity: Entity, res: Vec3): number;
getInsideLonLat(obj: Entity | PlanetCamera): LonLat;
isEntityInside(entity: Entity): boolean;
/**
* Returns distance from object to terrain coordinates and terrain point that calculates out in the res parameter.
* @public
* @param {Vec3} xyz - Cartesian object position.
* @param {LonLat} insideSegmentPosition - Geodetic object position.
* @param {Vec3} [res] - Result cartesian coordinates on the terrain.
* @returns {number} -
*/
getTerrainPoint(xyz: Vec3, insideSegmentPosition: LonLat, res: Vec3): number;
/**
* Project wgs86 to segment native projection.
* @public
* @param {LonLat} lonlat - Coordinates to project.
* @returns {LonLat} -
*/
projectNative(lonlat: LonLat): LonLat;
loadTerrain(forceLoading?: boolean): void;
/**
* Terrain obtained from server.
* @param {Float32Array} elevations - Elevation data.
*/
elevationsExists(elevations: number[] | TypedArray): void;
/**
* Keep plain elevation segment for rendering
*
* 'this.tileZoom <= this.planet.terrain.maxZoom' it means, that the segment is plain
*
*/
elevationsNotExists(): void;
protected _checkEqualization(neighborSide: number, neigborNode: Node): boolean;
equalize(): void;
engage(): void;
_terrainWorkerCallback(data: ITerrainWorkerData): void;
_normalMapEdgeEqualize(side: number): void;
applyTerrain(elevations?: number[] | TypedArray | null): void;
deleteBuffers(): void;
deleteMaterials(): void;
deleteElevations(): void;
clearSegment(): void;
childrenInitialized(): boolean;
destroySegment(): void;
/**
* @todo: looks like it could be simplified in Segment contructor
*/
_setExtentLonLat(): void;
protected _createExtentNormals(): void;
createBoundsByExtent(): void;
createBoundsByParent(): void;
setBoundingSphere(x: number, y: number, z: number, v: Vec3): void;
setBoundingVolume(xmin: number, ymin: number, zmin: number, xmax: number, ymax: number, zmax: number): void;
setBoundingVolume3v(vmin: Vec3, vmax: Vec3): void;
setBoundingVolumeArr(bounds: NumberArray6): void;
createCoordsBuffers(verticesHigh: Float32Array, verticesLow: Float32Array, gridSize: number): void;
_addViewExtent(): void;
protected _assignTileIndexes(): void;
initialize(): void;
protected _assignGlobalTextureCoordinates(): void;
createPlainSegmentAsync(): void;
_plainSegmentWorkerCallback(data: IPlainSegmentWorkerData): void;
createPlainSegment(): void;
protected _projToDeg(lon: number, lat: number): LonLat;
protected _createPlainVertices(): void;
/**
* Gets specific layer material.
* @public
* @param {Layer} layer - Layer object.
* @returns {Material | undefined} - Segment material.
*/
getMaterialByLayer(layer: Layer): Material | undefined;
/**
* @param layer
* @protected
*
* @todo siplify layer._extentMerc in this.getLayerExtent(layer)
*
*/
protected _getLayerExtentOffset(layer: Layer): [number, number, number, number];
initSlice(sliceIndex: number): Slice;
screenRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean, forcedOpacity?: number): void;
increaseTransitionOpacity(): void;
fadingTransitionOpacity(): void;
colorPickingRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean): void;
depthRendering(sh: Program, layerSlice?: Layer[]): void;
protected _getIndexBuffer(): WebGLBufferExt;
layerOverlap(layer: Layer): boolean;
getDefaultTexture(): WebGLTextureExt | null;
getExtentLonLat(): Extent;
getExtentMerc(): Extent;
getExtent(): Extent;
getNeighborSide(b: Segment): 0 | 1 | 2 | 3 | -1;
}
export { Segment };