@openglobus/og 0.19.3 → 0.20.0

package/lib/@openglobus/js/math.d.ts

@@ -0,0 +1,266 @@
+import { Vec3 } from "./math/Vec3";
+/** @const */
+export declare const TWO_PI: number;
+/** @const */
+export declare const PI_TWO: number;
+export declare const X = 0;
+export declare const Y = 1;
+export declare const Z = 2;
+export declare const W = 3;
+export declare const MAX_FLOAT: number;
+/** @const */
+export declare const LOG2: number;
+/** @const */
+export declare const MAX32 = 2147483647;
+/** @const */
+export declare const MAX = 549755748352;
+/** @const */
+export declare const MIN: number;
+/** @const */
+export declare const RADIANS: number;
+/** @const */
+export declare const DEGREES: number;
+/** @const */
+export declare const DEGREES_DOUBLE: number;
+/** @const */
+export declare const RADIANS_HALF: number;
+/** @const */
+export declare const ARCSECONDS_TO_RADIANS = 0.00000484813681109536;
+/** @const */
+export declare const RADIANS_TO_HOURS = 3.819718634205488;
+/** @const */
+export declare const HOURS_TO_RADIANS = 0.26179938779914946;
+/** @const */
+export declare const HOURS_TO_DEGREES = 15;
+/** @const */
+export declare const DEGREES_TO_HOURS: number;
+/** @const */
+export declare const SQRT_HALF: number;
+export declare const EPS1 = 0.1;
+export declare const EPS2 = 0.01;
+export declare const EPS3 = 0.001;
+export declare const EPS4 = 0.0001;
+export declare const EPS5 = 0.00001;
+export declare const EPS6 = 0.000001;
+export declare const EPS7 = 1e-7;
+export declare const EPS8 = 1e-8;
+export declare const EPS9 = 1e-9;
+export declare const EPS10 = 1e-10;
+export declare const EPS11 = 1e-11;
+export declare const EPS12 = 1e-12;
+export declare const EPS13 = 1e-13;
+export declare const EPS14 = 1e-14;
+export declare const EPS15 = 1e-15;
+export declare const EPS16 = 1e-16;
+export declare const EPS17 = 1e-17;
+export declare const EPS18 = 1e-18;
+export declare const EPS19 = 1e-19;
+export declare const EPS20 = 1e-20;
+/**
+ * The log function returns the power to which the base value has to be raised to produce n.
+ * @function
+ * @param {number} n - Produce value.
+ * @param {number} base - Base value.
+ * @returns {number} -
+ * @example
+ * log(64, 2)
+ * //returns 6
+ */
+export declare function log(n: number, base: number): number;
+/**
+ * Clamp the number.
+ * @function
+ * @param {number} number - Input number.
+ * @param {number} min - Minimal edge.
+ * @param {number} max - Maximal edge.
+ * @returns {number} -
+ * @example
+ * clamp(12, 1, 5)
+ * //returns 5
+ */
+export declare function clamp(number: number, min: number, max: number): number;
+/**
+ * Converts degrees value to radians.
+ * @function
+ * @param {number} degrees - Degree value.
+ * @returns {number} -
+ */
+export declare function DEG2RAD(degrees: number): number;
+/**
+ * Converts radians value to degrees.
+ * @function
+ * @param {number} angle - Degree value.
+ * @returns {number} -
+ */
+export declare function RAD2DEG(angle: number): number;
+/**
+ * Check the number is a power of two.
+ * @function
+ * @param {number} x - Input value.
+ * @returns {boolean} -
+ */
+export declare function isPowerOfTwo(x: number): boolean;
+/**
+ * Returns next value that is power of two.
+ * @function
+ * @param {number} x - Input value.
+ * @param {number} [maxValue=4096] - Maximal value.
+ * @returns {number} -
+ */
+export declare function nextHighestPowerOfTwo(x: number, maxValue?: number): number;
+/**
+ * Returns random integer number within the bounds.
+ * @function
+ * @param {number} min - Minimal bound.
+ * @param {number} max - Maximal bound.
+ * @returns {number} -
+ */
+export declare function randomi(min?: number, max?: number): number;
+/**
+ * Returns random number within the bounds.
+ * @function
+ * @param {number} [min=0] - Minimal bound.
+ * @param {number} [max=1] - Maximal bound.
+ * @returns {number} -
+ */
+export declare function random(min?: number, max?: number): number;
+/**
+ * Converts degrees value to decimal.
+ * @function
+ * @param {number} d - Degrees.
+ * @param {number} m - Minutes.
+ * @param {number} s - Seconds.
+ * @param {boolean} [p] - Positive flag. False - default.
+ * @returns {number} -
+ **/
+export declare function degToDec(d: number, m: number, s: number, p: number): number;
+/**
+ * The modulo operation that also works for negative dividends.
+ * @function
+ * @param {number} m - The dividend.
+ * @param {number} n - The divisor.
+ * @returns {number} The remainder.
+ */
+export declare function mod(m: number, n: number): number;
+/**
+ * Returns an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
+ * @function
+ * @param {number} a - Angle in radians
+ * @returns {number} -
+ */
+export declare function zeroTwoPI(a: number): number;
+/**
+ * Returns 0.0 if x is smaller than edge and otherwise 1.0.
+ * @function
+ * @param {number} edge -
+ * @param {number} x - Value to edge.
+ * @returns {number} -
+ */
+export declare function step(edge: number, x: number): number;
+/**
+ * The frac function returns the fractional part of x, i.e. x minus floor(x).
+ * @function
+ * @param {number} x - Input value.
+ * @returns {number} -
+ */
+export declare function frac(x: number): number;
+/**
+ * Returns Math.log(x) / Math.log(2)
+ * @function
+ * @param {number} x - Input value.
+ * @returns {number} -
+ */
+export declare function log2(x: number): number;
+/**
+ * Returns two power of n.
+ * @function
+ * @param {number} n - Power value.
+ * @returns {number} -
+ */
+export declare function exp2(n: number): number;
+/**
+ * Returns two power of integer n.
+ * @function
+ * @param {number} n - Integer power value.
+ * @returns {number} -
+ */
+export declare function pow2i(n: number): number;
+/**
+ * Returns a slice of linear interpolation t * (h1 - h0)
+ * @param {number} t - A value that linearly interpolates between the h0 parameter and the h1 parameter.
+ * @param {number} h1 - End value.
+ * @param {number} h0 - Start value.
+ * @returns {number} -
+ */
+export declare function slice(t: number, h1: number, h0: number): number;
+/**
+ * Performs a linear interpolation.
+ * @function
+ * @param {number} t - A value that linearly interpolates between the h0 parameter and the h1 parameter.
+ * @param {number} h1 - End value.
+ * @param {number} h0 - Start value.
+ * @returns {number} -
+ */
+export declare function lerp(t: number, h1: number, h0: number): number;
+export declare function cube(f: number): number;
+export declare function square(f: number): number;
+export declare function bezier1v(t: number, p0: number, p1: number, p2: number, p3: number): number;
+/**
+ * Performs a 3D bezier interpolation.
+ * @function
+ * @param {number} t - Interpolation value.
+ * @param {Vec3} p0 - First control point.
+ * @param {Vec3} p1 - Second control point.
+ * @param {Vec3} p2 - Third control point.
+ * @param {Vec3} p3 - Fourth control point.
+ * @returns {Vec3} -
+ */
+export declare function bezier3v(t: number, p0: Vec3, p1: Vec3, p2: Vec3, p3: Vec3): Vec3;
+/**
+ * Clamp angle value within 360.
+ * @function
+ * @param {number} x - Input angle.
+ * @returns {number} -
+ */
+export declare function rev(x: number): number;
+/**
+ * Clamp longitude within: -180 to +180 degrees.
+ * @function
+ * @param {number} lon - Longitude.
+ * @returns {number} -
+ */
+export declare function norm_lon(lon: number): number;
+/**
+ * Returns an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
+ * @function
+ * @param {number} a - Angle in radians.
+ * @returns {number} -
+ */
+export declare function negativePItoPI(a: number): number;
+/**
+ * Solve using iteration method and a fixed number of steps.
+ * @function
+ * @param {Function} f - Equation. Used in Euler's equation(see og.orbit) solving.
+ * @param {number} x0 - First approximation.
+ * @param {number} maxIter - Maximum iterations.
+ * @returns {number} -
+ */
+export declare function solve_iteration_fixed(f: (x: number) => number, x0: number, maxIter: number): number;
+/**
+ * Solve using iteration; terminate when error is below err or the maximum
+ * number of iterations is reached. Used in Euler's equation(see og.orbit) solving.
+ * @function
+ * @param {(x: number) => number} f - Equation.
+ * @param {number} x0 - First approximation.
+ * @param {number} err - Maximal accepted error value.
+ * @param {number} maxIter - Maximum iterations.
+ * @returns {number} -
+ */
+export declare function solve_iteration(f: (x: number) => number, x0: number, err: number, maxIter?: number): number;
+/**
+ * Returns angle between two azimuths
+ * @param {number} a - First azimuth angle
+ * @param {number} b - Second azimuth angle
+ * @returns {number}
+ */
+export declare function getAngleBetweenAzimuths(a: number, b: number): number;

