react-map4d-map 1.2.5 → 1.2.6

package/dist/engine/Color.d.ts

@@ -0,0 +1,34 @@
+import { Vector3 } from "./Vector3";
+export declare class Color {
+    alpha: number;
+    private _buffer;
+    /**
+     * create a color
+     */
+    constructor(red?: number, green?: number, blue?: number, alpha?: number);
+    /**
+     * get the buffer
+     */
+    rgbBuffer(): Float32Array;
+    /**
+     * get the buffer
+     */
+    buffer(): Float32Array;
+    get red(): number;
+    get green(): number;
+    get blue(): number;
+    /**
+     * string style for canvas
+     * @return {string}
+     */
+    get rgba(): string;
+    /**
+     * create color from hex string
+     */
+    static fromHex(hexString?: string): Color;
+    static fromInt(colorCode?: number): Color;
+    static fromVec3(color: Vector3): Color;
+    static mix(a: Color, b: Color, factor: number): Color;
+    get code(): string;
+    static isValid(colorString: string): boolean;
+}

package/dist/engine/Framebuffer.d.ts

@@ -0,0 +1,16 @@
+import { Texture } from "./Texture";
+export declare class FrameBuffer {
+    private gl;
+    private width;
+    private height;
+    frameBufferId: WebGLFramebuffer;
+    colorTexture: Texture;
+    depthBuffer: WebGLRenderbuffer;
+    private isReady;
+    constructor(gl: WebGLRenderingContext, width: number, height: number);
+    init(): boolean;
+    bind(): void;
+    unbind(): void;
+    drawDebug(): void;
+    destroy(): void;
+}

package/dist/engine/MathUtils.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from "./Vector2";
+export declare class MathUtils {
+    static clamp(value: number, min: number, max: number): number;
+    static toRadians(angleDegrees: number): number;
+    static distance(p1: Vector2, p2: Vector2): number;
+    static findNextPowerOf2(n: number): number;
+    static findPreviousPowerOf2(n: number): number;
+}

package/dist/engine/Matrix.d.ts

@@ -0,0 +1,115 @@
+/**
+ * the matrix class
+ */
+import { Vector3 } from "./Vector3";
+export declare class Matrix4 {
+    data: Float32Array;
+    /**
+     * create an eye 4x4 matrix
+     * @param data
+     */
+    constructor(data?: Float32Array);
+    setIdentity(x?: number, y?: number, z?: number): this;
+    copy(other: Matrix4): this;
+    /**
+     * get a translation matrix
+     * @param x
+     * @param y
+     * @param z
+     * @returns {Matrix4}
+     */
+    static translate(x: number, y: number, z?: number): Matrix4;
+    translate(x: number, y: number, z?: number): this;
+    get position(): Vector3;
+    /**
+     * get a rotation matrix around x-axis
+     * @param alpha
+     * @returns {Matrix4}
+     */
+    static rotateX(alpha: number): Matrix4;
+    setRotationX(alpha: number): this;
+    rotateX(alpha: number): this;
+    /**
+     * get a rotation matrix around y-axis
+     * @param alpha
+     * @returns {Matrix4}
+     */
+    static rotateY(alpha: number): Matrix4;
+    setRotationY(alpha: number): this;
+    rotateY(alpha: number): this;
+    /**
+     * get a rotation matrix around z-axis
+     * @param alpha
+     * @returns {Matrix4}
+     */
+    static rotateZ(alpha: number): Matrix4;
+    setRotationZ(alpha: number): this;
+    rotateZ(alpha: number): this;
+    /**
+     * get a scale matrix
+     * @param x
+     * @param y
+     * @param z
+     * @returns {Matrix4}
+     */
+    /**
+     * concatenate with other transformation matrix
+     * @param matrix
+     * @returns {Matrix4}
+     */
+    multiply(matrix: Matrix4): Matrix4;
+    /**
+     *
+     * @param left
+     * @param right
+     * @param bottom
+     * @param top
+     * @param near
+     * @param far
+     * @returns {Matrix4}
+     */
+    static ortho(left: number, right: number, bottom: number, top: number, near?: number, far?: number): Matrix4;
+    setOrtho(left: number, right: number, bottom: number, top: number, near?: number, far?: number): this;
+    /**
+     * create a perspective matrix
+     * @param fov
+     * @param aspect
+     * @param near
+     * @param far
+     * @returns {Matrix4}
+     */
+    static perspective(fov: number, aspect: number, near: number, far: number): Matrix4;
+    setPerspective(fov: number, aspect: number, near: number, far: number): void;
+    /**
+     *
+     * @param left
+     * @param right
+     * @param bottom
+     * @param top
+     * @param near
+     * @param far
+     * @returns {Matrix4}
+     */
+    static frustum(left: number, right: number, bottom: number, top: number, near?: number, far?: number): Matrix4;
+    setFrustum(left: number, right: number, bottom: number, top: number, near?: number, far?: number): void;
+    /**
+     * transform a vector
+     * @param vector
+     * @param w include transformation
+     */
+    transform(vector: Vector3, w?: number): Vector3;
+    /**
+     * get the matrix buffer
+     * @returns {number[]}
+     */
+    buffer(): Float32Array;
+    /**
+     * return look at matrix
+     * @param eye
+     * @param target
+     * @param scale
+     * @param up
+     * @returns {Matrix4}
+     */
+    inverse(): Matrix4;
+}

