@realsee/dnalogel 2.1.0-alpha.13 → 2.1.0-alpha.15

package/libs/src/floorplan/utils/formatPosition.js

@@ -0,0 +1,50 @@
+export function pathD(points, options = {}) {
+    let d = '';
+    const { needZ, needA } = options;
+    const _points = needZ ? points.slice().concat(points[0]) : points.slice();
+    _points.forEach((_point, index) => {
+        const { x, y } = options.format ? options.format(_point) : _point;
+        const point = x + ',' + y;
+        if (index === 0) {
+            d += 'M' + point;
+            return d;
+        }
+        if (needA === null || needA === void 0 ? void 0 : needA[index]) {
+            d += 'A' + needA[index] + ',' + point;
+            return d;
+        }
+        d += 'L' + point;
+        return d;
+    });
+    return d + (needZ ? 'Z' : '');
+}
+/** 把户型图上点点位转换到 SVG 上的点位 */
+export default function formatFloorplanPoint({ x, y }, bounding) {
+    const { max, min } = bounding;
+    return { x: x - min.x, y: max.y - y };
+}
+/** 模型坐标转户型图坐标 */
+export function modelPosition2FloorplanPosition(position, floorplanData) {
+    const x = position.x * 1000 + floorplanData.bounding.origin.x;
+    const y = -position.z * 1000 + floorplanData.bounding.origin.y;
+    return { x, y };
+}
+/** 户型图点位转在图片上的相对坐标 */
+export function floorplanPosition2ImagePosition(position, floorplanData) {
+    const bounding = floorplanData.bounding;
+    const boundingWidth = bounding.max.x - bounding.min.x;
+    const boundingHeight = bounding.max.y - bounding.min.y;
+    return {
+        x: (position.x - bounding.min.x) / boundingWidth,
+        y: (bounding.max.y - position.y) / boundingHeight,
+    };
+}
+/** 求三维坐标点所在的楼层 */
+export function getFloorIndexFromModelPosition(position, five) {
+    const floorIndex = Math.max(...five.work.observers.map((observer) => {
+        if (position.z >= observer.standingPosition.z)
+            return observer.floorIndex;
+        return 0;
+    }));
+    return floorIndex;
+}

package/libs/src/index.d.ts

@@ -0,0 +1,22 @@
+export * from './ModelViewPlugin';
+export * from './CSS3DRenderPlugin';
+export * from './PanoCursorRaycasterPlugin';
+export * from './ModelRoomLabelPlugin';
+export * from './floorplan';
+export * from './ModelChassisCompassPlugin';
+export * from './ModelEntryDoorGuidePlugin';
+export * from './CameraMovementPlugin';
+export * from './PanoRulerPlugin';
+export * from './PanoRulerProPlugin';
+export * from './PanoCompassPlugin';
+export * from './PanoMeasurePlugin';
+export * from './PanoSpatialTagPlugin';
+export * from './ModelItemLabelPlugin';
+export * from './ModelTVVideoPlugin';
+export * from './ItemLabelPlugin';
+export * from './PanoDoorLabelPlugin';
+export * from './GuideLinePlugin';
+export * from './CruisePlugin';
+export * from './PanoTagPlugin';
+export * from './Object3DHelperPlugin';
+export declare const DnalogelVersion = "2.0.0-alpha.58";

package/libs/src/index.js

@@ -0,0 +1,39 @@
+export * from './ModelViewPlugin';
+export * from './CSS3DRenderPlugin';
+export * from './PanoCursorRaycasterPlugin';
+// 模型房屋标签
+export * from './ModelRoomLabelPlugin';
+// floorplan
+export * from './floorplan';
+// 模型底盘
+export * from './ModelChassisCompassPlugin';
+// 模型入户门
+export * from './ModelEntryDoorGuidePlugin';
+export * from './CameraMovementPlugin';
+// 全景标尺
+export * from './PanoRulerPlugin';
+// 全景标尺Pro版
+export * from './PanoRulerProPlugin';
+// 全景指南针
+export * from './PanoCompassPlugin';
+// pc 全景测量工具
+export * from './PanoMeasurePlugin';
+// 空间三维标签
+export * from './PanoSpatialTagPlugin';
+// 模型物品标签插件
+export * from './ModelItemLabelPlugin';
+// 模型电视插件
+export * from './ModelTVVideoPlugin';
+// 物品标签
+export * from './ItemLabelPlugin';
+// 分间标签
+export * from './PanoDoorLabelPlugin';
+// 路线引导Mesh
+export * from './GuideLinePlugin';
+// 漫游插件
+export * from './CruisePlugin';
+// 全景标签插件
+export * from './PanoTagPlugin';
+// 三维物体编辑插件
+export * from './Object3DHelperPlugin';
+export const DnalogelVersion = '2.0.0-alpha.58';

