51world示例集合

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/nodeselection-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+declare class NodeSelectionController extends Basic {
+    private apiClassName;
+    constructor(obj: any);
+    Add(obj: any, nodeIds: Array<string>): Promise<ResultType>;
+    Remove(obj: any, nodeIds: Array<string>): Promise<ResultType>;
+    Draw(): Promise<ResultType>;
+    Clear(): Promise<ResultType>;
+    AddDraw(obj: any, nodeIds: Array<string>): Promise<ResultType>;
+    RemoveDraw(obj: any, nodeIds: Array<string>): Promise<ResultType>;
+    ClearDraw(): Promise<ResultType>;
+}
+export default NodeSelectionController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/outliner-controller.d.ts

+import { AtomController } from '../common/atom-controller';
+import { ResultType } from '../common/data-type';
+declare class OutlinerController extends AtomController {
+    private apiClassName;
+    constructor(obj: any);
+    Create(jsonData: any): Promise<ResultType>;
+    Get(eid?: string): Promise<ResultType>;
+    GenerateObject(res: any): Promise<any>;
+    GetOnly(eid: string): Promise<ResultType>;
+    Move(objects: Array<any>, position: number, category?: string): Promise<ResultType>;
+}
+export default OutlinerController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/outliner/index.d.ts

+import { ObjectAbstract } from '../../common/object-abstract';
+import { ResultType, BasicInfoAtomType } from '../../common/data-type';
+import { WdpSceneOutlinerAtomType, SceneOutlinerType } from '../../common/interface/outliner';
+import { ObjectController } from '../../common/object-controller';
+declare class Outliner extends ObjectController implements ObjectAbstract {
+    className: string;
+    private WdpSceneOutlinerAtom;
+    private entities;
+    constructor(opt?: SceneOutlinerType);
+    get eids(): {
+        [key: string]: {
+            eids: Array<string>;
+        };
+    };
+    set eids(eids: {
+        [key: string]: {
+            eids: Array<string>;
+        };
+    });
+    GetEids(): Promise<ResultType>;
+    SetEids(eids: {
+        [key: string]: {
+            eids: Array<string>;
+        };
+    }): Promise<ResultType>;
+    GetScheme(): {
+        WdpSceneOutlinerAtom: WdpSceneOutlinerAtomType;
+    };
+    GetData(): SceneOutlinerType;
+    SetData(opt: SceneOutlinerType): void;
+    generateAtomData(opt: SceneOutlinerType): {
+        WdpSceneOutlinerAtom?: Partial<WdpSceneOutlinerAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+    };
+}
+export default Outliner;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/section-controller.d.ts

+import { ResultType } from '../common/data-type';
+import { ISectionStart } from '../common/interface/section';
+import { Basic } from '../common/basic';
+declare class SectionController extends Basic {
+    private apiClassName;
+    constructor(obj: any);
+    Start(opt: ISectionStart): Promise<ResultType>;
+    End(): Promise<ResultType>;
+}
+export default SectionController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/tiles-controller.d.ts

+import { AtomController } from '../common/atom-controller';
+import { ResultType } from '../common/data-type';
+type layTypes = 'terrain' | 'building' | 'road' | 'tree' | 'water' | 'district' | 'buildinginstance' | 'roadinstance' | 'districtinstance';
+declare class TilesController extends AtomController {
+    private apiClassName;
+    constructor(obj: any);
+    ActivateAesTiles(tiles: any): Promise<ResultType>;
+    DeactivateAesTiles(tiles: any): Promise<ResultType>;
+    IsActivated(tiles: any): Promise<ResultType>;
+    SetLayersOutline(opt: {
+        tiles: any;
+        layers: Array<layTypes>;
+        bOutline?: boolean;
+        color?: string;
+    }): Promise<ResultType>;
+    SetLayersVisibility(opt: {
+        tiles: any;
+        layers: Array<layTypes>;
+        bVisible?: boolean;
+    }): Promise<ResultType>;
+    GetLayers(obj: any): Promise<ResultType>;
+}
+export default TilesController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/tiles/index.d.ts

