mx3d 0.1.6 → 0.2.0

package/App.d.ts

@@ -0,0 +1,32 @@
+import CameraController from "./tools/CameraController";
+import Environment from "./components/Environment";
+import Project from "./models/Project";
+import Resources from "./tools/Resources";
+import ToolTips from "./tools/ToolTips";
+import IEvent from "./components/Event/IEvent";
+export default class App {
+    canvas: HTMLCanvasElement;
+    engine: BABYLON.Engine;
+    scene: BABYLON.Scene;
+    CameraController: CameraController;
+    IEvent: IEvent;
+    HighlightLayer: BABYLON.HighlightLayer;
+    container: BABYLON.GUI.AdvancedDynamicTexture;
+    fps: HTMLDivElement;
+    Resources: Resources;
+    Environment: Environment;
+    Project: Project;
+    ToolTips: ToolTips;
+    constructor(_config: {
+        container: HTMLElement;
+        sl?: string;
+        rl?: string;
+    });
+    load(_config: {
+        pk: string;
+        isDefaultLevel: boolean;
+        progress: Function;
+        complete: Function;
+    }): Promise<unknown>;
+    dispose(): void;
+}

package/HubService.d.ts

@@ -0,0 +1,5 @@
+export default class HubService {
+    static connection: any;
+    static listener(_Url: string): Promise<void>;
+    static start(): Promise<void>;
+}

package/axios.d.ts

@@ -0,0 +1,2 @@
+declare const instance: import("axios").AxiosInstance;
+export default instance;

package/components/Builder.d.ts

@@ -0,0 +1,72 @@
+import IObject from "../models/IObject";
+import Capacity from "./Capacity";
+import HeatMap from "./HeatMap";
+import LineFromMesh from "./LineFromMesh";
+import Line from "./Line";
+export default class Builder {
+    static createMatrixCloud(_data: {
+        anchor: IObject;
+        value: {
+            maxX: number;
+            maxY: number;
+            data: Array<{
+                x: number;
+                y: number;
+                value: number;
+            }>;
+        };
+        displayValues: boolean;
+        height: number;
+        isLevelRender: boolean;
+        isAlpha: boolean;
+        isParticle: boolean;
+        radius: number;
+        range: {
+            max: number;
+            min: number;
+        };
+    }): HeatMap;
+    private static _getMatrixParticleTex;
+    static createPunctateCloud(_data: {
+        anchor: IObject;
+        value: number;
+        radius: number;
+        isLevelRender: boolean;
+        displayValues: boolean;
+        isAlpha: boolean;
+        isParticle: boolean;
+        range: {
+            max: number;
+            min: number;
+        };
+    }): HeatMap;
+    static createColumnCloud(_data: {
+        anchor: IObject;
+        data: Array<{
+            index: number;
+            value: number;
+        }>;
+        isLevelRender: boolean;
+        displayValues: boolean;
+        isAlpha: boolean;
+        isParticle: boolean;
+        radius: number;
+        range: {
+            max: number;
+            min: number;
+        };
+    }): HeatMap;
+    private static _getColumnarParticleTex;
+    private static createTempVlaue;
+    static createCapacity(obj: IObject, RATIO: number, _text: string, _fontSize?: string): Capacity;
+    static createTextMesh(obj: IObject, _text: string, RATIO: number, _fontSize?: string, _color?: string): BABYLON.Mesh;
+    static create2DLine(_id: string, _objs: Array<IObject>, _options?: {
+        width: number;
+        color: string;
+        isDotted: boolean;
+    }): Line;
+    static create3DLine(_id: string, _objs: Array<IObject>, _options?: {
+        width: number;
+        color: string;
+    }): LineFromMesh;
+}

package/components/Capacity.d.ts

@@ -0,0 +1,10 @@
+import IObject from "../models/IObject";
+export default class Capacity {
+    anchor: IObject;
+    mesh: BABYLON.Mesh;
+    ratio: number;
+    color: string;
+    textMesh: BABYLON.Mesh;
+    constructor(_object: IObject, RATIO: number);
+    dispose(): void;
+}

package/components/EffectMgr.d.ts

@@ -0,0 +1,11 @@
+export default class EffectMgr {
+    static colors: {
+        1: BABYLON.Color3;
+        2: BABYLON.Color3;
+        3: BABYLON.Color3;
+        4: BABYLON.Color3;
+        5: BABYLON.Color3;
+        6: BABYLON.Color3;
+    };
+    static init(): void;
+}

package/components/EffectType.d.ts

