@openglobus/og 0.24.2 → 0.25.0

package/lib/js/segment/SegmentLonLat.d.ts

@@ -1,40 +0,0 @@
-import { Extent } from "../Extent";
-import { Layer } from "../layer/Layer";
-import { Node } from "../quadTree/Node";
-import { Planet } from "../scene/Planet";
-import { Segment } from "./Segment";
-import { LonLat } from "../LonLat";
-import { Entity } from "../entity/Entity";
-import { PlanetCamera } from "../camera/PlanetCamera";
-import type { WebGLTextureExt } from "../webgl/Handler";
-export declare const POLE_PIECE_SIZE: number;
-/**
- * Planet segment Web Mercator tile class that stored and rendered with quad tree.
- * @class
- * @extends {Segment}
- */
-declare class SegmentLonLat extends Segment {
-    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
-    _setExtentLonLat(): void;
-    projectNative(coords: LonLat): LonLat;
-    getInsideLonLat(obj: Entity | PlanetCamera): LonLat;
-    protected _getMaxZoom(): number;
-    checkZoom(): boolean;
-    protected _assignTileIndexes(): void;
-    protected _assignTileXIndexes(extent: Extent): void;
-    protected _assignTileYIndexes(extent: Extent): void;
-    protected _projToDeg(lon: number, lat: number): LonLat;
-    protected _assignGlobalTextureCoordinates(): void;
-    /**
-     * @param layer
-     * @protected
-     *
-     * @todo simplify layer._extentMerc in layer.getNativeExtent(this)
-     *
-     */
-    protected _getLayerExtentOffset(layer: Layer): [number, number, number, number];
-    layerOverlap(layer: Layer): boolean;
-    getDefaultTexture(): WebGLTextureExt | null;
-    getExtentLonLat(): Extent;
-}
-export { SegmentLonLat };

package/lib/js/segment/SegmentLonLat.js