+import { ObjectAbstract } from '../../common/object-abstract';
+import { ResultType, AssetsAtomType, BasicInfoAtomType, TransformAtomType } from '../../common/data-type';
+import { TilesType, AesTilesEntityAtomType } from '../../common/interface/tiles';
+import { ObjectController } from '../../common/object-controller';
+declare class Tiles extends ObjectController implements ObjectAbstract {
+    className: string;
+    private apiClassName;
+    private AesTilesEntityAtom;
+    private AssetsAtom;
+    private AesTilesVisualAtom;
+    constructor(opt?: TilesType);
+    get spaceId(): string;
+    set spaceId(spaceId: string);
+    get rangeBox(): Array<Array<number>>;
+    set rangeBox(rangeBox: Array<Array<number>>);
+    get version(): string;
+    set version(version: string);
+    get seedIds(): Array<string>;
+    set seedIds(seedIds: Array<string>);
+    GetSpaceId(): Promise<ResultType>;
+    SetSpaceId(spaceId: string): Promise<ResultType>;
+    GetRangeBox(): Promise<ResultType>;
+    SetRangeBox(rangeBox: Array<Array<number>>): Promise<ResultType>;
+    GetVersion(): Promise<ResultType>;
+    SetVersion(version: string): Promise<ResultType>;
+    GetSeedIds(): Promise<ResultType>;
+    SetSeedIds(seedIds: Array<string>): Promise<ResultType>;
+    GetScheme(): {
+        AesTilesEntityAtom: AesTilesEntityAtomType;
+        AssetsAtom: AssetsAtomType;
+    };
+    GetData(): TilesType;
+    SetData(opt: TilesType): void;
+    generateAtomData(opt: TilesType): {
+        AesTilesEntityAtom?: Partial<AesTilesEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Tiles;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/tilesnode-controller.d.ts

+import { AtomController } from '../common/atom-controller';
+import { ResultType } from '../common/data-type';
+declare class TilesNodeController extends AtomController {
+    private apiClassName;
+    constructor(obj: any);
+    SetNodesOutline(opt: {
+        tiles: any;
+        nodeIds: Array<string>;
+        bOutline?: boolean;
+        color?: string;
+    }): Promise<ResultType>;
+    RemoveVisibilityGroup(opt: {
+        groupNames?: Array<string>;
+        tiles: any;
+    }): Promise<ResultType>;
+    UpdateVisibilityGroup(opt: {
+        newGroupName?: string;
+        groupName?: string;
+        addNodes?: Array<string>;
+        removeNodes?: Array<string>;
+        bVisible?: boolean;
+        tiles: any;
+    }): Promise<ResultType>;
+    GetVisibilityGroup(tiles: any): Promise<ResultType>;
+    AddVisibilityGroup(opt: {
+        groupName?: string;
+        nodeIds: Array<string>;
+        bVisible?: boolean;
+        tiles: any;
+    }): Promise<ResultType>;
+    SetNodesVisibility(opt: {
+        nodes: Array<string>;
+        bVisible?: boolean;
+        aesTiles: any;
+    }): Promise<ResultType>;
+}
+export default TilesNodeController;

gis_sdk/world51/51timapi/Plugins/tim/modules/setting-controller.d.ts

+import { Basic } from './common/basic';
+import { ResultType } from './common/data-type';
+import { IDefaultActionSetting, IGizmoSetting } from './common/interface/setting';
+declare class SettingController extends Basic {
+    private apiClassName;
+    private WdpActionSettingsAPI;
+    constructor(obj: any);
+    GetApiVersion(): Promise<ResultType>;
+    SetCoordType(coordTypeValue: number): Promise<ResultType>;
+    GetCoordType(): Promise<ResultType>;
+    SetCoordZType(coordZTypeValue: number): Promise<ResultType>;
+    GetCoordZType(): Promise<ResultType>;
+    SetAudioVolume(volume: number): Promise<ResultType>;
+    SetMode(mode?: string): Promise<ResultType>;
+    SetDefaultActionSetting(opt: IDefaultActionSetting): Promise<ResultType>;
+    SetGizmoSetting(opt?: IGizmoSetting): Promise<ResultType>;
+}
+export default SettingController;

gis_sdk/world51/51timapi/Plugins/tim/modules/system-controller.d.ts

+import { Basic } from './common/basic';
+import { ResultType } from './common/data-type';
+declare class SystemController extends Basic {
+    private apiClassName;
+    constructor(obj: any);
+    GetInfomation(): Promise<ResultType>;
+    SetOption(opt: {
+        url?: string;
+        order?: string;
+        resolution?: Array<number>;
+    }): Promise<ResultType>;
+    SetDefaultBrowserFunctionKeyboard(bool?: boolean): Promise<void>;
+    SetDefaultKeyboard(bool?: boolean): Promise<void>;
+    SetDeviceLock(bool?: boolean): Promise<void>;
+    SetFullScreen(bool?: boolean): Promise<void>;
+    SetTimeoutTime(timeout?: number): Promise<void>;
+    SetApiRequestMode(mode: string, url?: string): Promise<void>;
+}
+export default SystemController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools-controller.d.ts

+import { Basic } from './common/basic';
+import CoordAideController from './tools/coordaide-controller';
+import CoordinateController from './tools/coordinate-controller';
+import MeasureController from './tools/measure-controller';
+import PickerController from './tools/picker-controller';
+import PickerPointController from './tools/pickerpoint-controller';
+import PickerPolylineController from './tools/pickerpolyline-controller';
+import MiniMapController from './tools/minimap-controller';
+declare class ToolsController extends Basic {
+    CoordAide: CoordAideController;
+    Coordinate: CoordinateController;
+    Measure: MeasureController;
+    Picker: PickerController;
+    PickerPoint: PickerPointController;
+    PickerPolyline: PickerPolylineController;
+    MiniMap: MiniMapController;
+    constructor(obj: any);
+}
+export default ToolsController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/coordaide-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+declare class CoordAideController extends Basic {
+    private apiClassName;
+    constructor(obj: any);
+    Display(opt: {
+        entity?: Array<any>;
+        coordZRef?: number;
+        coordZ?: number;
+    }): Promise<ResultType>;
+    Clear(): Promise<ResultType>;
+}
+export default CoordAideController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/coordinate-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType, CoordType } from '../common/data-type';
+declare class CoordinateController extends Basic {
+    private static instance;
+    private apiClassName;
+    constructor(obj: any);
+    static getInstance(obj: any): CoordinateController;
+    GISToCartesian(from: Array<CoordType>): Promise<ResultType>;
+    CartesianToGIS(from: Array<CoordType>): Promise<ResultType>;
+    WorldPosToScreenPos(worldPos: CoordType): Promise<ResultType>;
+}
+export default CoordinateController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/measure-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+declare class MeasureController extends Basic {
+    private apiClassName;
+    constructor(obj: any);
+    Start(): Promise<ResultType>;
+    End(): Promise<ResultType>;
+}
+export default MeasureController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/minimap-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+import { IMiniMap } from '../common/interface/minimap';
+declare class MiniMapController extends Basic {
+    private apiClassName;
+    private miniMap;
+    constructor(obj: any);
+    Start(opt?: IMiniMap): Promise<ResultType>;
+    End(): Promise<ResultType>;
+}
+export default MiniMapController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/minimap/index.d.ts

+import { IMiniMap } from '../../common/interface/minimap';
+declare class MiniMap {
+    private eid;
+    private type;
+    private source;
+    private mappingAnchors;
+    private display;
+    GetData(): IMiniMap;
+    SetData(opt: IMiniMap): void;
+}
+export default MiniMap;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/picker-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType, Coord2DType } from '../common/data-type';
+import { IPickerRectangle, IPickerMaterial, IPickerTilesNode } from '../common/interface/tool';
+declare class PickerController extends Basic {
+    private static instance;
+    private apiClassName;
+    constructor(obj: any);
+    static getInstance(obj: any): PickerController;
+    PickByScreenPos(screenPos: Coord2DType): Promise<ResultType>;
+    PickWorldPointByScreenPos(screenPos: Coord2DType): Promise<ResultType>;
+    PickAesTilesNodeByScreenPos(screenPos: Coord2DType, EntityTypeFilter: Array<string>, bFilterForExclude?: boolean): Promise<ResultType>;
+    PickAesTilesNodesByRectangle(opt: IPickerTilesNode): Promise<ResultType>;
+    PickEntityByRectangle(opt: IPickerRectangle): Promise<ResultType>;
+    PickMaterialByScreenPos(opt: IPickerMaterial): Promise<ResultType>;
+}
+export default PickerController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/pickerpoint-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+declare class PickerPointController extends Basic {
+    private apiClassName;
+    constructor(obj: any);
+    StartPickPoint(coordinateShow: boolean, iconShow: boolean): Promise<ResultType>;
+    EndPickPoint(): Promise<ResultType>;
+    GetPickedPoints(coordZRef?: number): Promise<ResultType>;
+}
+export default PickerPointController;