@@ -0,0 +1,5 @@
+export declare enum EffectType {
+    Opaque = 0,
+    Flash = 1,
+    Transparent = 2
+}

package/components/Environment.d.ts

@@ -0,0 +1,28 @@
+import App from "../App";
+import Dictionary from "../tools/Dictionary";
+import LightObject from "../lights/LightObject";
+export default class Environment {
+    app: App;
+    lights: Dictionary<LightObject>;
+    _color: BABYLON.Color4;
+    background: BABYLON.Layer;
+    reflexEnabled: boolean;
+    reflexIntensity: number;
+    constructor(_app: App);
+    set fogDistance(_value: number);
+    set color(_value: BABYLON.Color4);
+    reflex(url: string, intensity: number): void;
+    setBackground(url: string): void;
+    setReflexEnabled(_reflexEnabled: boolean): void;
+    setFlexIntensity(_intensity: number): void;
+    defaultLights(): void;
+    offAllLight(): void;
+    openAllLight(): void;
+    loadLight(Lights: Array<any>): void;
+    setLightIntensity(_intensity?: number): void;
+    showTips(): void;
+    closeTips(): void;
+    showFps(cssText?: string): void;
+    hideFps(): void;
+    showDebug(): void;
+}

package/components/Event/DefaultEvent.d.ts

@@ -0,0 +1,9 @@
+import App from "../../App";
+import IEvent from "./IEvent";
+export default class DefaultEvent implements IEvent {
+    app: App;
+    constructor(_app: App);
+    runRender(): void;
+    onPointer(pointerInfo: BABYLON.PointerInfo): void;
+    onKeyboard(kbInfo: BABYLON.KeyboardInfo): void;
+}

package/components/Event/FPSCameraEvent.d.ts

@@ -0,0 +1,16 @@
+import App from "../../App";
+import IEvent from "./IEvent";
+export default class FPSCameraEvent implements IEvent {
+    app: App;
+    isFPS: boolean;
+    angle: number;
+    direction: BABYLON.Vector3;
+    isMoveLeft: boolean;
+    isMoveRight: boolean;
+    isMoveDown: boolean;
+    isMoveUp: boolean;
+    constructor(_app: App);
+    runRender(): void;
+    onPointer(pointerInfo: BABYLON.PointerInfo): void;
+    onKeyboard(_e: BABYLON.KeyboardInfo): void;
+}

package/components/Event/IEvent.d.ts

@@ -0,0 +1,5 @@
+export default interface IEvent {
+    runRender(): void;
+    onPointer(e: BABYLON.PointerInfo): void;
+    onKeyboard(e: BABYLON.KeyboardInfo): void;
+}

package/components/EventType.d.ts

@@ -0,0 +1,8 @@
+export declare enum EventType {
+    leftClick = "leftClick",
+    rightClick = "rightClick",
+    doubleClick = "doubleClick",
+    eover = "eover",
+    longPress = "longPress",
+    out = "out"
+}

package/components/HeatMap.d.ts

@@ -0,0 +1,13 @@
+import BaseNode from "../tools/BaseNode";
+import IObject from "../models/IObject";
+export default class HeatMap implements BaseNode {
+    id: string;
+    anchor: IObject;
+    mesh: BABYLON.Mesh;
+    displayValue: boolean;
+    texts: Array<BABYLON.GUI.TextBlock>;
+    constructor(_anchor: IObject);
+    isEnabled(_bool: boolean): void;
+    set displayValues(_value: boolean);
+    dispose(): void;
+}

package/components/Icon.d.ts

@@ -0,0 +1,32 @@
+import BaseNode from "../tools/BaseNode";
+export default class Icon implements BaseNode {
+    id: string;
+    scene: BABYLON.Scene;
+    pint: BABYLON.Mesh;
+    private textDics;
+    private _line;
+    rect: BABYLON.GUI.Rectangle;
+    private _background;
+    size: {
+        width: number;
+        height: number;
+    };
+    height: number;
+    container: BABYLON.GUI.AdvancedDynamicTexture;
+    constructor(_id: string, _scene: BABYLON.Scene);
+    set background(_url: string);
+    addEventListener(_action: Function): void;
+    setTexts(_textArr: [{
+        text: string;
+        fontSize: string;
+        color: string;
+        top: number;
+        left: number;
+    }]): void;
+    line(_line: {
+        width: number;
+        color: string;
+    }): void;
+    dispose(): void;
+    isEnabled(_isEnabled: boolean): void;
+}

package/components/IconFromMesh.d.ts

