soonspacejs 2.13.5 → 2.13.7

package/dist/src/Animation/createPathAnimation.d.ts

@@ -0,0 +1,61 @@
+import { CreateCurveAnimationClipOptions, BonePathAnimationOptions, AnimationOperate, BonePathAnimationInfo as CreateBonePathAnimationResult, CreateChainSkeletalModelOptions, CreateCurveAnimationClipForBonesOptions } from '@three3d/animation';
+import type { Camera, Curve, Object3D, Skeleton } from 'three';
+import { Vector3 } from 'three';
+import type { IVector3 } from '../Interface';
+import { Topology } from '../Library';
+import { VectorMembersToIVectors } from '@three3d/tools';
+import SoonSpace from '../index';
+/**
+ * 动画的路径
+ * @remarks
+ * 可以是一组点，或者一个曲线 Curve，或者拓扑路径 Topology
+ */
+export type AnimationPath = IVector3[] | Curve<Vector3> | Topology;
+/**
+ * 格式化动画路径信息
+ * @param path
+ * @returns
+ */
+export declare function formatAnimationPath(path: AnimationPath): {
+    curve?: Curve<Vector3> | undefined;
+    points?: Vector3[] | undefined;
+};
+export type CreatePathAnimationOptions = VectorMembersToIVectors<Omit<CreateCurveAnimationClipOptions, 'target' | 'curve' | 'points'>>;
+export declare function createPathAnimation(target: Object3D, path: AnimationPath, ssp: SoonSpace, options?: CreatePathAnimationOptions): AnimationOperate;
+export interface CreatePathAnimationActionForCameraOptions_Base {
+    /**
+     * 眼睛高度
+     */
+    eyeHeight?: number;
+}
+export type CreatePathAnimationActionForCameraOptions = CreatePathAnimationActionForCameraOptions_Base & CreatePathAnimationOptions;
+export declare function createPathAnimationActionForCamera(camera: Camera, path: IVector3[] | Curve<Vector3> | Topology, ssp: SoonSpace, options?: CreatePathAnimationActionForCameraOptions): AnimationOperate;
+export type CreateBonePathAnimationOptions = VectorMembersToIVectors<Omit<BonePathAnimationOptions, 'mixer' | 'model'>>;
+export type BonePathAnimationInfo = Omit<CreateBonePathAnimationResult, 'action'> & {
+    action: AnimationOperate;
+};
+/**
+ * 创建骨骼路径动画
+ * @param options
+ * @returns
+ */
+export declare function createBonePathAnimation(model: Object3D, path: AnimationPath, ssp: SoonSpace, options: CreateBonePathAnimationOptions): BonePathAnimationInfo;
+/**
+ * 为指定的 模型 创建其对应的链式骨骼模型
+ * @param model
+ * @param options
+ * @returns
+ */
+export declare function createChainSkeletalModel(model: Object3D, options: Omit<CreateChainSkeletalModelOptions, 'target'>): {
+    skeletalModel: Object3D<import("three").Event<string, unknown>>;
+    skeleton: Skeleton;
+};
+/**
+ * 创建骨骼沿曲线路径运动的动画
+ * @remarks
+ * 纯 Bone 动画方案，不会在 target 上生成动画数据
+ *
+ * @param options
+ * @returns
+ */
+export declare function createPathAnimationForBones(model: Object3D, skeleton: Skeleton, ssp: SoonSpace, options: Omit<CreateCurveAnimationClipForBonesOptions, 'target'>): AnimationOperate | undefined;

package/dist/src/Animation/index.d.ts

@@ -0,0 +1,4 @@
+import { Tween } from 'three/examples/jsm/libs/tween.module.js';
+import { AnimationOptions } from '../Interface';
+declare function Animation<PropType extends Record<string, any>>(source: PropType, target: PropType, options?: AnimationOptions, onUpdate?: (source: PropType, tween: Tween<PropType>) => void, onStart?: (tween: Tween<PropType>) => void): Promise<void>;
+export default Animation;

package/dist/src/Animation/path-animation.d.ts

