@openglobus/og 0.19.4 → 0.20.0

package/lib/@openglobus/js/layer/Layer.d.ts

@@ -0,0 +1,415 @@
+import { EventsHandler } from "../Events";
+import { Extent } from "../Extent";
+import { Node } from "../quadTree/Node";
+import { Material } from "./Material";
+import { Planet } from "../scene/Planet";
+import { Segment } from "../segment/Segment";
+import { Vec3, NumberArray3 } from "../math/Vec3";
+import { NumberArray4 } from "../math/Vec4";
+import { IDefaultTextureParams } from "../webgl/Handler";
+export interface ILayerParams {
+    properties?: any;
+    labelMaxLetters?: number;
+    hideInLayerSwitcher?: boolean;
+    opacity?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    attribution?: string;
+    zIndex?: number;
+    isBaseLayer?: boolean;
+    defaultTextures?: [IDefaultTextureParams, IDefaultTextureParams];
+    visibility?: boolean;
+    fading?: boolean;
+    height?: number;
+    textureFilter?: string;
+    isSRGB?: boolean;
+    pickingEnabled?: boolean;
+    preLoadZoomLevels?: number[];
+    extent?: Extent | [[number, number], [number, number]];
+    ambient?: string | NumberArray3 | Vec3;
+    diffuse?: string | NumberArray3 | Vec3;
+    specular?: string | NumberArray3 | Vec3;
+    shininess?: number;
+    nightTextureCoefficient?: number;
+    iconSrc?: string | null;
+}
+/**
+ * @class
+ * Base class; normally only used for creating subclasses and not instantiated in apps.
+ * A visual representation of raster or vector map data well known as a layer.
+ * @class
+ * @param {String} [name="noname"] - Layer name.
+ * @param {Object} [options] - Layer options:
+ * @param {number} [options.opacity=1.0] - Layer opacity.
+ * @param {number} [options.minZoom=0] - Minimal visibility zoom level.
+ * @param {number} [options.maxZoom=0] - Maximal visibility zoom level.
+ * @param {string} [options.attribution] - Layer attribution that displayed in the attribution area on the screen.
+ * @param {boolean} [options.isBaseLayer=false] - This is a base layer.
+ * @param {boolean} [options.visibility=true] - Layer visibility.
+ * @param {boolean} [options.hideInLayerSwitcher=false] - Presence of layer in dialog window of LayerSwitcher control.
+ * @param {boolean} [options.isSRGB=false] - Layer image webgl internal format.
+ * @param {Extent} [options.extent=[[-180.0, -90.0], [180.0, 90.0]]] - Visible extent.
+ * @param {string} [options.textureFilter="anisotropic"] - Image texture filter. Available values: "nearest", "linear", "mipmap" and "anisotropic".
+ * @param {string} [options.icon] - Icon for LayerSwitcher
+ * @fires EventsHandler<LayerEventsList>#visibilitychange
+ * @fires EventsHandler<LayerEventsList>#add
+ * @fires EventsHandler<LayerEventsList>#remove
+ * @fires EventsHandler<LayerEventsList>#mousemove
+ * @fires EventsHandler<LayerEventsList>#mouseenter
+ * @fires EventsHandler<LayerEventsList>#mouseleave
+ * @fires EventsHandler<LayerEventsList>#lclick
+ * @fires EventsHandler<LayerEventsList>#rclick
+ * @fires EventsHandler<LayerEventsList>#mclick
+ * @fires EventsHandler<LayerEventsList>#ldblclick
+ * @fires EventsHandler<LayerEventsList>#rdblclick
+ * @fires EventsHandler<LayerEventsList>#mdblclick
+ * @fires EventsHandler<LayerEventsList>#lup
+ * @fires EventsHandler<LayerEventsList>#rup
+ * @fires EventsHandler<LayerEventsList>#mup
+ * @fires EventsHandler<LayerEventsList>#ldown
+ * @fires EventsHandler<LayerEventsList>#rdown
+ * @fires EventsHandler<LayerEventsList>#mdown
+ * @fires EventsHandler<LayerEventsList>#lhold
+ * @fires EventsHandler<LayerEventsList>#rhold
+ * @fires EventsHandler<LayerEventsList>#mhold
+ * @fires EventsHandler<LayerEventsList>#mousewheel
+ * @fires EventsHandler<LayerEventsList>#touchmove
+ * @fires EventsHandler<LayerEventsList>#touchstart
+ * @fires EventsHandler<LayerEventsList>#touchend
+ * @fires EventsHandler<LayerEventsList>#doubletouch
+ */
+declare class Layer {
+    static __counter__: number;
+    /**
+     * Uniq identifier.
+     * @public
+     * @type {number}
+     */
+    __id: number;
+    /**
+     * Events handler.
+     * @public
+     * @type {Events}
+     */
+    events: EventsHandler<LayerEventsList>;
+    /**
+     * Layer user name.
+     * @public
+     * @type {string}
+     */
+    name: string;
+    properties: any;
+    hideInLayerSwitcher: boolean;
+    /**
+     * Minimal zoom level when layer is visible.
+     * @public
+     * @type {number}
+     */
+    minZoom: number;
+    /**
+     * Maximal zoom level when layer is visible.
+     * @public
+     * @type {number}
+     */
+    maxZoom: number;
+    /**
+     * Planet node.
+     * @public
+     * @type {Planet}
+     */
+    _planet: Planet | null;
+    createTexture: Function | null;
+    nightTextureCoefficient: number;
+    protected _hasImageryTiles: boolean;
+    /**
+     * Layer global opacity.
+     * @public
+     * @type {number}
+     */
+    protected _opacity: number;
+    /**
+     * Layer attribution.
+     * @protected
+     * @type {string}
+     */
+    protected _attribution: string;
+    /**
+     * Layer z-index.
+     * @protected
+     * @type {number}
+     */
+    protected _zIndex: number;
+    /**
+     * Base layer type flag.
+     * @protected
+     * @type {boolean}
+     */
+    protected _isBaseLayer: boolean;
+    _defaultTextures: [IDefaultTextureParams | null, IDefaultTextureParams | null];
+    /**
+     * Layer visibility.
+     * @protected
+     * @type {boolean}
+     */
+    protected _visibility: boolean;
+    _fading: boolean;
+    protected _fadingFactor: number;
+    _fadingOpacity: number;
+    /**
+     * Height over the ground.
+     * @public
+     * @type {number}
+     */
+    _height: number;
+    protected _textureFilter: string;
+    protected _isSRGB: boolean;
+    _internalFormat: number | null;
+    /**
+     * Visible degrees extent.
+     * @public
+     * @type {Extent}
+     */
+    _extent: Extent;
+    /**
+     * Visible mercator extent.
+     * @public
+     * @type {Extent}
+     */
+    _extentMerc: Extent;
+    /**
+     * Layer picking color. Assign when added to the planet.
+     * @public
+     * @type {Vec3}
+     */
+    _pickingColor: Vec3;
+    _pickingEnabled: boolean;
+    protected _isPreloadDone: boolean;
+    protected _preLoadZoomLevels: number[];
+    _ambient: Float32Array | null;
+    _diffuse: Float32Array | null;
+    _specular: Float32Array | null;
+    isVector: boolean;
+    protected _iconSrc: string | null;
+    constructor(name?: string | null, options?: ILayerParams);
+    get iconSrc(): string | null;
+    set iconSrc(src: string | null);
+    set diffuse(rgb: string | NumberArray3 | Vec3 | null | undefined);
+    set ambient(rgb: string | NumberArray3 | Vec3 | null | undefined);
+    set specular(rgb: string | NumberArray3 | Vec3 | null | undefined);
+    set shininess(v: number);
+    static getTMS(x: number, y: number, z: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    static getTileIndex(x: number, y: number, z: number, tileGroup: number): string;
+    get instanceName(): string;
+    get rendererEvents(): EventsHandler<LayerEventsList>;
+    set opacity(opacity: number);
+    set pickingEnabled(picking: boolean);
+    get pickingEnabled(): boolean;
+    /**
+     * Returns true if a layer has imagery tiles.
+     * @public
+     * @virtual
+     * @returns {boolean} - Imagery tiles flag.
+     */
+    hasImageryTiles(): boolean;
+    /**
+     * Gets layer identifier.
+     * @public
+     * @returns {string} - Layer object id.
+     */
+    getID(): number;
+    get id(): number;
+    /**
+     * @todo: remove after all
+     */
+    get _id(): number;
+    /**
+     * Compares layers instances.
+     * @public
+     * @param {Layer} layer - Layer instance to compare.
+     * @returns {boolean} - Returns true if the layers is the same instance of the input.
+     */
+    isEqual(layer: Layer): boolean;
+    /**
+     * Assign the planet.
+     * @protected
+     * @virtual
+     * @param {Planet} planet - Planet render node.
+     */
+    _assignPlanet(planet: Planet): void;
+    get isIdle(): boolean;
+    /**
+     * Assign picking color to the layer.
+     * @protected
+     * @virtual
+     */
+    protected _bindPicking(): void;
+    /**
+     * Adds layer to the planet.
+     * @public
+     * @param {Planet} planet - Adds layer to the planet.
+     */
+    addTo(planet: Planet): void;
+    /**
+     * Removes from planet.
+     * @public
+     * @returns {Layer} -This layer.
+     */
+    remove(): this;
+    /**
+     * Clears layer material.
+     * @virtual
+     */
+    clear(): void;
+    /**
+     * Returns planet instance.
+     */
+    get planet(): Planet | null;
+    /**
+     * Sets layer attribution text.
+     * @public
+     * @param {string} html - HTML code that represents layer attribution, it could be just a text.
+     */
+    setAttribution(html: string): void;
+    /**
+     * Gets layer attribution.
+     * @public
+     * @returns {string} Layer attribution
+     */
+    getAttribution(): string;
+    /**
+     * Sets height over the ground.
+     * @public
+     * @param {number} height - Layer height.
+     */
+    setHeight(height: number): void;
+    /**
+     * Gets layer height.
+     * @public
+     * @returns {number} -
+     */
+    getHeight(): number;
+    /**
+     * Sets z-index.
+     * @public
+     * @param {number} zIndex - Layer z-index.
+     */
+    setZIndex(zIndex: number): void;
+    /**
+     * Gets z-index.
+     * @public
+     * @returns {number} -
+     */
+    getZIndex(): number;
+    /**
+     * Set zIndex to the maximal value depend on other layers on the planet.
+     * @public
+     */
+    bringToFront(): void;
+    /**
+     * Returns true if the layer is a base.
+     * @public
+     * @returns {boolean} - Base layer flag.
+     */
+    isBaseLayer(): boolean;
+    /**
+     * Sets base layer type true.
+     * @public
+     * @param {boolean} isBaseLayer -
+     */
+    setBaseLayer(isBaseLayer: boolean): void;
+    /**
+     * Sets layer visibility.
+     * @public
+     * @virtual
+     * @param {boolean} visibility - Layer visibility.
+     */
+    setVisibility(visibility: boolean): void;
+    protected _forceMaterialApply(segment: Segment): void;
+    clearMaterial(material: Material): void;
+    loadMaterial(material: Material, forceLoading?: boolean): void;
+    applyMaterial(m: Material, isForced?: boolean): NumberArray4;
+    protected _preLoadRecursive(node: Node, maxZoom: number): void;
+    protected _preLoad(): void;
+    /**
+     * Gets layer visibility.
+     * @public
+     * @returns {boolean} - Layer visibility.
+     */
+    getVisibility(): boolean;
+    /**
+     * Sets visible geographical extent.
+     * @public
+     * @param {Extent} extent - Layer visible geographical extent.
+     */
+    setExtent(extent: Extent): void;
+    /**
+     * Gets layer extent.
+     * @public
+     * @return {Extent} - Layer geodetic extent.
+     */
+    getExtent(): Extent;
+    /**
+     * Gets layer web-mercator extent.
+     * @public
+     * @return {Extent} - Layer extent.
+     */
+    getExtentMerc(): Extent;
+    /**
+     * Fly extent.
+     * @public
+     */
+    flyExtent(): void;
+    /**
+     * View extent.
+     * @public
+     */
+    viewExtent(): void;
+    /**
+     * Special correction of the whole globe extent.
+     * @protected
+     */
+    protected _correctFullExtent(): void;
+    get opacity(): number;
+    get screenOpacity(): number;
+    _refreshFadingOpacity(): boolean;
+    createMaterial(segment: Segment): Material;
+    redraw(): void;
+    abortMaterialLoading(material: Material): void;
+    abortLoading(): void;
+}
+export type LayerEventsList = [
+    "visibilitychange",
+    "add",
+    "remove",
+    "mousemove",
+    "mouseenter",
+    "mouseleave",
+    "lclick",
+    "rclick",
+    "mclick",
+    "ldblclick",
+    "rdblclick",
+    "mdblclick",
+    "lup",
+    "rup",
+    "mup",
+    "ldown",
+    "rdown",
+    "mdown",
+    "lhold",
+    "rhold",
+    "mhold",
+    "mousewheel",
+    "touchmove",
+    "touchstart",
+    "touchend",
+    "doubletouch",
+    "touchleave",
+    "touchenter"
+];
+export declare const LAYER_EVENTS: LayerEventsList;
+export { Layer };

package/lib/@openglobus/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/@openglobus/js/layer/OpenStreetMap.d.ts

@@ -0,0 +1,4 @@
+import { XYZ, IXYZParams } from "./XYZ";
+export declare class OpenStreetMap extends XYZ {
+    constructor(name: string | null, options?: IXYZParams);
+}

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

@@ -0,0 +1,246 @@
+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 = [
+    "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;
+    /**
+     * @todo: remove, or replace with node strategy
+     */
+    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 };