vis-core 0.0.1

package/dist/script.d.ts

@@ -0,0 +1,10 @@
+import Editor from './index';
+export default class {
+    editor: Editor;
+    scripts: Record<string, string | undefined>;
+    events: Record<string, Array<(this: any, ...args: any[]) => void>>;
+    constructor(editor: Editor);
+    set(uuid: string, script?: string): void;
+    load(): void;
+    dispatch(key: string): void;
+}

package/dist/utils/clipGeojson.d.ts

@@ -0,0 +1,5 @@
+export declare function clipGeojson(clipping_geojson: any, input_geojson: any): {
+    type: string;
+    features: any[];
+};
+export declare const getBoxMultiPoly: (json: any) => import("@turf/turf").Feature<import("@turf/turf").Polygon, import("@turf/turf").Properties>[];

package/dist/utils/compareVersion.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (s1: string, s2: string) => 0 | 1 | -1;
+export default _default;

package/dist/utils/e.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: string, data: string) => string;
+export default _default;

package/dist/utils/jsonFetch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (url: string) => Promise<any>;
+export default _default;

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "0.0.1";
+export default _default;

package/dist/viewport.d.ts

@@ -0,0 +1,39 @@
+import Base from "./vis/Base";
+import Editor from "./index";
+import * as THREE from 'three';
+interface BgOptions {
+    layoutWidth: number;
+    layoutHeight: number;
+    texture?: THREE.Texture;
+}
+export default class {
+    editor: Editor;
+    vis?: Base;
+    container: HTMLElement;
+    saveCamera: boolean;
+    bg: BgOptions;
+    extendsOptions: Record<string, any>;
+    delLoadObj?: Record<string, boolean>;
+    visFactoriesMap: {
+        base: typeof Base;
+    };
+    constructor(editor: Editor);
+    setSaveCamera(saveCamera: boolean): void;
+    initContainer(dom: HTMLElement): void;
+    addVis(type: string, options?: Record<string, any>): Promise<void>;
+    setVis(type: string, options?: Record<string, any>): Promise<void>;
+    initEvent(): void;
+    addObj(type: string, options?: Record<string, any>): Promise<void>;
+    removeObj(uuid: string): Promise<void>;
+    setExtendsOptions(name: string, value: any): void;
+    setBgOptions(obj: Partial<BgOptions>): void;
+    toJSON(): {
+        eo: Record<string, any>;
+        delLoadObj: string[] | undefined;
+        bg: {};
+    };
+    fromJSON(json: any): void;
+    setTransformControlsModal(modal: 'translate' | 'rotate' | 'scale'): void;
+    dispose(): void;
+}
+export {};