@@ -0,0 +1,108 @@
+import { Vector3 } from 'three';
+import type { Object3D } from 'three';
+import type { Tween } from 'three/examples/jsm/libs/tween.module.js';
+import { IVector3 } from '../Interface';
+/**
+ * 路径动画选项
+ */
+export interface PathAnimationOptions {
+    /**
+     * 移动速度
+     */
+    speed?: number;
+    /**
+     * 反向播放
+     */
+    reverse?: boolean;
+    /**
+     * 是否需要旋转
+     */
+    needsRotate?: boolean;
+    /**
+     * 位置更新回调
+     * @remarks
+     * 每当目标位置有更新时会触发
+     */
+    onUpdate?: (position: Vector3, tween: Tween<Vector3>) => void;
+    /**
+     * 动画开始时回调
+     */
+    onStart?: (tween: Tween<Vector3>) => void;
+    /**
+     * 每段 tween 动画开始时回调
+     * @param tween
+     */
+    onEveryStart?: (tween: Tween<Vector3>) => void;
+    /**
+     * 当到达一个点时回调
+     */
+    onPoint?: (index: number, point: Vector3) => void;
+}
+/**
+ * 路径动画
+ */
+export declare class PathAnimation implements PathAnimationOptions {
+    target: Object3D;
+    points: IVector3[];
+    /**
+     *
+     * @param target - 被动画的目标对象
+     * @param points - 路径点列表
+     * @param options - 选项
+     */
+    constructor(target: Object3D, points: IVector3[], options?: PathAnimationOptions);
+    /**
+     * 移动速度
+     */
+    speed: number;
+    /**
+     * 反向播放
+     */
+    reverse: boolean;
+    /**
+     * 是否需要旋转
+     */
+    needsRotate: boolean;
+    /**
+     * 位置更新回调
+     * @remarks
+     * 每当目标位置有更新时会触发
+     */
+    onUpdate?: (position: Vector3, tween: Tween<Vector3>) => void;
+    /**
+     * 动画开始时回调
+     */
+    onStart?: (tween: Tween<Vector3>) => void;
+    /**
+     * 每段 tween 动画开始时回调
+     * @param tween
+     */
+    onEveryStart?: (tween: Tween<Vector3>) => void;
+    /**
+     * 当到达一个点时回调
+     */
+    onPoint?: (index: number, point: Vector3) => void;
+    /**
+     * 当前目标点的索引
+     */
+    index: number;
+    /**
+     * 是否正在播放
+     */
+    get isPlaying(): boolean;
+    protected _tween?: Tween<any> | null;
+    /**
+     * 播放
+     */
+    play(): Promise<boolean | undefined>;
+    protected _play(points: IVector3[]): Promise<true | undefined>;
+    /**
+     * 暂停
+     */
+    pause(): void;
+    resume(): void;
+    /**
+     * 停止
+     */
+    stop(): void;
+}

package/dist/src/Cache/ObjectsCache.d.ts

@@ -0,0 +1,19 @@
+import { Group, Light, Object3D } from 'three';
+import { BaseObject3D, Canvas3D, Decal, Model, PluginObject, Poi, PoiNode, Topology } from '../Library';
+declare class ObjectsCache {
+    objects: Map<BaseObject3D['sid'], Object3D>;
+    classified: {
+        Group: Set<Group<import("three").Object3DEventMap>>;
+        Light: Set<Light<import("three").LightShadow<import("three").Camera> | undefined>>;
+        Model: Set<Model>;
+        Poi: Set<Poi>;
+        PoiNode: Set<PoiNode>;
+        Canvas3D: Set<Canvas3D>;
+        Topology: Set<Topology>;
+        Helper: Set<Object3D<import("three").Object3DEventMap>>;
+        Decal: Set<Decal>;
+        PluginObject: Set<PluginObject>;
+    };
+    dispose(): void;
+}
+export { ObjectsCache, };

package/dist/src/Cache/index.d.ts

@@ -0,0 +1 @@
+export { ObjectsCache, } from './ObjectsCache';

package/dist/src/Constants/headers.d.ts

@@ -0,0 +1 @@
+export declare const FileRequestHeaders: {};

package/dist/src/Constants/index.d.ts