package/lib/@openglobus/js/mercator.d.ts

@@ -0,0 +1,92 @@
+import { Extent } from "./Extent";
+import { LonLat } from './LonLat';
+/**
+ * Mercator size.
+ * @const
+ * @type {number}
+ */
+export declare const POLE = 20037508.34;
+export declare const POLE2: number;
+export declare const PI_BY_POLE: number;
+export declare const POLE_BY_PI: number;
+export declare const POLE_BY_180: number;
+export declare const INV_POLE_BY_180: number;
+/**
+ * Double mercator size.
+ * @const
+ * @type {number}
+ */
+export declare const POLE_DOUBLE: number;
+/**
+ * One by mercator double size.
+ * @const
+ * @type {number}
+ */
+export declare const ONE_BY_POLE_DOUBLE: number;
+export declare function forward(lonLat: LonLat): LonLat;
+/**
+ * Converts degrees longitude to mercator coordinate.
+ * @function
+ * @param {number} lon - Degrees geodetic longitude.
+ * @returns {number} -
+ */
+export declare function forward_lon(lon: number): number;
+/**
+ * Converts degrees latitude to mercator coordinate.
+ * @function
+ * @param {number} lat - Degrees geodetic latitude.
+ * @returns {number} -
+ */
+export declare function forward_lat(lat: number): number;
+/**
+ * Converts mercator longitude to degrees coordinate.
+ * @function
+ * @param {number} lon - Mercator longitude.
+ * @returns {number} -
+ */
+export declare function inverse_lon(lon: number): number;
+/**
+ * Converts mercator latitude to degrees coordinate.
+ * @function
+ * @param {number} lon - Mercator latitude.
+ * @returns {number} -
+ */
+export declare function inverse_lat(lat: number): number;
+/**
+ * Returns mercator map tile grid horizontal coordinate index by geodetic
+ * longitude and zoom level. Where top left corner of the grid is 0 coordinate index.
+ * @function
+ * @param {number} lon - Geodetic degrees longitude.
+ * @param {number} zoom - Zoom level.
+ * @returns {number}
+ */
+export declare function getTileX(lon: number, zoom: number): number;
+/**
+ * Returns mercator map tile grid vertical coordinate index by geodetic
+ * latitude and zoom level. Where top left corner of the grid is 0 coordinate index.
+ * @function
+ * @param {number} lat - Geodetic degrees latitude.
+ * @param {number} zoom - Zoom level.
+ * @returns {number}
+ */
+export declare function getTileY(lat: number, zoom: number): number;
+/**
+ * Converts geodetic coordinate array to mercator coordinate array.
+ * @function
+ * @param {Array.<LonLat>} lonLatArr - LonLat array to convert.
+ * @returns {Array.<LonLat>}
+ */
+export declare function forwardArray(lonlatArr: LonLat[]): LonLat[];
+export declare function getTileExtent(x: number, y: number, z: number): Extent;
+/**
+ * Max mercator latitude.
+ * @const
+ * @type {number}
+ */
+export declare const MAX_LAT: number;
+/**
+ * Min mercator latitude.
+ * @const
+ * @type {number}
+ */
+export declare const MIN_LAT: number;

