51world示例集合

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/point-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class PointController extends AtomController {
+    constructor(obj: any);
+}
+export default PointController;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/point/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, PointType, CoordType, PointEntityAtomType, BasicInfoAtomType } from '../../../common/data-type';
+import { ObjectController } from '../../../common/object-controller';
+declare class Point extends ObjectController implements ObjectAbstract {
+    className: string;
+    private PointEntityAtom;
+    constructor(opt?: PointType);
+    get point(): CoordType;
+    set point(point: CoordType);
+    GetPoint(): Promise<ResultType>;
+    SetPoint(point: CoordType): Promise<ResultType>;
+    GetScheme(): {
+        PointEntityAtom: PointEntityAtomType;
+    };
+    GetData(): PointType;
+    SetData(opt: PointType): void;
+    generateAtomData(opt: PointType): {
+        PointEntityAtom?: Partial<PointEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+    };
+}
+export default Point;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/polygon-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class PolygonController extends AtomController {
+    constructor(obj: any);
+}
+export default PolygonController;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/polygon/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, PolygonType, PolygonLoopType, PolygonEntityAtomType, BasicInfoAtomType } from '../../../common/data-type';
+import { ObjectController } from '../../../common/object-controller';
+declare class Polygon extends ObjectController implements ObjectAbstract {
+    className: string;
+    private PolygonEntityAtom;
+    constructor(opt?: PolygonType);
+    get polygon(): PolygonLoopType;
+    set polygon(polygon: PolygonLoopType);
+    GetPolygon(): Promise<ResultType>;
+    SetPolygon(polygon: PolygonLoopType): Promise<ResultType>;
+    GetScheme(): {
+        PolygonEntityAtom: PolygonEntityAtomType;
+    };
+    GetData(): PolygonType;
+    SetData(opt: PolygonType): void;
+    generateAtomData(opt: PolygonType): {
+        PolygonEntityAtom?: Partial<PolygonEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+    };
+}
+export default Polygon;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/polygon2d-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class PolygonController extends AtomController {
+    constructor(obj: any);
+}
+export default PolygonController;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/polygon2d/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, Polygon2DType, Polygon2DLoopType, Polygon2DEntityAtomType, BasicInfoAtomType } from '../../../common/data-type';
+import { ObjectController } from '../../../common/object-controller';
+declare class Polygon2D extends ObjectController implements ObjectAbstract {
+    className: string;
+    private apiClassName;
+    private Polygon2DEntityAtom;
+    constructor(opt?: Polygon2DType);
+    get polygon(): Polygon2DLoopType;
+    set polygon(polygon: Polygon2DLoopType);
+    GetPolygon(): Promise<ResultType>;
+    SetPolygon(polygon: Polygon2DLoopType): Promise<ResultType>;
+    GetScheme(): {
+        Polygon2DEntityAtom: Polygon2DEntityAtomType;
+    };
+    GetData(): Polygon2DType;
+    SetData(opt: Polygon2DType): void;
+    generateAtomData(opt: Polygon2DType): {
+        Polygon2DEntityAtom?: Partial<Polygon2DEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+    };
+}
+export default Polygon2D;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/polyline-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class PolylineController extends AtomController {
+    constructor(obj: any);
+}
+export default PolylineController;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry/polyline/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, PolylineType, CoordType, PolylineEntityAtomType, BasicInfoAtomType } from '../../../common/data-type';
+import { ObjectController } from '../../../common/object-controller';
+declare class Polyline extends ObjectController implements ObjectAbstract {
+    className: string;
+    private apiClassName;
+    private PolylineEntityAtom;
+    constructor(opt?: PolylineType);
+    get polyline(): {
+        points: Array<CoordType>;
+    };
+    set polyline(polyline: {
+        points: Array<CoordType>;
+    });
+    GetPolyline(): Promise<ResultType>;
+    SetPolyline(polyline: {
+        points: Array<CoordType>;
+    }): Promise<ResultType>;
+    GetScheme(): {
+        PolylineEntityAtom: PolylineEntityAtomType;
+    };
+    GetData(): PolylineType;
+    SetData(opt: PolylineType): void;
+    generateAtomData(opt: PolylineType): {
+        PolylineEntityAtom?: Partial<PolylineEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+    };
+}
+export default Polyline;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/material-controller.d.ts

