@openglobus/og 0.22.1 → 0.23.0

package/lib/js/Globe.js

@@ -123,7 +123,8 @@ class Globe {
             context: {
                 //alpha: false,
                 antialias: false,
-                premultipliedAlpha: false
+                premultipliedAlpha: false,
+                preserveDrawingBuffer: false
             }
         }), {
             autoActivate: false,

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/camera/Camera.d.ts

@@ -80,6 +80,7 @@ declare class Camera {
      * @type {Mat4}
      */
     protected _viewMatrix: Mat4;
+    protected _viewMatrixRTE: Mat4;
     /**
      * Camera normal matrix.
      * @protected
@@ -116,6 +117,7 @@ declare class Camera {
     frustumColors: number[];
     FARTHEST_FRUSTUM_INDEX: number;
     currentFrustumIndex: number;
+    frustumColorIndex: number;
     isFirstPass: boolean;
     constructor(renderer: Renderer | null, options?: ICameraParams);
     checkMoveEnd(): void;
@@ -300,6 +302,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 +320,6 @@ declare class Camera {
      * @returns {Mat4} - Inverse projection-view matrix.
      */
     getInverseProjectionMatrix(): NumberArray16;
+    viewDistance(cartesian: Vec3, distance?: number): void;
 }
 export { Camera };

package/lib/js/camera/Camera.js

@@ -6,6 +6,7 @@ import { Mat4 } from "../math/Mat4";
 import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Vec4 } from "../math/Vec4";