package/dist/engine/Model.d.ts

@@ -0,0 +1,77 @@
+import { AttributeInfo } from "./Shader";
+import { ResourceReference } from "./ResourceReference";
+import { Vector3 } from "./Vector3";
+import { Point } from "../public/Point";
+export declare class Model extends ResourceReference {
+    private gl;
+    /**
+     *
+     * @type {Array}
+     */
+    attributeInfos: AttributeInfo[];
+    /**
+     * the vertices buffer
+     */
+    arrayBuffer: WebGLBuffer;
+    /**
+     * the index buffer
+     */
+    indexBuffer: WebGLBuffer;
+    /**
+     * Number of vertices
+     */
+    numOfVertices: number;
+    highestModelPosition: Vector3;
+    private _points;
+    private _minX;
+    private _maxX;
+    private _minY;
+    private _maxY;
+    private _minZ;
+    private _maxZ;
+    /**
+     * create an model with
+     * @param gl
+     * @param type the item type
+     * @param data
+     * @param properties
+     * @param attributes
+     * @param indices the indices
+     */
+    constructor(gl: WebGLRenderingContext, data?: any[], properties?: string[], attributes?: string[], indices?: number[]);
+    init(data?: any, attributeInfos?: AttributeInfo[], indices?: number[]): void;
+    init3dObjectFormArrayBuffer(vertices?: ArrayBuffer): void;
+    init3dObject(data?: number[], indices?: number[]): void;
+    /**
+     * set indices
+     * @param indices
+     */
+    setIndices(indices: number[]): void;
+    bind(): void;
+    unbind(): void;
+    /**
+     * render this model
+     */
+    render(type: number): void;
+    renderPartial(type: number, first: number, count: number): void;
+    /**
+     * destroy the model to save memory
+     */
+    destroy(): void;
+    setHighestModelPosition(highestModelPosition: Vector3): void;
+    getHighestModelPosition(): Vector3;
+    get points(): Point[];
+    set points(value: Point[]);
+    get maxX(): number;
+    set maxX(value: number);
+    get maxY(): number;
+    set maxY(value: number);
+    get maxZ(): number;
+    set maxZ(value: number);
+    get minX(): number;
+    set minX(value: number);
+    get minY(): number;
+    set minY(value: number);
+    get minZ(): number;
+    set minZ(value: number);
+}

package/dist/engine/ResourceReference.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class ResourceReference {
+    private _reference;
+    protected constructor();
+    protected abstract destroy(): void;
+    retain(): void;
+    release(): void;
+    get reference(): number;
+}

package/dist/engine/Shader.d.ts