@@ -0,0 +1,21 @@
+import BaseNode from "../tools/BaseNode";
+export default class IconFromMesh implements BaseNode {
+    id: string;
+    scene: BABYLON.Scene;
+    instance: BABYLON.Mesh;
+    url: string;
+    scaling: number;
+    constructor(_id: string, _anchor: BABYLON.Vector3, _url: string, _scaling: number, _height: number, _scene: BABYLON.Scene);
+    setBackground(): void;
+    addEventListener(_action: Function): void;
+    setColor(color: string): void;
+    setContents(_textArr: [{
+        text: string;
+        fontSize: string;
+        top: number;
+        left: number;
+        color?: string;
+    }]): void;
+    dispose(): void;
+    isEnabled(_bool: boolean): void;
+}

package/components/Line.d.ts

@@ -0,0 +1,13 @@
+import IObject from "../models/IObject";
+export default class Line {
+    id: string;
+    objs: Array<IObject>;
+    instance: BABYLON.GUI.MultiLine;
+    color: string;
+    width: number;
+    isDotted: boolean;
+    update(): void;
+    addEventListener(_action: Function): void;
+    isEnabled(_isEnabled: boolean): void;
+    dispose(): void;
+}

package/components/LineFromMesh.d.ts

@@ -0,0 +1,12 @@
+import IObject from "../models/IObject";
+export default class LineFromMesh {
+    id: string;
+    objs: Array<IObject>;
+    instance: BABYLON.Mesh;
+    color: string;
+    width: number;
+    update(): void;
+    addEventListener(_action: Function): void;
+    isEnabled(_isEnabled: boolean): void;
+    dispose(): void;
+}

package/components/UI.d.ts

@@ -0,0 +1,10 @@
+import Icon from "./Icon";
+import IconFromMesh from "./IconFromMesh";
+import IObject from "../models/IObject";
+export default class UI {
+    static createIconFromMesh(_id: string, _anchor: IObject, url: string, _scaling: number, _height: number): IconFromMesh;
+    static createIcon(_id: string, _anchor: IObject, _size: {
+        width: number;
+        height: number;
+    }, _height: number): Icon;
+}

package/lights/Directional.d.ts

@@ -0,0 +1,7 @@
+import LightObject from "./LightObject";
+export default class Directional extends LightObject {
+    direction: BABYLON.Vector3;
+    position: BABYLON.Vector3;
+    light: BABYLON.DirectionalLight;
+    load(): void;
+}

package/lights/Hemispheric.d.ts

@@ -0,0 +1,6 @@
+import LightObject from "./LightObject";
+export default class Hemispheric extends LightObject {
+    direction: BABYLON.Vector3;
+    light: BABYLON.HemisphericLight;
+    load(): void;
+}

package/lights/ILightObject.d.ts

@@ -0,0 +1,10 @@
+export default interface ILightObject {
+    id: string;
+    sceneId: string;
+    name: string;
+    light: BABYLON.Light;
+    color: string;
+    lightType: string;
+    intensity: number;
+    load: Function;
+}

package/lights/LightObject.d.ts

@@ -0,0 +1,15 @@
+import App from "../App";
+import ILightObject from "./ILightObject";
+export default class LightObject implements ILightObject {
+    id: string;
+    sceneId: string;
+    name: string;
+    light: BABYLON.Light;
+    color: string;
+    objectType: string;
+    lightType: string;
+    intensity: number;
+    app: App;
+    constructor(_app: App);
+    load(): void;
+}

package/lights/LightType.d.ts

@@ -0,0 +1,8 @@
+export declare enum LightType {
+    Point = "Point",
+    Spot = "Spot",
+    Directional = "Directional",
+    Hemispheric = "Hemispheric"
+}
+declare let typeFromat: Function;
+export default typeFromat;

package/lights/Point.d.ts

@@ -0,0 +1,7 @@
+import LightObject from "./LightObject";
+export default class Point extends LightObject {
+    position: BABYLON.Vector3;
+    light: BABYLON.PointLight;
+    range: number;
+    load(): void;
+}

package/lights/Spot.d.ts

@@ -0,0 +1,10 @@
+import LightObject from "./LightObject";
+export default class Spot extends LightObject {
+    direction: BABYLON.Vector3;
+    position: BABYLON.Vector3;
+    angle: number;
+    exponent: number;
+    range: number;
+    light: BABYLON.SpotLight;
+    load(): void;
+}

package/mapboxgl/BabylonLayer.d.ts

