mx3d 0.1.1 → 0.1.4

package/index.d.ts

@@ -2,128 +2,128 @@
 @author gzmaijing 
 @email mj@gzmaijing.com
 */
-declare module MX3D{
-export  class App {
+declare module MX3D {
+  export class App {
     canvas: HTMLCanvasElement;
-    engine: BABYLON.Engine;
-    scene: BABYLON.Scene;
+    engine: any;
+    scene: any;
     CameraController: CameraController;
-    HighlightLayer: BABYLON.HighlightLayer;
-    container: BABYLON.GUI.AdvancedDynamicTexture;
+    HighlightLayer: any;
+    container: any;
     fps: HTMLDivElement;
     Resources: Resources;
     Environment: Environment;
     Project: Project;
     ToolTips: ToolTips;
     constructor(_config: {
-        container: HTMLElement;
-        sl?: string;
-        rl?: string;
+      container: HTMLElement;
+      sl?: string;
+      rl?: string;
     });
     load(_config: {
-        pk: string;
-        progress?: Function;
-        complete?: Function;
+      pk: string;
+      progress?: Function;
+      complete?: Function;
     }): Promise<void>;
     dispose(): void;
-}
+  }
 
-export  class Builder {
+  export class Builder {
     static createCapacity(_obj: IObject, _RATIO: number, _text: string, _fontSize?: string): void;
     static createTextMesh(_obj: IObject, _text: string, _RATIO: number, _fontSize?: string, _color?: string): void;
     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;
-        };
+      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;
+      };
     }): void;
     static createPunctateCloud(_data: {
-        anchor: IObject;
-        value: number;
-        radius: number;
-        isLevelRender: boolean;
-        displayValues: boolean;
-        isAlpha: boolean;
-        isParticle: boolean;
-        range: {
-            max: number;
-            min: number;
-        };
+      anchor: IObject;
+      value: number;
+      radius: number;
+      isLevelRender: boolean;
+      displayValues: boolean;
+      isAlpha: boolean;
+      isParticle: boolean;
+      range: {
+        max: number;
+        min: number;
+      };
     }): void;
     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;
-        };
+      anchor: IObject;
+      data: Array<{
+        index: number;
+        value: number;
+      }>;
+      isLevelRender: boolean;
+      displayValues: boolean;
+      isAlpha: boolean;
+      isParticle: boolean;
+      radius: number;
+      range: {
+        max: number;
+        min: number;
+      };
     }): void;
     static create2DLine(_id: string, _objs: Array<IObject>, _options?: {
-        _width: number;
-        _color: string;
-        isDotted: boolean;
+      _width: number;
+      _color: string;
+      isDotted: boolean;
     }): void;
     static create3DLine(_id: string, _objs: Array<IObject>, _options?: {
-        _width: number;
-        _color: string;
+      _width: number;
+      _color: string;
     }): void;
-}
+  }
 
-export  class Capacity {
+  export class Capacity {
     anchor: IObject;
-    mesh: BABYLON.Mesh;
+    mesh: any;
     ratio: number;
     color: string;
-    textMesh: BABYLON.Mesh;
+    textMesh: any;
     constructor(_object: IObject, _RATIO: number);
     dispose(): void;
-}
+  }
 
-export  class EffectMgr {
+  export class EffectMgr {
     static colors: {};
     static init(): void;
-}
+  }
 
-export enum EffectType {
+  export enum EffectType {
     Opaque = 0,
     Flash = 1,
     Transparent = 2
-}
+  }
 
