@openglobus/og 0.22.2 → 0.24.0

package/lib/js/entity/GeoObject.js

@@ -1,11 +1,19 @@
 import * as utils from "../utils/shared";
-import { Quat, Vec3 } from "../math/index";
+import { Quat, Vec3, Vec4 } from "../math/index";
 import { Object3d } from "../Object3d";
-import { RADIANS } from "../math";
+export const LOCAL_FORWARD = new Vec3(0.0, 0.0, -1.0);
 /**
+ * Represents 3D object on the the globe or 3d space
  * @class
- * @param {Object} options -  Geo object parameters:
- * @param {Vec3} [options.position] - Geo object position.
+ * @param {IGeoObjectParams} options -  Geo object parameters:
+ * @param {Object3d} [options.object3d] - 3D object associated with the geo object.
+ * @param {string} [options.objSrc] - Source url of the 3D object.
+ * @param {string} [options.tag] - Unique instancing drawing identifier tag.
+ * @param {Vec3 | NumberArray3} [options.position] - Position in Cartesian coordinates.
+ * @param {number | Vec3 | NumberArray3} [options.scale=1] - Scale of the object.
+ * @param {Vec3 | NumberArray3} [options.translate] - Translation offset.
+ * @param {Vec4 | NumberArray4 | string} [options.color] - RGBA color or HTML color string.
+ * @param {boolean} [options.visibility=true] - Visibility flag.
  *
  * @todo: GeoObject and GeoObjectHandler provides instanced objects only.
  * It would be nice if it could provide not instanced rendering loop too.
@@ -13,23 +21,15 @@ import { RADIANS } from "../math";
 class GeoObject {
     constructor(options) {
         this._handlerIndex = -1;
-        this._tag = options.tag || "none";
-        this.instanced = true;
+        this._tag = options.tag || `tag_${GeoObject.__counter__++}`;
         this._entity = null;
         this._position = utils.createVector3(options.position);
-        this._positionHigh = new Vec3();
-        this._positionLow = new Vec3();
-        Vec3.doubleToTwoFloats(this._position, this._positionHigh, this._positionLow);
-        this._pitch = options.pitch || 0.0;
-        this._yaw = options.yaw || 0.0;
-        this._roll = options.roll || 0.0;
-        this._pitchRad = this._pitch * RADIANS;
-        this._yawRad = this._yaw * RADIANS;
-        this._rollRad = this._roll * RADIANS;
+        this._rtcPositionHigh = new Vec3();
+        this._rtcPositionLow = new Vec3();
         this._scale = utils.createVector3(options.scale, new Vec3(1, 1, 1));
         this._translate = utils.createVector3(options.translate, new Vec3());
-        this._color = utils.createColorRGBA(options.color);
-        this._qRot = Quat.IDENTITY;
+        this._localPosition = new Vec3();
+        this._color = utils.createColorRGBA(options.color, new Vec4(0.15, 0.15, 0.15, 1.0));
         this._handler = null;
         this._handlerIndex = -1;
         this._tagData = null;
@@ -43,60 +43,91 @@ class GeoObject {
             this._objectSrc = options.objSrc;
         }
         this._object3d = object3d;
-        if (options.textureSrc) {
-            this.setTextureSrc(options.textureSrc);
-        }
+        // if (options.colorTexture) {
+        //     this.setColorTexture(options.colorTexture)
+        // }
         this._visibility = (options.visibility != undefined ? options.visibility : true);
         this._children = [];
         this._direction = new Vec3();
-        this._qNorthFrame = new Quat();
+        this._qFrame = new Quat();
+        this._qRot = Quat.IDENTITY;
     }
+    /**
+     * Gets the unique tag of the geo object.
+     * @returns {string}
+     */
     get tag() {
         return this._tag;
     }
+    /**
+     * Gets the position of the geo object.
+     * @public
+     * @returns {Vec3}
+     */
     getPosition() {
         return this._position;
     }