@@ -0,0 +1,118 @@
+/**
+ * attribute information to store
+ * data for webgl attribute
+ */
+export declare class AttributeInfo {
+    name: string;
+    size: number;
+    offset: number;
+    stride: number;
+    /**
+     * create an attribute information
+     * @param name
+     * @param size
+     * @param offset
+     * @param stride
+     */
+    constructor(name: string, size: number, offset?: number, stride?: number);
+}
+/**
+ * the shader class - for managing shader
+ */
+export declare class Shader {
+    private gl;
+    /**
+     * the program to user
+     */
+    program: WebGLProgram;
+    fragmentShader: WebGLShader;
+    vertexShader: WebGLShader;
+    /**
+     * current texture unit
+     * @type {number}
+     */
+    textureUnit: number;
+    readonly mvpMatrixUniform: WebGLUniformLocation;
+    readonly timeUniform: WebGLUniformLocation;
+    readonly enableWaterUniform: WebGLUniformLocation;
+    readonly textureUniform: WebGLUniformLocation;
+    readonly waterDisplacementUniform: WebGLUniformLocation;
+    readonly waterColorUniform: WebGLUniformLocation;
+    readonly opacityUniform: WebGLUniformLocation;
+    readonly lightColorUniform: WebGLUniformLocation;
+    readonly lightPositionUniform: WebGLUniformLocation;
+    readonly fogStartUniform: WebGLUniformLocation;
+    readonly fogRangeUniform: WebGLUniformLocation;
+    readonly fogColorUniform: WebGLUniformLocation;
+    readonly shadowMvpMatrixUniform: WebGLUniformLocation;
+    readonly shadowMapUniform: WebGLUniformLocation;
+    readonly lineWidthUniform: WebGLUniformLocation;
+    readonly colorUniform: WebGLUniformLocation;
+    readonly textureScaleUniform: WebGLUniformLocation;
+    readonly useStrokePatternUniform: WebGLUniformLocation;
+    readonly useIconUniform: WebGLUniformLocation;
+    readonly radiusUniform: WebGLUniformLocation;
+    readonly strokeColorUniform: WebGLUniformLocation;
+    readonly outerRadiusUniform: WebGLUniformLocation;
+    readonly innerRadiusUniform: WebGLUniformLocation;
+    readonly modelMatrixUniform: WebGLUniformLocation;
+    readonly cameraDirectionUniform: WebGLUniformLocation;
+    readonly lowerLimitUniform: WebGLUniformLocation;
+    readonly upperLimitUniform: WebGLUniformLocation;
+    readonly skyColorUniform: WebGLUniformLocation;
+    readonly texsizeUniform: WebGLUniformLocation;
+    readonly pixelScaleUniform: WebGLUniformLocation;
+    readonly gammaScaleUniform: WebGLUniformLocation;
+    readonly isHaloUniform: WebGLUniformLocation;
+    readonly textSizeUniform: WebGLUniformLocation;
+    readonly useMaskTextureUniform: WebGLUniformLocation;
+    readonly spriteInfoUniform: WebGLUniformLocation;
+    readonly paddingUniform: WebGLUniformLocation;
+    /**
+     * dictionary that stores all attributes
+     * @type {{}}
+     */
+    attributes: {
+        [key: string]: number;
+    };
+    /**
+     * create a shader with sources
+     * @param gl
+     * @param vertexSource
+     * @param fragmentSource
+     */
+    constructor(gl: WebGLRenderingContext, vertexSource: string, fragmentSource: string);
+    /**
+     * load all attributes of this shader
+     */
+    loadAttributes(): void;
+    /**
+     * load a shader with source
+     * @param type type of the shader | either VERTEX_SHADER or FRAGMENT_SHADER
+     * @param source
+     * @returns {WebGLShader}
+     */
+    loadShader(type: number, source: string): WebGLShader;
+    /**
+     * Bind the shader to use
+     */
+    bind(): void;
+    /**
+     * Reset texture unit
+     */
+    resetTextureUnit(): void;
+    /**
+     * Set attributes
+     * @param attributeInfos
+     */
+    setAttributes(attributeInfos: AttributeInfo[]): void;
+    setTexture(location: WebGLUniformLocation, textureId: WebGLTexture): void;
+    /**
+     * disable all attributes
+     */
+    disableAttributes(): void;
+    /**
+     * destroy this shader to release memory
+     */
+    destroy(): void;
+}

package/dist/engine/ShaderSource.d.ts