package/lib/@openglobus/js/proj/EPSG3857.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module og/proj/EPSG3857
+ */
+import { Proj } from "./Proj";
+/**
+ * EPSG:3857 projection object.
+ * @type {Proj}
+ */
+export declare const EPSG3857: Proj;

package/lib/@openglobus/js/proj/EPSG4326.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module og/proj/EPSG4326
+ */
+import { Proj } from "./Proj";
+/**
+ * EPSG:4326 projection object.
+ * @type {Proj}
+ */
+export declare const EPSG4326: Proj;

package/lib/@openglobus/js/proj/Proj.d.ts

@@ -0,0 +1,43 @@
+interface IProjParams {
+    units: string;
+    code: string;
+}
+/**
+ * Projection units: 'degrees', 'ft', 'm' or 'km'.
+ * @enum {string}
+ * @api
+ */
+export declare const Units: {
+    DEGREES: string;
+    FEET: string;
+    METERS: string;
+    KILOMETERS: string;
+};
+/**
+ * Meters per unit lookup table.
+ * @const
+ * @type {Record<string, number>}
+ */
+export declare const METERS_PER_UNIT: Record<string, number>;
+declare class Proj {
+    id: number;
+    /**
+     * @public
+     * @type {string}
+     */
+    code: string;
+    /**
+     * @public
+     * @type {Units}
+     */
+    units: string;
+    constructor(options: IProjParams);
+    /**
+     * Compare projections.
+     * @public
+     * @param {Proj} proj - Projection object.
+     * @returns {boolean}
+     */
+    equal(proj: Proj): boolean;
+}
+export { Proj };