@@ -1,111 +0,0 @@
-import * as mercator from "../mercator";
-import { EPSG4326 } from "../proj/EPSG4326";
-import { Extent } from "../Extent";
-import { Layer } from "../layer/Layer";
-import { getTileCellIndex, Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "./Segment";
-import { LonLat } from "../LonLat";
-const MAX_POLE_ZOOM = 7;
-export const POLE_PIECE_SIZE = (90.0 - mercator.MAX_LAT) / Math.pow(2, MAX_POLE_ZOOM);
-/**
- * Planet segment Web Mercator tile class that stored and rendered with quad tree.
- * @class
- * @extends {Segment}
- */
-class SegmentLonLat extends Segment {
-    constructor(node, planet, tileZoom, extent) {
-        super(node, planet, tileZoom, extent);
-        this._projection = EPSG4326;
-        this._extentLonLat = this._extent;
-        this._extentMerc = new Extent(extent.southWest.forwardMercatorEPS01(), extent.northEast.forwardMercatorEPS01());
-        this._isNorth = this._extent.northEast.lat > 0;
-        this.isPole = true;
-    }
-    _setExtentLonLat() {
-        this._extentLonLat = this._extent;
-    }
-    projectNative(coords) {
-        return coords;
-    }
-    getInsideLonLat(obj) {
-        return obj._lonLat;
-    }
-    _getMaxZoom() {
-        let maxPoleZoom = 0;
-        if (this._isNorth) {
-            //north pole limits
-            let Yz = Math.floor((90.0 - this._extent.northEast.lat) / POLE_PIECE_SIZE);
-            maxPoleZoom = Math.floor(Yz / 16) + 7;
-        }
-        else {
-            //south pole limits
-            let Yz = Math.floor((mercator.MIN_LAT - this._extent.northEast.lat) / POLE_PIECE_SIZE);
-            maxPoleZoom = 12 - Math.floor(Yz / 16);
-        }
-        return maxPoleZoom;
-    }
-    checkZoom() {
-        return super.checkZoom() && this.tileZoom <= this._getMaxZoom();
-    }
-    _assignTileIndexes() {
-        this._assignTileXIndexes(this._extent);
-        this._assignTileYIndexes(this._extent);
-        this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, this.tileZoom, this._tileGroup);
-    }
-    _assignTileXIndexes(extent) {
-        this.tileX = getTileCellIndex(extent.getCenter().lon, extent.getWidth(), -180);
-        let p2 = 1 << this.tileZoom;
-        this.tileXE = (this.tileX + 1) % p2;
-        this.tileXW = (p2 + this.tileX - 1) % p2;
-    }
-    _assignTileYIndexes(extent) {
-        const lat = extent.getCenter().lat; //extent.northEast.lat;
-        if (lat > 0) {
-            this._tileGroup = TILEGROUP_NORTH;
-            this.tileY = getTileCellIndex(lat, extent.getHeight(), 90.0);
-        }
-        else {
-            this._tileGroup = TILEGROUP_SOUTH;
-            this.tileY = getTileCellIndex(lat, extent.getHeight(), mercator.MIN_LAT);
-        }
-        this.tileYN = this.tileY - 1;
-        this.tileYS = this.tileY + 1;
-    }
-    _projToDeg(lon, lat) {
-        return new LonLat(lon, lat);
-    }
-    _assignGlobalTextureCoordinates() {
-        const e = this._extent;
-        this._globalTextureCoordinates[0] = (e.southWest.lon + 180.0) / 360.0;
-        this._globalTextureCoordinates[1] = (90 - e.northEast.lat) / 180.0;
-        this._globalTextureCoordinates[2] = (e.northEast.lon + 180.0) / 360.0;
-        this._globalTextureCoordinates[3] = (90 - e.southWest.lat) / 180.0;
-    }
-    /**
-     * @param layer
-     * @protected
-     *
-     * @todo simplify layer._extentMerc in layer.getNativeExtent(this)
-     *
-     */
-    _getLayerExtentOffset(layer) {
-        const v0s = layer._extent;
-        const v0t = this._extent;
-        const sSize_x = v0s.northEast.lon - v0s.southWest.lon;
-        const sSize_y = v0s.northEast.lat - v0s.southWest.lat;
-        const dV0s_x = (v0t.southWest.lon - v0s.southWest.lon) / sSize_x;
-        const dV0s_y = (v0s.northEast.lat - v0t.northEast.lat) / sSize_y;
-        const dSize_x = (v0t.northEast.lon - v0t.southWest.lon) / sSize_x;
-        const dSize_y = (v0t.northEast.lat - v0t.southWest.lat) / sSize_y;
-        return [dV0s_x, dV0s_y, dSize_x, dSize_y];
-    }
-    layerOverlap(layer) {
-        return this._extent.overlaps(layer._extent);
-    }
-    getDefaultTexture() {
-        return this._isNorth ? this.planet.solidTextureOne : this.planet.solidTextureTwo;
-    }
-    getExtentLonLat() {
-        return this._extent;
-    }
-}
-export { SegmentLonLat };

package/lib/js/segment/SegmentLonLatEqui.d.ts

@@ -1,13 +0,0 @@
-import { Extent } from "../Extent";
-import { Node } from "../quadTree/Node";
-import { Planet } from "../scene/Planet";
-import { SegmentLonLat } from "./SegmentLonLat";
-import type { WebGLTextureExt } from "../webgl/Handler";
-export declare const POLE_PIECE_SIZE: number;
-export declare class SegmentLonLatEqui extends SegmentLonLat {
-    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
-    protected _getMaxZoom(): number;
-    protected _assignTileYIndexes(extent: Extent): void;
-    protected _assignTileXIndexes(extent: Extent): void;
-    getDefaultTexture(): WebGLTextureExt | null;
-}

package/lib/js/segment/SegmentLonLatEqui.js