+import { AtomController } from '../common/atom-controller';
+import { ResultType } from '../common/data-type';
+declare class MaterialController extends AtomController {
+    private apiClassName;
+    constructor(obj: any);
+    Apply(obj: any, newMaterialsInfo: Array<any>): Promise<ResultType>;
+    Get(obj: any): Promise<ResultType>;
+}
+export default MaterialController;

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

+import { Basic } from './common/basic';
+import GeometryController from './data-model/geometry-controller';
+import AssetLoaderController from './data-model/assetloader-controller';
+import MaterialController from './data-model/material-controller';
+declare class DataModelController extends Basic {
+    Geometry: GeometryController;
+    AssetLoader: AssetLoaderController;
+    Material: MaterialController;
+    constructor(obj: any);
+}
+export default DataModelController;

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

+import { ResultType } from './common/data-type';
+import { Basic } from './common/basic';
+declare class DebugController extends Basic {
+    private Log;
+    constructor(obj: any);
+    SetLogMode(mode?: string): Promise<void>;
+    StartRecord(): Promise<void>;
+    EndRecord(): Promise<void>;
+    GetRecord(): Promise<void>;
+    GetDebugLogs(): Promise<ResultType>;
+}
+export default DebugController;

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

+import { Basic } from './common/basic';
+import { ResultType } from './common/data-type';
+declare class EnvironmentController extends Basic {
+    private apiClassName;
+    private RequestEntity;
+    private objectMap;
+    constructor(obj: any);
+    Get(eid?: string): Promise<ResultType>;
+    GetOnly(eid: string): Promise<ResultType>;
+    GetCurrentWeather(cityName: string): Promise<ResultType>;
+    GetCityInfo(cityName: string): Promise<ResultType>;
+    SetRealTimeWeatherTimerAllowed(isAllowed?: boolean): Promise<ResultType>;
+    GetSkylightTime(): Promise<ResultType>;
+    SetSkylightTime(skylightTime: string, durationSeconds: number, bRealtime?: boolean): Promise<ResultType>;
+    GetSceneWeather(): Promise<ResultType>;
+    SetSceneWeather(sceneWeather: string, durationSeconds: number, bRealtime?: boolean): Promise<ResultType>;
+}
+export default EnvironmentController;

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

+declare class Environment {
+    className: string;
+    private WdpEnvironmentAtom;
+    get skylightTime(): string;
+    set skylightTime(skylightTime: string);
+    get bSkylightRealtime(): boolean;
+    set bSkylightRealtime(bSkylightRealtime: boolean);
+    get sceneWeather(): string;
+    set sceneWeather(sceneWeather: string);
+    get bSceneWeatherRealtime(): boolean;
+    set bSceneWeatherRealtime(bSceneWeatherRealtime: boolean);
+}
+export default Environment;

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

+import { Basic } from './common/basic';
+import { ResultType } from './common/data-type';
+declare class PluginController extends Basic {
+    private pluginInstance;
+    constructor(obj: any);
+    Install(pluginObj: any): Promise<ResultType>;
+    Uninstall(): Promise<ResultType>;
+}
+export default PluginController;

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

+import { Basic } from './common/basic';
+import { ResultType } from './common/data-type';
+interface eventType {
+    name: string;
+    func: any;
+}
+declare class RendererController extends Basic {
+    constructor(obj: any);
+    Start(): Promise<ResultType>;
+    Restart(): Promise<void>;
+    Stop(): Promise<void>;
+    StartByTaskId(io: string, taskId: string): Promise<ResultType>;
+    setResolutionMultiple(multiple?: number): Promise<ResultType>;
+    GetMaxFpsRequest(): Promise<void>;
+    SetResolution(w: number, h: number): Promise<ResultType>;
+    SetFrameRateLimit(maxFPS: number): Promise<ResultType>;
+    SetBitrate(bitrate: number): Promise<ResultType>;
+    GetStats(): Promise<ResultType>;
+    RegisterEvent(events: Array<eventType>): Promise<void>;
+    registerSceneEvent(events: Array<eventType>): Promise<void>;
+    SetRendererMode(mode: string, resolution?: Array<number>): Promise<void>;
+}
+export default RendererController;

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