@@ -0,0 +1,22 @@
+export declare const INNER_ID = "[soonspacejs]: ";
+export declare enum ObjecType {
+    Group = "Group",
+    Light = "Light",
+    Model = "Model",
+    Poi = "Poi",
+    PoiNode = "PoiNode",
+    Canvas3D = "Canvas3D",
+    Topology = "Topology",
+    Helper = "Helper",
+    Decal = "Decal",
+    PluginObject = "PluginObject"
+}
+export declare enum ModelFormat {
+    sbm = "SBM",
+    sbmx = "SBMX",
+    glb = "GLB",
+    gltf = "GLTF",
+    fbx = "FBX",
+    obj = "OBJ",
+    stl = "STL"
+}

package/dist/src/Constants/viewpoints.d.ts

@@ -0,0 +1,7 @@
+import { Euler, Spherical } from 'three';
+export declare const viewpoints: {
+    [viewpoint: string]: Euler;
+};
+export declare const viewpointsSpherical: {
+    [viewpoint: string]: Spherical;
+};

package/dist/src/Controls/index.d.ts

@@ -0,0 +1,14 @@
+import Viewport from '../Viewport';
+import CameraControls from 'camera-controls';
+import { ControlsOptions } from '../Interface';
+declare class Controls extends CameraControls {
+    readonly viewport: Viewport;
+    dollySpeed: number;
+    azimuthRotateSpeed: number;
+    polarRotateSpeed: number;
+    truckSpeed: number;
+    draggingSmoothTime: number;
+    constructor(viewport: Viewport);
+    setOptions(options: ControlsOptions): void;
+}
+export default Controls;

package/dist/src/Interface/animation.d.ts

@@ -0,0 +1,10 @@
+type AnimationModeType = 'Linear.None' | 'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' | 'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' | 'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' | 'Quintic.In' | 'Quintic.Out' | 'Quintic.InOut' | 'Sinusoidal.In' | 'Sinusoidal.Out' | 'Sinusoidal.InOut' | 'Exponential.In' | 'Exponential.Out' | 'Exponential.InOut' | 'Circular.In' | 'Circular.Out' | 'Circular.InOut' | 'Elastic.In' | 'Elastic.Out' | 'Elastic.InOut' | 'Back.In' | 'Back.Out' | 'Back.InOut' | 'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut';
+type AnimationModeValueType = (amount: number) => number;
+interface AnimationOptions {
+    duration?: number;
+    delay?: number;
+    repeat?: number | boolean;
+    mode?: AnimationModeType;
+    yoyo?: boolean;
+}
+export { AnimationModeType, AnimationModeValueType, AnimationOptions, };

package/dist/src/Interface/base.d.ts

@@ -0,0 +1,63 @@
+import { ColorRepresentation, Object3D } from 'three';
+interface Interpolate {
+    t: number;
+}
+interface IVector2 {
+    x: number;
+    y: number;
+}
+interface PlaneIVector2 {
+    x: number;
+    z: number;
+}
+interface IVector3 extends IVector2 {
+    z: number;
+}
+interface IVector3 extends IVector2 {
+    z: number;
+}
+type Position = IVector3;
+type Rotation = IVector3;
+type Scale = IVector3;
+type IColor = ColorRepresentation;
+interface Level {
+    max: number | null;
+    min: number | null;
+}
+interface OffsetPoint {
+    offsetX: number;
+    offsetY: number;
+}
+type FlyToViewpoint = 'current' | 'top' | 'bottom' | 'front' | 'back' | 'left' | 'right' | 'frontTop' | 'backTop' | 'leftTop' | 'rightTop' | 'leftFrontTop' | 'rightFrontTop' | 'leftBackTop' | 'rightBackTop';
+type AxisType = 'x' | 'y' | 'z';
+type SceneEventType = 'hover' | 'click' | 'rightClick' | 'dblClick';
+type SceneEventTypeUppercase = 'Hover' | 'Click' | 'RightClick' | 'DblClick';
+type PoiType = '2d' | '2D' | '2.5d' | '2.5D' | '3d' | '3D';
+type PoiNodeType = PoiType;
+interface BaseSelectOptions {
+    color?: IColor;
+    opacity?: number;
+}
+interface BaseObjectInfo {
+    id: string;
+    name?: string;
+    level?: Level;
+    visible?: boolean;
+    position?: Position;
+    rotation?: Rotation;
+    scale?: Scale;
+    userData?: any;
+    extraIds?: string[];
+}
+interface BaseObject3DInfo extends BaseObjectInfo {
+    onLoad?: ((object: Object3D) => void) | null;
+    onClick?: ((object: Object3D) => void) | null;
+    onDblClick?: ((object: Object3D) => void) | null;
+    onRightClick?: ((object: Object3D) => void) | null;
+}
+interface ScaleFixed {
+    originScale: number;
+    fixedScale: number;
+    distance: number;
+}
+export { Interpolate, IVector2, IVector3, Position, Rotation, Scale, IColor, PlaneIVector2, Level, OffsetPoint, FlyToViewpoint, AxisType, SceneEventType, SceneEventTypeUppercase, PoiType, PoiNodeType, BaseSelectOptions, BaseObject3DInfo, BaseObjectInfo, ScaleFixed, };