@@ -1,46 +0,0 @@
-import { SegmentLonLat } from "./SegmentLonLat";
-import { getTileCellIndex, TILEGROUP_COMMON } from "./Segment";
-import { equi } from "../proj/equi";
-const MAX_POLE_ZOOM = 5;
-export const POLE_PIECE_SIZE = 5 / Math.pow(2, MAX_POLE_ZOOM);
-export class SegmentLonLatEqui extends SegmentLonLat {
-    constructor(node, planet, tileZoom, extent) {
-        super(node, planet, tileZoom, extent);
-        this._projection = equi;
-        this.isPole = false;
-        this._tileGroup = TILEGROUP_COMMON;
-    }
-    _getMaxZoom() {
-        let maxPoleZoom = 0;
-        if (this._extent.northEast.lat > 85) {
-            //north pole limits
-            let Yz = Math.floor((90.0 - this._extent.northEast.lat) / POLE_PIECE_SIZE);
-            maxPoleZoom = Math.floor(Yz / 16) + MAX_POLE_ZOOM;
-        }
-        else if (this._extent.southWest.lat < -85) {
-            //south pole limits
-            let Yz = Math.floor((90 + this._extent.southWest.lat) / POLE_PIECE_SIZE);
-            maxPoleZoom = Math.floor(Yz / 16) + MAX_POLE_ZOOM;
-        }
-        else {
-            maxPoleZoom = 50;
-        }
-        return maxPoleZoom;
-    }
-    _assignTileYIndexes(extent) {
-        const lat = extent.getCenter().lat;
-        this.tileY = getTileCellIndex(lat, extent.getHeight(), 90.0);
-        this.tileYN = this.tileY - 1;
-        this.tileYS = this.tileY + 1;
-    }
-    _assignTileXIndexes(extent) {
-        let lon = extent.getCenter().lon;
-        this.tileX = getTileCellIndex(lon, extent.getWidth(), -180);
-        let p2 = (1 << this.tileZoom) * 2;
-        this.tileXE = (this.tileX + 1) % p2;
-        this.tileXW = (p2 + this.tileX - 1) % p2;
-    }
-    getDefaultTexture() {
-        return this.planet.solidTextureOne;
-    }
-}

package/lib/js/segment/Slice.d.ts

@@ -1,13 +0,0 @@
-import { Layer } from "../layer/Layer";
-import { Segment } from "./Segment";
-import { Material } from "../layer/Material";
-declare class Slice {
-    segment: Segment;
-    layers: Layer[];
-    tileOffsetArr: Float32Array;
-    layerOpacityArr: Float32Array;
-    constructor(segment: Segment);
-    clear(): void;
-    append(layer: Layer, material: Material): void;
-}
-export { Slice };

package/lib/js/segment/Slice.js

@@ -1,33 +0,0 @@
-class Slice {
-    constructor(segment) {
-        this.segment = segment;
-        this.layers = [];
-        this.tileOffsetArr = new Float32Array(segment.planet.SLICE_SIZE_4);
-        this.layerOpacityArr = new Float32Array(segment.planet.SLICE_SIZE);
-    }
-    clear() {
-        // @ts-ignore
-        this.layers = null;
-        // @ts-ignore
-        this.tileOffsetArr = null;
-        // @ts-ignore
-        this.layerOpacityArr = null;
-    }
-    append(layer, material) {
-        let n = this.layers.length;
-        this.layers.push(layer);
-        this.layerOpacityArr[n] = layer.screenOpacity;
-        let n4 = n * 4;
-        let arr = layer.applyMaterial(material);
-        this.tileOffsetArr[n4] = arr[0];
-        this.tileOffsetArr[n4 + 1] = arr[1];
-        this.tileOffsetArr[n4 + 2] = arr[2];
-        this.tileOffsetArr[n4 + 3] = arr[3];
-        //arr = this.segment._getLayerExtentOffset(layer);
-        //slice.visibleExtentOffsetArr[n4] = arr[0];
-        //slice.visibleExtentOffsetArr[n4 + 1] = arr[1];
-        //slice.visibleExtentOffsetArr[n4 + 2] = arr[2];
-        //slice.visibleExtentOffsetArr[n4 + 3] = arr[3];
-    }
-}
-export { Slice };