@@ -0,0 +1,42 @@
+export declare class ShaderSource {
+    static lightEffect: string;
+    static waterFragment: string;
+    static basicVS: string;
+    static basicFS: string;
+    static rasterFogVS: string;
+    static rasterFogFS: string;
+    static polylineVS: string;
+    static polylineFS: string;
+    static fillVS: string;
+    static fillFS: string;
+    static geoJsonVS: string;
+    static geoJsonFS: string;
+    static circleVS: string;
+    static circleFS: string;
+    static markerVS: string;
+    static markerFS: string;
+    static buildingVS: string;
+    static buildingFS: string;
+    static buildingSelectionVS: string;
+    static buildingSelectionFS: string;
+    static debugSelectionVS: string;
+    static debugSelectionFS: string;
+    static skyVS: string;
+    static skyFS: string;
+    static shadowMappingVS: string;
+    static shadowMappingFS: string;
+    static shadowFS: string;
+    static raster3DWithShadowVS: string;
+    static raster3DWithShadowFS: string;
+    static rasterWithShadowVS: string;
+    static rasterWithShadowFS: string;
+    static buildingWithShadowVS: string;
+    static buildingWithShadowFS: string;
+    static buildingOutliningFS: string;
+    static textLabelVS: string;
+    static textLabelFS: string;
+    static tileDebugVS: string;
+    static tileDebugFS: string;
+    static collisionDebugVS: string;
+    static collisionDebugFS: string;
+}

package/dist/engine/Texture.d.ts

@@ -0,0 +1,51 @@
+import { ResourceReference } from "./ResourceReference";
+import { Color } from "./Color";
+export declare class TextureFiltering {
+    min?: number;
+    mag?: number;
+    constructor(min: number, mag: number);
+}
+export declare class TextureWrapping {
+    wraps: number;
+    wrapt: number;
+    constructor(wraps: number, wrapt: number);
+}
+export declare class TextureOptions {
+    target: number;
+    internalFormat: number;
+    format: number;
+    type: number;
+    filtering: TextureFiltering;
+    wrapping: TextureWrapping;
+    constructor(target: number, internalFormat: number, format: number, type: number, filtering: TextureFiltering, wrapping: TextureWrapping);
+}
+/**
+ * class for managing texture 2d
+ */
+export declare class Texture extends ResourceReference {
+    private gl;
+    /**
+     * the texture Id
+     */
+    textureId: WebGLTexture;
+    options: TextureOptions;
+    width: number;
+    height: number;
+    isLoaded: boolean;
+    constructor(gl: WebGLRenderingContext, options?: TextureOptions);
+    private initDefaultTextureOptions;
+    private init;
+    bind(): void;
+    unbind(): void;
+    loadColor(color: Color): void;
+    loadImageFromArrayBuffer(data: ArrayBuffer, width: number, height: number, flip?: boolean, onLoad?: Function): void;
+    loadImage(url: string, onLoad?: Function, flip?: boolean): void;
+    loadImageDataArray(data: Uint8Array, width: number, height: number, filterParam: number, onLoad?: Function): void;
+    /**
+     * destroy the map texture
+     */
+    destroy(): void;
+    applyFilter(isGenerateMipmap?: boolean): void;
+    initFrameBufferTexture(width: number, height: number): void;
+    isPowerOf2(value: any): boolean;
+}

package/dist/engine/Vector2.d.ts