+import { Basic } from './common/basic';
+import { ResultType, RotatorType, CoordObjType, IOperations } from './common/data-type';
+import { ObjectController } from '../modules/common/object-controller';
+import CoveringController from './scene/covering-controller';
+import ModelController from './scene/model-controller';
+import TilesController from './scene/tiles-controller';
+import TilesNodeController from './scene/tilesnode-controller';
+import EffectsController from './scene/effects-controller';
+import NodeSelectionController from './scene/nodeselection-controller';
+import OutlinerController from './scene/outliner-controller';
+import GroupController from './scene/group-controller';
+import SectionController from './scene/section-controller';
+declare class SceneController extends Basic {
+    private apiClassName;
+    private per;
+    Covering: CoveringController;
+    Model: ModelController;
+    Tiles: TilesController;
+    TilesNode: TilesNodeController;
+    Effects: EffectsController;
+    NodeSelection: NodeSelectionController;
+    Outliner: OutlinerController;
+    Group: GroupController;
+    Section: SectionController;
+    private Action;
+    private Selection;
+    private RequestEntity;
+    private Gizmo;
+    constructor(obj: any);
+    Create(defaultParam: Record<string, any>, batchParams?: Record<string, any>, operations?: IOperations): Promise<ResultType>;
+    Delete(objs: Array<Record<string, any>>): Promise<ResultType>;
+    Add(obj: Array<Record<string, any>> | Record<string, any>, operations?: IOperations): Promise<ResultType>;
+    GetTypesByEids(eids: Array<string>): Promise<ResultType>;
+    Clear(EntityTypesToIgnore?: Array<string>): Promise<ResultType>;
+    ClearByObjects(objs: Array<Record<string, any>>): Promise<ResultType>;
+    SetVisibleByObjects(objs: Array<any>, bVisible?: boolean): Promise<ResultType>;
+    private AddAct;
+    private AddActMulit;
+    RunAction(actionName: string, actionParams: any): Promise<ResultType>;
+    EndAction(): Promise<ResultType>;
+    GetAction(): Promise<ResultType>;
+    AddSelection(objects: Array<any>): Promise<ResultType>;
+    RemoveSelection(objects: Array<any>): Promise<ResultType>;
+    ClearSelection(): Promise<ResultType>;
+    DrawSelection(): Promise<ResultType>;
+    GetSelection(): Promise<ResultType>;
+    Save(containerId: string): Promise<ResultType>;
+    Load(containerId: string): Promise<ResultType>;
+    GetObjectEid(eid?: string): Promise<ResultType>;
+    GetAll(): Promise<ResultType>;
+    Merge(containerId: string, anotherContainerId: string, EntityTypesToIgnore?: never[]): Promise<ResultType>;
+    SetLocation(objects: Array<ObjectController>, location: CoordObjType): Promise<ResultType>;
+    SetLocations(datas: Array<{
+        object: ObjectController;
+        location: CoordObjType;
+    }>): Promise<ResultType>;
+    SetRotator(objects: Array<ObjectController>, rotator: RotatorType): Promise<ResultType>;
+    SetRotators(datas: Array<{
+        object: ObjectController;
+        rotator: RotatorType;
+    }>): Promise<ResultType>;
+    SetScale3D(objects: Array<ObjectController>, scale3d: CoordObjType): Promise<ResultType>;
+    SetScale3Ds(datas: Array<{
+        object: ObjectController;
+        scale3d: CoordObjType;
+    }>): Promise<ResultType>;
+    SetVisible(objects: Array<ObjectController>, bVisible?: boolean): Promise<ResultType>;
+    Update(objs: Array<Record<string, any>>, opt: Record<string, any>, operations?: IOperations): Promise<ResultType>;
+    ClearByCustomId(cids: Array<string>): Promise<ResultType>;
+    GetByCustomId(cids: Array<string>): Promise<ResultType>;
+    UpdateByCustomId(cids: Array<string>, opt: Record<string, any>): Promise<ResultType>;
+    ClearByEntityName(entityNames: Array<string>): Promise<ResultType>;
+    GetByEntityName(entityNames: Array<string>): Promise<ResultType>;
+    UpdateByEntityName(entityNames: Array<string>, opt: Record<string, any>): Promise<ResultType>;
+}
+export default SceneController;

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

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+import RangeController from './covering/range-controller';
+import PoiController from './covering/poi-controller';
+import PathController from './covering/path-controller';
+import Text3DController from './covering/text3d-controller';
+import ParticleController from './covering/particle-controller';
+import HighlightAreaController from './covering/highlightarea-controller';
+import HeatMapController from './covering/heatmap-controller';
+import ColumnarHeatMapController from './covering/columnarheatmap-controller';
+import WindowController from './covering/window-controller';
+import ViewshedController from './covering/viewshed-controller';
+import ParabolaController from './covering/parabola-controller';
+import RasterController from './covering/raster-controller';
+import RoadHeatMapController from './covering/roadheatmap-controller';
+import RealTimeVideoController from './covering/realtimevideo-controller';
+import SpaceHeatMapController from './covering/spaceheatmap-controller';
+import BoundController from './covering/bound-controller';
+declare class CoveringController extends Basic {
+    private RequestEntity;
+    Range: RangeController;
+    Poi: PoiController;
+    Path: PathController;
+    Text3D: Text3DController;
+    Particle: ParticleController;
+    HighlightArea: HighlightAreaController;
+    HeatMap: HeatMapController;
+    ColumnarHeatMap: ColumnarHeatMapController;
+    Window: WindowController;
+    Viewshed: ViewshedController;
+    Parabola: ParabolaController;
+    Raster: RasterController;
+    RoadHeatMap: RoadHeatMapController;
+    RealTimeVideo: RealTimeVideoController;
+    SpaceHeatMap: SpaceHeatMapController;
+    Bound: BoundController;
+    constructor(obj: any);
+    ClearByTypes(types: Array<string>): Promise<ResultType>;
+    Clear(): Promise<ResultType>;
+    ClearCache(): Promise<ResultType>;
+}
+export default CoveringController;

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