@@ -0,0 +1,24 @@
+import mapboxgl from "mapbox-gl";
+export default class BabylonLayer implements mapboxgl.CustomLayerInterface {
+    readonly id: string;
+    readonly type: "custom";
+    readonly renderingMode: "3d";
+    drones: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    initialCoordinates: mapboxgl.LngLatLike;
+    private map;
+    private scene;
+    private camera;
+    private modelMatrix;
+    private sceneOrigin;
+    private modelScale;
+    private modelsId;
+    private rotation;
+    constructor(id: string, _modelsId?: string, _initialCoordinates?: mapboxgl.LngLatLike, _rotation?: number);
+    recalculateProjectionMatrix(coordinates: mapboxgl.LngLatLike): void;
+    onAdd: (map: any, gl: WebGLRenderingContext) => void;
+    render: (_gl: WebGLRenderingContext, matrix: number[]) => void;
+}

package/mapboxgl/Earth.d.ts

@@ -0,0 +1,9 @@
+import mapboxgl from "mapbox-gl";
+export default class Earth {
+    initialCoordinates: any;
+    map: any;
+    constructor(_container: string, _initialCoordinates?: mapboxgl.LngLatLike);
+    load(_action: Function): void;
+    laodScene(_modelId: string, _initialCoordinates?: [], _rotation?: number): void;
+    flyTo(_center?: [], _zoom?: number, _bearing?: number, _pitch?: number, _duration?: number): void;
+}

package/models/CabinetObject.d.ts

@@ -0,0 +1,4 @@
+import DefaultObject from "./DefaultObject";
+export default class CabinetObject extends DefaultObject {
+    computeView(): void;
+}

package/models/ConduitObject.d.ts

@@ -0,0 +1,12 @@
+import DefaultObject from "./DefaultObject";
+export default class ConduitObject extends DefaultObject {
+    alpha: number;
+    color: string;
+    bind(_m: any): void;
+    setColor(r: number, b: number, g: number): void;
+    reColor(): void;
+    computeView(): void;
+    setFlash(_level?: number): void;
+    setOpaque(): void;
+    setTransparent(alpha?: number): void;
+}

package/models/CornerObject.d.ts

@@ -0,0 +1,5 @@
+import DefaultObject from "./DefaultObject";
+export default class CornerObject extends DefaultObject {
+    height: number;
+    bind(_m: any): boolean;
+}

package/models/DefaultObject.d.ts

@@ -0,0 +1,40 @@
+import App from "../App";
+import Dictionary from "../tools/Dictionary";
+import { EffectType } from "../components/EffectType";
+import IObject from "./IObject";
+import Sight from "../tools/Sight";
+export default class DefaultObject implements IObject {
+    app: App;
+    id: string;
+    name: string;
+    customNumber: string;
+    customType: string;
+    parentId: string;
+    modelId: string;
+    instance: BABYLON.Mesh | BABYLON.InstancedMesh;
+    objectType: string;
+    action: BABYLON.ActionManager;
+    executes: Dictionary<BABYLON.ExecuteCodeAction>;
+    clickEvents: Dictionary<Function>;
+    touchtime: number;
+    effectType: EffectType;
+    Sight: Sight;
+    animation: boolean;
+    isloop: boolean;
+    isAutoPlay: boolean;
+    constructor(_app: App);
+    setEnabled(_value: boolean): void;
+    set showBoundingBox(_value: boolean);
+    get showBoundingBox(): boolean;
+    bind(_m: any): void;
+    computeView(): void;
+    optimization(_isOptimization: boolean): void;
+    alwaysActive(): void;
+    addEventListener(type: string, callback: Function): void;
+    removeEventListener(type: string): void;
+    setFlash(_level: number): void;
+    setOpaque(): void;
+    setTransparent(alpha?: number): void;
+    play(): void;
+    stop(): void;
+}

package/models/DoorObject.d.ts

@@ -0,0 +1,5 @@
+import DefaultObject from "./DefaultObject";
+export default class DoorObject extends DefaultObject {
+    height: number;
+    bind(_m: any): void;
+}

package/models/FloorObject.d.ts

@@ -0,0 +1,5 @@
+import DefaultObject from "./DefaultObject";
+export default class FloorObject extends DefaultObject {
+    height: number;
+    bind(_m: any): void;
+}

package/models/IBase.d.ts

@@ -0,0 +1,8 @@
+import App from "../App";
+export default interface IBase {
+    app: App;
+    id: string;
+    name: string;
+    parentId: string;
+    objectType: string;
+}

package/models/IObject.d.ts