@@ -0,0 +1,82 @@
+/**
+ * class vector 2
+ */
+export declare class Vector2 {
+    x: number;
+    y: number;
+    /**
+     * create a vector 2 class
+     * @param x
+     * @param y
+     */
+    constructor(x?: number, y?: number);
+    clone(): Vector2;
+    /**
+     * get the length of the vector
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * @return {number}
+     */
+    get lengthSq(): number;
+    /**
+     * normalize the vector
+     * @returns {Vector2}
+     */
+    normalize(): Vector2;
+    /**
+     * set value of the vector
+     * @param a
+     */
+    set(a: Vector2): void;
+    /**
+     * invert the vector direction
+     * @returns {Vector2}
+     */
+    invert(): Vector2;
+    /**
+     * rotate 90
+     * @returns {Vector2}
+     */
+    rotate90(): Vector2;
+    /**
+     * add to another vector
+     * @param a
+     * @returns {Vector2}
+     */
+    add(a: Vector2): Vector2;
+    /**
+     * subtract with another vector
+     * @param a
+     * @returns {Vector2}
+     */
+    subtract(a: Vector2): Vector2;
+    /**
+     * multiply by a number
+     * @param a
+     * @returns {Vector2}
+     */
+    multiply(a: number): Vector2;
+    /**
+     * rotate by an angle
+     * @param a
+     * @returns {Vector2}
+     */
+    rotateBy(a: number): Vector2;
+    rotateByRadian(a: number): Vector2;
+    /**
+     * multiply by a vector
+     * @param a
+     * @returns {Vector2}
+     */
+    cross(a: Vector2): number;
+    /**
+     * dot a vector
+     * @param a
+     * @returns {number}
+     */
+    dot(a: Vector2): number;
+    static perp(v1: number[], v2: number[]): Vector2;
+    static neg(v: Vector2): Vector2;
+}

package/dist/engine/Vector3.d.ts

@@ -0,0 +1,84 @@
+/**
+ * class vector 3
+ */
+export declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    /**
+     * create a vector 3 class
+     * @param x
+     * @param y
+     * @param z
+     */
+    constructor(x?: number, y?: number, z?: number);
+    clone(): Vector3;
+    buffer(): Float32Array;
+    /**
+     * get the length of the vector
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * @return {number}
+     */
+    get lengthSq(): number;
+    /**
+     * normalize the vector
+     * @returns {Vector3}
+     */
+    normalize(): Vector3;
+    /**
+     * set value of the vector
+     * @param a
+     */
+    set(a: Vector3): void;
+    /**
+     * invert the vector direction
+     * @returns {Vector3}
+     */
+    invert(): Vector3;
+    /**
+     * rotate 90
+     * @returns {Vector3}
+     */
+    rotate90(): Vector3;
+    /**
+     * add to another vector
+     * @param a
+     * @returns {Vector3}
+     */
+    add(a: Vector3): Vector3;
+    /**
+     * subtract with another vector
+     * @param a
+     * @returns {Vector3}
+     */
+    subtract(a: Vector3): Vector3;
+    /**
+     * multiply by a number
+     * @param a
+     * @returns {Vector3}
+     */
+    multiply(a: number): Vector3;
+    /**
+     * rotate by an angle
+     * @param a
+     * @returns {Vector3}
+     */
+    rotateBy(a: number): Vector3;
+    /**
+     * multiply by a vector
+     * @param a
+     * @returns {Vector3}
+     */
+    cross(a: Vector3): Vector3;
+    /**
+     * dot a vector
+     * @param a
+     * @returns {number}
+     */
+    dot(a: Vector3): number;
+    static perp(v1: number[], v2: number[]): Vector3;
+    static neg(v: Vector3): Vector3;
+}

package/dist/engine/Vertex.d.ts

@@ -0,0 +1,2 @@
+export declare class Vertex<A1> {
+}

package/dist/index.d.ts

@@ -13,4 +13,6 @@ import MFPOIOverlay from './components/MFPOIOverlay';
 import MFPolygon from './components/MFPolygon';
 import MFPolyline from './components/MFPolyline';
 import MFTileOverlay from './components/MFTileOverlay';
-export { MFBuilding, MFBuildingOverlay, MFCircle, MFDataLayer, MFDirectionsRenderer, MFGroundOverlay, MFImageOverlay, MFMap, MFMarker, MFMarkerCluster, MFPOI, MFPOIOverlay, MFPolygon, MFPolyline, MFTileOverlay };
+import { CoordinateTransformer } from './ultils/CoordinateTransformer';
+import { LatLng } from './models/LatLng';
+export { MFBuilding, MFBuildingOverlay, MFCircle, MFDataLayer, MFDirectionsRenderer, MFGroundOverlay, MFImageOverlay, MFMap, MFMarker, MFMarkerCluster, MFPOI, MFPOIOverlay, MFPolygon, MFPolyline, MFTileOverlay, CoordinateTransformer, LatLng };