package/lib/@openglobus/js/quadTree/EPSG4326QuadTreeStrategy.d.ts

@@ -0,0 +1,6 @@
+import { Planet } from "../scene/Planet";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+export declare class EPSG4326QuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet: Planet);
+    init(): void;
+}

package/lib/@openglobus/js/quadTree/EarthQuadTreeStrategy.d.ts

@@ -0,0 +1,9 @@
+import { Planet } from "../scene/Planet";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+import { LonLat } from "../LonLat";
+export declare class EarthQuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet: Planet);
+    init(): void;
+    getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];
+    getLonLatTileOffset(lonLat: LonLat, x: number, y: number, z: number, gridSize: number): [number, number];
+}

package/lib/@openglobus/js/quadTree/EntityCollectionNode.d.ts

@@ -0,0 +1,54 @@
+import { EntityCollection } from '../entity/EntityCollection';
+import { Extent } from '../Extent';
+import { LonLat } from '../LonLat';
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { Sphere } from '../bv/Sphere';
+import { Segment } from "../segment/Segment";
+import { Vector } from "../layer/Vector";
+import { Entity } from "../entity/Entity";
+type NodesDict = Record<number, Node>;
+/**
+ * @todo: remove planet parameter. It's already available in the layer.
+ */
+declare class EntityCollectionNode {
+    layer: Vector;
+    parentNode: EntityCollectionNode | null;
+    childrenNodes: EntityCollectionNode[];
+    partId: number;
+    nodeId: number;
+    state: number | null;
+    extent: Extent;
+    count: number;
+    deferredEntities: Entity[];
+    entityCollection: EntityCollection | null;
+    zoom: number;
+    bsphere: Sphere;
+    _inTheQueue: boolean;
+    constructor(layer: Vector, partId: number, parent: EntityCollectionNode | null, extent: Extent, planet: Planet, zoom: number);
+    insertEntity(entity: Entity, rightNow?: boolean): void;
+    protected _addEntitiesToCollection(entities: Entity[], rightNow?: boolean): void;
+    protected _setExtentBounds(): void;
+    __setLonLat__(entity: Entity): LonLat;
+    buildTree(entities: Entity[], rightNow?: boolean): void;
+    isInside(entity: Entity): boolean;
+    createChildrenNodes(): void;
+    collectRenderCollectionsPASS1(visibleNodes: NodesDict, outArr: EntityCollection[]): void;
+    collectRenderCollectionsPASS2(visibleNodes: NodesDict, outArr: EntityCollection[], renderingNodeId: number): void;
+    applyCollection(): void;
+    traverseTree(callback: Function): void;
+    renderCollection(outArr: EntityCollection[], visibleNodes: NodesDict, renderingNodeId?: number): void;
+    alignEntityToTheGround(entity: Entity, segment: Segment): void;
+    isVisible(): boolean;
+}
+declare class EntityCollectionNodeWGS84 extends EntityCollectionNode {
+    isNorth: boolean;
+    constructor(layer: Vector, partId: number, parent: EntityCollectionNodeWGS84 | null, extent: Extent, planet: Planet, zoom: number);
+    createChildrenNodes(): void;
+    protected _setExtentBounds(): void;
+    __setLonLat__(entity: Entity): LonLat;
+    isVisible(): boolean;
+    isInside(entity: Entity): boolean;
+    renderCollection(outArr: EntityCollection[], visibleNodes: NodesDict, renderingNode: number): void;
+}
+export { EntityCollectionNode, EntityCollectionNodeWGS84 };

