@openglobus/og 0.18.0 → 0.18.2

package/{src/scene/SkyBox.ts → lib/js/scene/SkyBox.js}

@@ -1,21 +1,13 @@
 import * as shaders from '../shaders/skybox';
-import {RenderNode} from './RenderNode';
-import {WebGLBufferExt, WebGLTextureExt, Texture3DParams} from "../webgl/Handler";
-
+import { RenderNode } from './RenderNode';
 class SkyBox extends RenderNode {
-
-    public params: Texture3DParams;
-    public vertexPositionBuffer: WebGLBufferExt | null;
-    public texture: WebGLTextureExt | null;
-
-    constructor(params: Texture3DParams) {
+    constructor(params) {
         super("skybox");
         this.params = params;
         this.vertexPositionBuffer = null;
         this.texture = null;
     }
-
-    static createDefault(RESOURCES_URL: string) {
+    static createDefault(RESOURCES_URL) {
         return new SkyBox({
             nx: RESOURCES_URL + "skybox/gal/_nx.jpg",
             px: RESOURCES_URL + "skybox/gal/_px.jpg",
@@ -25,38 +17,32 @@ class SkyBox extends RenderNode {
             nz: RESOURCES_URL + "skybox/gal/_nz.jpg"
         });
     }
-
-    public override init() {
-        this.renderer!.handler!.addProgram(shaders.skybox(), true);
-        this.texture = this.renderer!.handler.loadCubeMapTexture(this.params);
+    init() {
+        this.renderer.handler.addProgram(shaders.skybox(), true);
+        this.texture = this.renderer.handler.loadCubeMapTexture(this.params);
         this._createBuffers();
-        this.drawMode = this.renderer!.handler.gl!.TRIANGLES;
+        this.drawMode = this.renderer.handler.gl.TRIANGLES;
     }
-
-    public override frame() {
-        let h = this.renderer!.handler;
-        let gl = h.gl!;
-        let cam = this.renderer!.activeCamera!;
+    frame() {
+        let h = this.renderer.handler;
+        let gl = h.gl;
+        let cam = this.renderer.activeCamera;
         gl.disable(gl.DEPTH_TEST);
-
         h.programs.skybox.activate();
         let sh = h.programs.skybox._program;
         let shu = sh.uniforms;
         gl.uniformMatrix4fv(shu.projectionViewMatrix, false, cam.getProjectionViewMatrix());
         gl.uniform3fv(shu.pos, cam.eye.toArray());
         gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.texture!);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, this.texture);
         gl.uniform1i(shu.uSampler, 0);
-        let buf = this.vertexPositionBuffer!;
+        let buf = this.vertexPositionBuffer;
         gl.bindBuffer(gl.ARRAY_BUFFER, buf);
         gl.vertexAttribPointer(sh.attributes.aVertexPosition, buf.itemSize, gl.FLOAT, false, 0, 0);
-
         gl.drawArrays(this.drawMode, 0, buf.numItems);
         gl.enable(gl.DEPTH_TEST);
     }
-
-    protected _createBuffers() {
-
+    _createBuffers() {
         const vertices = new Float32Array([
             -100000000.0, 100000000.0, -100000000.0,
             -100000000.0, -100000000.0, -100000000.0,
@@ -64,35 +50,30 @@ class SkyBox extends RenderNode {
             100000000.0, -100000000.0, -100000000.0,
             100000000.0, 100000000.0, -100000000.0,
             -100000000.0, 100000000.0, -100000000.0,
-
             -100000000.0, -100000000.0, 100000000.0,
             -100000000.0, -100000000.0, -100000000.0,
             -100000000.0, 100000000.0, -100000000.0,
             -100000000.0, 100000000.0, -100000000.0,
             -100000000.0, 100000000.0, 100000000.0,
             -100000000.0, -100000000.0, 100000000.0,
-
             100000000.0, -100000000.0, -100000000.0,
             100000000.0, -100000000.0, 100000000.0,
             100000000.0, 100000000.0, 100000000.0,
             100000000.0, 100000000.0, 100000000.0,
             100000000.0, 100000000.0, -100000000.0,
             100000000.0, -100000000.0, -100000000.0,
-
             -100000000.0, -100000000.0, 100000000.0,
             -100000000.0, 100000000.0, 100000000.0,
             100000000.0, 100000000.0, 100000000.0,
             100000000.0, 100000000.0, 100000000.0,
             100000000.0, -100000000.0, 100000000.0,
             -100000000.0, -100000000.0, 100000000.0,
-
             -100000000.0, 100000000.0, -100000000.0,
             100000000.0, 100000000.0, -100000000.0,
             100000000.0, 100000000.0, 100000000.0,
             100000000.0, 100000000.0, 100000000.0,
             -100000000.0, 100000000.0, 100000000.0,
             -100000000.0, 100000000.0, -100000000.0,
-
             -100000000.0, -100000000.0, -100000000.0,
             -100000000.0, -100000000.0, 100000000.0,
             100000000.0, -100000000.0, -100000000.0,
@@ -100,9 +81,7 @@ class SkyBox extends RenderNode {
             -100000000.0, -100000000.0, 100000000.0,
             100000000.0, -100000000.0, 100000000.0
         ]);
-
-        this.vertexPositionBuffer = this.renderer!.handler.createArrayBuffer(vertices, 3, vertices.length / 3);
+        this.vertexPositionBuffer = this.renderer.handler.createArrayBuffer(vertices, 3, vertices.length / 3);
     }
 }
-
-export {SkyBox};
+export { SkyBox };

package/{src/scene/index.ts → lib/js/scene/index.d.ts}

@@ -2,5 +2,4 @@ import { Axes } from "./Axes";
 import { Planet } from "./Planet";
 import { SkyBox } from "./SkyBox";
 import { RenderNode } from "./RenderNode";
-
 export { Planet, Axes, SkyBox, RenderNode };

package/lib/js/scene/index.js

@@ -0,0 +1,5 @@
+import { Axes } from "./Axes";
+import { Planet } from "./Planet";
+import { SkyBox } from "./SkyBox";
+import { RenderNode } from "./RenderNode";
+export { Planet, Axes, SkyBox, RenderNode };

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

@@ -0,0 +1,278 @@
+import { Box } from "../bv/Box";
+import { Extent } from "../Extent";
+import { Entity } from "../entity/Entity";
+import { TypedArray } from "../utils/shared";
+import { Handler, WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+import { 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 { NumberArray6, Sphere } from "../bv/Sphere";
+import { Slice } from "./Slice";
+import { Vec3 } from "../math/Vec3";
+import { IPlainSegmentWorkerData } from "../utils/PlainSegmentWorker";
+export declare const TILEGROUP_COMMON = 0;
+export declare const TILEGROUP_NORTH = 1;
+export declare const TILEGROUP_SOUTH = 2;
+/**
+ * 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;
+    /**
+     * 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;
+    /**
+     * 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 allready made.
+     * @type {boolean}
+     */
+    normalMapReady: boolean;
+    /**
+     * Terrain is allready 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;
+    constructor(node: Node, planet: Planet, 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;
+    destroySegment(): void;
+    /**
+     * @todo: looks like it could be simplified in Segment contructor
+     */
+    _setExtentLonLat(): 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 _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];
+    screenRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean): void;
+    heightPickingRendering(sh: Program, layerSlice: Layer[]): void;
+    colorPickingRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean): void;
+    depthRendering(sh: Program, layerSlice: Layer[]): void;
+    protected _getIndexBuffer(): WebGLBufferExt;
+    /**
+     * @todo: replace to the strategy
+     */
+    _collectVisibleNodes(): void;
+    layerOverlap(layer: Layer): boolean;
+    getDefaultTexture(): WebGLTextureExt | null;
+    getExtentLonLat(): Extent;
+    getExtentMerc(): Extent;
+    getExtent(): Extent;
+    /**
+     * @todo replace to the strategy
+     */
+    getNodeState(): number;
+    getNeighborSide(b: Segment): 0 | 1 | 2 | 3 | -1;
+}
+export { Segment };