@@ -0,0 +1,23 @@
+import { EffectType } from "../components/EffectType";
+import IBase from "./IBase";
+import Sight from "../tools/Sight";
+export default interface IObject extends IBase {
+    customNumber: string;
+    customType: string;
+    modelId: string;
+    instance: BABYLON.Mesh | BABYLON.InstancedMesh;
+    Sight: Sight;
+    effectType: EffectType;
+    bind(_m?: any): any;
+    optimization(isOptimization: boolean): any;
+    showBoundingBox: boolean;
+    setFlash(level: number): any;
+    setTransparent(): any;
+    setOpaque(): any;
+    setEnabled(isEnabled: any): any;
+    addEventListener(type: string, callback: Function): any;
+    removeEventListener(type: string): any;
+    play(isloop: boolean): any;
+    stop(): any;
+    computeView(): any;
+}

package/models/LeakWaterObject.d.ts

@@ -0,0 +1,7 @@
+import DefaultObject from "./DefaultObject";
+export default class LeakWaterObject extends DefaultObject {
+    bind(_l: any): void;
+    computeView(): void;
+    addEventListener(type: string, callback: Function): void;
+    removeEventListener(type: string): void;
+}

package/models/ObjectType.d.ts

@@ -0,0 +1,14 @@
+export declare enum ObjectType {
+    Region = "Region",
+    Cabinet = "Cabinet",
+    Corner = "Corner",
+    Other = "Other",
+    Door = "Door",
+    Floor = "Floor",
+    LeakWater = "LeakWater",
+    UI3D = "UI3D",
+    VirtualBox = "VirtualBox",
+    Wall = "Wall",
+    Window = "Window",
+    Conduit = "Conduit"
+}

package/models/OptimizedWallObject.d.ts

@@ -0,0 +1,5 @@
+import DefaultObject from "./DefaultObject";
+export default class OptimizedWallObject extends DefaultObject {
+    nativeMaterial: BABYLON.StandardMaterial;
+    bind(_w: any): void;
+}

package/models/Project.d.ts

@@ -0,0 +1,33 @@
+import IObject from "./IObject";
+import App from "../App";
+import { ObjectType } from "./ObjectType";
+import Dictionary from "../tools/Dictionary";
+import RegionObject from "./RegionObject";
+export default class Project {
+    app: App;
+    id: string;
+    current: RegionObject;
+    root: IObject;
+    objectDatas: Dictionary<IObject>;
+    constructor(_app: App);
+    clear(): void;
+    optimization(): void;
+    getChildsById(_id?: string, _includeSub?: boolean): IObject[];
+    getSceneTree(_id?: string, _excludeTypes?: Array<string>): {
+        name: string;
+        id: string;
+        customNumber: string;
+        modelType: string;
+        customType: string;
+        children: any[];
+    };
+    findObjectById(_id: string): IObject;
+    findObjectByCustomNumber(_customNumber: string): any;
+    findObjectsByCustomType(_customType: string, queryParameters?: {
+        isCurrent: boolean;
+        isEnabled: boolean;
+    }): any[];
+    findObjectsByType(_type: ObjectType): IObject[];
+    computeSight(_objs: Array<IObject>): any;
+    switchLevel(_id?: string, _isFocus?: boolean, _includeSub?: boolean): void;
+}

package/models/RegionObject.d.ts

@@ -0,0 +1,14 @@
+import DefaultObject from './DefaultObject';
+import App from '../App';
+export default class RegionObject extends DefaultObject {
+    index: number;
+    height: number;
+    constructor(app: App, _storey: any);
+    bind(_storey: any, _isOptimized?: boolean): void;
+    computeView(): void;
+    flyTo(): void;
+    focus(): void;
+    setEnabled(_value: boolean): void;
+    getBounding(): BABYLON.BoundingInfo;
+    dispose(): void;
+}

package/models/UI3DTextObject.d.ts

@@ -0,0 +1,4 @@
+import DefaultObject from "./DefaultObject";
+export default class UI3DTextObject extends DefaultObject {
+    bind(_u: any): void;
+}

package/models/VirtualBoxObject.d.ts

@@ -0,0 +1,4 @@
+import DefaultObject from "./DefaultObject";
+export default class VirtualBoxObject extends DefaultObject {
+    bind(_m: any): Promise<void>;
+}

package/models/WallObject.d.ts

@@ -0,0 +1,7 @@
+import DefaultObject from "./DefaultObject";
+export default class WallObject extends DefaultObject {
+    nativeMaterial: BABYLON.StandardMaterial;
+    baseModel: any;
+    height: number;
+    bind(_w: any): void;
+}