package/dist/vis/Base.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import Pencil, { BaseObject } from 'gl-draw';
+import MaterialList from "./all/MaterialList";
+import { Loader } from 'gl-draw/dist/plugins';
+import { Wk } from 'gl-draw/dist/plugins';
+import { Node } from 'gl-draw/dist/objects';
+import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment';
+import * as THREE from 'three';
+import { Timer } from 'esus-lite';
+export default class Base {
+    static VisName: string;
+    container: HTMLElement;
+    playing: boolean;
+    isSDK: boolean;
+    leftTruck: boolean;
+    options: Record<string, any>;
+    pencilConfig: Record<string, any>;
+    event: EventEmitter;
+    showState: boolean | 'ing';
+    settings: Record<string, any>;
+    delLoadObj?: Record<string, boolean>;
+    extendsOptions: Record<string, any>;
+    pencil: Pencil;
+    drawController: any;
+    mList: MaterialList;
+    loader: Loader;
+    worker: Wk;
+    pmremGenerator: THREE.PMREMGenerator | null;
+    re: RoomEnvironment | null;
+    roomEnvMap?: THREE.Texture;
+    visName: string;
+    checkDprTimer: Timer;
+    private eventHandlers;
+    constructor(container: HTMLElement, options?: {});
+    emit(eventName: string, ...args: any[]): void;
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    addListener(node: HTMLElement, event: string, handler: (e: MouseEvent) => void, capture?: boolean): void;
+    removeListener(targetNode: HTMLElement | '', event: string): void;
+    removeAllListeners(): void;
+    devicePixelRatio: number;
+    getDevicePixelRatio(): number;
+    init(...args: any[]): Promise<void>;
+    initPencil(): Promise<void>;
+    initPencilPlugin(): void;
+    initSettingsObj?: Record<string, any>;
+    set verticalDragToForward(value: boolean);
+    get verticalDragToForward(): boolean;
+    mouseButtonsActiveStore: Record<string, any>;
+    initSettings(): void;
+    handleSetting(key: string, value: any): Promise<any>;
+    show(): void;
+    hide(): void;
+    addCSS2D(dom: HTMLElement, options?: {
+        display?: string;
+        onTop?: number;
+    }): Promise<Node>;
+    tween(obj: any): import("@tweenjs/tween.js").Tween<any>;
+    lookAt(positionX: number, positionY: number, positionZ: number, targetX: number, targetY: number, targetZ: number, enableTransition?: boolean): void;
+    unproject(e: MouseEvent, targetZ?: number): THREE.Vector3;
+    getRoomEnvMap(): THREE.Texture;
+    handlePick(objArr: BaseObject[] | (() => BaseObject[] | BaseObject | undefined) | undefined, type: string, cb: (o: BaseObject | undefined, e: MouseEvent) => void): void;
+    getScreenPosition(x: number, y: number, z: number): {
+        x: number;
+        y: number;
+    };
+    dispose(): void;
+}

package/dist/vis/all/MaterialList.d.ts

@@ -0,0 +1,25 @@
+import * as THREE from 'three';
+import Pencil from 'gl-draw';
+export default class MaterialList {
+    pluginName: string;
+    pencil: Pencil;
+    materialList: Map<string, {
+        material: THREE.Material;
+    }>;
+    showMaterialList: Map<string, string | string[]>;
+    objectList: Map<THREE.Object3D<THREE.Object3DEventMap>, {
+        name: string;
+        meta?: any;
+    }>;
+    install(pencil: Pencil): void;
+    setMaterial(name: string, material: THREE.Material): void;
+    setMaterialObj(name: string, obj: Record<string, THREE.Material>): void;
+    getMaterial(name: string): THREE.Material | undefined;
+    getMaterialObj(name: string): Record<string, THREE.Material> | undefined;
+    getShowMaterial(name: string): THREE.Material | THREE.Material[];
+    emitObject3dChange(): void;
+    setObject3d(object3d: THREE.Object3D, name: string, meta?: any): void;
+    changeObject3dName(object3d: THREE.Object3D, name: string): void;
+    removeObject3d(object3d: THREE.Object3D): void;
+    dispose(): void;
+}

package/dist/vis/all/objects/Arc/index.d.ts

@@ -0,0 +1,33 @@
+import Pencil, { BaseObject } from 'gl-draw';
+import * as THREE from 'three';
+import { Line } from 'gl-draw/dist/objects';
+interface Options {
+    from: number[];
+    to: number[];
+    radius?: number;
+    globe?: boolean;
+    color?: string;
+    lineWidth?: number;
+    helper?: boolean;
+    offsetLoop?: boolean;
+}
+export default class extends BaseObject {
+    options: Options;
+    line: Line;
+    helperMesh?: THREE.Mesh[];
+    helperMeshPosition?: THREE.Vector3[];
+    constructor(options: Options);
+    static getInitOptions(pencil: Pencil, options: Options): {
+        from: THREE.Vector3Tuple;
+        to: THREE.Vector3Tuple;
+    };
+    create(): Promise<void>;
+    instantiate(): Promise<this>;
+    setPath(from: THREE.Vector3, to: THREE.Vector3, radius: number, setPointWidth?: (p: number) => number): void;
+    setColor(color: string): void;
+    animateIn(duration?: number): void;
+    update(): void;
+    setMList(): void;
+    render(): void;
+}
+export {};