package/libs/src/shared-utils/Object3DHelper/Base/BaseController.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from 'three';
+import { Subscribe } from '../../Subscribe';
+import type { HelperEventMap } from '../typings';
+import type { BaseHelper } from './BaseHelper';
+import DomEvents from '../utils/threex/domevents';
+export declare let originOpacity: {
+    opacity: number;
+} | null;
+export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
+    hooks: Subscribe<HelperEventMap>;
+    helperObject3D: T;
+    originObject3D: K;
+    protected camera: THREE.Camera;
+    protected model: THREE.Object3D;
+    protected scene: THREE.Scene;
+    protected container: HTMLElement;
+    protected domEvents: DomEvents;
+    protected isDragging: boolean;
+    protected onRender: () => void;
+    protected enabled: boolean;
+    constructor(camera: THREE.Camera, model: THREE.Object3D, originObject3D: K, helperObject3D: T, container: HTMLElement, scene: THREE.Scene, onRender?: () => void);
+    initialHelperPosition(): void;
+    initialHelperQuaternion(): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    setOpacity(opacity: number): void;
+    restoreOpacity(): void;
+    setOriginOpacityProperty(): void;
+    updateHelperPosition(): void;
+    updateHelperQuaternion(): void;
+    applyHelperMatrix4(matrix4: THREE.Matrix4): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    applyHelperScaleMatrix4(matrix4: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    onWantsTapGesture: (raycaster: THREE.Raycaster) => false | void;
+    onWantsGesture(type: 'press' | 'pan' | string, pointers: {
+        x: number;
+        y: number;
+    }[], final: boolean): false | void;
+    protected render(): void;
+    protected hoverListener(object3D: THREE.Object3D | undefined | THREE.Group | (THREE.Object3D | undefined | THREE.Group)[], hoverColor?: THREE.Color | string | number, hoverOpacity?: number): () => void;
+    private getIntersectObject;
+}

package/libs/src/shared-utils/Object3DHelper/Base/BaseController.js

