51world示例集合

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPointValueAtom, IPoint } from '../../../common/data-type';
+import { RoadHeatMapType, RoadHeatMapEntityAtomType } from '../../../common/interface/roadheatmap';
+import { ObjectController } from '../../../common/object-controller';
+declare class RoadHeatMap extends ObjectController implements ObjectAbstract {
+    className: string;
+    private RoadHeatMapEntityAtom;
+    private PointValueAtom;
+    constructor(opt?: RoadHeatMapType);
+    get sType(): string;
+    set sType(type: string);
+    get width(): number;
+    set width(width: number);
+    get mappingValueRange(): Array<number>;
+    set mappingValueRange(mappingValueRange: Array<number>);
+    get gradientSetting(): Array<string>;
+    set gradientSetting(gradientSetting: Array<string>);
+    get filter(): Array<string>;
+    set filter(filter: Array<string>);
+    get features(): Array<IPoint>;
+    set features(features: Array<IPoint>);
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetWidth(): Promise<ResultType>;
+    SetWidth(width: number): Promise<ResultType>;
+    GetMappingValueRange(): Promise<ResultType>;
+    SetMappingValueRange(mappingValueRange: Array<number>): Promise<ResultType>;
+    GetGradientSetting(): Promise<ResultType>;
+    SetGradientSetting(gradientSetting: Array<string>): Promise<ResultType>;
+    GetFilter(): Promise<ResultType>;
+    SetFilter(filter: Array<string>): Promise<ResultType>;
+    GetFeatures(): Promise<ResultType>;
+    SetFeatures(features: Array<IPoint>): Promise<ResultType>;
+    GetScheme(): {
+        RoadHeatMapEntityAtom: RoadHeatMapEntityAtomType;
+        PointValueAtom: IPointValueAtom;
+    };
+    GetData(): RoadHeatMapType;
+    SetData(opt: RoadHeatMapType): void;
+    generateAtomData(opt: RoadHeatMapType): {
+        RoadHeatMapEntityAtom?: Partial<RoadHeatMapEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        PointValueAtom?: Partial<IPointValueAtom>;
+    };
+}
+export default RoadHeatMap;

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

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

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPointValueAtom, IPoint } from '../../../common/data-type';
+import { SpaceHeatMapType, SpaceHeatMapEntityAtomType } from '../../../common/interface/spaceheatmap';
+import { ObjectController } from '../../../common/object-controller';
+declare class SpaceHeatMap extends ObjectController implements ObjectAbstract {
+    className: string;
+    private SpaceHeatMapEntityAtom;
+    private PointValueAtom;
+    constructor(opt?: SpaceHeatMapType);
+    get brushDiameter(): number;
+    set brushDiameter(brushDiameter: number);
+    get mappingValueRange(): Array<number>;
+    set mappingValueRange(mappingValueRange: Array<number>);
+    get gradientSetting(): Array<string>;
+    set gradientSetting(gradientSetting: Array<string>);
+    get features(): Array<IPoint>;
+    set features(features: Array<IPoint>);
+    GetBrushDiameter(): Promise<ResultType>;
+    SetBrushDiameter(brushDiameter: number): Promise<ResultType>;
+    GetMappingValueRange(): Promise<ResultType>;
+    SetMappingValueRange(mappingValueRange: Array<number>): Promise<ResultType>;
+    GetGradientSetting(): Promise<ResultType>;
+    SetGradientSetting(gradientSetting: Array<string>): Promise<ResultType>;
+    GetFeatures(): Promise<ResultType>;
+    SetFeatures(features: Array<IPoint>): Promise<ResultType>;
+    GetScheme(): {
+        SpaceHeatMapEntityAtom: SpaceHeatMapEntityAtomType;
+        PointValueAtom: IPointValueAtom;
+    };
+    GetData(): SpaceHeatMapType;
+    SetData(opt: SpaceHeatMapType): void;
+    generateAtomData(opt: SpaceHeatMapType): {
+        SpaceHeatMapEntityAtom?: Partial<SpaceHeatMapEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        PointValueAtom?: Partial<IPointValueAtom>;
+    };
+}
+export default SpaceHeatMap;

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

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

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { Text3DType, Text3DEntityAtomType } from '../../../common/interface/text3d';
+import { ObjectController } from '../../../common/object-controller';
+declare class Text3D extends ObjectController implements ObjectAbstract {
+    className: string;
+    private Text3DEntityAtom;
+    constructor(opt?: Text3DType);
+    get text(): string;
+    set text(text: string);
+    get color(): string;
+    set color(color: string);
+    get sType(): string;
+    set sType(type: string);
+    get outline(): number;
+    set outline(outline: number);
+    get portrait(): boolean;
+    set portrait(portrait: boolean);
+    get space(): number;
+    set space(space: number);
+    get bounce(): number;
+    set bounce(bounce: number);
+    GetText(): Promise<ResultType>;
+    SetText(text: string): Promise<ResultType>;
+    GetColor(): Promise<ResultType>;
+    SetColor(color: string): Promise<ResultType>;
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetOutline(): Promise<ResultType>;
+    SetOutline(outline: number): Promise<ResultType>;
+    GetPortrait(): Promise<ResultType>;
+    SetPortrait(portrait: boolean): Promise<ResultType>;
+    GetSpace(): Promise<ResultType>;
+    SetSpace(space: number): Promise<ResultType>;
+    GetBounce(): Promise<ResultType>;
+    SetBounce(bounce: number): Promise<ResultType>;
+    GetScheme(): {
+        Text3DEntityAtom: Text3DEntityAtomType;
+    };
+    GetData(): Text3DType;
+    SetData(opt: Text3DType): void;
+    generateAtomData(opt: Text3DType): {
+        Text3DEntityAtom?: Partial<Text3DEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Text3D;

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

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

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { ViewshedType, ViewShedEntityAtomType } from '../../../common/interface/viewshed';
+import { ObjectController } from '../../../common/object-controller';
+declare class Viewshed extends ObjectController implements ObjectAbstract {
+    className: string;
+    private ViewShedEntityAtom;
+    constructor(opt?: ViewshedType);
+    get visibleColor(): string;
+    set visibleColor(visibleColor: string);
+    get hiddenColor(): string;
+    set hiddenColor(hiddenColor: string);
+    get outline(): boolean;
+    set outline(outline: boolean);
+    get fieldOfView(): number;
+    set fieldOfView(fieldOfView: number);
+    get radius(): number;
+    set radius(radius: number);
+    GetVisibleColor(): Promise<ResultType>;
+    SetVisibleColor(visibleColor: string): Promise<ResultType>;
+    GetHiddenColor(): Promise<ResultType>;
+    SetHiddenColor(hiddenColor: string): Promise<ResultType>;
+    GetOutline(): Promise<ResultType>;
+    SetOutline(outline: boolean): Promise<ResultType>;
+    GetFieldOfView(): Promise<ResultType>;
+    SetFieldOfView(fieldOfView: number): Promise<ResultType>;
+    GetRadius(): Promise<ResultType>;
+    SetRadius(radius: number): Promise<ResultType>;
+    GetScheme(): {
+        ViewShedEntityAtom: ViewShedEntityAtomType;
+    };
+    GetData(): ViewshedType;
+    SetData(opt: ViewshedType): void;
+    generateAtomData(opt: ViewshedType): {
+        ViewShedEntityAtom?: Partial<ViewShedEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Viewshed;

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

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

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, MinMaxType, Coord2DType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { WindowType, WindowEntityAtomType } from '../../../common/interface/window';
+import { ObjectController } from '../../../common/object-controller';
+declare class Poi extends ObjectController implements ObjectAbstract {
+    className: string;
+    private apiClassName;
+    private WindowEntityAtom;
+    constructor(opt?: WindowType);
+    get url(): string;
+    set url(url: string);
+    get size(): MinMaxType;
+    set size(size: MinMaxType);
+    get offset(): Coord2DType;
+    set offset(offset: Coord2DType);
+    GetUrl(): Promise<ResultType>;
+    SetUrl(url: string): Promise<ResultType>;
+    GetSize(): Promise<ResultType>;
+    SetSize(size: MinMaxType): Promise<ResultType>;
+    GetOffset(): Promise<ResultType>;
+    SetOffset(offset: Coord2DType): Promise<ResultType>;
+    GetScheme(): {
+        WindowEntityAtom: WindowEntityAtomType;
+    };
+    GetData(): WindowType;
+    SetData(opt: WindowType): void;
+    generateAtomData(opt: WindowType): {
+        WindowEntityAtom?: Partial<WindowEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Poi;

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

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

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

+import { ObjectAbstract } from '../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, TransformAtomType } from '../../common/data-type';
+import { EffectType, EffectsAtomType } from '../../common/interface/effect';
+import { ObjectController } from '../../common/object-controller';
+declare class Effects extends ObjectController implements ObjectAbstract {
+    className: string;
+    private EffectsAtom;
+    constructor(opt?: EffectType);
+    get bActive(): boolean;
+    set bActive(bActive: boolean);
+    get speed(): number;
+    set speed(speed: number);
+    GetbActive(): Promise<ResultType>;
+    SetbActive(bActive: boolean): Promise<ResultType>;
+    GetSpeed(): Promise<ResultType>;
+    SetSpeed(speed: number): Promise<ResultType>;
+    GetScheme(): {
+        EffectsAtom: EffectsAtomType;
+    };
+    GetData(): EffectType;
+    SetData(opt: EffectType): void;
+    generateAtomData(opt: EffectType): {
+        PathEntEffectsAtomityAtom?: Partial<EffectsAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Effects;

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

+import { AtomController } from '../common/atom-controller';
+import { ResultType } from '../common/data-type';
+declare class GroupController extends AtomController {
+    constructor(obj: any);
+    Get(eid?: string): Promise<ResultType>;
+    GenerateObject(res: any): Promise<any>;
+    GetOnly(eid: string): Promise<ResultType>;
+}
+export default GroupController;

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

+import { ObjectAbstract } from '../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, TransformAtomType, VisibleAtomType, CoordType, RotatorType, ScaleType } from '../../common/data-type';
+import { GroupType, EntityChildrenAtomType } from '../../common/interface/group';
+import { ObjectController } from '../../common/object-controller';
+declare class Group extends ObjectController implements ObjectAbstract {
+    className: string;
+    private apiClassName;
+    private EntityChildrenAtom;
+    private childrenEntities;
+    private WdpGroupTransformAtom;
+    private WdpGroupVisibleAtom;
+    constructor(opt?: GroupType);
+    get bVisible(): boolean;
+    set bVisible(bVisible: boolean);
+    get location(): CoordType;
+    set location(location: CoordType);
+    get rotator(): RotatorType;
+    set rotator(rotator: RotatorType);
+    get scale3d(): ScaleType;
+    set scale3d(scale3d: ScaleType);
+    get childrenEids(): Array<string>;
+    set childrenEids(childrenEids: Array<string>);
+    get children(): Array<any>;
+    set children(childrenEntities: Array<any>);
+    getChildren(): Promise<ResultType>;
+    setChildren(childrenEntities: Array<any>): Promise<ResultType>;
+    GetVisible(): Promise<ResultType>;
+    SetVisible(bVisible?: boolean): Promise<ResultType>;
+    GetLocation(): Promise<ResultType>;
+    SetLocation(location: CoordType): Promise<ResultType>;
+    GetRotator(): Promise<ResultType>;
+    SetRotator(rotator: RotatorType): Promise<ResultType>;
+    GetScale3d(): Promise<ResultType>;
+    SetScale3d(scale3d: ScaleType): Promise<ResultType>;
+    GetScheme(): {
+        EntityChildrenAtom: EntityChildrenAtomType;
+    };
+    GetData(): GroupType;
+    SetData(opt: GroupType): void;
+    generateAtomData(opt: GroupType): {
+        EntityChildrenAtom?: Partial<EntityChildrenAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        WdpGroupTransformAtom?: Partial<TransformAtomType>;
+        WdpGroupVisibleAtom?: Partial<VisibleAtomType>;
+    };
+    generateLocationAtom(location: CoordType): any;
+    generateRotatorAtom(rotator: RotatorType): any;
+    generateScale3dAtom(scale3d: ScaleType): any;
+    generateVisibleAtom(bVisible: boolean): any;
+    UnGroup(): Promise<ResultType>;
+    Add(objs: Array<Record<string, any>>, addToGroupPosition?: number): Promise<ResultType>;
+}
+export default Group;

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

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+import StaticController from './model/static-controller';
+import HierarchyController from './model/hierarchy-controller';
+import SkeletalController from './model/skeletal-controller';
+declare class ModelController extends Basic {
+    private RequestEntity;
+    Static: StaticController;
+    Hierarchy: HierarchyController;
+    Skeletal: SkeletalController;
+    constructor(obj: any);
+    ClearByTypes(types: Array<string>): Promise<ResultType>;
+    Clear(): Promise<ResultType>;
+    ClearCache(): Promise<ResultType>;
+}
+export default ModelController;

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

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

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, AssetAtomType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { MaterialAtomType, IMaterial } from '../../../common/interface/material';
+import { HierarchyType } from '../../../common/interface/hierarchy';
+import { ObjectController } from '../../../common/object-controller';
+declare class Hierarchy extends ObjectController implements ObjectAbstract {
+    className: string;
+    private AssetAtom;
+    private MaterialAtom;
+    constructor(opt?: HierarchyType);
+    get seedId(): string | null;
+    set seedId(seedId: string | null);
+    get changedMaterialInfo(): Array<IMaterial>;
+    set changedMaterialInfo(changedMaterialInfo: Array<IMaterial>);
+    GetSeedId(): Promise<ResultType>;
+    SetSeedId(seedId: string | null): Promise<ResultType>;
+    GetChangedMaterialInfo(): Promise<ResultType>;
+    SetChangedMaterialInfo(changedMaterialInfo: Array<IMaterial>): Promise<ResultType>;
+    GetScheme(): {
+        AssetAtom: AssetAtomType;
+        MaterialAtom: MaterialAtomType;
+    };
+    GetData(): HierarchyType;
+    SetData(opt: HierarchyType): void;
+    generateAtomData(opt: HierarchyType): {
+        AssetAtom?: Partial<AssetAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Hierarchy;

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

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

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, AssetAtomType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { SkeletalType, SkeletalMeshAtomType } from '../../../common/interface/skeletal';
+import { ObjectController } from '../../../common/object-controller';
+declare class Skeletal extends ObjectController implements ObjectAbstract {
+    className: string;
+    private AssetAtom;
+    private SkeletalMeshAtom;
+    constructor(opt?: SkeletalType);
+    get seedId(): string | null;
+    set seedId(seedId: string | null);
+    get animSequenceIndex(): number;
+    set animSequenceIndex(animSequenceIndex: number);
+    get bPause(): boolean;
+    set bPause(bPause: boolean);
+    get bLoop(): boolean;
+    set bLoop(bLoop: boolean);
+    get playRate(): number;
+    set playRate(playRate: number);
+    get playInterval(): {
+        min: number;
+        max: number;
+    };
+    set playInterval(playInterval: {
+        min: number;
+        max: number;
+    });
+    GetSeedId(): Promise<ResultType>;
+    SetSeedId(seedId: string | null): Promise<ResultType>;
+    GetAnimSequenceIndex(): Promise<ResultType>;
+    SetAnimSequenceIndex(animSequenceIndex: number): Promise<ResultType>;
+    GetbPause(): Promise<ResultType>;
+    SetbPause(bPause: boolean): Promise<ResultType>;
+    GetbLoop(): Promise<ResultType>;
+    SetbLoop(bLoop: boolean): Promise<ResultType>;
+    GetPlayRate(): Promise<ResultType>;
+    SetPlayRate(playRate: number): Promise<ResultType>;
+    GetPlayInterval(): Promise<ResultType>;
+    SetPlayInterval(playInterval: {
+        min: number;
+        max: number;
+    }): Promise<ResultType>;
+    GetScheme(): {
+        AssetAtom: AssetAtomType;
+        SkeletalMeshAtom: SkeletalMeshAtomType;
+    };
+    GetData(): SkeletalType;
+    SetData(opt: SkeletalType): void;
+    generateAtomData(opt: SkeletalType): {
+        SkeletalMeshAtom?: Partial<SkeletalMeshAtomType>;
+        AssetAtom?: Partial<AssetAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Skeletal;

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

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

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

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, AssetAtomType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { MaterialAtomType, IMaterial } from '../../../common/interface/material';
+import { StaticType } from '../../../common/interface/static';
+import { ObjectController } from '../../../common/object-controller';
+declare class Static extends ObjectController implements ObjectAbstract {
+    className: string;
+    private AssetAtom;
+    private MaterialAtom;
+    constructor(opt?: StaticType);
+    get seedId(): string | null;
+    set seedId(seedId: string | null);
+    get changedMaterialInfo(): Array<IMaterial>;
+    set changedMaterialInfo(changedMaterialInfo: Array<IMaterial>);
+    GetSeedId(): Promise<ResultType>;
+    SetSeedId(seedId: string | null): Promise<ResultType>;
+    GetChangedMaterialInfo(): Promise<ResultType>;
+    SetChangedMaterialInfo(changedMaterialInfo: Array<IMaterial>): Promise<ResultType>;
+    GetScheme(): {
+        AssetAtom: AssetAtomType;
+        MaterialAtom: MaterialAtomType;
+    };
+    GetData(): StaticType;
+    SetData(opt: StaticType): void;
+    generateAtomData(opt: StaticType): {
+        AssetAtom?: Partial<AssetAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Static;