package/dist/vis/all/objects/Arc/utils.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from 'three';
+import Pencil from 'gl-draw';
+export declare const getLineTexture: (length: number, lightColor?: string, lineColor?: string) => THREE.Texture;
+export declare const createFlyPath: (v0: THREE.Vector3, v3: THREE.Vector3, h?: number) => THREE.CubicBezierCurve3;
+export declare const createFlyPath2: (v0: THREE.Vector3, v3: THREE.Vector3, h?: number) => THREE.CubicBezierCurve3;
+export declare const pixel2unit: (pencil: Pencil, pixel: number) => number;

package/dist/vis/all/objects/Box.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Capsule.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Circle.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Cylinder.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Dodecahedron.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Icosahedron.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Lathe.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Light.d.ts

@@ -0,0 +1,18 @@
+import { BaseObject } from 'gl-draw';
+import * as THREE from 'three';
+interface LightOptions {
+    type: 'AmbientLight' | 'DirectionalLight' | 'PointLight' | 'SpotLight';
+    [key: string]: any;
+}
+export default class extends BaseObject {
+    options: LightOptions;
+    directionalLight?: THREE.DirectionalLight;
+    spotLight?: THREE.SpotLight;
+    pointLight?: THREE.PointLight;
+    hemisphereLight?: THREE.HemisphereLight;
+    constructor(options: LightOptions);
+    create(): void;
+    render(): void;
+    dispose(): void;
+}
+export {};

package/dist/vis/all/objects/Octahedron.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Plane.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Point.d.ts

@@ -0,0 +1,11 @@
+import { BaseObject } from 'gl-draw';
+interface Options {
+    sprite?: boolean;
+}
+export default class extends BaseObject {
+    options: Options;
+    constructor(options: Options);
+    create(): Promise<void>;
+    getImage(color: string): string;
+}
+export {};

package/dist/vis/all/objects/Ring.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Sphere.d.ts

@@ -0,0 +1,7 @@
+import { BaseObject } from 'gl-draw';
+import * as THREE from 'three';
+export default class extends BaseObject {
+    radius: number;
+    material?: THREE.Material;
+    create(): void;
+}

package/dist/vis/all/objects/Sprite.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Tetrahedron.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Torus.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/TorusKnot.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/Tube.d.ts

@@ -0,0 +1,4 @@
+import { BaseObject } from 'gl-draw';
+export default class extends BaseObject {
+    create(): void;
+}

package/dist/vis/all/objects/index.d.ts

@@ -0,0 +1,66 @@
+import { Draw as DrawController } from 'gl-draw/dist/plugins';
+import { Node, Image, Line, ExtrudePolygon, Group } from 'gl-draw/dist/objects';
+import Light from './Light';
+import Point from './Point';
+import Arc from './Arc';
+import Box from './Box';
+import Capsule from './Capsule';
+import Circle from './Circle';
+import Cylinder from './Cylinder';
+import Dodecahedron from './Dodecahedron';
+import Icosahedron from './Icosahedron';
+import Lathe from './Lathe';
+import Octahedron from './Octahedron';
+import Plane from './Plane';
+import Ring from './Ring';
+import Sphere from './Sphere';
+import Sprite from './Sprite';
+import Tetrahedron from './Tetrahedron';
+import Torus from './Torus';
+import TorusKnot from './TorusKnot';
+import Tube from './Tube';
+export declare const objs2: {
+    Box: typeof Box;
+    Capsule: typeof Capsule;
+    Circle: typeof Circle;
+    Cylinder: typeof Cylinder;
+    Dodecahedron: typeof Dodecahedron;
+    Icosahedron: typeof Icosahedron;
+    Lathe: typeof Lathe;
+    Octahedron: typeof Octahedron;
+    Plane: typeof Plane;
+    Ring: typeof Ring;
+    Sphere: typeof Sphere;
+    Sprite: typeof Sprite;
+    Tetrahedron: typeof Tetrahedron;
+    Torus: typeof Torus;
+    TorusKnot: typeof TorusKnot;
+    Tube: typeof Tube;
+};
+declare const d: DrawController<{
+    Box: typeof Box;
+    Capsule: typeof Capsule;
+    Circle: typeof Circle;
+    Cylinder: typeof Cylinder;
+    Dodecahedron: typeof Dodecahedron;
+    Icosahedron: typeof Icosahedron;
+    Lathe: typeof Lathe;
+    Octahedron: typeof Octahedron;
+    Plane: typeof Plane;
+    Ring: typeof Ring;
+    Sphere: typeof Sphere;
+    Sprite: typeof Sprite;
+    Tetrahedron: typeof Tetrahedron;
+    Torus: typeof Torus;
+    TorusKnot: typeof TorusKnot;
+    Tube: typeof Tube;
+    Node: typeof Node;
+    Image: typeof Image;
+    Line: typeof Line;
+    ExtrudePolygon: typeof ExtrudePolygon;
+    Group: typeof Group;
+    Light: typeof Light;
+    Point: typeof Point;
+    Arc: typeof Arc;
+}>;
+export default d;