package/lib/js/segment/segmentHelper.js

@@ -1,180 +0,0 @@
-/**
- * @module og/segment/SegmentHelper
- */
-import { N, W, S, E } from '../quadTree/quadTree';
-function NewIndexesTypedArray(arr) {
-    return new Uint32Array(arr);
-}
-function NewIndexesTypedArrayEmpty(size) {
-    return new Uint32Array(size);
-}
-function createCenterBodyIndexes(size) {
-    let indexes = [];
-    let i0 = 1, j0 = 1;
-    let i1 = 1, j1 = 1;
-    let ind1 = 0, ind2 = 0, nr = 0;
-    for (let i = i0; i < size - 1 - i1; i++) {
-        for (let j = j0; j < size - j1; j++) {
-            ind1 = i * size + j;
-            nr = (i + 1) * size;
-            ind2 = nr + j;
-            indexes.push(ind1, ind2);
-        }
-        indexes.push(ind2, nr + j0);
-    }
-    indexes.push(indexes[indexes.length - 1], size * size - size);
-    return NewIndexesTypedArray(indexes);
-}
-function createWestNeighborSkirt(size, deltaGr) {
-    let indexes = [];
-    const grCount = (size - 1) / deltaGr;
-    const b = size * size - size;
-    let k = 0;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        let rind = b - size * i - size + 1, lind = b - size * k;
-        indexes.push(lind, rind);
-    }
-    if (deltaGr === (size - 1)) {
-        indexes.push(size);
-        indexes.push(0);
-    }
-    return NewIndexesTypedArray(indexes);
-}
-function createNorthNeighborSkirt(size, deltaGr) {
-    let indexes = [];
-    const grCount = (size - 1) / deltaGr;
-    let k = 0;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        let rind = size + i + 1, lind = k;
-        indexes.push(lind, rind);
-    }
-    if (deltaGr === (size - 1)) {
-        indexes.push(size - 2);
-        indexes.push(size - 1);
-    }
-    return NewIndexesTypedArray(indexes);
-}
-function createEastNeighborSkirt(size, deltaGr) {
-    let indexes = [];
-    const grCount = (size - 1) / deltaGr;
-    let k = 0;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        let rind = size * (i + 1) + size - 2, lind = size + size * k - 1;
-        indexes.push(lind, rind);
-    }
-    if (deltaGr === (size - 1)) {
-        indexes.push(size * (size - 1) - 1);
-        indexes.push(size * size - 1);
-    }
-    return NewIndexesTypedArray(indexes);
-}
-function createSouthNeighborSkirt(size, deltaGr) {
-    let indexes = [];
-    const grCount = (size - 1) / deltaGr;
-    let k = 0;
-    const rb = size * (size - 1) - 2;
-    const lb = size * size - 1;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        let rind = rb - i, lind = lb - k;
-        indexes.push(lind, rind);
-    }
-    if (deltaGr === (size - 1)) {
-        indexes.push(size * size - size + 1);
-    }
-    indexes.push(size * size - size);
-    return NewIndexesTypedArray(indexes);
-}
-function initIndexesBodySkirts(pow) {
-    let table = [[], [], [], []];
-    for (let i = 0; i <= pow; i++) {
-        let d = Math.pow(2, i), d1 = d + 1;
-        table[N][i] = [];
-        table[W][i] = [];
-        table[S][i] = [];
-        table[E][i] = [];
-        for (let j = 0; j <= pow; j++) {
-            let dd = Math.pow(2, j);
-            table[W][i][j] = createWestNeighborSkirt(d1, dd);
-            table[N][i][j] = createNorthNeighborSkirt(d1, dd);
-            table[E][i][j] = createEastNeighborSkirt(d1, dd);
-            table[S][i][j] = createSouthNeighborSkirt(d1, dd);
-        }
-    }
-    return table;
-}
-function initIndexBodiesTable(pow) {
-    let table = [];
-    for (let i = 0; i <= pow; i++) {
-        const d = Math.pow(2, i);
-        table[i] = createCenterBodyIndexes(d + 1);
-    }
-    return table;
-}
-function createTextureCoords(size) {
-    let texCoords = new Uint16Array((size + 1) * (size + 1) * 2);
-    let k = 0;
-    for (let i = 0; i <= size; i++) {
-        for (let j = 0; j <= size; j++) {
-            texCoords[k++] = j / size * 0xFFFF;
-            texCoords[k++] = i / size * 0xFFFF;
-        }
-    }
-    return texCoords;
-}
-class SegmentHelper {
-    constructor(maxGridSize = 0) {
-        this._maxGridSize = maxGridSize;
-        this.centerIndexesTable = initIndexBodiesTable(this._maxGridSize);
-        this.skirtsIndexesTable = initIndexesBodySkirts(this._maxGridSize);
-    }
-    get maxGridSize() {
-        return this._maxGridSize;
-    }
-    init() {
-        this.centerIndexesTable = initIndexBodiesTable(this._maxGridSize);
-        this.skirtsIndexesTable = initIndexesBodySkirts(this._maxGridSize);
-    }
-    setMaxGridSize(gridSize) {
-        this._maxGridSize = gridSize;
-        this.init();
-    }
-    createSegmentIndexes(size, sidesSizes) {
-        if (size) {
-            let c = this.centerIndexesTable[size], w = this.skirtsIndexesTable[W][size][sidesSizes[W]], n = this.skirtsIndexesTable[N][size][sidesSizes[N]], e = this.skirtsIndexesTable[E][size][sidesSizes[E]], s = this.skirtsIndexesTable[S][size][sidesSizes[S]];
-            let indexes = NewIndexesTypedArrayEmpty(c.length + w.length + n.length + e.length + s.length);
-            indexes.set(c, 0);
-            indexes.set(w, c.length);
-            indexes.set(n, c.length + w.length);
-            indexes.set(e, c.length + w.length + n.length);
-            indexes.set(s, c.length + w.length + n.length + e.length);
-            return indexes;
-        }
-        else {
-            return NewIndexesTypedArray([0, 2, 1, 3]);
-        }
-    }
-    initTextureCoordsTable(pow) {
-        let table = [];
-        for (let i = 0; i <= pow; i++) {
-            const d = Math.pow(2, i);
-            table[i] = createTextureCoords(d);
-        }
-        return table;
-    }
-}
-let instance = new SegmentHelper();
-export function getInstance() {
-    return instance;
-}

package/lib/js/shaders/atmos.d.ts

@@ -1,20 +0,0 @@
-import { Program } from '../webgl/Program';
-import type { NumberArray3 } from "../math/Vec3";
-export interface AtmosphereParameters {
-    ATMOS_HEIGHT: number;
-    RAYLEIGH_SCALE: number;
-    MIE_SCALE: number;
-    GROUND_ALBEDO: number;
-    BOTTOM_RADIUS: number;
-    rayleighScatteringCoefficient: NumberArray3;
-    mieScatteringCoefficient: number;
-    mieExtinctionCoefficient: number;
-    ozoneAbsorptionCoefficient: NumberArray3;
-    SUN_ANGULAR_RADIUS: number;
-    SUN_INTENSITY: number;
-    ozoneDensityHeight: number;
-    ozoneDensityWide: number;
-}
-export declare const COMMON: (atmosParams?: AtmosphereParameters) => string;
-export declare function transmittance(atmosParams?: AtmosphereParameters): Program;
-export declare function scattering(atmosParams?: AtmosphereParameters): Program;