mx3d 0.0.42 → 0.0.43

package/index.d.ts

@@ -1,7 +1,8 @@
-/* 
-@author gzmaijing 
-@email mj@gzmaijing.com
-*/
+/* 
+@author gzmaijing 
+@email mj@gzmaijing.com
+*/
+
 
 
 
@@ -2877,3 +2878,585 @@ export default class ToolTips {
     setBackground(_url: string): void;
 }
 
+export default class App {
+    canvas: HTMLCanvasElement;
+    engine: BABYLON.Engine;
+    scene: BABYLON.Scene;
+    Camera: Camera;
+    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;
+        progress?: Function;
+        complete?: Function;
+    }): Promise<void>;
+    dispose(): void;
+}
+
+export default class Capacity {
+    anchor: IObject;
+    mesh: BABYLON.Mesh;
+    ratio: number;
+    color: string;
+    textMesh: BABYLON.Mesh;
+    constructor(_object: IObject, _RATIO: number);
+    dispose(): void;
+}
+
+export default class CapacityBuilder {
+    static createCapacity(_obj: IObject, _RATIO: number, _text: string, _fontSize?: string): void;
+    static createTextMesh(_obj: IObject, _text: string, _RATIO: number, _fontSize?: string, _color?: string): void;
+}
+
+export default class EffectMgr {
+    static colors: {};
+    static init(): void;
+}
+
+export enum EffectType {
+    Opaque = 0,
+    Flash = 1,
+    Transparent = 2
+}
+
+export default class Environment {
+    app: App;
+    lights: any;
+    _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;
+    showTips(): void;
+    closeTips(): void;
+    showFps(): void;
+    hideFps(): void;
+    showDebug(): void;
+    setLightIntensity(_intensity?: number): void;
+}
+
+export enum EventType {
+    leftClick = "leftClick",
+    rightClick = "rightClick",
+    doubleClick = "doubleClick",
+    eover = "eover",
+    longPress = "longPress",
+    out = "out"
+}
+
+export default class HeatMap implements BaseNode {
+    id: string;
+    scene: BABYLON.Scene;
+    anchor: string;
+    mesh: BABYLON.Mesh;
+    texts: Array<BABYLON.GUI.TextBlock>;
+    constructor(_anchor: string);
+    isEnabled(_bool: boolean): void;
+    set displayValues(_value: boolean);
+    dispose(): void;
+}
+
+export default class HeatMapBuilder {
+    static createMatrixHeatMap(_data: {
+        anchor: BABYLON.Mesh | BABYLON.InstancedMesh;
+        rootUrl: string;
+        FogTex: BABYLON.Texture;
+        container: BABYLON.GUI.AdvancedDynamicTexture;
+        config: {
+            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 createColumnarHeatMap(_data: {
+        anchor: BABYLON.Mesh | BABYLON.InstancedMesh;
+        FogTex: BABYLON.Texture;
+        container: BABYLON.GUI.AdvancedDynamicTexture;
+        config: Array<{
+            index: number;
+            value: number;
+        }>;
+        isLevelRender: boolean;
+        displayValues: boolean;
+        isAlpha: boolean;
+        isParticle: boolean;
+        radius: number;
+        range: {
+            max: number;
+            min: number;
+        };
+    }): void;
+}
+
+export default class Icon implements BaseNode {
+    id: string;
+    scene: BABYLON.Scene;
+    pint: BABYLON.Mesh;
+    rect: BABYLON.GUI.Rectangle;
+    onPointerClick: Function;
+    size: {
+        width: number;
+        height: number;
+    };
+    height: number;
+    container: BABYLON.GUI.AdvancedDynamicTexture;
+    constructor(_id: string, _scene: BABYLON.Scene);
+    set background(_url: string);
+    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;
+}
+
+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;
+}
+
+export default 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;
+    }, _height: number): void;
+}
+
+export default class Directional extends LightObject {
+    direction: BABYLON.Vector3;
+    position: BABYLON.Vector3;
+    light: BABYLON.DirectionalLight;
+    load(): void;
+}
+
+export default class Hemispheric extends LightObject {
+    direction: BABYLON.Vector3;
+    light: BABYLON.HemisphericLight;
+    load(): void;
+}
+
+export default interface ILightObject {
+    id: string;
+    sceneId: string;
+    name: string;
+    light: BABYLON.Light;
+    color: string;
+    lightType: string;
+    intensity: number;
+    load: Function;
+}
+
+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;
+}
+
+export enum LightType {
+    Point = "Point",
+    Spot = "Spot",
+    Directional = "Directional",
+    Hemispheric = "Hemispheric"
+}
+let typeFromat: Function;
+export default typeFromat;
+
+export default class Point extends LightObject {
+    position: BABYLON.Vector3;
+    light: BABYLON.PointLight;
+    range: number;
+    load(): void;
+}
+
+export default class Spot extends LightObject {
+    direction: BABYLON.Vector3;
+    position: BABYLON.Vector3;
+    angle: number;
+    exponent: number;
+    range: number;
+    light: BABYLON.SpotLight;
+    load(): void;
+}
+
+export default class CabinetObject extends 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;
+}
+
+export default class CornerObject extends DefaultObject {
+    height: number;
+    bind(_m: any): void;
+}
+
+export default class DefaultObject implements IObject {
+    app: App;
+    id: string;
+    name: string;
+    parentId: string;
+    modelId: string;
+    instance: BABYLON.Mesh | BABYLON.InstancedMesh;
+    objectType: string;
+    modelType: 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);
+    showBoundingBox: boolean;
+    setEnabled(_value: boolean): void;
+    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;
+    flyTo(): void;
+    focus(): void;
+}
+
+export default class DoorObject extends DefaultObject {
+    height: number;
+    bind(_m: any): void;
+}
+
+export default class FloorObject extends DefaultObject {
+    height: number;
+    bind(_m: any): void;
+}
+
+export default interface IBase {
+    app: App;
+    id: string;
+    name: string;
+    parentId: string;
+    objectType: string;
+}
+
+export default interface IObject extends IBase {
+    modelId: string;
+    instance: BABYLON.Mesh | BABYLON.InstancedMesh;
+    modelType: string;
+    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;
+    flyTo(): any;
+    focus(): any;
+    computeView(): any;
+}
+
+export default class LeakWaterObject extends DefaultObject {
+    bind(_l: any): void;
+    computeView(): void;
+    addEventListener(_type: string, _callback: Function): void;
+    removeEventListener(_type: string): void;
+}
+
+export enum ObjectType {
+    Campus = "Campus",
+    Building = "Building",
+    Scene = "Scene",
+    Humiture = "Humiture",
+    Battery = "Battery",
+    PowerCabinet = "PowerCabinet",
+    Cabinet = "Cabinet",
+    AirCondition = "AirCondition",
+    UPS = "UPS",
+    Camera = "Camera",
+    NewWindMachine = "NewWindMachine",
+    SmokeDetector = "SmokeDetector",
+    AudibleVisualAlarm = "AudibleVisualAlarm",
+    LeakWater = "LeakWater",
+    Wall = "Wall",
+    Floor = "Floor",
+    Window = "Window",
+    Door = "Door",
+    AirFlow = "AirFlow",
+    Corner = "Corner",
+    FireFighting = "FireFighting",
+    Lighting = "Lighting",
+    Enclosure = "Enclosure",
+    ParkingLot = "ParkingLot",
+    Elevator = "Elevator",
+    Other = "Other",
+    InrackAsset = "InrackAsset",
+    GasDetection = "GasDetection",
+    Security = "Security",
+    OutDoorScene = "OutDoorScene",
+    Infrared = "Infrared",
+    SkyBox = "SkyBox",
+    UI3D = "UI3D",
+    ColdTongDoor = "ColdTongDoor",
+    VirtualBox = "VirtualBox",
+    PathPint = "PathPint",
+    Port = "Port",
+    Positioner = "Positioner",
+    AutoAnimation = "AutoAnimation",
+    MapModel = "MapModel",
+    radiator = "radiator",
+    Conduit = "Conduit",
+    Region = "Region",
+    optimizedWall = "optimizedWall"
+}
+
+export default class Project {
+    app: App;
+    id: string;
+    root: IObject;
+    current: IObject;
+    Sight: Sight;
+    objectDatas: Dictionary<IObject>;
+    constructor(_app: App);
+    clear(): void;
+    optimization(): void;
+    computeView(): void;
+    getChildNodes(_id: string): void;
+    getTrees(): void;
+    find(_id: string): void;
+    findFormObjectType(_type: ObjectType, _isCurent?: boolean): void;
+    show(): void;
+    getBounding(): void;
+    flyTo(): void;
+}
+
+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(): void;
+    dispose(): void;
+}
+
+export default class UI3DTextObject extends DefaultObject {
+    bind(_u: any): void;
+}
+
+export default class VirtualBoxObject extends DefaultObject {
+    bind(_m: any): Promise<void>;
+}
+
+export default class WallObject extends DefaultObject {
+    nativeMaterial: BABYLON.StandardMaterial;
+    baseModel: any;
+    height: number;
+    bind(_w: any): void;
+}
+
+export default class WindowObject extends DefaultObject {
+    height: number;
+    bind(_m: any): void;
+}
+
+export default class ArrayEx<T> extends Array<T> {
+    remove(_val: any): void;
+}
+
+export default interface BaseNode {
+    id: string;
+    scene: BABYLON.Scene;
+    dispose(): any;
+    isEnabled(bool: boolean): any;
+}
+
+export default class Camera {
+    app: App;
+    camera: BABYLON.ArcRotateCamera;
+    frustrum: number;
+    isOverLook: boolean;
+    constructor(_app: App);
+    orthographic(): void;
+    perspective(): void;
+    focusingFromProperty(_visualAngle: Sight): void;
+    flyTo(_visualAngle: Sight, _sheep?: number): void;
+    translation(_visualAngle: Sight, _sheep?: number): void;
+    computeCameraView(): void;
+    _wheel(_p: any): void;
+}
+
+export default class Dictionary<T> {
+    map: {
+        [key: string]: T;
+    };
+    constructor();
+    add(_key: string, _value: T): void;
+    find(_key: string): void;
+    remove(_key: string): void;
+    termRemove(_callback: Function): void;
+    showAll(): void;
+    count(): void;
+    clear(): void;
+}
+
+export default class GUID {
+    static getGUID(_length: number): void;
+}
+
+export default 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;
+    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;
+    delete(_isAll?: boolean): void;
+    GetWalls(_url: string, _projectId: string): Promise<void>;
+}
+
+export default class Sight {
+    alpha: number;
+    focus: BABYLON.Vector3;
+    radius: number;
+    beta: number;
+    minimumLimit: number;
+    maximumLimit: number;
+    minBeta: number;
+    maxBeta: number;
+    setVisual(_visual: any): void;
+    setLimit(_miniLimit: number, _maxiLimit: number): void;
+    setBeta(_minBeta: number, _maxBeta: number): void;
+}
+
+export default class Tools {
+    static vector3ToJson(_old: BABYLON.Vector3): any;
+    static vector3ARRToJson(_olds: BABYLON.Vector3[]): 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 norm(_x: number, _y: number): void;
+    static MergeMeshes(_meshes: Array<BABYLON.Mesh>, _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 RandomNumBoth(_Min: any, _Max: any): void;
+}
+
+export default class ToolTips {
+    app: App;
+    url: string;
+    ele: HTMLDivElement;
+    time: number;
+    id: string;
+    isOK: boolean;
+    _text: string;
+    constructor(_parent: HTMLElement, _app: App);
+    update(_e: BABYLON.PointerInfo): void;
+    close(): void;
+    setBackground(_url: string): void;
+    dispose(): void;
+}
+

package/mx3d.js

@@ -154,6 +154,8 @@ var external_babylonjs_serializers_ = __webpack_require__(4);
 class App {
     constructor(_config) { }
     async load(_config) { }
+    //销毁整个场景
+    dispose() { }
 }
 
 // CONCATENATED MODULE: ./src/public/components/EffectMgr.ts