gis_sdk/world51/51timapi/Plugins/tim/modules/tools/pickerpolyline-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+declare class PickerPolylineController extends Basic {
+    private static instance;
+    private apiClassName;
+    constructor(obj: any);
+    static getInstance(obj: any): PickerPolylineController;
+    StartPickPolyline(): Promise<ResultType>;
+    EndPickPolyline(): Promise<ResultType>;
+    GetPickedPolylines(coordZRef?: number): Promise<ResultType>;
+}
+export default PickerPolylineController;

gis_sdk/world51/51timapi/Plugins/tim/modules/transaction-controller.d.ts

+import { Basic } from './common/basic';
+import { ResultType } from './common/data-type';
+import { StartTransactionType } from './common/interface/transaction';
+declare class TransactionController extends Basic {
+    private apiClassName;
+    private per;
+    private RequestEntity;
+    constructor(obj: any);
+    SetEnable(bEnableTransaction?: boolean): Promise<ResultType>;
+    Start(opt: StartTransactionType): Promise<ResultType>;
+    Commit(): Promise<ResultType>;
+    Rollback(): Promise<ResultType>;
+    Undo(): Promise<ResultType>;
+    Redo(): Promise<ResultType>;
+    CanUndo(): Promise<ResultType>;
+    CanRedo(): Promise<ResultType>;
+    Clear(): Promise<ResultType>;
+    Get(): Promise<ResultType>;
+}
+export default TransactionController;

gis_sdk/world51/51timapi/Plugins/tim/plugins/tim/common/base-controller.d.ts

+declare const ControllerCore: any;
+declare class BaseController extends ControllerCore {
+    protected obj: any;
+    constructor(obj: any, ObjectClass?: any);
+    protected setType(type: string): void;
+}
+export default BaseController;