@openglobus/og 0.17.2 → 0.18.1

package/src/og/segment/SegmentLonLat.js

@@ -1,294 +0,0 @@
-"use strict";
-
-import { Extent } from "../Extent.js";
-import { Layer } from "../layer/Layer.js";
-import { LonLat } from "../LonLat.js";
-import { Vec3 } from "../math/Vec3.js";
-import * as mercator from "../mercator.js";
-import { EPSG4326 } from "../proj/EPSG4326.js";
-import * as quadTree from "../quadTree/quadTree.js";
-import { Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "./Segment.js";
-
-const MAX_POLE_ZOOM = 7;
-export const POLE_PIECE_SIZE = (90.0 - mercator.MAX_LAT) / Math.pow(2, MAX_POLE_ZOOM);
-
-let _tempHigh = new Vec3(),
-    _tempLow = new Vec3();
-
-/**
- * Planet segment Web Mercator tile class that stored and rendered with quad tree.
- * @class
- * @extends {Segment}
- * @param {quadNode.Node} node - Quad tree segment node.
- * @param {Planet} planet - Scene planet.
- * @param {Number} tileZoom - Segment tile zoom index.
- * @param {Extent} extent - Segment WGS84 extent.
- */
-class SegmentLonLat extends Segment {
-    /**
-     * @param {quadTree.Node} node - Segment node.
-     * @param {Planet} planet - Current planet scene.
-     * @param {number} tileZoom - Zoom index.
-     * @param {Extent} extent - Segment extent.
-     */
-    constructor(node, planet, tileZoom, extent) {
-        super(node, planet, tileZoom, extent);
-
-        this._projection = EPSG4326;
-
-        this._extentMerc = new Extent(
-            extent.southWest.forwardMercatorEPS01(),
-            extent.northEast.forwardMercatorEPS01()
-        );
-
-        if (this._extent.northEast.lat > 0) {
-            this._isNorth = true;
-        } else {
-            this._isNorth = false;
-        }
-
-        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);
-    }
-
-    _assignTileXIndexes(extent) {
-        this.tileX = Math.round(
-            Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon)
-        );
-
-        let p2 = 1 << this.tileZoom;
-        this.tileXE = (this.tileX + 1) % p2;
-        this.tileXW = (p2 + this.tileX - 1) % p2;
-    }
-
-    _assignTileYIndexes(extent) {
-        var lat = extent.northEast.lat;
-        if (lat > 0) {
-            this._tileGroup = TILEGROUP_NORTH;
-            this.tileY = Math.round((90.0 - lat) / (extent.northEast.lat - extent.southWest.lat));
-        } else {
-            this._tileGroup = TILEGROUP_SOUTH;
-            this.tileY = Math.round(
-                (mercator.MIN_LAT - lat) / (extent.northEast.lat - extent.southWest.lat)
-            );
-        }
-        this.tileYN = this.tileY - 1;
-        this.tileYS = this.tileY + 1;
-    }
-
-
-    _createPlainVertices() {
-        var gridSize = this.planet.terrain.gridSizeByZoom[this.tileZoom];
-
-        var e = this._extent,
-            fgs = this.planet.terrain.plainGridSize;
-        var lonSize = e.getWidth();
-        var latSize = e.getHeight();
-        var llStep = lonSize / Math.max(fgs, gridSize);
-        var ltStep = latSize / gridSize;
-        var esw_lon = e.southWest.lon,
-            ene_lat = e.northEast.lat;
-        var dg = Math.max(fgs / gridSize, 1),
-            gs = Math.max(fgs, gridSize) + 1;
-        var r2 = this.planet.ellipsoid._invRadii2;
-        var ind = 0,
-            nmInd = 0;
-        const gsgs = gs * gs;
-
-        var gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;
-
-        this.plainNormals = new Float32Array(gridSize3);
-        this.plainVertices = new Float64Array(gridSize3);
-        this.plainVerticesHigh = new Float32Array(gridSize3);
-        this.plainVerticesLow = new Float32Array(gridSize3);
-
-        this.normalMapNormals = new Float32Array(gsgs * 3);
-        this.normalMapVertices = new Float64Array(gsgs * 3);
-        this.normalMapVerticesHigh = new Float32Array(gsgs * 3);
-        this.normalMapVerticesLow = new Float32Array(gsgs * 3);
-
-        let xmin = 549755748352.0,
-            xmax = -549755748352.0,
-            ymin = 549755748352.0,
-            ymax = -549755748352.0,
-            zmin = 549755748352.0,
-            zmax = -549755748352.0;
-
-        var verts = this.plainVertices,
-            vertsHigh = this.plainVerticesHigh,
-            vertsLow = this.plainVerticesLow,
-            norms = this.plainNormals,
-            nmVerts = this.normalMapVertices,
-            nmVertsHigh = this.normalMapVerticesHigh,
-            nmVertsLow = this.normalMapVerticesLow,
-            nmNorms = this.normalMapNormals;
-
-        for (let k = 0; k < gsgs; k++) {
-            var j = k % gs,
-                i = ~~(k / gs);
-
-            var v = this.planet.ellipsoid.lonLatToCartesian(
-                new LonLat(esw_lon + j * llStep, ene_lat - i * ltStep)
-            );
-            var nx = v.x * r2.x,
-                ny = v.y * r2.y,
-                nz = v.z * r2.z;
-            var l = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);
-            var nxl = nx * l,
-                nyl = ny * l,
-                nzl = nz * l;
-
-            Vec3.doubleToTwoFloats(v, _tempHigh, _tempLow);
-
-            nmVerts[nmInd] = v.x;
-            nmVertsHigh[nmInd] = _tempHigh.x;
-            nmVertsLow[nmInd] = _tempLow.x;
-            nmNorms[nmInd++] = nxl;
-
-            nmVerts[nmInd] = v.y;
-            nmVertsHigh[nmInd] = _tempHigh.y;
-            nmVertsLow[nmInd] = _tempLow.y;
-            nmNorms[nmInd++] = nyl;
-
-            nmVerts[nmInd] = v.z;
-            nmVertsHigh[nmInd] = _tempHigh.z;
-            nmVertsLow[nmInd] = _tempLow.z;
-            nmNorms[nmInd++] = nzl;
-
-            if (i % dg === 0 && j % dg === 0) {
-                verts[ind] = v.x;
-                vertsHigh[ind] = _tempHigh.x;
-                vertsLow[ind] = _tempLow.x;
-                norms[ind++] = nxl;
-
-                verts[ind] = v.y;
-                vertsHigh[ind] = _tempHigh.y;
-                vertsLow[ind] = _tempLow.y;
-                norms[ind++] = nyl;
-
-                verts[ind] = v.z;
-                vertsHigh[ind] = _tempHigh.z;
-                vertsLow[ind] = _tempLow.z;
-                norms[ind++] = nzl;
-
-                if (v.x < xmin) xmin = v.x;
-                if (v.x > xmax) xmax = v.x;
-                if (v.y < ymin) ymin = v.y;
-                if (v.y > ymax) ymax = v.y;
-                if (v.z < zmin) zmin = v.z;
-                if (v.z > zmax) zmax = v.z;
-            }
-        }
-
-        this.terrainVertices = verts;
-        this.terrainVerticesHigh = vertsHigh;
-        this.terrainVerticesLow = vertsLow;
-
-        //store raw normals
-        this.normalMapNormalsRaw = new Float32Array(nmNorms.length);
-        this.normalMapNormalsRaw.set(nmNorms);
-
-        let x = (xmax - xmin) * 0.5,
-            y = (ymax - ymin) * 0.5,
-            z = (zmax - zmin) * 0.5;
-
-        this._plainRadius = Math.sqrt(x * x + y * y + z * z);
-
-        this.plainReady = true;
-    }
-
-    _assignGlobalTextureCoordinates() {
-        var 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;
-    }
-
-    _collectVisibleNodes() {
-        if (this._isNorth) {
-            this.planet._visibleNodesNorth[this.node.nodeId] = this.node;
-        } else {
-            this.planet._visibleNodesSouth[this.node.nodeId] = this.node;
-        }
-    }
-
-    _getLayerExtentOffset(layer) {
-        var v0s = layer._extent;
-        var v0t = this._extent;
-        var sSize_x = v0s.northEast.lon - v0s.southWest.lon;
-        var sSize_y = v0s.northEast.lat - v0s.southWest.lat;
-        var dV0s_x = (v0t.southWest.lon - v0s.southWest.lon) / sSize_x;
-        var dV0s_y = (v0s.northEast.lat - v0t.northEast.lat) / sSize_y;
-        var dSize_x = (v0t.northEast.lon - v0t.southWest.lon) / sSize_x;
-        var 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;
-    }
-
-    getExtentMerc() {
-        return this._extentMerc;
-    }
-
-    getNodeState() {
-        var vn;
-        if (this._isNorth) {
-            vn = this.planet._visibleNodesNorth[this.node.nodeId];
-        } else {
-            vn = this.planet._visibleNodesSouth[this.node.nodeId];
-        }
-        return (vn && vn.state) || quadTree.NOTRENDERING;
-    }
-
-    _freeCache() {
-        //empty for a time
-    }
-}
-
-export { SegmentLonLat };