-    getPitch() {
-        return this._pitch;
-    }
-    getYaw() {
-        return this._yaw;
-    }
-    getRoll() {
-        return this._roll;
-    }
+    /**
+     * Gets the 3D object associated with this geo object.
+     * @public
+     * @returns {Object3d}
+     */
     get object3d() {
         return this._object3d;
     }
+    /**
+     * Gets geometry mesh vertices.
+     * @public
+     * @returns {number[]}
+     */
     get vertices() {
         return this._object3d.vertices;
     }
+    /**
+     * Gets geometry mesh normals.
+     * @public
+     * @returns {number[]}
+     */
     get normals() {
         return this._object3d.normals;
     }
+    /**
+     * Gets geometry mesh texture coordinates.
+     * @public
+     * @returns {number[]}
+     */
     get texCoords() {
         return this._object3d.texCoords;
     }
+    /**
+     * Gets geometry mesh indices.
+     * @public
+     * @returns {number[]}
+     */
     get indices() {
         return this._object3d.indices;
     }
     /**
-     * Sets geo object opacity.
-     * @public
-     * @param {number} a - Billboard opacity.
+     * Sets the opacity of the geo object.
+     * @param {number} a - Opacity value (0 to 1).
      */
     setOpacity(a) {
         this._color.w = a;
         this.setColor(this._color.x, this._color.y, this._color.z, a);
     }
     /**
-     * Sets color.
-     * @public
-     * @param {number} r - Red.
-     * @param {number} g - Green.
-     * @param {number} b - Blue.
-     * @param {number} [a] - Alpha.
+     * Gets the opacity of the geo object.
+     * @returns {number}
+     */
+    getOpacity() {
+        return this._color.w;
+    }
+    /**
+     * Sets the color of the geo object.
+     * @param {number} r - Red component.
+     * @param {number} g - Green component.
+     * @param {number} b - Blue component.
+     * @param {number} [a] - Alpha component.
      */
     setColor(r, g, b, a) {
         this._color.x = r;
@@ -145,75 +176,69 @@ class GeoObject {
         this._position.x = x;
         this._position.y = y;
         this._position.z = z;
-        Vec3.doubleToTwoFloats(this._position, this._positionHigh, this._positionLow);
-        this._handler &&
-            this._handler.setPositionArr(this._tagData, this._tagDataIndex, this._positionHigh, this._positionLow);
+        this.updateRTCPosition();
         this.updateRotation();
     }
+    updateRTCPosition() {
+        //Vec3.doubleToTwoFloats(this._position, this._rtcPositionHigh, this._rtcPositionLow);
+        if (this._handler) {
+            this._handler.getRTCPosition(this._position, this._rtcPositionHigh, this._rtcPositionLow);
+            this._handler.setRTCPositionArr(this._tagData, this._tagDataIndex, this._rtcPositionHigh, this._rtcPositionLow);
+        }
+    }
     /**
      * Sets geo object position.
      * @public
      * @param {Vec3} position - Cartesian coordinates.
      */
     setPosition3v(position) {
-        this._position.x = position.x;
-        this._position.y = position.y;
-        this._position.z = position.z;
-        Vec3.doubleToTwoFloats(position, this._positionHigh, this._positionLow);
-        this._handler && this._handler.setPositionArr(this._tagData, this._tagDataIndex, this._positionHigh, this._positionLow);
-        this.updateRotation();
-    }
-    setYaw(yaw) {
-        this._yaw = yaw;
-        this._yawRad = yaw * RADIANS;
-        this.updateRotation();
+        this.setPosition(position.x, position.y, position.z);
     }
+    /**
+     * Sets Object3d for the object
+     * @param {Object3d} object
+     */
     setObject(object) {
         this._object3d = object;
     }
+    /**
+     * Sets the object url source.
+     * @param {string} src
+     */
     setObjectSrc(src) {
         this._objectSrc = src;
         this._handler && this._handler.setObjectSrc(src, this.tag);
     }
-    setTextureSrc(src) {
-        this._textureSrc = src;
-        this._object3d && (this._object3d.src = src);
-        this._handler && this._handler.setTextureTag(src, this.tag);
-    }
+    /**
+     * Sets object HTML color.
+     * @param {string} color
+     */
     setColorHTML(color) {
         this.setColor4v(utils.htmlColorToRgba(color));
     }
     /**
-     *
-     * @param {number} pitch - Pitch in radians
+     * Sets scales.
+     * @public
+     * @param {number} scale
      */
-    setPitch(pitch) {
-        this._pitch = pitch;
-        this._pitchRad = pitch * RADIANS;
-        this.updateRotation();
-    }
-    setRoll(roll) {
-        this._roll = roll;
-        this._rollRad = roll * RADIANS;
-        this.updateRotation();
-    }
-    setPitchYawRoll(pitch, yaw, roll) {
-        this._pitch = pitch;
-        this._yaw = yaw;
-        this._roll = roll;
-        this._pitchRad = pitch * RADIANS;
-        this._yawRad = yaw * RADIANS;
-        this._rollRad = roll * RADIANS;
-        this.updateRotation();
-    }
     setScale(scale) {
         this._scale.x = this._scale.y = this._scale.z = scale;
         this._handler && this._handler.setScaleArr(this._tagData, this._tagDataIndex, this._scale);
     }
+    /**
+     * Sets X, Y, Z axis scales
+     * @public
+     * @param {Vec3} scale
+     */
     setScale3v(scale) {
         this._scale.copy(scale);
         this._handler && this._handler.setScaleArr(this._tagData, this._tagDataIndex, scale);
     }
+    /**
+     * Gets scale.
+     * @publci
+     * @returns {Vec3}
+     */
     getScale() {
         return this._scale;
     }
@@ -222,10 +247,26 @@ class GeoObject {
         this._handler && this._handler.setTranslateArr(this._tagData, this._tagDataIndex, translate);
     }
     getTranslate() {
-        return this._translate;
+        return this._translate.clone();
+    }
+    /**
+     * Sets local offset position.
+     * @param {Vec3} localPosition
+     */
+    setLocalPosition3v(localPosition) {
+        this._localPosition.copy(localPosition);
+        this._handler && this._handler.setLocalPositionArr(this._tagData, this._tagDataIndex, localPosition);
+    }
+    /**
+     * Gets local offset position.
+     * @public
+     * @returns {Vec3}
+     */
+    getLocalPosition() {
+        return this._localPosition.clone();
     }
     /**
-     * Removes geo object from handler.
+     * Removes the geo object from the handler.
      * @public
      */
     remove() {
@@ -240,19 +281,38 @@ class GeoObject {
     setPickingColor3v(color) {
         this._handler && this._handler.setPickingColorArr(this._tagData, this._tagDataIndex, color);
     }
+    /**
+     * Sets the rotation quaternion.
+     * @public
+     * @param {Quat} qRot - Rotation quaternion.
+     */
+    setRotation(qRot) {
+        this._qRot.copy(qRot);
+        this._qRot.mulVec3Res(LOCAL_FORWARD, this._direction).normalize();
+        this.updateRotation();
+    }
+    /**
+     * Returns orientation quaternion.
+     * @public
+     * @returns {Quat}
+     */
+    getRotation() {
+        return this._qRot;
+    }
+    /**
+     * Update object rotation
+     */
     updateRotation() {
-        if (this._handler && this._handler._planet) {
-            this._qNorthFrame = this._handler._planet.getNorthFrameRotation(this._position);
-            let qp = Quat.xRotation(-this._pitchRad);
-            let qy = Quat.yRotation(this._yawRad);
-            let qr = Quat.zRotation(-this._rollRad);
-            this._qRot = qr.mul(qp).mul(qy).mul(this._qNorthFrame).conjugate();
-            this._direction = this._qRot.mulVec3(new Vec3(0.0, 0.0, -1.0)).normalize();
-            this._handler.setQRotArr(this._tagData, this._tagDataIndex, this._qRot);
-        }
+        this._handler && this._handler.setQRotArr(this._tagData, this._tagDataIndex, this._qRot);
     }
+    /**
+     * Returns object direction
+     * @publcu
+     * @returns {Vec3}
+     */
     getDirection() {
         return this._direction.clone();
     }
 }
+GeoObject.__counter__ = 0;
 export { GeoObject };

package/lib/js/entity/GeoObjectHandler.d.ts

@@ -1,65 +1,25 @@
-import { TypedArray } from "../utils/shared";
 import { EntityCollection } from "./EntityCollection";
 import { GeoObject } from "./GeoObject";
-import { Planet } from "../scene/Planet";
 import { Vec3 } from "../math/Vec3";
 import { Vec4 } from "../math/Vec4";
 import { Quat } from "../math/Quat";
-import { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
 import { Object3d } from "../Object3d";
-declare class InstanceData {
-    isFree: boolean;
-    _geoObjectHandler: GeoObjectHandler;
-    geoObjects: GeoObject[];
-    numInstances: number;
-    _texture: WebGLTextureExt | null;
-    _textureSrc: string | null;
-    _objectSrc?: string;
-    _sizeArr: number[] | TypedArray;
-    _translateArr: number[] | TypedArray;
-    _vertexArr: number[] | TypedArray;
-    _positionHighArr: number[] | TypedArray;
-    _positionLowArr: number[] | TypedArray;
-    _qRotArr: number[] | TypedArray;
-    _rgbaArr: number[] | TypedArray;
-    _normalsArr: number[] | TypedArray;
-    _indicesArr: number[] | TypedArray;
-    _pickingColorArr: number[] | TypedArray;
-    _visibleArr: number[] | TypedArray;
-    _texCoordArr: number[] | TypedArray;
-    _sizeBuffer: WebGLBufferExt | null;
-    _translateBuffer: WebGLBufferExt | null;
-    _vertexBuffer: WebGLBufferExt | null;
-    _positionHighBuffer: WebGLBufferExt | null;
-    _positionLowBuffer: WebGLBufferExt | null;
-    _qRotBuffer: WebGLBufferExt | null;
-    _rgbaBuffer: WebGLBufferExt | null;
-    _normalsBuffer: WebGLBufferExt | null;
-    _indicesBuffer: WebGLBufferExt | null;
-    _pickingColorBuffer: WebGLBufferExt | null;
-    _visibleBuffer: WebGLBufferExt | null;
-    _texCoordBuffer: WebGLBufferExt | null;
-    _buffersUpdateCallbacks: Function[];
-    _changedBuffers: boolean[];
-    constructor(geoObjectHandler: GeoObjectHandler);
-    createTexture(image: HTMLCanvasElement | ImageBitmap | ImageData | HTMLImageElement): void;
-    clear(): void;
-    _deleteBuffers(): void;
-    createVertexBuffer(): void;
-    createVisibleBuffer(): void;
-    createSizeBuffer(): void;
-    createTranslateBuffer(): void;
-    createTexCoordBuffer(): void;
-    createPositionBuffer(): void;
-    createRgbaBuffer(): void;
-    createQRotBuffer(): void;
-    createNormalsBuffer(): void;
-    createIndicesBuffer(): void;
-    createPickingColorBuffer(): void;
-    refresh(): void;
-    update(): void;
-}
-declare class GeoObjectHandler {
+import { InstanceData } from "./InstanceData";
+import { Renderer } from "../renderer/Renderer";
+import { RenderNode } from "../scene/RenderNode";
+export declare const VERTEX_BUFFER = 0;
+export declare const RTC_POSITION_BUFFER = 1;
+export declare const RGBA_BUFFER = 2;
+export declare const NORMALS_BUFFER = 3;
+export declare const INDEX_BUFFER = 4;
+export declare const QROT_BUFFER = 5;
+export declare const SIZE_BUFFER = 6;
+export declare const PICKINGCOLOR_BUFFER = 7;
+export declare const VISIBLE_BUFFER = 8;
+export declare const TEXCOORD_BUFFER = 9;
+export declare const TRANSLATE_BUFFER = 10;
+export declare const LOCALPOSITION_BUFFER = 11;
+export declare class GeoObjectHandler {
     static __counter__: number;
     protected __id: number;
     /**
@@ -69,37 +29,53 @@ declare class GeoObjectHandler {
      */
     pickingEnabled: boolean;
     protected _entityCollection: EntityCollection;
-    _planet: Planet | null;
+    _renderNode: RenderNode | null;
+    _renderer: Renderer | null;
     protected _geoObjects: GeoObject[];
     protected _instanceDataMap: Map<string, InstanceData>;
     protected _instanceDataMapValues: InstanceData[];
     protected _dataTagUpdateQueue: InstanceData[];
+    protected _relativeCenter: Vec3;
+    protected _rtcEyePositionHigh: Float32Array;
+    protected _rtcEyePositionLow: Float32Array;
     constructor(entityCollection: EntityCollection);
     initProgram(): void;
-    setRenderNode(renderNode: Planet): void;
-    setTextureTag(src: string, tag: string): void;
+    setRenderNode(renderNode: RenderNode): void;
+    setColorTextureTag(src: string, tag: string): void;
+    setNormalTextureTag(src: string, tag: string): void;
+    setMetallicRoughnessTextureTag(src: string, tag: string): void;
     setObjectSrc(src: string, tag: string): void;
     _updateInstanceData(object: Object3d, tag: string): void;
     protected _addGeoObjectToArray(geoObject: GeoObject): void;
-    _displayPASS(): void;
+    protected _bindCommon(): void;
+    _displayOpaquePASS(): void;
+    _displayTransparentPASS(): void;
+    protected _depthPASS(): void;
+    drawDepth(): void;
     drawPicking(): void;
     protected _pickingPASS(): void;
-    _loadDataTagTexture(tagData: InstanceData): Promise<void>;
+    _loadColorTexture(tagData: InstanceData): Promise<void>;
+    _loadNormalTexture(tagData: InstanceData): Promise<void>;
+    _loadMetallicRoughnessTexture(tagData: InstanceData): Promise<void>;
     setQRotArr(tagData: InstanceData, tagDataIndex: number, qRot: Quat): void;
     setVisibility(tagData: InstanceData, tagDataIndex: number, visibility: boolean): void;
-    setPositionArr(tagData: InstanceData, tagDataIndex: number, positionHigh: Vec3, positionLow: Vec3): void;
+    setRTCPositionArr(tagData: InstanceData, tagDataIndex: number, rtcPositionHigh: Vec3, rtcPositionLow: Vec3): void;
     setRgbaArr(tagData: InstanceData, tagDataIndex: number, rgba: Vec4): void;
     setPickingColorArr(tagData: InstanceData, tagDataIndex: number, color: Vec3): void;
     setScaleArr(tagData: InstanceData, tagDataIndex: number, scale: Vec3): void;
     setTranslateArr(tagData: InstanceData, tagDataIndex: number, translate: Vec3): void;
+    setLocalPositionArr(tagData: InstanceData, tagDataIndex: number, localPosition: Vec3): void;
     protected _updateTag(dataTag: InstanceData): void;
     update(): void;
     _removeAll(): void;
     clear(): void;
+    getRTCPosition(pos: Vec3, rtcPositionHigh: Vec3, rtcPositionLow: Vec3): void;
+    setRelativeCenter(c: Vec3): void;
+    protected _updateRTCEyePosition(): void;
     draw(): void;
+    drawTransparent(): void;
     add(geoObject: GeoObject): void;
     remove(geoObject: GeoObject): void;
     _clearDataTagQueue(): void;
     _removeGeoObject(geoObject: GeoObject): void;
 }
-export { GeoObjectHandler, InstanceData };