+import { Quat } from "../math/Quat";
 const EVENT_NAMES = [
     /**
      * When camera has been updated.
@@ -44,6 +45,7 @@ class Camera {
         this._aspect = options.aspect || 1.0;
         this._viewAngle = options.viewAngle || 47.0;
         this._viewMatrix = new Mat4();
+        this._viewMatrixRTE = new Mat4();
         this._normalMatrix = new Mat3();
         this._r = new Vec3(1.0, 0.0, 0.0);
         this._u = new Vec3(0.0, 1.0, 0.0);
@@ -74,7 +76,7 @@ class Camera {
             }
         }
         else {
-            let near = 1.0, far = 10000.0;
+            let near = 0.1, far = 1000.0;
             let fr = new Frustum({
                 fov: this._viewAngle,
                 aspect: this._aspect,
@@ -88,6 +90,7 @@ class Camera {
         }
         this.FARTHEST_FRUSTUM_INDEX = this.frustums.length - 1;
         this.currentFrustumIndex = 0;
+        this.frustumColorIndex = 0;
         this.isFirstPass = false;
         this._projSizeConst = 0;
         this.set(options.eye || new Vec3(0.0, 0.0, 1.0), options.look || new Vec3(), options.up || new Vec3(0.0, 1.0, 0.0));
@@ -163,10 +166,17 @@ class Camera {
             u.z, v.z, n.z, 0.0,
             -eye.dot(u), -eye.dot(v), -eye.dot(n), 1.0
         ]);
+        this._viewMatrixRTE.set([
+            u.x, v.x, n.x, 0.0,
+            u.y, v.y, n.y, 0.0,
+            u.z, v.z, n.z, 0.0,
+            0, 0, 0, 1.0
+        ]);
         // do not clean up, someday it will be using
         //this._normalMatrix = this._viewMatrix.toMatrix3(); // this._viewMatrix.toInverseMatrix3().transposeTo();
         for (let i = 0, len = this.frustums.length; i < len; i++) {
             this.frustums[i].setViewMatrix(this._viewMatrix);
+            this.frustums[i].setProjectionViewRTEMatrix(this._viewMatrixRTE);
         }
         this.events.dispatch(this.events.viewchange, this);
     }
@@ -409,6 +419,7 @@ class Camera {
     }
     setCurrentFrustum(k) {
         this.currentFrustumIndex = k;
+        this.frustumColorIndex = (k + 1) * 10.0 / 255.0;
         this.isFirstPass = k === this.FARTHEST_FRUSTUM_INDEX;
     }
     getCurrentFrustum() {
@@ -441,6 +452,14 @@ class Camera {
     getProjectionViewMatrix() {
         return this.frustum.projectionViewMatrix._m;
     }
+    /**
+     * Returns projection and model RTE matrix product.
+     * @public
+     * @return {Mat4} - Projection-view matrix.
+     */
+    getProjectionViewRTEMatrix() {
+        return this.frustum.projectionViewRTEMatrix._m;
+    }
     /**
      * Returns inverse projection and model matrix product.
      * @public
@@ -457,5 +476,12 @@ class Camera {
     getInverseProjectionMatrix() {
         return this.frustum.inverseProjectionMatrix._m;
     }
+    viewDistance(cartesian, distance = 10000.0) {
+        let p0 = this.eye.add(this.getForward().scaleTo(distance));
+        let _rot = Quat.getRotationBetweenVectors(p0.getNormal(), cartesian.getNormal());
+        let newPos = cartesian.add(this.getBackward().scaleTo(distance));
+        this.set(newPos, cartesian);
+        this.update();
+    }
 }
 export { Camera };

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

@@ -35,6 +35,7 @@ declare class Frustum {
      * @type {Mat4}
      */
     projectionViewMatrix: Mat4;
+    projectionViewRTEMatrix: Mat4;
     /**
      * Inverse projectionView Matrix.
      * @protected
@@ -81,6 +82,7 @@ declare class Frustum {
     getBackwardPlane(): NumberArray4;
     getForwardPlane(): NumberArray4;
     getProjectionViewMatrix(): NumberArray16;
+    getProjectionViewRTEMatrix(): NumberArray16;
     getProjectionMatrix(): NumberArray16;
     getInverseProjectionMatrix(): NumberArray16;
     /**
@@ -92,6 +94,7 @@ declare class Frustum {
      * @param {number} far - Far camera distance.
      */
     setProjectionMatrix(angle: number, aspect: number, near: number, far: number): void;
+    setProjectionViewRTEMatrix(viewRTEMatrix: Mat4): void;
     /**
      * Camera's projection matrix values.
      * @public

package/lib/js/camera/Frustum.js

@@ -19,6 +19,7 @@ class Frustum {
         this.projectionMatrix = new Mat4();
         this.inverseProjectionMatrix = new Mat4();
         this.projectionViewMatrix = new Mat4();
+        this.projectionViewRTEMatrix = new Mat4();
         this.inverseProjectionViewMatrix = new Mat4();
         this.left = 0.0;
         this.right = 0.0;
@@ -50,6 +51,9 @@ class Frustum {
     getProjectionViewMatrix() {
         return this.projectionViewMatrix._m;
     }
+    getProjectionViewRTEMatrix() {
+        return this.projectionViewRTEMatrix._m;
+    }
     getProjectionMatrix() {
         return this.projectionMatrix._m;
     }
@@ -74,6 +78,9 @@ class Frustum {
         this.projectionMatrix.setPerspective(this.left, this.right, this.bottom, this.top, near, far);
         this.projectionMatrix.inverseTo(this.inverseProjectionMatrix);
     }
+    setProjectionViewRTEMatrix(viewRTEMatrix) {
+        this.projectionViewRTEMatrix = this.projectionMatrix.mul(viewRTEMatrix);
+    }
     /**
      * Camera's projection matrix values.
      * @public

package/lib/js/control/Atmosphere.js

@@ -94,18 +94,22 @@ export class Atmosphere extends Control {
             width: width,
             height: height,
             useDepth: false,
-            filter: "LINEAR",
-            type: "FLOAT",
-            internalFormat: "RGBA16F"
+            targets: [{
+                    filter: "LINEAR",
+                    type: "FLOAT",
+                    internalFormat: "RGBA16F"
+                }]
         });
         this._transmittanceBuffer.init();
         this._scatteringBuffer = new Framebuffer(this.renderer.handler, {
             width: width,
             height: height,
             useDepth: false,
-            filter: "LINEAR",
-            type: "FLOAT",
-            internalFormat: "RGBA16F"
+            targets: [{
+                    filter: "LINEAR",
+                    type: "FLOAT",
+                    internalFormat: "RGBA16F"
+                }]
         });
         this._scatteringBuffer.init();
     }

package/lib/js/control/CameraLock.d.ts

@@ -0,0 +1,38 @@
+import { Control, IControlParams } from "./Control";
+import { LonLat } from "../LonLat";
+import { Vec3 } from "../math/Vec3";
+import { EventsHandler } from "../Events";
+import { Entity } from "../entity/Entity";
+import { IMouseState } from "../renderer/RendererEvents";
+import { Planet } from "../scene/Planet";
+type CameraLockEventsList = ["lockview", "unlockview"];
+interface ICameraLockParams extends IControlParams {
+    planet?: Planet | null;
+}
+export declare class CameraLock extends Control {
+    events: EventsHandler<CameraLockEventsList>;
+    protected _lockDistance: number;
+    protected _isFromTheBack: boolean;
+    protected _lockEntity: Entity | null;
+    protected _viewDir: Vec3;
+    constructor(options?: ICameraLockParams);
+    onactivate(): void;
+    ondeactivate(): void;
+    oninit(): void;
+    flyCartesian(cartesian: Vec3, dist?: number): void;
+    lockView(entity: Entity, fromTheBack?: boolean): void;
+    protected _activateNav(): void;
+    protected _deactivateNav(): void;
+    unlockView(): void;
+    private _getCenterDist;
+    protected _getDistance(entity: Entity, prevEntity?: Entity | null): number;
+    isVisibleDistance(cart: Vec3, C?: number): boolean;
+    get lockEntity(): Entity | null;
+    flyLonLat(lonLat: LonLat, dist?: number): void;
+    protected _activateLockViewEvents(): void;
+    protected _deactivateLockViewEvents(): void;
+    private _onLockViewDraw;
+    protected _onMouseWheel: (e: IMouseState) => void;
+    protected _onMouseMove: (ms: IMouseState) => void;
+}
+export {};