@openglobus/og 0.17.2 → 0.18.1

package/lib/js/layer/Material.d.ts

@@ -0,0 +1,34 @@
+import { Layer } from "./Layer";
+import { Node } from "../quadTree/Node";
+import { Segment } from "../segment/Segment";
+import { WebGLTextureExt } from "../webgl/Handler";
+import { NumberArray4 } from "../math/Vec4";
+/**
+ * @class Material
+ * @param {Segment} segment
+ * @param {Layer} layer
+ */
+declare class Material {
+    segment: Segment;
+    layer: Layer;
+    isReady: boolean;
+    isLoading: boolean;
+    texture: WebGLTextureExt | null;
+    pickingMask: WebGLTextureExt | null;
+    textureExists: boolean;
+    appliedNodeId: number;
+    appliedNode: Node | null;
+    texOffset: NumberArray4;
+    loadingAttempts: number;
+    _updateTexture: WebGLTextureExt | null;
+    _updatePickingMask: WebGLTextureExt | null;
+    pickingReady: boolean;
+    constructor(segment: Segment, layer: Layer);
+    abortLoading(): void;
+    _createTexture(img: HTMLCanvasElement | ImageBitmap | HTMLImageElement): any;
+    applyImage(img: HTMLCanvasElement | ImageBitmap | HTMLImageElement): void;
+    applyTexture(texture: WebGLTextureExt | null, pickingMask?: WebGLTextureExt | null): void;
+    textureNotExists(): void;
+    clear(): void;
+}
+export { Material };

package/lib/js/layer/Material.js

@@ -0,0 +1,69 @@
+/**
+ * @class Material
+ * @param {Segment} segment
+ * @param {Layer} layer
+ */
+class Material {
+    constructor(segment, layer) {
+        this.segment = segment;
+        this.layer = layer;
+        this.isReady = false;
+        this.isLoading = false;
+        this.texture = null;
+        this.pickingMask = null;
+        this.textureExists = false;
+        this.appliedNodeId = 0;
+        this.appliedNode = null;
+        this.texOffset = [0.0, 0.0, 1.0, 1.0];
+        this.loadingAttempts = 0;
+        this._updateTexture = null;
+        this._updatePickingMask = null;
+        this.pickingReady = false;
+    }
+    abortLoading() {
+        this.layer.abortMaterialLoading(this);
+    }
+    _createTexture(img) {
+        return this.layer._planet && this.layer.createTexture(img, this.layer._internalFormat, this.isReady ? this.texture : null);
+    }
+    applyImage(img) {
+        if (this.segment.initialized) {
+            this._updateTexture = null;
+            //this.image = img;
+            this.texture = this._createTexture(img);
+            this.isReady = true;
+            this.pickingReady = true;
+            this.textureExists = true;
+            this.isLoading = false;
+            this.appliedNodeId = this.segment.node.nodeId;
+            this.texOffset = [0.0, 0.0, 1.0, 1.0];
+        }
+    }
+    applyTexture(texture, pickingMask) {
+        if (this.segment.initialized) {
+            this.texture = texture;
+            this._updateTexture = null;
+            this.pickingMask = pickingMask || null;
+            this._updatePickingMask = null;
+            this.isReady = true;
+            this.pickingReady = true;
+            this.textureExists = true;
+            this.isLoading = false;
+            this.appliedNodeId = this.segment.node.nodeId;
+            this.texOffset = [0.0, 0.0, 1.0, 1.0];
+        }
+    }
+    textureNotExists() {
+        if (this.segment.initialized) {
+            this.pickingReady = true;
+            this.isLoading = false;
+            this.isReady = true;
+            this.textureExists = false;
+        }
+    }
+    clear() {
+        this.loadingAttempts = 0;
+        this.layer.clearMaterial(this);
+    }
+}
+export { Material };

package/lib/js/layer/Vector.d.ts