-export  class Environment {
+  export class Environment {
     app: App;
     lights: any;
-    _color: BABYLON.Color4;
-    background: BABYLON.Layer;
+    _color: any;
+    background: any;
     reflexEnabled: boolean;
     reflexIntensity: number;
     constructor(_app: App);
     set fogDistance(_value: number);
-    set color(_value: BABYLON.Color4);
+    set color(_value: any);
     reflex(_url: string, _intensity: number): void;
     setBackground(_url: string): void;
     setReflexEnabled(_reflexEnabled: boolean): void;
@@ -138,150 +138,150 @@ export  class Environment {
     hideFps(): void;
     showDebug(): void;
     setLightIntensity(_intensity?: number): void;
-}
+  }
 
-export  class DefaultEvent implements IEvent {
+  export class DefaultEvent implements IEvent {
     app: App;
     runRender(): void;
-    onPointer(_pointerInfo: BABYLON.PointerInfo): void;
-    onKeyboard(_kbInfo: BABYLON.KeyboardInfo): void;
-}
+    onPointer(_pointerInfo: any): void;
+    onKeyboard(_kbInfo: any): void;
+  }
 
-export  class FPSCameraEvent implements IEvent {
+  export class FPSCameraEvent implements IEvent {
     app: App;
     isFPS: boolean;
     angle: number;
-    direction: BABYLON.Vector3;
+    direction: any;
     isMoveLeft: boolean;
     isMoveRight: boolean;
     isMoveDown: boolean;
     isMoveUp: boolean;
     runRender(): void;
-    onPointer(_pointerInfo: BABYLON.PointerInfo): void;
-    onKeyboard(_e: BABYLON.KeyboardInfo): void;
-}
+    onPointer(_pointerInfo: any): void;
+    onKeyboard(_e: any): void;
+  }
 
-export  interface IEvent {
+  export interface IEvent {
     runRender(): void;
-    onPointer(e: BABYLON.PointerInfo): void;
-    onKeyboard(e: BABYLON.KeyboardInfo): void;
-}
+    onPointer(e: any): void;
+    onKeyboard(e: any): void;
+  }
 
-export enum EventType {
+  export enum EventType {
     leftClick = "leftClick",
     rightClick = "rightClick",
     doubleClick = "doubleClick",
     eover = "eover",
     longPress = "longPress",
     out = "out"
-}
+  }
 
-export  class HeatMap implements BaseNode {
+  export class HeatMap implements BaseNode {
     id: string;
     anchor: IObject;
-    mesh: BABYLON.Mesh;
+    mesh: any;
     displayValue: boolean;
-    texts: Array<BABYLON.GUI.TextBlock>;
+    texts: Array<any>;
     constructor(_anchor: string);
     isEnabled(_bool: boolean): void;
     set displayValues(_value: boolean);
     dispose(): void;
-}
+  }
 
-export  class Icon implements BaseNode {
+  export class Icon implements BaseNode {
     id: string;
-    scene: BABYLON.Scene;
-    pint: BABYLON.Mesh;
-    rect: BABYLON.GUI.Rectangle;
+    scene: any;
+    pint: any;
+    rect: any;
     onPointerClick: Function;
     size: {
-        width: number;
-        height: number;
+      width: number;
+      height: number;
     };
     height: number;
-    container: BABYLON.GUI.AdvancedDynamicTexture;
-    constructor(_id: string, _scene: BABYLON.Scene);
+    container: any;
+    constructor(_id: string, _scene: any);
     set background(_url: string);
     addEventListener(_action: Function): void;
     setTexts(_textArr: [{
-        text: string;
-        fontSize: string;
-        color: string;
-        top: number;
-        left: number;
+      text: string;
+      fontSize: string;
+      color: string;
+      top: number;
+      left: number;
     }]): void;
     line(_line: {
-        width: number;
-        color: string;
+      width: number;
+      color: string;
     }): void;
     dispose(): void;
     isEnabled(_isEnabled: boolean): void;
-}
+  }
 
-export  class IconFromMesh implements BaseNode {
+  export class IconFromMesh implements BaseNode {
     id: string;
-    scene: BABYLON.Scene;
-    instance: BABYLON.Mesh;
+    scene: any;
+    instance: any;
     url: string;
     scaling: number;
-    constructor(_id: string, _anchor: BABYLON.Vector3, _url: string, _scaling: number, _height: number, _scene: BABYLON.Scene);
+    constructor(_id: string, _anchor: any, _url: string, _scaling: number, _height: number, _scene: any);
     setBackground(): void;
     addEventListener(_action: Function): void;
     setColor(_color: string): void;
     setContents(_textArr: [{
-        text: string;
-        fontSize: string;
-        top: number;
-        left: number;
-        color?: string;
+      text: string;
+      fontSize: string;
+      top: number;
+      left: number;
+      color?: string;
     }]): void;
     dispose(): void;
     isEnabled(_bool: boolean): void;
-}
+  }
 
-export  class UI {
+  export class UI {
     static createIconFromMesh(_id: string, _anchor: IObject, _url: string, _scaling: number, _height: number): void;
     static createIcon(_id: string, _anchor: IObject, _size: {
-        width: number;
-        height: number;
+      width: number;
+      height: number;
     }, _height: number): void;
-}
+  }
 
-export  class HubService {
+  export class HubService {
     static connection: any;
     static listener(_Url: string): Promise<void>;
     static start(): Promise<void>;
-}
+  }
 
-export  class Directional extends LightObject {
-    direction: BABYLON.Vector3;
-    position: BABYLON.Vector3;
-    light: BABYLON.DirectionalLight;
+  export class Directional extends LightObject {
+    direction: any;
+    position: any;
+    light: any;
     load(): void;
-}
+  }
 
-export  class Hemispheric extends LightObject {
-    direction: BABYLON.Vector3;
-    light: BABYLON.HemisphericLight;
+  export class Hemispheric extends LightObject {
+    direction: any;
+    light: any;
     load(): void;
-}
+  }
 
-export  interface ILightObject {
+  export interface ILightObject {
     id: string;
     sceneId: string;
     name: string;
-    light: BABYLON.Light;
+    light: any;
     color: string;
     lightType: string;
     intensity: number;
     load: Function;
-}
+  }
 
-export  class LightObject implements ILightObject {
+  export class LightObject implements ILightObject {
     id: string;
     sceneId: string;
     name: string;
-    light: BABYLON.Light;
+    light: any;
     color: string;
     objectType: string;
     lightType: string;
@@ -289,36 +289,59 @@ export  class LightObject implements ILightObject {
     app: App;
     constructor(_app: App);
     load(): void;
-}
+  }
 
-export enum LightType {
+  export enum LightType {
     Point = "Point",
     Spot = "Spot",
     Directional = "Directional",
     Hemispheric = "Hemispheric"
-}
+  }
 
-export  class Point extends LightObject {
-    position: BABYLON.Vector3;
-    light: BABYLON.PointLight;
+  export class Point extends LightObject {
+    position: any;
+    light: any;
     range: number;
     load(): void;
-}
+  }
 
-export  class Spot extends LightObject {
-    direction: BABYLON.Vector3;
-    position: BABYLON.Vector3;
+  export class Spot extends LightObject {
+    direction: any;
+    position: any;
     angle: number;
     exponent: number;
     range: number;
-    light: BABYLON.SpotLight;
+    light: any;
     load(): void;
-}
-
-export  class CabinetObject extends DefaultObject {
-}
-
-export  class ConduitObject extends DefaultObject {
+  }
+
+  export class BabylonLayer {
+    readonly id: string;
+    readonly type: "custom";
+    readonly renderingMode: "3d";
+    drones: {
+      x: number;
+      y: number;
+      z: number;
+    };
+    initialCoordinates: [];
+    recalculateProjectionMatrix(_coordinates: []): void;
+    onAdd: (_map: any, _gl: WebGLRenderingContext) => void;
+    render: (_gl: WebGLRenderingContext, _matrix: number[]) => void;
+  }
+
+  export class Earth {
+    initialCoordinates: [];
+    map: any;
+    load(_action: Function): void;
+    laodScene(_url: string, _initialCoordinates: []): void;
+    flyTo(_center?: [], _zoom?: number, _bearing?: number, _pitch?: number, _duration?: number): void;
+  }
+
+  export class CabinetObject extends DefaultObject {
+  }
+
+  export class ConduitObject extends DefaultObject {
     alpha: number;
     color: string;
     bind(_m: any): void;
@@ -328,23 +351,23 @@ export  class ConduitObject extends DefaultObject {
     setFlash(_level?: number): void;
     setOpaque(): void;
     setTransparent(_alpha?: number): void;
-}
+  }
 
-export  class CornerObject extends DefaultObject {
+  export class CornerObject extends DefaultObject {
     height: number;
     bind(_m: any): void;
-}
+  }
 
-export  class DefaultObject implements IObject {
+  export class DefaultObject implements IObject {
     app: App;
     id: string;
     name: string;
     parentId: string;
     modelId: string;
-    instance: BABYLON.Mesh | BABYLON.InstancedMesh;
+    instance: any | any;
     objectType: string;
-    action: BABYLON.ActionManager;
-    executes: Dictionary<BABYLON.ExecuteCodeAction>;
+    action: any;
+    executes: Dictionary<any>;
     clickEvents: Dictionary<Function>;
     touchtime: number;
     effectType: EffectType;
@@ -368,31 +391,31 @@ export  class DefaultObject implements IObject {
     setTransparent(_alpha?: number): void;
     play(): void;
     stop(): void;
-}
+  }
 
-export  class DoorObject extends DefaultObject {
+  export class DoorObject extends DefaultObject {
     height: number;
     bind(_m: any): void;
-}
+  }
 
-export  class FloorObject extends DefaultObject {
+  export class FloorObject extends DefaultObject {
     height: number;
     bind(_m: any): void;
-}
+  }
 
-export  interface IBase {
+  export interface IBase {
     app: App;
     id: string;
     name: string;
     parentId: string;
     objectType: string;
-}
+  }
 
-export  interface IObject extends IBase {
+  export interface IObject extends IBase {
     customNumber: string;
     customType: string;
     modelId: string;
-    instance: BABYLON.Mesh | BABYLON.InstancedMesh;
+    instance: any | any;
     Sight: Sight;
     effectType: EffectType;
     bind(_m?: any): any;
@@ -407,16 +430,16 @@ export  interface IObject extends IBase {
     play(isloop: boolean): any;
     stop(): any;
     computeView(): any;
-}
+  }
 
-export  class LeakWaterObject extends DefaultObject {
+  export class LeakWaterObject extends DefaultObject {
     bind(_l: any): void;
     computeView(): void;
     addEventListener(_type: string, _callback: Function): void;
     removeEventListener(_type: string): void;
-}
+  }
 
-export enum ObjectType {
+  export enum ObjectType {
     Region = "Region",
     Cabinet = "Cabinet",
     Corner = "Corner",
@@ -429,9 +452,9 @@ export enum ObjectType {
     Wall = "Wall",
     Window = "Window",
     Conduit = "Conduit"
-}
+  }
 
-export  class Project {
+  export class Project {
     app: App;
     id: string;
     root: IObject;
@@ -450,9 +473,9 @@ export  class Project {
     findObjectByCustomNumber(): void;
     findObjectsByCustomType(): void;
     switchLevel(_id?: string, _isFocus?: boolean, _includeSub?: boolean): void;
-}
+  }
 
-export  class RegionObject extends DefaultObject {
+  export class RegionObject extends DefaultObject {
     index: number;
     height: number;
     constructor(app: App, _storey: any);
@@ -463,41 +486,41 @@ export  class RegionObject extends DefaultObject {
     setEnabled(_value: boolean): void;
     getBounding(): void;
     dispose(): void;
-}
+  }
 
-export  class UI3DTextObject extends DefaultObject {
+  export class UI3DTextObject extends DefaultObject {
     bind(_u: any): void;
-}
+  }
 
-export  class VirtualBoxObject extends DefaultObject {
+  export class VirtualBoxObject extends DefaultObject {
     bind(_m: any): Promise<void>;
-}
+  }
 
-export  class WallObject extends DefaultObject {
-    nativeMaterial: BABYLON.StandardMaterial;
+  export class WallObject extends DefaultObject {
+    nativeMaterial: any;
     baseModel: any;
     height: number;
     bind(_w: any): void;
-}
+  }
 
-export  class WindowObject extends DefaultObject {
+  export class WindowObject extends DefaultObject {
     height: number;
     bind(_m: any): void;
-}
+  }
 
-export  class ArrayEx<T> extends Array<T> {
+  export class ArrayEx<T> extends Array<T> {
     remove(_val: any): void;
-}
+  }
 
-export  interface BaseNode {
+  export interface BaseNode {
     id: string;
     dispose(): any;
     isEnabled(bool: boolean): any;
-}
+  }
 
-export  class CameraController {
+  export class CameraController {
     app: App;
-    camera: BABYLON.ArcRotateCamera;
+    camera: any;
     frustrum: number;
     isOverLook: boolean;
     constructor(_app: App);
@@ -510,11 +533,11 @@ export  class CameraController {
     _wheel(_p: any): void;
     switchArcRotateCamera(): void;
     switchFPSCamera(): void;
-}
+  }
 
-export  class Dictionary<T> {
+  export class Dictionary<T> {
     map: {
-        [key: string]: T;
+      [key: string]: T;
     };
     constructor();
     add(_key: string, _value: T): void;
@@ -524,36 +547,36 @@ export  class Dictionary<T> {
     showAll(): void;
     count(): void;
     clear(): void;
-}
+  }
 
-export  class GUID {
+  export class GUID {
     static getGUID(_length: number): void;
-}
+  }
 
-export  class Resources {
+  export class Resources {
     app: App;
-    walls: Dictionary<BABYLON.AbstractMesh>;
-    resources: Dictionary<BABYLON.AssetContainer>;
-    ndoeMats: Dictionary<BABYLON.NodeMaterial>;
-    transparentBox: BABYLON.Mesh;
-    BOX: BABYLON.Mesh;
-    FogTex: BABYLON.Texture;
+    walls: Dictionary<any>;
+    resources: Dictionary<any>;
+    ndoeMats: Dictionary<any>;
+    transparentBox: any;
+    BOX: any;
+    FogTex: any;
     constructor(_app: App);
     loadModelMesh(_baseModel: any): Promise<void>;
     loadModelMeshAsync(_baseModel: any, _callback: Function): void;
-    Materials: Dictionary<BABYLON.StandardMaterial>;
-    Textures: Dictionary<BABYLON.Texture>;
-    GetMaterial(_textureData: any, _scene: BABYLON.Scene): void;
-    GetTexture(_textureData: any, _scene: BABYLON.Scene): void;
-    MergeMaterials: Dictionary<BABYLON.CustomMaterial>;
-    GetMergeMaterial(_textureData: any, _scene: BABYLON.Scene): void;
+    Materials: Dictionary<any>;
+    Textures: Dictionary<any>;
+    GetMaterial(_textureData: any, _scene: any): void;
+    GetTexture(_textureData: any, _scene: any): void;
+    MergeMaterials: Dictionary<any>;
+    GetMergeMaterial(_textureData: any, _scene: any): void;
     delete(_isAll?: boolean): void;
     GetWalls(_url: string, _projectId: string): Promise<void>;
-}
+  }
 
-export  class Sight {
+  export class Sight {
     alpha: number;
-    focus: BABYLON.Vector3;
+    focus: any;
     radius: number;
     beta: number;
     minimumLimit: number;
@@ -564,28 +587,28 @@ export  class Sight {
     toString(): void;
     setLimit(_miniLimit: number, _maxiLimit: number): void;
     setBeta(_minBeta: number, _maxBeta: number): void;
-}
+  }
 
-export  class Tools {
-    static vector3ToJson(_old: BABYLON.Vector3): any;
-    static vector3ARRToJson(_olds: BABYLON.Vector3[]): void;
+  export class Tools {
+    static vector3ToJson(_old: any): any;
+    static vector3ARRToJson(_olds: any[]): void;
     static ToVector3(_old: any): void;
     static ToARRVector3(_olds: any[]): void;
-    static computeBounds(_mscene: BABYLON.Mesh): void;
-    static computeBoundsToARR(_meshs: Array<BABYLON.Mesh>): void;
-    static Expand(_polygon: Array<BABYLON.Vector3>, _expand: number): void;
+    static computeBounds(_mscene: any): void;
+    static computeBoundsToARR(_meshs: Array<any>): void;
+    static Expand(_polygon: Array<any>, _expand: number): void;
     static norm(_x: number, _y: number): void;
-    static MergeMeshes(_meshes: Array<BABYLON.Mesh>, _app: App): void;
+    static MergeMeshes(_meshes: Array<any>, _app: App): void;
     static DeconsTructMesh(_mesh: any, _height: any, _app: App): void;
-    static getVisualAngle(_bound: BABYLON.BoundingInfo, _app: App): void;
-    static pathTransformation(_oldPath: Array<BABYLON.Vector3>, _radius: number): void;
-    static createTube(_id: string, _paths: Array<BABYLON.Vector3>, _radius: number, _app: App): void;
-    static getAngleFromVector2(_startV: BABYLON.Vector2, _coreV: BABYLON.Vector2, _endV: BABYLON.Vector2): void;
-    static getAngleFromVector3(_startV: BABYLON.Vector3, _coreV: BABYLON.Vector3, _endV: BABYLON.Vector3): void;
+    static getVisualAngle(_bound: any, _app: App): void;
+    static pathTransformation(_oldPath: Array<any>, _radius: number): void;
+    static createTube(_id: string, _paths: Array<any>, _radius: number, _app: App): void;
+    static getAngleFromVector2(_startV: any, _coreV: any, _endV: any): void;
+    static getAngleFromVector3(_startV: any, _coreV: any, _endV: any): void;
     static RandomNumBoth(_Min: any, _Max: any): void;
-}
+  }
 
-export  class ToolTips {
+  export class ToolTips {
     app: App;
     url: string;
     ele: HTMLDivElement;
@@ -594,10 +617,9 @@ export  class ToolTips {
     isOK: boolean;
     _text: string;
     constructor(_parent: HTMLElement, _app: App);
-    update(_e: BABYLON.PointerInfo): void;
+    update(_e: any): void;
     close(): void;
     setBackground(_url: string): void;
     dispose(): void;
-}
-
+  }
 }