package/src/og/segment/SegmentLonLatWgs84.js

@@ -1,40 +0,0 @@
-"use strict";
-
-import { TILEGROUP_COMMON } from "./Segment.js";
-import { SegmentLonLat } from "./SegmentLonLat.js";
-
-export class SegmentLonLatWgs84 extends SegmentLonLat {
-    constructor(node, planet, tileZoom, extent) {
-        super(node, planet, tileZoom, extent);
-        this.isPole = false;
-        this._tileGroup = TILEGROUP_COMMON;
-    }
-
-    _getMaxZoom() {
-        return 150;
-        // let lat = 0;
-        // if (this._isNorth) {
-        //     lat = this._extent.northEast.lat;
-        // } else {
-        //     lat = Math.abs(this._extent.southWest.lat);
-        // }
-        // let Yz = Math.floor((90 - lat) / POLE_PIECE_SIZE);
-        // return Math.floor(Yz / 16) + 7;
-    }
-
-    _assignTileYIndexes(extent) {
-        this.tileY = Math.round((90.0 - extent.northEast.lat) / (extent.northEast.lat - extent.southWest.lat));
-        this.tileYN = this.tileY - 1;
-        this.tileYS = this.tileY + 1;
-    }
-
-    _assignTileXIndexes(extent) {
-        this.tileX = Math.round(
-            Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon)
-        );
-
-        let p2 = (1 << this.tileZoom) * 2;
-        this.tileXE = (this.tileX + 1) % p2;
-        this.tileXW = (p2 + this.tileX - 1) % p2;
-    }
-}