package/lib/@openglobus/js/quadTree/MarsQuadTreeStrategy.d.ts

@@ -0,0 +1,11 @@
+import { Planet } from "../scene/Planet";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+import { LonLat } from "../LonLat";
+export declare class MarsQuadTreeStrategy extends QuadTreeStrategy {
+    private _westExtent;
+    private _eastExtent;
+    constructor(planet: Planet);
+    init(): void;
+    getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];
+    getLonLatTileOffset(lonLat: LonLat, x: number, y: number, z: number, gridSize: number): [number, number];
+}

package/lib/@openglobus/js/quadTree/Node.d.ts

@@ -0,0 +1,80 @@
+import { Extent } from "../Extent";
+import { Planet } from "../scene/Planet";
+import { Segment } from "../segment/Segment";
+import { PlanetCamera } from "../camera/PlanetCamera";
+/**
+ * Quad tree planet segment node.
+ * @constructor
+ * @param {Segment} segmentPrototype - Planet segment node constructor.
+ * @param {Planet} planet - Planet scene instance.
+ * @param {number} partId - NorthEast, SouthWest etc.
+ * @param {Node} parent - Parent of this node.
+ * @param {number} id - Tree node identifier (id * 4 + 1);
+ * @param {number} tileZoom - Deep index of the quad tree.
+ * @param {Extent} extent - Planet segment extent.
+ */
+declare class Node {
+    __id: number;
+    SegmentPrototype: typeof Segment;
+    planet: Planet;
+    parentNode: Node | null;
+    partId: number;
+    nodeId: number;
+    state: number | null;
+    prevState: number | null;
+    appliedTerrainNodeId: number;
+    sideSizeLog2: [number, number, number, number];
+    ready: boolean;
+    neighbors: [Node[], Node[], Node[], Node[]];
+    equalizedSideWithNodeId: number[];
+    nodes: [Node, Node, Node, Node] | [];
+    segment: Segment;
+    _cameraInside: boolean;
+    inFrustum: number;
+    _fadingNodes: Node[];
+    constructor(SegmentPrototype: typeof Segment, planet: Planet, partId: number, parent: Node | null, tileZoom: number, extent: Extent);
+    createChildrenNodes(): void;
+    createBounds(): void;
+    getState(): number | null;
+    /**
+     * Returns the same deep existent neighbour node.
+     * @public
+     * @param {number} side - Neighbour side index e.g. og.quadTree.N, og.quadTree.W etc.
+     * @returns {Node} -
+     */
+    getEqualNeighbor(side: number): Node | undefined;
+    traverseNodes(cam: PlanetCamera, maxZoom?: number | null, terrainReadySegment?: Segment | null, stopLoading?: boolean, zoomPassNode?: Node): void;
+    renderTree(cam: PlanetCamera, maxZoom?: number | null, terrainReadySegment?: Segment | null, stopLoading?: boolean, zoomPassNode?: Node): void;
+    renderNode(inFrustum: number, onlyTerrain?: boolean, terrainReadySegment?: Segment | null, stopLoading?: boolean): void;
+    childrenPrevStateEquals(state: number): boolean;
+    isFading(): boolean;
+    _collectFadingNodes(): void;
+    clearNeighbors(): void;
+    _refreshTransitionOpacity(): void;
+    /**
+     * Picking up current node to render processing.
+     * @public
+     */
+    addToRender(inFrustum: number): void;
+    applyNeighbor(node: Node, side: number): void;
+    /**
+     * Searching current node for its neighbours.
+     * @public
+     */
+    getRenderedNodesNeighbors(nodes: Node[]): void;
+    /**
+     * Checking if current node has a common side with input node and return side index N, E, S or W. Otherwise returns -1.
+     * @param {Node} node - Input node
+     * @returns {number} - Node side index
+     */
+    getCommonSide(node: Node): number;
+    whileNormalMapCreating(): void;
+    whileTerrainLoading(terrainReadySegment?: Segment | null): void;
+    destroy(): void;
+    clearTree(): void;
+    clearBranches(): void;
+    destroyBranches(): void;
+    traverseTree(callback: Function): void;
+    getOffsetOppositeNeighbourSide(neighbourNode: Node, side: number): number;
+}
+export { Node };