@@ -0,0 +1,271 @@
+import * as THREE from 'three';
+import { Subscribe } from '../../Subscribe';
+import DomEvents from '../utils/threex/domevents';
+import { notNil } from '../../isNil';
+import { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/CSS3DObjectPlus';
+export let originOpacity = null;
+export class BaseController {
+    constructor(camera, model, originObject3D, helperObject3D, container, scene, onRender) {
+        Object.defineProperty(this, "hooks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Subscribe()
+        });
+        Object.defineProperty(this, "helperObject3D", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "originObject3D", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "camera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scene", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "container", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "domEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isDragging", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onRender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "enabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onWantsTapGesture", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (raycaster) => {
+                const selectedObject = this.getIntersectObject(raycaster);
+                if (selectedObject)
+                    return false;
+                return;
+            }
+        });
+        this.camera = camera;
+        this.model = model;
+        this.originObject3D = originObject3D;
+        this.helperObject3D = helperObject3D;
+        this.container = container;
+        this.scene = scene;
+        this.domEvents = new DomEvents(camera, container);
+        this.onRender = onRender !== null && onRender !== void 0 ? onRender : (() => { });
+        this.initialHelperPosition();
+        this.initialHelperQuaternion();
+        this.enable();
+    }
+    initialHelperPosition() {
+        this.helperObject3D.updatePosition();
+    }
+    initialHelperQuaternion() {
+        this.helperObject3D.updateQuaternion();
+    }
+    enable() {
+        if (this.enabled)
+            return;
+        this.enabled = true;
+        this.scene.add(this.helperObject3D);
+        this.render();
+    }
+    disable() {
+        if (!this.enabled)
+            return;
+        this.enabled = false;
+        this.scene.remove(this.helperObject3D);
+        this.render();
+    }
+    show() {
+        this.helperObject3D.show();
+        this.render();
+    }
+    hide() {
+        this.helperObject3D.hide();
+        this.render();
+    }
+    dispose() {
+        this.helperObject3D.dispose();
+        this.scene.remove(this.helperObject3D);
+        this.render();
+    }
+    setOpacity(opacity) {
+        this.setOriginOpacityProperty();
+        const originObject3D = this.originObject3D;
+        if (originObject3D instanceof THREE.Mesh) {
+            originObject3D.material.opacity = opacity;
+        }
+        if (originObject3D instanceof CSS3DObjectPlus) {
+            originObject3D.container.style.opacity = opacity;
+        }
+        this.render();
+    }
+    restoreOpacity() {
+        if (originOpacity === null)
+            return;
+        const originObject3D = this.originObject3D;
+        if (originObject3D instanceof THREE.Mesh) {
+            originObject3D.material.opacity = originOpacity.opacity;
+        }
+        if (originObject3D instanceof CSS3DObjectPlus) {
+            originObject3D.container.style.opacity = originOpacity.opacity;
+        }
+        this.render();
+    }
+    setOriginOpacityProperty() {
+        var _a;
+        if (originOpacity === null) {
+            const originObject3D = this.originObject3D;
+            if (originObject3D instanceof THREE.Mesh) {
+                originOpacity = {
+                    opacity: originObject3D.material.opacity,
+                };
+            }
+            if (originObject3D instanceof CSS3DObjectPlus) {
+                originOpacity = {
+                    opacity: (_a = originObject3D.container.style.opacity) !== null && _a !== void 0 ? _a : 1,
+                };
+            }
+        }
+    }
+    updateHelperPosition() {
+        this.helperObject3D.updatePosition();
+    }
+    updateHelperQuaternion() {
+        this.helperObject3D.updateQuaternion();
+    }
+    // public setHelperPosition(position: THREE.Vector3) {
+    //   this.helperObject3D.setPosition(position)
+    // }
+    applyHelperMatrix4(matrix4) {
+        this.helperObject3D.applyMatrix4(matrix4);
+    }
+    applyHelperQuaternion(quaternion, origin) {
+        this.helperObject3D.applyHelperQuaternion(quaternion, origin);
+    }
+    applyHelperScaleMatrix4(matrix4, params) {
+        this.helperObject3D.applyHelperScaleMatrix4(matrix4, params);
+    }
+    onWantsGesture(type, pointers, final) {
+        if (this.isDragging)
+            return false;
+    }
+    render() {
+        this.onRender();
+    }
+    hoverListener(object3D, hoverColor = 0xffffff, hoverOpacity = 1) {
+        const objects = (Array.isArray(object3D) ? object3D : [object3D]).filter(notNil);
+        const disposers = [];
+        for (const object of objects) {
+            if (object instanceof THREE.Mesh || object instanceof THREE.Group) {
+                const meshes = object instanceof THREE.Group ? object.children.filter((child) => child instanceof THREE.Mesh) : [object];
+                meshes.forEach((mesh) => {
+                    ;
+                    mesh['__originalColor__'] = mesh.material.color.clone();
+                    mesh['__originalOpacity__'] = mesh.material.opacity;
+                });
+                const setHoverColor = () => {
+                    meshes.forEach((mesh) => {
+                        mesh.material.color.set(hoverColor);
+                        mesh.material.opacity = hoverOpacity;
+                    });
+                    this.render();
+                };
+                const resetColor = () => {
+                    meshes.forEach((mesh) => {
+                        mesh.material.color.copy(mesh['__originalColor__']);
+                        mesh.material.opacity = mesh['__originalOpacity__'];
+                    });
+                    this.render();
+                };
+                const handleMouseover = () => {
+                    if (this.isDragging)
+                        return;
+                    setHoverColor();
+                };
+                const handleMouseout = () => {
+                    if (this.isDragging)
+                        return;
+                    resetColor();
+                };
+                for (const mesh of meshes) {
+                    this.domEvents.addEventListener(mesh, 'mouseover', handleMouseover);
+                    this.domEvents.addEventListener(mesh, 'mouseout', handleMouseout);
+                    this.hooks.on('moveStart', setHoverColor);
+                    this.hooks.on('moveEnd', resetColor);
+                    this.hooks.on('rotateEnd', resetColor);
+                    disposers.push(() => {
+                        this.domEvents.removeEventListener(mesh, 'mouseover', handleMouseover);
+                        this.domEvents.removeEventListener(mesh, 'mouseout', handleMouseout);
+                        this.hooks.off('moveStart', setHoverColor);
+                        this.hooks.off('moveEnd', resetColor);
+                        this.hooks.off('rotateEnd', resetColor);
+                    });
+                }
+            }
+        }
+        return () => disposers.forEach((disposer) => disposer === null || disposer === void 0 ? void 0 : disposer());
+    }
+    getIntersectObject(raycaster) {
+        const cameraPosition = this.camera.position;
+        const object = this.helperObject3D;
+        // 如果当前没有模型，则不存在模型被点击
+        if (!object)
+            return undefined;
+        // 如果存在模型，需要判断模型与射线的交点和 model 与射线的交点的远近
+        let objectIntersection;
+        const intersection = raycaster.intersectObject(object, true)[0];
+        if (!intersection)
+            return undefined;
+        objectIntersection = intersection;
+        objectIntersection.object = object;
+        if (!objectIntersection)
+            return undefined;
+        // 如果 five model intersection 更近，返回 undefined
+        if (this.model['intersectRaycaster']) {
+            const modelIntersection = this.model.intersectRaycaster(raycaster)[0];
+            if (modelIntersection && modelIntersection.point.distanceTo(cameraPosition) < objectIntersection.point.distanceTo(cameraPosition))
+                return undefined;
+        }
+        return objectIntersection.object;
+    }
+}