package/dist/vis/city/config.d.ts

@@ -0,0 +1,22 @@
+export declare const IS_DEV: boolean;
+import * as THREE from 'three';
+export declare const PENCIL_CONFIG: {
+    camera: {
+        near: number;
+        far: number;
+        fov: number;
+        up: THREE.Vector3;
+    };
+    bloom: boolean;
+    bloomParams: {
+        intensity: number;
+        mipmapBlurPassRadius: number;
+        luminancePass: boolean;
+        luminanceThreshold: number;
+        luminanceSmoothing: number;
+    };
+    scene: {
+        om: boolean;
+    };
+};
+export declare const cacheVersion: string | undefined;

package/dist/vis/city/index.d.ts

@@ -0,0 +1,102 @@
+import { BaseObject } from 'gl-draw';
+import Base from "../Base";
+import * as THREE from 'three';
+import { getProjection } from 'gl-draw/dist/utils';
+import { Group } from "./objects";
+interface CityOptions {
+    adcode: number;
+    jsonName: string;
+    cacheKey?: string;
+    center?: [number, number];
+    bbox?: [number, number, number, number];
+    fitTo?: boolean;
+    loaderAdd?: boolean;
+    coordtransformFunc?: (lng: number, lat: number) => {
+        longitude: number;
+        latitude: number;
+    };
+    plane?: boolean;
+    grey?: boolean;
+    clip?: {
+        features: any[];
+    };
+    clipOutShow?: boolean;
+    planeOut?: boolean;
+    assetsPrefix?: string;
+}
+export default class extends Base {
+    static VisName: string;
+    drawController: import("gl-draw/dist/plugins").Draw<{
+        Node: typeof import("gl-draw/dist/objects").Node;
+        Image: typeof import("gl-draw/dist/objects").Image;
+        Line: typeof import("./objects").Line;
+        ExtrudePolygon: typeof import("./objects").ExtrudePolygon;
+        Building: typeof import("./objects/building").default;
+        Road: typeof import("./objects/road").default;
+        Area: typeof import("./objects/area").default;
+        Video: typeof import("gl-draw/dist/objects").Video;
+        Group: typeof Group;
+        Light: typeof import("../map/objects").Light;
+        Plane: typeof import("./objects/plane").default;
+        Target: typeof import("./objects/target").default;
+    }>;
+    adcode: number;
+    pcenter: [number, number];
+    pscale: number;
+    projection: ReturnType<typeof getProjection>;
+    options: CityOptions;
+    group: Group;
+    building: any;
+    outAreaGroup: Group;
+    constructor(container: HTMLElement, options?: CityOptions);
+    multiplyScalar: number;
+    loaderAdd(): void;
+    loaderAddJson(jsonName: string): void;
+    initMaterial(): Promise<void>;
+    init(): Promise<void>;
+    getInvert(vector3: THREE.Vector3): any;
+    fitTo(obj: BaseObject, enableTransition?: boolean): Promise<void>;
+    initCity(): Promise<void>;
+    fitToTarget(adcode: number, lnglat?: [number, number]): Promise<void>;
+    lookAtTarget(pos: THREE.Vector3, distance: number, polarAngle: number, azimuthAngle?: number): Promise<void>;
+    drawBuilding(options?: {
+        json?: {
+            features: any[];
+        };
+        meters?: number;
+        clip?: {
+            features: any[];
+        };
+        grey?: boolean;
+        group?: Group;
+    }): Promise<import("./objects/building").default | undefined>;
+    drawArea(options?: {
+        json?: {
+            features: any[];
+        };
+        type?: 'river' | 'grassland';
+        oArr?: number[];
+        clip?: {
+            features: any[];
+        };
+        grey?: boolean;
+        group?: Group;
+    }): Promise<import("./objects/area").default | undefined>;
+    drawRoad(options?: {
+        json?: {
+            features: any[];
+        };
+        meters?: number;
+        z?: number;
+        clip?: {
+            features: any[];
+        };
+        grey?: boolean;
+        group?: Group;
+    }): Promise<import("./objects/road").default | undefined>;
+    getWorldPosition(longitude: number, latitude: number): {
+        x: any;
+        y: number;
+    };
+}
+export {};