package/lib/@openglobus/js/quadTree/QuadTreeStrategy.d.ts

@@ -0,0 +1,28 @@
+import { Layer } from "../layer/Layer";
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { Proj } from "../proj/Proj";
+import { LonLat } from "../LonLat";
+export declare class QuadTreeStrategy {
+    name: string;
+    projection: Proj;
+    protected _planet: Planet;
+    /**
+     * grid tree list.
+     * @protected
+     * @type {Node[]}
+     */
+    protected _quadTreeList: Node[];
+    constructor(planet: Planet, name?: string, proj?: Proj);
+    destroyBranches(): void;
+    clearLayerMaterial(layer: Layer): void;
+    get planet(): Planet;
+    init(): void;
+    preRender(): void;
+    preLoad(): void;
+    collectRenderNodes(): void;
+    clear(): void;
+    get quadTreeList(): Node[];
+    getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];
+    getLonLatTileOffset(lonLat: LonLat, x: number, y: number, z: number, gridSize: number): [number, number];
+}

package/lib/@openglobus/js/quadTree/Wgs84QuadTreeStrategy.d.ts

@@ -0,0 +1,6 @@
+import { Planet } from "../scene/Planet";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+export declare class Wgs84QuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet: Planet);
+    init(): void;
+}

package/lib/@openglobus/js/quadTree/index.d.ts

@@ -0,0 +1,12 @@
+import { EarthQuadTreeStrategy } from "./EarthQuadTreeStrategy";
+import { MarsQuadTreeStrategy } from "./MarsQuadTreeStrategy";
+import { EPSG4326QuadTreeStrategy } from "./EPSG4326QuadTreeStrategy";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+import { Wgs84QuadTreeStrategy } from "./Wgs84QuadTreeStrategy";
+declare const quadTreeStrategyType: {
+    epsg4326: typeof EPSG4326QuadTreeStrategy;
+    earth: typeof EarthQuadTreeStrategy;
+    mars: typeof MarsQuadTreeStrategy;
+    wgs84: typeof Wgs84QuadTreeStrategy;
+};
+export { quadTreeStrategyType, QuadTreeStrategy, Wgs84QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy };

package/lib/@openglobus/js/quadTree/quadTree.d.ts

@@ -0,0 +1,40 @@
+export declare const VISIBLE_DISTANCE = 3570;
+export declare const MAX_RENDERED_NODES = 1000;
+export declare const NW = 0;
+export declare const NE = 1;
+export declare const SW = 2;
+export declare const SE = 3;
+export declare const N = 0;
+export declare const E = 1;
+export declare const S = 2;
+export declare const W = 3;
+export declare const NOTRENDERING = 0;
+export declare const RENDERING = 1;
+export declare const WALKTHROUGH = 2;
+/**
+ * World opposite side table.
+ */
+export declare const OPSIDE: number[];
+/**
+ * First index is {N,E,S,W} and second is {NW,NE,SW,SE}
+ */
+export declare const NEIGHBOUR: number[][];
+/**
+ * Neighbor's oposite part. For example oposite side
+ * on the east neighbor side is: [S][SE] = NE
+ */
+export declare const OPPART: number[][];
+/**
+ * Neighbos's opside array order. For example NW node
+ * by E side array index is 0, SE node by S side is 1.
+ */
+export declare const NOPSORD: number[][];
+/**
+ * First index is {NW,NE,SW,SE}, another one is {N,E,S,W}
+ */
+export declare const COMSIDE: boolean[][];
+/**
+ * Gets segment part left to right or up to downo ffset against neighbour side.
+ * Where 0 - no offset 1 - half segment size offset.
+ */
+export declare const PARTOFFSET: number[][];