@openglobus/og 0.18.0 → 0.18.1

package/{src/Object3d.ts → lib/js/Object3d.js}

@@ -1,76 +1,40 @@
-import {htmlColorToFloat32Array, TypedArray} from './utils/shared';
-import {NumberArray3, Vec3} from './math/Vec3';
-import {MAX, MIN} from './math';
-import {transformLeftToRightCoordinateSystem, objParser} from "./utils/objParser";
-
-function getColor(color?: number[] | TypedArray | string): Float32Array {
+import { htmlColorToFloat32Array } from './utils/shared';
+import { Vec3 } from './math/Vec3';
+import { MAX, MIN } from './math';
+import { transformLeftToRightCoordinateSystem, objParser } from "./utils/objParser";
+function getColor(color) {
     if (color instanceof Array) {
         return new Float32Array(color);
-    } else if (typeof color === 'string') {
+    }
+    else if (typeof color === 'string') {
         return htmlColorToFloat32Array(color);
     }
     return new Float32Array([1.0, 1.0, 1.0, 1.0]);
 }
-
-interface IObject3dParams {
-    name?: string;
-    vertices?: number[];
-    texCoords?: number[];
-    indices?: number[];
-    normals?: number[];
-    center?: boolean;
-    src?: string;
-    color?: number[] | TypedArray | string;
-    scale?: number;
-}
-
 class Object3d {
-
-    protected _name: string;
-    protected _vertices: number[];
-    protected _numVertices: number;
-    protected _texCoords: number[];
-
-    /**
-     * Image src.
-     * @protected
-     * @type {string}
-     */
-    protected _src: string | null;
-
-    protected color: Float32Array;
-
-    protected _indices: number[];
-    protected _normals: number[];
-
-    constructor(data: IObject3dParams = {}) {
-
+    constructor(data = {}) {
         this._name = data.name || "noname";
         this._vertices = data.vertices || [];
         this._numVertices = this._vertices.length / 3;
         this._texCoords = data.texCoords || new Array(2 * this._numVertices);
-
         if (data.center) {
             Object3d.centering(this._vertices);
         }
-
         /**
          * Image src.
          * @protected
          * @type {string}
          */
         this._src = data.src || null;
-
         this.color = getColor(data.color);
-
         if (data.scale) {
             Object3d.scale(this._vertices, data.scale);
         }
-
         if (data.indices) {
             this._indices = data.indices;
             this._normals = data.normals || [];
-        } else {
+        }
+        else {
             this._normals = Object3d.getNormals(this._vertices);
             this._indices = new Array(this._vertices.length / 3);
             for (let i = 0, len = this._indices.length; i < len; i++) {
@@ -78,136 +42,113 @@ class Object3d {
             }
         }
     }
-
-    static centering(verts: number[]) {
+    static centering(verts) {
         let min_x = MAX, min_y = MAX, min_z = MAX, max_x = MIN, max_y = MIN, max_z = MIN;
         for (let i = 0, len = verts.length; i < len; i += 3) {
             let x = verts[i], y = verts[i + 1], z = verts[i + 2];
-            if (x < min_x) min_x = x;
-            if (y < min_y) min_y = y;
-            if (z < min_z) min_z = z;
-            if (x > max_x) max_x = x;
-            if (y > max_y) max_y = y;
-            if (z > max_z) max_z = z;
+            if (x < min_x)
+                min_x = x;
+            if (y < min_y)
+                min_y = y;
+            if (z < min_z)
+                min_z = z;
+            if (x > max_x)
+                max_x = x;
+            if (y > max_y)
+                max_y = y;
+            if (z > max_z)
+                max_z = z;
         }
-
         let c_x = min_x + (max_x - min_x) * 0.5;
         let c_y = min_y + (max_y - min_y) * 0.5;
         let c_z = min_z + (max_z - min_z) * 0.5;
-
         for (let i = 0, len = verts.length; i < len; i += 3) {
             verts[i] -= c_x;
             verts[i + 1] -= c_y;
             verts[i + 2] -= c_z;
         }
     }
-
-    public get src(): string | null {
+    get src() {
         return this._src;
     }
-
-    public set src(src: string | null) {
+    set src(src) {
         this._src = src;
     }
-
-    public get name(): string {
+    get name() {
         return this._name;
     }
-
-    public get vertices(): number[] {
+    get vertices() {
         return this._vertices;
     }
-
-    public get normals(): number[] {
+    get normals() {
         return this._normals;
     }
-
-    public get indices(): number[] {
+    get indices() {
         return this._indices;
     }
-
-    public get texCoords(): number[] {
+    get texCoords() {
         return this._texCoords;
     }
-
-    public get numVertices(): number {
+    get numVertices() {
         return this._numVertices;
     }
-
-    static scale(vertices: number[], s: number) {
+    static scale(vertices, s) {
         for (let i = 0; i < vertices.length; i++) {
             vertices[i] *= s;
         }
     }
-
-    static centroid(vertices: number[]) {
+    static centroid(vertices) {
         let minX = 1000.0, minY = 1000.0, minZ = 1000.0, maxX = -1000.0, maxY = -1000.0, maxZ = -1000.0;
-
         for (let i = 0; i < vertices.length; i += 3) {
             let x = vertices[i], y = vertices[i + 1], z = vertices[i + 2];
-            if (x < minX) minX = x;
-            if (y < minY) minY = y;
-            if (z < minZ) minZ = z;
-            if (x > maxX) maxX = x;
-            if (y > maxY) maxY = y;
-            if (z > maxZ) maxZ = z;
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (z < minZ)
+                minZ = z;
+            if (x > maxX)
+                maxX = x;
+            if (y > maxY)
+                maxY = y;
+            if (z > maxZ)
+                maxZ = z;
         }
-
         return [minX + (maxX - minX) * 0.5, minY + (maxY - minY) * 0.5, minZ + (maxZ - minZ) * 0.5];
     }
-
-    static translate(vertices: number[], v: NumberArray3) {
+    static translate(vertices, v) {
         for (let i = 0; i < vertices.length; i += 3) {
             vertices[i] -= v[0];
             vertices[i + 1] -= v[1];
             vertices[i + 2] -= v[2];
         }
     }
-
-    static getNormals(vertices: number[]): number[] {
+    static getNormals(vertices) {
         let res = new Array(vertices.length);
-
         for (let i = 0; i < vertices.length; i += 9) {
-
-            let t03 = i, t13 = i + 3, t23 = i + 6, v0_x = vertices[t03], v0_y = vertices[t03 + 1],
-                v0_z = vertices[t03 + 2], v1_x = vertices[t13], v1_y = vertices[t13 + 1], v1_z = vertices[t13 + 2],
-                v2_x = vertices[t23], v2_y = vertices[t23 + 1], v2_z = vertices[t23 + 2], vv0_x = v1_x - v0_x,
-                vv0_y = v1_y - v0_y, vv0_z = v1_z - v0_z, vv1_x = v2_x - v0_x, vv1_y = v2_y - v0_y, vv1_z = v2_z - v0_z,
-                n_x = vv0_y * vv1_z - vv0_z * vv1_y, n_y = vv0_z * vv1_x - vv0_x * vv1_z,
-                n_z = vv0_x * vv1_y - vv0_y * vv1_x;
-
+            let t03 = i, t13 = i + 3, t23 = i + 6, v0_x = vertices[t03], v0_y = vertices[t03 + 1], v0_z = vertices[t03 + 2], v1_x = vertices[t13], v1_y = vertices[t13 + 1], v1_z = vertices[t13 + 2], v2_x = vertices[t23], v2_y = vertices[t23 + 1], v2_z = vertices[t23 + 2], vv0_x = v1_x - v0_x, vv0_y = v1_y - v0_y, vv0_z = v1_z - v0_z, vv1_x = v2_x - v0_x, vv1_y = v2_y - v0_y, vv1_z = v2_z - v0_z, n_x = vv0_y * vv1_z - vv0_z * vv1_y, n_y = vv0_z * vv1_x - vv0_x * vv1_z, n_z = vv0_x * vv1_y - vv0_y * vv1_x;
             let l = Math.sqrt(n_x * n_x + n_y * n_y + n_z * n_z);
-
             n_x /= l;
             n_y /= l;
             n_z /= l;
-
             res[t03] = n_x;
             res[t03 + 1] = n_y;
             res[t03 + 2] = n_z;
-
             res[t13] = n_x;
             res[t13 + 1] = n_y;
             res[t13 + 2] = n_z;
-
             res[t23] = n_x;
             res[t23 + 1] = n_y;
             res[t23 + 2] = n_z;
         }
-
         return res;
     }
-
-    static createSphere(lonBands: number = 16, latBands: number = 16, radius: number = 1.0,
-                        offsetX: number = 0, offsetY: number = 0, offsetZ: number = 0): Object3d {
-
+    static createSphere(lonBands = 16, latBands = 16, radius = 1.0, offsetX = 0, offsetY = 0, offsetZ = 0) {
         let vertices = [], indices = [], normals = [];
-
         for (let latNumber = 0; latNumber <= latBands; latNumber++) {
             let theta = latNumber * Math.PI / latBands;
             let sinTheta = Math.sin(theta);
             let cosTheta = Math.cos(theta);
-
             for (let longNumber = 0; longNumber <= lonBands; longNumber++) {
                 let phi = longNumber * 2 * Math.PI / lonBands;
                 let sinPhi = Math.sin(phi);
@@ -227,181 +168,124 @@ class Object3d {
                 vertices.push(radius * z);
             }
         }
-
         for (let latNumber = 0; latNumber < latBands; latNumber++) {
             for (let longNumber = 0; longNumber < lonBands; longNumber++) {
                 let first = (latNumber * (lonBands + 1)) + longNumber;
                 let second = first + lonBands + 1;
-
                 indices.push(first);
                 indices.push(first + 1);
                 indices.push(second);
-
                 indices.push(second);
                 indices.push(first + 1);
                 indices.push(second + 1);
             }
         }
-
         return new Object3d({
             'vertices': vertices, 'normals': normals, 'indices': indices
         });
     }
-
-    static createDisc(radius: number = 1.0, height: number = 0.0,
-                      radialSegments: number = 8, isTop: boolean = true, startIndex: number = 0,
-                      offsetX: number = 0, offsetY: number = 0, offsetZ: number = 0
-    ): Object3d {
-
+    static createDisc(radius = 1.0, height = 0.0, radialSegments = 8, isTop = true, startIndex = 0, offsetX = 0, offsetY = 0, offsetZ = 0) {
         let vertices = [], indices = [], normals = [];
-
         let thetaStart = 0.0, thetaLength = Math.PI * 2;
-
         let sign = isTop ? 1.0 : -1.0;
-
         let centerIndexStart = startIndex;
-
         for (let x = 1; x <= radialSegments; x++) {
             vertices.push(offsetX, height * sign + offsetY, offsetZ);
             normals.push(0, sign, 0);
             //texCoords.push(0.5, 0.5);
             startIndex++;
         }
-
         let centerIndexEnd = startIndex;
-
         for (let x = 0; x <= radialSegments; x++) {
-
             let u = x / radialSegments;
             let theta = u * thetaLength + thetaStart;
-
             let cosTheta = Math.cos(theta);
             let sinTheta = Math.sin(theta);
-
             vertices.push(radius * sinTheta + offsetX, height * sign + offsetY, radius * cosTheta + offsetZ);
             normals.push(0, sign, 0);
             //texCoords.push((cosTheta * 0.5) + 0.5, (sinTheta * 0.5 * sign) + 0.5);
-
             startIndex++;
         }
-
         for (let x = 0; x < radialSegments; x++) {
             let c = centerIndexStart + x, i = centerIndexEnd + x;
             if (isTop) {
                 indices.push(i, i + 1, c);
-            } else {
+            }
+            else {
                 indices.push(i + 1, i, c);
             }
         }
-
         return new Object3d({
             'vertices': vertices, 'normals': normals, 'indices': indices
         });
     }
-
-    static createCylinder(radiusTop: number = 1.0, radiusBottom: number = 1.0, height: number = 1.0,
-                          radialSegments: number = 32, heightSegments: number = 1.0, isTop: boolean = true,
-                          isBottom: boolean = true, offsetX: number = 0, offsetY: number = 0, offsetZ: number = 0): Object3d {
-
-        let vertices: number[] = [],
-            indices: number[] = [],
-            normals: number[] = [];
-
+    static createCylinder(radiusTop = 1.0, radiusBottom = 1.0, height = 1.0, radialSegments = 32, heightSegments = 1.0, isTop = true, isBottom = true, offsetX = 0, offsetY = 0, offsetZ = 0) {
+        let vertices = [], indices = [], normals = [];
         let thetaStart = 0.0, thetaLength = Math.PI * 2;
-
         let index = 0;
         let indexArray = [];
-
         let normal = new Vec3();
-
         let slope = (radiusBottom - radiusTop) / height;
-
         for (let y = 0; y <= heightSegments; y++) {
-
             let indexRow = [];
-
             let v = y / heightSegments;
-
             let radius = v * (radiusBottom - radiusTop) + radiusTop;
-
             for (let x = 0; x <= radialSegments; x++) {
-
                 let u = x / radialSegments;
-
                 let theta = u * thetaLength + thetaStart;
-
                 let sinTheta = Math.sin(theta), cosTheta = Math.cos(theta);
-
                 vertices.push(radius * sinTheta + offsetX, -v * height + height + offsetY, radius * cosTheta + offsetZ);
-
                 normal.set(sinTheta, slope, cosTheta).normalize();
                 normals.push(normal.x, normal.y, normal.z);
-
                 //texCoords.push(u, 1 - v);
-
                 indexRow.push(index++);
             }
             indexArray.push(indexRow);
         }
-
         for (let x = 0; x < radialSegments; x++) {
             for (let y = 0; y < heightSegments; y++) {
-
-                let a = indexArray[y][x], b = indexArray[y + 1][x], c = indexArray[y + 1][x + 1],
-                    d = indexArray[y][x + 1];
-
+                let a = indexArray[y][x], b = indexArray[y + 1][x], c = indexArray[y + 1][x + 1], d = indexArray[y][x + 1];
                 indices.push(a, b, d);
                 indices.push(b, c, d);
             }
         }
-
         if (radiusTop !== 0.0 && isTop) {
             let cap = Object3d.createDisc(radiusTop, height, radialSegments, true, index, offsetX, offsetY, offsetZ);
             vertices.push(...cap.vertices);
             normals.push(...cap.normals);
             indices.push(...cap.indices);
         }
-
         if (radiusBottom !== 0.0 && isBottom) {
             let cap = Object3d.createDisc(radiusBottom, 0, radialSegments, false, index + (isTop ? (1 + 2 * radialSegments) : 0), offsetX, offsetY, offsetZ);
             vertices.push(...cap.vertices);
             normals.push(...cap.normals);
             indices.push(...cap.indices);
         }
-
         return new Object3d({
             vertices: vertices,
             normals: normals,
             indices: indices
         });
     }
-
-    static createCube(length: number = 1, height: number = 1, depth: number = 1,
-                      xOffset: number = 0, yOffset: number = 0, zOffset: number = 0): Object3d {
+    static createCube(length = 1, height = 1, depth = 1, xOffset = 0, yOffset = 0, zOffset = 0) {
         let l = length * 0.5 + xOffset, h = height * 0.5 + yOffset, d = depth * 0.5 + zOffset;
-
         return new Object3d({
-            vertices: [//bottom
+            vertices: [
                 -l, -h, d, l, -h, -d, l, -h, d, -l, -h, d, -l, -h, -d, l, -h, -d,
-
                 //top
                 -l, h, d, l, h, d, l, h, -d, -l, h, d, l, h, -d, -l, h, -d,
-
                 //front
                 -l, -h, d, l, -h, d, -l, h, d, -l, h, d, l, -h, d, l, h, d,
-
                 //back
                 -l, -h, -d, -l, h, -d, l, -h, -d, -l, h, -d, l, h, -d, l, -h, -d,
-
                 //left
                 l, -h, d, l, -h, -d, l, h, d, l, h, d, l, -h, -d, l, h, -d,
-
                 //right
-                -l, -h, d, -l, h, d, -l, -h, -d, -l, h, d, -l, h, -d, -l, -h, -d]
+                -l, -h, d, -l, h, d, -l, -h, -d, -l, h, d, -l, h, -d, -l, -h, -d
+            ]
         });
     }
-
-    static createArrow(back: number = 0.0, height: number = 2.1, front: number = -15): Object3d {
+    static createArrow(back = 0.0, height = 2.1, front = -15) {
         return new Object3d({
             vertices: [0, height, 0, 7, 0, 6, 0, 0, front,
                 0, 0, back, 7, 0, 6, 0, height, 0,
@@ -410,20 +294,16 @@ class Object3d {
                 -7, 0, 6, 0, 0, front, 0, 0, back, 0, 0, back, 0, 0, front, 7, 0, 6]
         });
     }
-
-
-    static async loadObj(src: string): Promise<Object3d[]> {
-        const obj: any = await fetch(src, {mode: "cors",})
+    static async loadObj(src) {
+        const obj = await fetch(src, { mode: "cors", })
             .then((response) => response.text())
             .then((data) => transformLeftToRightCoordinateSystem(objParser(data)))
             .catch(() => []);
-
-        return obj.geometries.map(({data: {vertices, normals, textures}}: any) => new Object3d({
+        return obj.geometries.map(({ data: { vertices, normals, textures } }) => new Object3d({
             vertices,
             normals,
             texCoords: textures
         }));
     }
 }
-
-export {Object3d};
+export { Object3d };

package/lib/js/Popup.d.ts

@@ -0,0 +1,46 @@
+import { EventsHandler } from "./Events";
+import { LonLat } from "./LonLat";
+import { Planet } from "./scene/Planet";
+import { NumberArray2, Vec2 } from "./math/Vec2";
+import { NumberArray3, Vec3 } from "./math/Vec3";
+import { View, IViewParams, ViewEventsList } from './ui/View';
+interface IPopupParams extends IViewParams {
+    planet: Planet;
+    title?: string;
+    className?: string;
+    visibility?: boolean;
+    content?: string;
+    offset?: NumberArray2;
+    lonLat?: LonLat | NumberArray2 | NumberArray3;
+}
+type PopupEventsList = ["open", "close"];
+declare class Popup extends View<null> {
+    events: EventsHandler<PopupEventsList> & EventsHandler<ViewEventsList>;
+    $content: HTMLElement | null;
+    $tip: HTMLElement | null;
+    $title: HTMLElement | null;
+    protected _content: string | HTMLElement | null;
+    protected _planet: Planet;
+    protected _offset: NumberArray2;
+    protected _lonLat: LonLat;
+    protected _cartPos: Vec3;
+    protected _visibility: boolean;
+    constructor(options: IPopupParams);
+    _updatePosition(): void;
+    setScreen(p: Vec2): void;
+    get clientWidth(): number;
+    get clientHeight(): number;
+    setOffset(x?: number, y?: number): this;
+    render(params?: any): this;
+    setVisibility(visibility: boolean): this;
+    getContainer(): HTMLElement | null;
+    getToolbarContainer(): HTMLElement;
+    show(): this;
+    hide(): this;
+    setCartesian3v(cart: Vec3, height?: number): this;
+    setTitle(html: string): void;
+    setLonLat(lonLat: LonLat): void;
+    setContent(content?: string | HTMLElement | null): void;
+    clear(): void;
+}
+export { Popup };