@@ -0,0 +1,244 @@
+import { Entity, IEntityParams } from "../entity/Entity";
+import { EntityCollection } from "../entity/EntityCollection";
+import { EntityCollectionNode, EntityCollectionNodeWGS84 } from "../quadTree/EntityCollectionNode";
+import { EventsHandler } from "../Events";
+import { GeometryHandler } from "../entity/GeometryHandler";
+import { ILayerParams, Layer, LayerEventsList } from "./Layer";
+import { NumberArray3 } from "../math/Vec3";
+import { Planet } from "../scene/Planet";
+import { QueueArray } from "../QueueArray";
+import { Material } from "./Material";
+import { NumberArray4 } from "../math/Vec4";
+export interface IVectorParams extends ILayerParams {
+    entities?: Entity[] | IEntityParams[];
+    polygonOffsetUnits?: number;
+    nodeCapacity?: number;
+    relativeToGround?: boolean;
+    clampToGround?: boolean;
+    async?: boolean;
+    pickingScale?: number;
+    scaleByDistance?: NumberArray3;
+    labelMaxLetters?: number;
+}
+type VectorEventsList = [
+    "entitymove",
+    "draw",
+    "entityadd",
+    "entityremove"
+];
+export type VectorEventsType = EventsHandler<VectorEventsList> & EventsHandler<LayerEventsList>;
+/**
+ * Vector layer represents alternative entities store. Used for geospatial data rendering like
+ * points, lines, polygons, geometry objects etc.
+ * @class
+ * @extends {Layer}
+ * @param {string} [name="noname"] - Layer name.
+ * @param {IVectorParams} [options] - Layer options:
+ * @param {number} [options.minZoom=0] - Minimal visible zoom. 0 is default
+ * @param {number} [options.maxZoom=50] - Maximal visible zoom. 50 is default.
+ * @param {string} [options.attribution] - Layer attribution.
+ * @param {string} [options.zIndex=0] - Layer Z-order index. 0 is default.
+ * @param {boolean} [options.visibility=true] - Layer visibility. True is default.
+ * @param {boolean} [options.isBaseLayer=false] - Layer base layer. False is default.
+ * @param {Array.<Entity>} [options.entities] - Entities array.
+ * @param {Array.<number>} [options.scaleByDistance] - Scale by distance parameters. (exactly 3 entries)
+ *      First index - near distance to the entity, after entity becomes full scale.
+ *      Second index - far distance to the entity, when entity becomes zero scale.
+ *      Third index - far distance to the entity, when entity becomes invisible.
+ * @param {number} [options.nodeCapacity=30] - Maximum entities quantity in the tree node. Rendering optimization parameter. 30 is default.
+ * @param {boolean} [options.async=true] - Asynchronous vector data handling before rendering. True for optimization huge data.
+ * @param {boolean} [options.clampToGround = false] - Clamp vector data to the ground.
+ * @param {boolean} [options.relativeToGround = false] - Place vector data relative to the ground relief.
+ * @param {Number} [options.polygonOffsetUnits=0.0] - The multiplier by which an implementation-specific value is multiplied with to create a constant depth offset.
+ *
+ * @fires EventsHandler<VectorEventsList>#entitymove
+ * @fires EventsHandler<VectorEventsList>#draw
+ * @fires EventsHandler<VectorEventsList>#add
+ * @fires EventsHandler<VectorEventsList>#remove
+ * @fires EventsHandler<VectorEventsList>#entityadd
+ * @fires EventsHandler<VectorEventsList>#entityremove
+ * @fires EventsHandler<VectorEventsList>#visibilitychange
+ */
+declare class Vector extends Layer {
+    events: VectorEventsType;
+    /**
+     * Entities collection.
+     * @protected
+     */
+    protected _entities: Entity[];
+    /**
+     * First index - near distance to the entity, after that entity becomes full scale.
+     * Second index - far distance to the entity, when entity becomes zero scale.
+     * Third index - far distance to the entity, when entity becomes invisible.
+     * @public
+     * @type {NumberArray3} - (exactly 3 entries)
+     */
+    scaleByDistance: NumberArray3;
+    pickingScale: number;
+    /**
+     * Asynchronous data handling before rendering.
+     * @public
+     * @type {boolean}
+     */
+    async: boolean;
+    /**
+     * Clamp vector data to the ground.
+     * @public
+     * @type {boolean}
+     */
+    clampToGround: boolean;
+    /**
+     * Sets vector data relative to the ground relief.
+     * @public
+     * @type {boolean}
+     */
+    relativeToGround: boolean;
+    protected _stripEntityCollection: EntityCollection;
+    protected _polylineEntityCollection: EntityCollection;
+    protected _geoObjectEntityCollection: EntityCollection;
+    _geometryHandler: GeometryHandler;
+    /**
+     * Maximum entities quantity in the tree node.
+     * @public
+     */
+    _nodeCapacity: number;
+    protected _entityCollectionsTree: EntityCollectionNode | null;
+    protected _entityCollectionsTreeNorth: EntityCollectionNodeWGS84 | null;
+    protected _entityCollectionsTreeSouth: EntityCollectionNodeWGS84 | null;
+    _renderingNodes: Record<number, boolean>;
+    _renderingNodesNorth: Record<number, boolean>;
+    _renderingNodesSouth: Record<number, boolean>;
+    protected _counter: number;
+    protected _deferredEntitiesPendingQueue: QueueArray<EntityCollectionNode>;
+    protected _pendingsQueue: Entity[];
+    /**
+     * Specifies the scale Units for gl.polygonOffset function to calculate depth values, 0.0 is default.
+     * @public
+     * @type {Number}
+     */
+    polygonOffsetUnits: number;
+    _secondPASS: EntityCollectionNode[];
+    protected _labelMaxLetters: number;
+    constructor(name?: string | null, options?: IVectorParams);
+    get labelMaxLetters(): number;
+    get instanceName(): string;
+    protected _bindPicking(): void;
+    /**
+     * Adds layer to the planet.
+     * @public
+     * @param {Planet} planet - Planet scene object.
+     * @returns {Vector} -
+     */
+    addTo(planet: Planet): void;
+    remove(): this;
+    /**
+     * Returns stored entities.
+     * @public
+     * @returns {Array.<Entity>} -
+     */
+    getEntities(): Entity[];
+    /**
+     * Adds entity to the layer.
+     * @public
+     * @param {Entity} entity - Entity.
+     * @param {boolean} [rightNow=false] - Entity insertion option. False is default.
+     * @returns {Vector} - Returns this layer.
+     */
+    add(entity: Entity, rightNow?: boolean): this;
+    /**
+     * Adds entity to the layer in the index position.
+     * @public
+     * @param {Entity} entity - Entity.
+     * @param {Number} index - Index position.
+     * @param {boolean} [rightNow] - Entity insertion option. False is default.
+     * @returns {Vector} - Returns this layer.
+     */
+    insert(entity: Entity, index: number, rightNow?: boolean): this;
+    protected _proceedEntity(entity: Entity, rightNow?: boolean): void;
+    /**
+     * Adds entity array to the layer.
+     * @public
+     * @param {Array.<Entity>} entities - Entities array.
+     * @param {boolean} [rightNow=false] - Entity insertion option. False is default.
+     * @returns {Vector} - Returns this layer.
+     */
+    addEntities(entities: Entity[], rightNow?: boolean): this;
+    /**
+     * Remove entity from layer.
+     * TODO: memory leaks.
+     * @public
+     * @param {Entity} entity - Entity to remove.
+     * @returns {Vector} - Returns this layer.
+     */
+    removeEntity(entity: Entity): this;
+    /**
+     * Set layer picking events active.
+     * @public
+     * @param {boolean} picking - Picking enable flag.
+     */
+    set pickingEnabled(picking: boolean);
+    /**
+     * Refresh collected entities indexes from startIndex entities collection array position.
+     * @protected
+     * @param {number} startIndex - Entity array index.
+     */
+    protected _reindexEntitiesArray(startIndex: number): void;
+    /**
+     * Removes entities from layer.
+     * @public
+     * @param {Array.<Entity>} entities - Entity array.
+     * @returns {Vector} - Returns this layer.
+     */
+    removeEntities(entities: Entity[]): this;
+    /**
+     * TODO: Clear the layer.
+     * @public
+     */
+    clear(): void;
+    /**
+     * Safety entities loop.
+     * @public
+     * @param {(entity: Entity, index?: number) => void} callback - Entity callback.
+     */
+    each(callback: (entity: Entity, index?: number) => void): void;
+    /**
+     * Removes current entities from layer and adds new entities.
+     * @public
+     * @param {Array.<Entity>} entities - New entity array.
+     * @returns {Vector} - Returns layer instance.
+     */
+    setEntities(entities: Entity[]): this;
+    /**
+     * @todo: replace to a strategy node collecting algorithm
+     */
+    protected _createEntityCollectionsTree(entitiesForTree: Entity[]): void;
+    /**
+     * @todo (refactoring) could be used in somethig like bindEntityCollectionQuad(...)
+     * @param entityCollection
+     */
+    _bindEventsDefault(entityCollection: EntityCollection): void;
+    protected _collectStripCollectionPASS(outArr: EntityCollection[]): void;
+    protected _collectPolylineCollectionPASS(outArr: EntityCollection[]): void;
+    protected _collectGeoObjectCollectionPASS(outArr: EntityCollection[]): void;
+    collectVisibleCollections(outArr: EntityCollection[]): void;
+    _queueDeferredNode(node: EntityCollectionNode): void;
+    protected _execDeferredNode(node: EntityCollectionNode): void;
+    /**
+     * Start to load tile material.
+     * @public
+     * @virtual
+     * @param {Material} material - Current material.
+     */
+    loadMaterial(material: Material): void;
+    /**
+     * Abort exact material loading.
+     * @public
+     * @override
+     * @param {Material} material - Segment material.
+     */
+    abortMaterialLoading(material: Material): void;
+    applyMaterial(material: Material, isForced?: boolean): NumberArray4;
+    clearMaterial(material: Material): void;
+    update(): void;
+}
+export { Vector };