package/dist/src/Interface/controls.d.ts

@@ -0,0 +1,94 @@
+import { Object3D, Vector3 } from 'three';
+export type FreeControlsType = 'free';
+export type OrbitControlsType = 'orbit';
+export type ControlsType = FreeControlsType | OrbitControlsType;
+export interface FreeControlsOptions {
+    type: FreeControlsType;
+    enabled?: boolean;
+    enabledMousePointInteractive?: boolean;
+    fallbackInteractivePosition?: Vector3 | null;
+    enableZoom?: boolean;
+    zoomSpeed?: number;
+    zoomMinDistance?: number;
+    zoomMaxDistance?: number;
+    zoomMinStepDistance?: number;
+    zoomMaxStepDistance?: number;
+    enableRotate?: boolean;
+    enableRotateX?: boolean;
+    enableRotateY?: boolean;
+    rotateSpeed?: number;
+    rotateTiltRange?: {
+        max: number;
+        min: number;
+    };
+    enableAutoRotate?: boolean;
+    autoRotateSpeed?: number;
+    autoRotateClockwise?: boolean;
+    enableOutOfScene?: boolean;
+    unOffsetOfScene?: number;
+    enablePan?: boolean;
+    enablePanX?: boolean;
+    enablePanY?: boolean;
+    enablePanAxisX?: boolean;
+    enablePanAxisY?: boolean;
+    enablePanAxisZ?: boolean;
+    panSpeed?: number;
+}
+export type FreeControlsProperties = Required<Omit<FreeControlsOptions, 'type'>>;
+export interface OrbitControlsOptions {
+    type: OrbitControlsType;
+    enableAutoRotate?: boolean;
+    autoRotateSpeed?: number;
+    dampingFactor?: number;
+    enabled?: boolean;
+    enableDamping?: boolean;
+    enablePan?: boolean;
+    enableRotate?: boolean;
+    enableZoom?: boolean;
+    maxAzimuthAngle?: number;
+    maxDistance?: number;
+    maxPolarAngle?: number;
+    maxZoom?: number;
+    minAzimuthAngle?: number;
+    minDistance?: number;
+    minPolarAngle?: number;
+    minZoom?: number;
+    panSpeed?: number;
+    rotateSpeed?: number;
+    screenSpacePanning?: boolean;
+    target?: Vector3;
+    zoomSpeed?: number;
+}
+export type OrbitControlsProperties = Required<Omit<OrbitControlsOptions, 'type'>>;
+export interface ControlsOptions {
+    enabled?: boolean;
+    minDistance?: number;
+    maxDistance?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    minPolarAngle?: number;
+    maxPolarAngle?: number;
+    minAzimuthAngle?: number;
+    maxAzimuthAngle?: number;
+    boundaryFriction?: number;
+    boundaryEnclosesCamera?: boolean;
+    smoothTime?: number;
+    draggingSmoothTime?: number;
+    azimuthRotateSpeed?: number;
+    polarRotateSpeed?: number;
+    dollySpeed?: number;
+    truckSpeed?: number;
+    maxSpeed?: number;
+    verticalDragToForward?: boolean;
+    dollyToCursor?: boolean;
+    dollyDragInverted?: boolean;
+    interactiveArea?: DOMRect | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    colliderMeshes?: Object3D[];
+    infinityDolly?: boolean;
+    restThreshold?: number;
+}

package/dist/src/Interface/events.d.ts