package/src/og/segment/Slice.js

@@ -1,45 +0,0 @@
-'use strict';
-
-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);
-        this.init();
-    }
-
-    init() {}
-
-    clear() {
-        this.layers = null;
-        this.tileOffsetArr = null;
-        this.layerOpacityArr = null;
-        //this.visibleExtentOffsetArr = 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/src/og/segment/segmentHelper.js

@@ -1,230 +0,0 @@
-/**
- * @module og/segment/SegmentHelper
- */
-
-'use strict';
-
-import { N, W, S, E } from '../quadTree/quadTree.js';
-
-function NewIndexesTypedArray(arr) {
-    return new Uint32Array(arr);
-}
-
-function createCenterBodyIndexes(size) {
-
-    let indexes = [];
-
-    var i0 = 1,
-        j0 = 1;
-
-    var i1 = 1,
-        j1 = 1;
-
-    var ind1, ind2, nr;
-    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 = [];
-    var grCount = (size - 1) / deltaGr;
-    var b = size * size - size;
-    var k = 0;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        var 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 = [];
-    var grCount = (size - 1) / deltaGr;
-    var k = 0;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        var 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 = [];
-    var grCount = (size - 1) / deltaGr;
-    var k = 0;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        var 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 = [];
-    var grCount = (size - 1) / deltaGr;
-    var k = 0;
-    var rb = size * (size - 1) - 2;
-    var lb = size * size - 1;
-    for (let i = 0; i < size - 2; i++) {
-        if (i % grCount === 0) {
-            k = i;
-        }
-        var 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) {
-    var table = [];
-
-    table[N] = [];
-    table[W] = [];
-    table[S] = [];
-    table[E] = [];
-
-    for (let i = 0; i <= pow; i++) {
-        var 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++) {
-            var 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) {
-    var table = [];
-    for (let i = 0; i <= pow; i++) {
-        var d = Math.pow(2, i);
-        table[i] = createCenterBodyIndexes(d + 1);
-    }
-    return table;
-}
-
-function createTextureCoords(size) {
-    var 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;
-    }
-
-    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 = NewIndexesTypedArray(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) {
-        var table = [];
-        for (let i = 0; i <= pow; i++) {
-            var d = Math.pow(2, i);
-            table[i] = createTextureCoords(d);
-        }
-        return table;
-    }
-}
-
-let instance = new SegmentHelper();
-
-export function getInstance() {
-    return instance;
-}