@openglobus/og 0.22.2 → 0.24.0

package/lib/js/Globe.d.ts

@@ -33,7 +33,6 @@ export interface IGlobeParams {
     transitionOpacityEnabled?: boolean;
     terrain?: EmptyTerrain;
     controls?: Control[];
-    useEarthNavigation?: boolean;
     minSlope?: number;
     sun?: {
         active?: boolean;

package/lib/js/Globe.js

@@ -1,7 +1,6 @@
 // #StandWithUkraine
 import { CompassButton } from "./control/CompassButton";
 import { EarthCoordinates } from "./control/EarthCoordinates";
-import { EarthNavigation } from "./control/EarthNavigation";
 import { EmptyTerrain } from "./terrain/EmptyTerrain";
 import { Handler } from "./webgl/Handler";
 import { isEmpty } from "./utils/shared";
@@ -178,7 +177,7 @@ class Globe {
         else {
             this.planet.addControls([
                 new ZoomControl(),
-                options.useEarthNavigation ? new EarthNavigation() : new MouseNavigation({ minSlope: options.minSlope }),
+                new MouseNavigation(),
                 new TouchNavigation(),
                 new EarthCoordinates(),
                 new ScaleControl(),
@@ -262,6 +261,9 @@ class Globe {
                 t.appendChild(this.$inner);
             }
         }
+        else {
+            console.warn(`Target container not found. Provided target: ${target}`);
+        }
     }
     detach() {
         if (this.$target) {

package/lib/js/Object3d.d.ts

@@ -8,32 +8,39 @@ interface IObject3dParams {
     indices?: number[];
     normals?: number[];
     center?: boolean;
-    src?: string;
     color?: number[] | TypedArray | string;
     scale?: number | Vec3;
+    ambient?: string | NumberArray3;
+    diffuse?: string | NumberArray3;
+    specular?: string | NumberArray3;
+    shininess?: number;
+    colorTexture?: string;
+    normalTexture?: string;
+    metallicRoughnessTexture?: string;
 }
 declare 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[];
+    color: Float32Array;
+    ambient: Float32Array;
+    diffuse: Float32Array;
+    specular: Float32Array;
+    shininess: number;
+    colorTexture: string;
+    normalTexture: string;
+    metallicRoughnessTexture: string;
+    center: Vec3;
     constructor(data?: IObject3dParams);
+    static getCenter(verts: number[]): Vec3;
     static centering(verts: number[]): void;
     centering(): this;
     applyMat4(m: Mat4): this;
     scale(s: Vec3): this;
     translate(v: Vec3): this;
-    get src(): string | null;
-    set src(src: string | null);
     get name(): string;
     get vertices(): number[];
     get normals(): number[];
@@ -63,8 +70,11 @@ declare class Object3d {
     static createFrustum(length?: number, width?: number, height?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
     static createCylinder(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, isTop?: boolean, isBottom?: boolean, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
     static createCube(length?: number, height?: number, depth?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
+    static createPlane(width?: number, height?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
     static createArrow(back?: number, height?: number, front?: number): Object3d;
+    static readFileObj(objFile: File, mtlFile?: File): Promise<Object3d[]>;
     static loadObj(src: string): Promise<Object3d[]>;
     merge(other: Object3d): Object3d;
+    static merge(objects: Object3d[], maxSize?: number): Object3d;
 }
 export { Object3d };

package/lib/js/Object3d.js

@@ -1,7 +1,7 @@
 import { htmlColorToFloat32Array } from './utils/shared';
 import { Vec3 } from './math/Vec3';
 import { DEGREES_DOUBLE, MAX, MIN, RADIANS_HALF } from './math';
-import { transformLeftToRightCoordinateSystem, objParser } from "./utils/objParser";
+import { Obj } from "./utils/objParser";
 function getColor(color) {
     if (color instanceof Array) {
         return new Float32Array(color);
@@ -11,22 +11,40 @@ function getColor(color) {
     }
     return new Float32Array([1.0, 1.0, 1.0, 1.0]);
 }
+function getColor3v(color) {
+    let res = new Float32Array([1.0, 1.0, 1.0]);
+    if (color instanceof Array) {
+        res[0] = color[0];
+        res[1] = color[1];
+        res[2] = color[2];
+    }
+    else if (typeof color === 'string') {
+        let c = htmlColorToFloat32Array(color);
+        res[0] = c[0];
+        res[1] = c[1];
+        res[2] = c[2];
+    }
+    return res;
+}
 class Object3d {
     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;
+        // if (data.texCoords) {
+        //     this._texCoords = data.texCoords;
+        // } else {
+        //     this._texCoords = Array.from({length: 2 * this._numVertices}, (_, i) => 0);
+        // }
         this.color = getColor(data.color);
+        this.ambient = getColor3v(data.ambient);
+        this.diffuse = getColor3v(data.diffuse);
+        this.specular = getColor3v(data.specular);
+        this.shininess = data.shininess || 100;
+        this.colorTexture = data.colorTexture || "";
+        this.normalTexture = data.normalTexture || "";
+        this.metallicRoughnessTexture = data.metallicRoughnessTexture || "";
         if (data.scale) {
             let s = data.scale;
             let scale;
@@ -38,19 +56,23 @@ class Object3d {
             }
             Object3d.scale(this._vertices, scale);
         }
+        if (data.center) {
+            Object3d.centering(this._vertices);
+        }
+        this.center = Object3d.getCenter(this._vertices);
         if (data.indices) {
             this._indices = data.indices;
             this._normals = data.normals || [];
         }
         else {
-            this._normals = Object3d.getNormals(this._vertices);
+            this._normals = data.normals || Object3d.getNormals(this._vertices);
             this._indices = new Array(this._vertices.length / 3);
             for (let i = 0, len = this._indices.length; i < len; i++) {
                 this._indices[i] = i;
             }
         }
     }
-    static centering(verts) {
+    static getCenter(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];
@@ -67,13 +89,14 @@ class Object3d {
             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;
+        return new Vec3(min_x + (max_x - min_x) * 0.5, min_y + (max_y - min_y) * 0.5, min_z + (max_z - min_z) * 0.5);
+    }
+    static centering(verts) {
+        let c = Object3d.getCenter(verts);
         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;
+            verts[i] -= c.x;
+            verts[i + 1] -= c.y;
+            verts[i + 2] -= c.z;
         }
     }
     centering() {
@@ -106,12 +129,6 @@ class Object3d {
         }
         return this;
     }
-    get src() {
-        return this._src;
-    }
-    set src(src) {
-        this._src = src;
-    }
     get name() {
         return this._name;
     }
@@ -390,6 +407,17 @@ class Object3d {
             ]
         });
     }
+    static createPlane(width = 1, height = 1, xOffset = 0, yOffset = 0, zOffset = 0) {
+        let sx = width * 0.5, sy = yOffset, sz = height * 0.5;
+        return new Object3d({
+            vertices: [
+                //bottom
+                -sx + xOffset, sy, sz + zOffset, sx + xOffset, sy, -sz + zOffset, sx + xOffset, sy, sz + zOffset, -sx + xOffset, sy, sz + zOffset, -sx + xOffset, sy, -sz + zOffset, sx + xOffset, sy, -sz + zOffset,
+                //top
+                -sx + xOffset, sy, sz + zOffset, sx + xOffset, sy, sz + zOffset, sx + xOffset, sy, -sz + zOffset, -sx + xOffset, sy, sz + zOffset, sx + xOffset, sy, -sz + zOffset, -sx + xOffset, sy, -sz + zOffset
+            ]
+        });
+    }
     static createArrow(back = 0.0, height = 2.1, front = -15) {
         return new Object3d({
             vertices: [0, height, 0, 7, 0, 6, 0, 0, front,
@@ -399,34 +427,82 @@ class Object3d {
                 -7, 0, 6, 0, 0, front, 0, 0, back, 0, 0, back, 0, 0, front, 7, 0, 6]
         });
     }
+    static async readFileObj(objFile, mtlFile) {
+        let obj = new Obj();
+        const res = await obj.readFile(objFile, mtlFile);
+        let materials = res.materials;
+        return res.geometries.map((obj) => {
+            let mat = materials[obj.material] || {};
+            return new Object3d({
+                name: obj.object,
+                vertices: obj.data.vertices,
+                normals: obj.data.normals,
+                texCoords: obj.data.texCoords,
+                ambient: mat.ambient,
+                diffuse: mat.diffuse,
+                specular: mat.specular,
+                shininess: mat.shininess,
+                color: mat.color,
+                colorTexture: mat.colorTexture,
+                normalTexture: mat.normalTexture,
+                metallicRoughnessTexture: mat.metallicRoughnessTexture
+            });
+        });
+    }
     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 } }) => new Object3d({
-            vertices,
-            normals,
-            texCoords: textures
-        }));
+        let obj = new Obj();
+        const res = await obj.load(src);
+        let materials = res.materials;
+        return res.geometries.map((obj) => {
+            let mat = materials[obj.material] || {};
+            return new Object3d({
+                name: obj.object,
+                vertices: obj.data.vertices,
+                normals: obj.data.normals,
+                texCoords: obj.data.texCoords,
+                ambient: mat.ambient,
+                diffuse: mat.diffuse,
+                specular: mat.specular,
+                shininess: mat.shininess,
+                color: mat.color,
+                colorTexture: mat.colorTexture,
+                normalTexture: mat.normalTexture,
+                metallicRoughnessTexture: mat.metallicRoughnessTexture
+            });
+        });
     }
     merge(other) {
-        const mergedVertices = [...this._vertices, ...other.vertices];
-        const mergedNormals = [...this._normals, ...other.normals];
-        const mergedTexCoords = [...this._texCoords, ...other.texCoords];
         const offset = this._vertices.length / 3;
-        const mergedIndices = [
-            ...this._indices,
-            ...other.indices.map(index => index + offset)
-        ];
-        return new Object3d({
-            name: `${this._name}_${other.name}`,
-            vertices: mergedVertices,
-            texCoords: mergedTexCoords,
-            indices: mergedIndices,
-            normals: mergedNormals,
-            color: this.color
-        });
+        let temp = this._vertices.length;
+        this._vertices.length = temp + other._vertices.length;
+        for (let i = 0; i < other._vertices.length; i++) {
+            this._vertices[temp + i] = other._vertices[i];
+        }
+        temp = this._normals.length;
+        this._normals.length = temp + other._normals.length;
+        for (let i = 0; i < other._normals.length; i++) {
+            this._normals[temp + i] = other._normals[i];
+        }
+        temp = this._texCoords.length;
+        this._texCoords.length = temp + other._texCoords.length;
+        for (let i = 0; i < other._texCoords.length; i++) {
+            this._texCoords[temp + i] = other._texCoords[i];
+        }
+        temp = this._indices.length;
+        this._indices.length = temp + other._indices.length;
+        for (let i = 0; i < other._indices.length; i++) {
+            this._indices[temp + i] = other._indices[i] + offset;
+        }
+        this._numVertices = this._vertices.length / 3;
+        return this;
+    }
+    static merge(objects, maxSize) {
+        let res = new Object3d();
+        let size = maxSize ? maxSize : objects.length;
+        for (let i = 0; i < size; i++) {
+            res.merge(objects[i]);
+        }
+        return res;
     }
 }
 export { Object3d };

package/lib/js/Popup.js

@@ -117,7 +117,7 @@ class Popup extends View {
             let look = cart.sub(cam.eye), v = Math.sqrt((f + g) * (f + g) - f * f);
             if (v > look.length() && cam.getForward().dot(look.normalize()) > 0.0) {
                 this.el.style.display = "block";
-                this.setScreen(cam.project(cart));
+                this.setScreen(cam.project3v(cart));
             }
             else {
                 this.el.style.display = "none";

package/lib/js/camera/Camera.d.ts

@@ -6,6 +6,7 @@ import { Renderer } from "../renderer/Renderer";
 import { Vec2, NumberArray2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Sphere } from "../bv/Sphere";
+import { Quat } from "../math/Quat";
 type CameraEvents = ["viewchange", "moveend"];
 export interface ICameraParams {
     eye?: Vec3;
@@ -80,6 +81,7 @@ declare class Camera {
      * @type {Mat4}
      */
     protected _viewMatrix: Mat4;
+    protected _viewMatrixRTE: Mat4;
     /**
      * Camera normal matrix.
      * @protected
@@ -88,22 +90,28 @@ declare class Camera {
     protected _normalMatrix: Mat3;
     /**
      * Camera right vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _r: Vec3;
     /**
      * Camera up vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _u: Vec3;
     /**
      * Camera backward vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _b: Vec3;
+    /**
+     * Camera forward vector.
+     * @protected
+     * @type {Vec3}
+     */
+    _f: Vec3;
     protected _pr: Vec3;
     protected _pu: Vec3;
     protected _pb: Vec3;
@@ -116,6 +124,7 @@ declare class Camera {
     frustumColors: number[];
     FARTHEST_FRUSTUM_INDEX: number;
     currentFrustumIndex: number;
+    frustumColorIndex: number;
     isFirstPass: boolean;
     constructor(renderer: Renderer | null, options?: ICameraParams);
     checkMoveEnd(): void;
@@ -206,23 +215,40 @@ declare class Camera {
      */
     slide(du: number, dv: number, dn: number): void;
     /**
-     * Roll the camera to the angle in degrees
+     * Roll the camera to the angle in radians
+     * @public
+     * @param {number} angle - Delta roll angle in radians
+     */
+    setRoll(angle: number): void;
+    /**
+     * Pitch the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta roll angle in degrees
+     * @param {number} angle - Delta pitch angle in radians
      */
-    roll(angle: number): void;
+    setPitch(angle: number): void;
     /**
-     * Pitch the camera to the angle in degrees
+     * Yaw the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta pitch angle in degrees
+     * @param {number} angle - Delta yaw angle in radians
      */
-    pitch(angle: number): void;
+    setYaw(angle: number): void;
+    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
+    getPitch(): number;
+    getYaw(): number;
+    getRoll(): number;
     /**
-     * Yaw the camera to the angle in degrees
+     * Returns camera quaternion
+     */
+    getRotation(): Quat;
+    setRotation(rot: Quat, up?: Vec3, right?: Vec3, back?: Vec3): void;
+    rotate(rot: Quat): void;
+    /**
+     * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
-     * @param {number} angle - Delta yaw angle in degrees
+     * @param {Vec2} pos - Screen X coordinate
+     * @returns {Vec3} - Direction vector
      */
-    yaw(angle: number): void;
+    unproject2v(pos: Vec2): Vec3;
     /**
      * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
@@ -237,7 +263,16 @@ declare class Camera {
      * @param {Vec3} v - Cartesian 3d coordinates
      * @returns {Vec2} - Screen point coordinates
      */
-    project(v: Vec3): Vec2;
+    project3v(v: Vec3): Vec2;
+    /**
+     * Gets projected 3d point to the 2d screen coordinates
+     * @public
+     * @param {number} x - X coordinate
+     * @param {number} y - Y coordinate
+     * @param {number} z - Z coordinate
+     * @returns {Vec2} - Screen point coordinates
+     */
+    project(x: number, y: number, z: number): Vec2;
     /**
      * Rotates camera around center point
      * @public
@@ -247,7 +282,7 @@ declare class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around
      * @param {Vec3} [up] - Camera up vector
      */
-    rotateAround(angle: number, isArc?: boolean, center?: Vec3 | null, up?: Vec3 | null): void;
+    rotateAround(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by horizontal.
      * @public
@@ -257,7 +292,7 @@ declare class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around.
      * @param {Vec3} [up] - Camera up vector.
      */
-    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3 | null, up?: Vec3 | null): void;
+    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by vertical.
      * @param {number} angle - Rotation angle in radians.
@@ -300,6 +335,12 @@ declare class Camera {
      * @return {Mat4} - Projection-view matrix.
      */
     getProjectionViewMatrix(): NumberArray16;
+    /**
+     * Returns projection and model RTE matrix product.
+     * @public
+     * @return {Mat4} - Projection-view matrix.
+     */
+    getProjectionViewRTEMatrix(): NumberArray16;
     /**
      * Returns inverse projection and model matrix product.
      * @public
@@ -312,5 +353,6 @@ declare class Camera {
      * @returns {Mat4} - Inverse projection-view matrix.
      */
     getInverseProjectionMatrix(): NumberArray16;
+    viewDistance(cartesian: Vec3, distance?: number): void;
 }
 export { Camera };