package/libs/src/shared-utils/Object3DHelper/Base/BaseHelper.d.ts

@@ -0,0 +1,91 @@
+import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
+import type * as THREE from 'three';
+import { Mesh, Object3D, Vector3 } from 'three';
+import type { Direction, Direction4 } from '../typings';
+import type { tipsDom } from '../Helper/HTML/tipsDom';
+export declare abstract class BaseHelper<OriginObject3D extends Object3D = Object3D> extends Object3D {
+    protected originObject3D: OriginObject3D;
+    protected onRender: () => any;
+    get helperObject(): Object3D;
+    constructor(originObject3D: OriginObject3D, config?: {
+        onRender?: () => any;
+    });
+    render(): void;
+    show(): void;
+    hide(): void;
+    updatePosition(): void;
+    updateQuaternion(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    abstract showDraggingHelper(directions?: Direction[]): void;
+    abstract dispose(): void;
+}
+export declare abstract class MoveHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract xArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+    abstract yArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+    abstract zArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+}
+export declare abstract class RotateHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract xyCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract xzCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract yzCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract xRingHelper: Object3D;
+    abstract yRingHelper: Object3D;
+    abstract zRingHelper: Object3D;
+    abstract xAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract yAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract zAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract angleTips?: ReturnType<typeof tipsDom>;
+    abstract showDraggingHelper(directions: Direction[]): void;
+    abstract updateAngleHelperQuaternion(): void;
+}
+export declare abstract class ScaleHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+}
+declare type NonVoid<T> = T extends void ? never : T;
+export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extends Object3D, PointType extends Object3D | HTMLElement> extends ScaleHelperAbstract<OriginObject3D> {
+    abstract points: PointType extends Object3D ? {
+        point: PointType;
+        direction: Direction4;
+    }[] : {
+        point: PointType;
+        direction: Direction4;
+        position: Vector3;
+    }[];
+    abstract cornerPositions: Vector3[];
+    abstract css3DInstance?: NonVoid<Create3DElementReturnType>;
+    abstract plane?: THREE.Mesh;
+    abstract updatePoints(): void;
+    abstract enable(): void;
+    abstract disable(): void;
+}
+export {};

package/libs/src/shared-utils/Object3DHelper/Base/BaseHelper.js