package/dist/vis/city/objects/area/index.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+import { BaseObject } from 'gl-draw';
+import { ExtrudePolygon } from '..';
+interface Options {
+    json: {
+        features: any[];
+    };
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    material: THREE.Material;
+    type: string;
+    cacheKey?: string;
+    oArr?: number[];
+    clip?: {
+        features: any[];
+    };
+}
+export default class extends BaseObject {
+    options: Options;
+    area: ExtrudePolygon[];
+    constructor(options: Options);
+    outJson: Map<any, any>;
+    create(): Promise<void>;
+    dispose(disposeWithMaterial?: boolean): void;
+}
+export {};

package/dist/vis/city/objects/building/index.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+import { BaseObject } from 'gl-draw';
+import { ExtrudePolygon } from '..';
+interface Options {
+    json: {
+        features: any[];
+    };
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    cacheKey?: string;
+    material?: THREE.Material | THREE.Material[];
+    meters?: number;
+    envMap?: THREE.Texture;
+    grey?: boolean;
+    clip?: {
+        features: any[];
+    };
+}
+export default class extends BaseObject {
+    options: Options;
+    constructor(options: Options);
+    building: Record<string, ExtrudePolygon[]>;
+    outJson: Map<any, any>;
+    create(): Promise<void>;
+    dispose(disposeWithMaterial?: boolean): void;
+}
+export {};

package/dist/vis/city/objects/index.d.ts

@@ -0,0 +1,38 @@
+import { Draw as DrawController } from 'gl-draw/dist/plugins';
+import { Node, Image, Line, ExtrudePolygon, Group, Video } from 'gl-draw/dist/objects';
+import Light from "../../all/objects/Light";
+import Building from './building';
+import Road from './road';
+import Area from './area';
+import Plane from './plane';
+import Target from './target';
+export { Line, ExtrudePolygon, Group } from 'gl-draw/dist/objects';
+export declare const objs: {
+    Node: typeof Node;
+    Image: typeof Image;
+    Line: typeof Line;
+    ExtrudePolygon: typeof ExtrudePolygon;
+    Building: typeof Building;
+    Road: typeof Road;
+    Area: typeof Area;
+    Video: typeof Video;
+    Group: typeof Group;
+    Light: typeof Light;
+    Plane: typeof Plane;
+    Target: typeof Target;
+};
+declare const _default: DrawController<{
+    Node: typeof Node;
+    Image: typeof Image;
+    Line: typeof Line;
+    ExtrudePolygon: typeof ExtrudePolygon;
+    Building: typeof Building;
+    Road: typeof Road;
+    Area: typeof Area;
+    Video: typeof Video;
+    Group: typeof Group;
+    Light: typeof Light;
+    Plane: typeof Plane;
+    Target: typeof Target;
+}>;
+export default _default;