@@ -0,0 +1,40 @@
+import { Mesh, Intersection } from 'three';
+import { Poi, Model } from '../Library';
+import { Position, SceneEventType } from './base';
+interface ScenePoiIntersect {
+    poi: Poi;
+    sourceData: Intersection;
+}
+interface SceneModelIntersect {
+    model: Model;
+    sourceData: Intersection;
+}
+interface ModelEventParams {
+    target: Model;
+    currentTarget: Mesh;
+    intersects: SceneModelIntersect[];
+    event: MouseEvent | TouchEvent;
+}
+interface PoiEventParams {
+    target: Poi;
+    event: MouseEvent | TouchEvent;
+}
+interface SceneClickParam {
+    type: SceneEventType;
+    event: MouseEvent | TouchEvent;
+}
+interface SceneGlobalEvents {
+    modelHover?: (param: ModelEventParams) => void;
+    modelUnHover?: (model: Model) => void;
+    modelClick?: (param: ModelEventParams) => void;
+    modelRightClick?: (param: ModelEventParams) => void;
+    modelDblClick?: (param: ModelEventParams) => void;
+    poiHover?: (poi: PoiEventParams) => void;
+    poiUnHover?: (poi: Poi) => void;
+    poiClick?: (poi: PoiEventParams) => void;
+    poiRightClick?: (poi: PoiEventParams) => void;
+    poiDblClick?: (poi: PoiEventParams) => void;
+    selectPosition?: (position: Position) => void;
+    sceneClick?: (param: SceneClickParam) => void;
+}
+export { ScenePoiIntersect, SceneModelIntersect, ModelEventParams, SceneClickParam, SceneGlobalEvents, };

package/dist/src/Interface/gmlToJson.d.ts

@@ -0,0 +1,189 @@
+interface State {
+    State: {
+        _attributes: {
+            'gml:id': string;
+            serialid: string;
+        };
+        topoNode: {
+            'gml:Node': {
+                _attributes: {
+                    'gml:id': string;
+                    serialid: string;
+                };
+                'gml:pointProperty': {
+                    'gml:Point': {
+                        'gml:Pos': string;
+                    };
+                };
+                floor: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                floor_name: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                node_name: string;
+                type: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                xcoord: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                ycoord: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                zcoord: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                link_cnt: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                adjacency_link: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+            };
+        };
+    };
+}
+interface Transition {
+    Transition: {
+        _attributes: {
+            'gml:id': string;
+            serialid: string;
+        };
+        topoEdge: {
+            'gml:Edge': {
+                'gml:directedNode': {
+                    _attributes: {
+                        'xlink:href': string;
+                    };
+                }[];
+                'gml:curveProperty': {
+                    'gml:LineString': {
+                        'gml:posList': string;
+                    };
+                };
+                link_name: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                snode: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                enode: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                length: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                type: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                move_type: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                passable: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                restrict: {
+                    _attributes: {
+                        type: string;
+                    };
+                    '#text': string;
+                };
+                Width: {
+                    _attributes: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+}
+interface X_floor {
+    _attributes: {
+        id: string;
+        number: string;
+        level: string;
+        displayname: string;
+        index: string;
+        lefttop: string;
+        rightbottom: string;
+    };
+    state: State[];
+    transition: Transition[];
+}
+interface GmlJson {
+    MultiLayeredGraph: {
+        _attributes: {
+            version: string;
+            xmlns: string;
+            'xmlns:gml': string;
+            'xmlns:xlink': string;
+            'xmlns:xsi': string;
+            'xsi:schemaLocation': string;
+        };
+        X_definition: {
+            zcoord: {
+                apply_floorheight: string;
+            };
+            restrict: {
+                restrict_bit: string;
+            };
+        };
+        SpaceLayerMember: {
+            SpaceLayer: {
+                _attributes: {
+                    northbound: string;
+                };
+                class: string;
+                'gml:name': string;
+                X_floor: X_floor | X_floor[];
+            };
+        };
+    };
+}
+export { State, Transition, X_floor, GmlJson, };

package/dist/src/Interface/index.d.ts

@@ -0,0 +1,13 @@
+export * from './base';
+export * from './events';
+export * from './animation';
+export * from './modelAnimation';
+export * from './manager';
+export * from './plugin';
+export * from './signals';
+export * from './viewport';
+export * from './controls';
+export * from './sbmCache';
+export * from './sbmXmlToJson';
+export * from './gmlToJson';
+export * from './poiMesh';