@@ -0,0 +1,55 @@
+import { Object3D } from 'three';
+export class BaseHelper extends Object3D {
+    constructor(originObject3D, config) {
+        var _a;
+        super();
+        Object.defineProperty(this, "originObject3D", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "onRender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.originObject3D = originObject3D;
+        this.onRender = (_a = config === null || config === void 0 ? void 0 : config.onRender) !== null && _a !== void 0 ? _a : (() => { });
+    }
+    get helperObject() {
+        return this;
+    }
+    render() {
+        this.onRender();
+    }
+    show() {
+        this.visible = true;
+        this.render();
+    }
+    hide() {
+        this.visible = false;
+        this.render();
+    }
+    updatePosition() {
+        this.position.copy(this.originObject3D.position);
+    }
+    updateQuaternion() {
+        this.quaternion.copy(this.originObject3D.quaternion);
+    }
+    applyHelperScaleMatrix4(matrix, params) {
+        this.scale.applyMatrix4(matrix);
+    }
+    applyHelperQuaternion(quaternion, origin) {
+        this.applyQuaternion(quaternion);
+    }
+}
+export class MoveHelperAbstract extends BaseHelper {
+}
+export class RotateHelperAbstract extends BaseHelper {
+}
+export class ScaleHelperAbstract extends BaseHelper {
+}
+export class RectangleScaleHelperAbstract extends ScaleHelperAbstract {
+}

package/libs/src/shared-utils/Object3DHelper/Constants/color.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+declare const AXES_COLOR: {
+    X: number;
+    Y: number;
+    Z: number;
+};
+declare class AXES_THREE_COLOR {
+    static get X(): THREE.Color;
+    static get Y(): THREE.Color;
+    static get Z(): THREE.Color;
+}
+export { AXES_COLOR, AXES_THREE_COLOR };

package/libs/src/shared-utils/Object3DHelper/Constants/color.js

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+const AXES_COLOR = {
+    X: 0xee5252,
+    Y: 0x48b74f,
+    Z: 0x4082ff,
+};
+// const AXES_THREE_COLOR = {
+//   X: new THREE.Color(AXES_COLOR.X).convertSRGBToLinear(),
+//   Y: new THREE.Color(AXES_COLOR.Y).convertSRGBToLinear(),
+//   Z: new THREE.Color(AXES_COLOR.Z).convertSRGBToLinear(),
+// }
+class AXES_THREE_COLOR {
+    static get X() {
+        return new THREE.Color(AXES_COLOR.X).convertSRGBToLinear().clone();
+    }
+    static get Y() {
+        return new THREE.Color(AXES_COLOR.Y).convertSRGBToLinear().clone();
+    }
+    static get Z() {
+        return new THREE.Color(AXES_COLOR.Z).convertSRGBToLinear().clone();
+    }
+}
+export { AXES_COLOR, AXES_THREE_COLOR };

package/libs/src/shared-utils/Object3DHelper/Controller/CSS3DScaleController.d.ts

@@ -0,0 +1,6 @@
+import type { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { RectangleScaleController } from './RectangleScaleController';
+export declare class CSS3DScaleController extends RectangleScaleController<CSS3DObject, HTMLElement> {
+    constructor(...params: ConstructorParameters<typeof RectangleScaleController<CSS3DObject, HTMLElement>>);
+    private addHTMLEventListener;
+}

package/libs/src/shared-utils/Object3DHelper/Controller/CSS3DScaleController.js

@@ -0,0 +1,21 @@
+import { RectangleScaleController } from './RectangleScaleController';
+import '../utils/getPoint';
+export class CSS3DScaleController extends RectangleScaleController {
+    constructor(...params) {
+        super(...params);
+        this.addHTMLEventListener();
+    }
+    addHTMLEventListener() {
+        this.helperObject3D.points.forEach((startPoint) => {
+            if (!startPoint)
+                return;
+            const element = startPoint.point;
+            const dragStart = (event) => this.dragStart(event, startPoint);
+            const dragging = this.dragging.bind(this);
+            const dragEnd = this.dragEnd.bind(this);
+            element.addEventListener('dragstart', dragStart);
+            element.addEventListener('drag', dragging);
+            element.addEventListener('dragend', dragEnd);
+        });
+    }
+}

package/libs/src/shared-utils/Object3DHelper/Controller/MoveController.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from '../Base/BaseController';
+import type { MoveHelperAbstract } from '../Helper';
+export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private move;
+    private dragEnd;
+}