+import { AtomController } from '../../common/atom-controller';
+declare class BoundController extends AtomController {
+    constructor(obj: any);
+}
+export default BoundController;

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType } from '../../../common/data-type';
+import { BoundType, MoveAlongPathEntityAtomType } from '../../../common/interface/bound';
+import { ObjectController } from '../../../common/object-controller';
+declare class Bound extends ObjectController implements ObjectAbstract {
+    className: string;
+    private MoveAlongPathEntityAtom;
+    private movingObj;
+    private pathObj;
+    constructor(opt?: BoundType);
+    get moving(): any;
+    set moving(movingObj: any);
+    get path(): any;
+    set path(pathObj: any);
+    get time(): number;
+    set time(time: number);
+    get bLoop(): boolean;
+    set bLoop(bLoop: boolean);
+    get bReverse(): boolean;
+    set bReverse(bReverse: boolean);
+    GetMoving(): Promise<ResultType>;
+    SetMoving(movingObj: any): Promise<ResultType>;
+    GetPath(): Promise<ResultType>;
+    SetPath(pathObj: any): Promise<ResultType>;
+    GetTime(): Promise<ResultType>;
+    SetTime(time: number): Promise<ResultType>;
+    GetbLoop(): Promise<ResultType>;
+    SetbLoop(bLoop: boolean): Promise<ResultType>;
+    GetbReverse(): Promise<ResultType>;
+    SetbReverse(bReverse: boolean): Promise<ResultType>;
+    GetScheme(): {
+        MoveAlongPathEntityAtom: MoveAlongPathEntityAtomType;
+    };
+    GetData(): BoundType;
+    SetData(opt: BoundType): void;
+    generateAtomData(opt: BoundType): {
+        MoveAlongPathEntityAtom?: Partial<MoveAlongPathEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+    };
+    SetVisible(bVisible?: boolean): Promise<ResultType>;
+}
+export default Bound;

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

+import { AtomController } from '../../common/atom-controller';
+declare class ColumnarHeatMapController extends AtomController {
+    constructor(obj: any);
+}
+export default ColumnarHeatMapController;