@x-viewer/editor 0.9.0

package/dist/types/Editor.d.ts

@@ -0,0 +1,14 @@
+import { EditorViewer2d } from "./viewers/EditorViewer2d";
+import { EditorViewer3d } from "./viewers/EditorViewer3d";
+export declare class Editor {
+    cfg: any;
+    viewer2d: EditorViewer2d;
+    viewer3d: EditorViewer3d;
+    constructor(cfg: any);
+    init(): void;
+    getAssetList(): import("@x-viewer/builder").AssetInfo[];
+    getModelInfo(id: string): import("@x-viewer/builder").AssetInfo | undefined;
+    getModelProperties(id: string): Record<string, any> | undefined;
+    loadExternalAssets(externalUrl: string, datas: any[]): void;
+    setDrawMode(mode: string, drawAssetId: string): Promise<void>;
+}

package/dist/types/EventBus.d.ts

@@ -0,0 +1,17 @@
+import { Event } from "@x-viewer/core";
+export declare enum EditorEvent {
+    createWall = "createWall",
+    updateWall = "updateWall",
+    createObject = "createObject",
+    selectObject = "selectObject",
+    updateObject = "updateObject",
+    exitDrawMode = "exitDrawMode",
+    gizmoDraggingStart = "gizmoDraggingStart",
+    gizmoDragging = "gizmoDragging",
+    gizmoDraggingEnd = "gizmoDraggingEnd"
+}
+type ViewerEvents = {
+    [K in EditorEvent]: any;
+};
+export declare const eventBus: Event<ViewerEvents>;
+export {};

package/dist/types/drawables/Door2dDrawable.d.ts

@@ -0,0 +1,6 @@
+import { PathDrawable, THREE } from "@x-viewer/core";
+export declare class Door2dDrawable extends PathDrawable {
+    renderOrder: number;
+    constructor(id: string, cfg: any);
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+}

package/dist/types/drawables/Object2dDrawable.d.ts

@@ -0,0 +1,30 @@
+import { Drawable, THREE } from "@x-viewer/core";
+export declare class Object2dDrawable extends Drawable {
+    protected lineWidth: number;
+    protected lineColor: number[];
+    protected fillColor: number[];
+    text: string;
+    renderOrder: number;
+    editable: boolean;
+    width: number;
+    height: number;
+    position: THREE.Vector3;
+    rotation2D: number;
+    scale: THREE.Vector3;
+    matrix: THREE.Matrix4;
+    matrixNeedsUpdate: boolean;
+    constructor(id: string, cfg: any);
+    setPoints(points: THREE.Vector3[]): void;
+    setPosition(x: number, y: number, z: number): void;
+    getPosition(): THREE.Vector3;
+    setRotation2D(rotation: number): void;
+    getRotation2D(): number;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawText(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawEditPoints(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    getVertexes(): THREE.Vector3[];
+    isPointInPath(p: THREE.Vector3): boolean;
+    clone(): Object2dDrawable;
+    getClassType(): string;
+}

package/dist/types/drawables/Room2dDrawable.d.ts

@@ -0,0 +1,21 @@
+import { PathDrawable, THREE } from "@x-viewer/core";
+export declare class Room2dDrawable extends PathDrawable {
+    protected lineWidth: number;
+    protected lineColor: number[];
+    protected fillColor: number[];
+    protected selectedEdgeIndex: number;
+    protected selectedPointIndex: number;
+    renderOrder: number;
+    assetId: string;
+    constructor(id: string, points: THREE.Vector3[], assetId: string);
+    setPoints(points: THREE.Vector3[]): void;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSelectBody(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSelectEdge(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawPoints(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isSelectEdge(p: THREE.Vector3): number;
+    isSelectPoint(p: THREE.Vector3): number;
+    updatePointByIndex(index: number, newPosition: THREE.Vector3): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+}

package/dist/types/gizmo/Gizmo.d.ts

@@ -0,0 +1,142 @@
+import { BaseViewer, THREE } from "@x-viewer/core";
+/**
+ * Default translation snap value, in meter.
+ * @internal
+ */
+export declare const DefaultTranslationSnap = 0.1;
+/**
+ * Default rotation snap value, in degree.
+ * @internal
+ */
+export declare const DefaultRotationSnap = 15;
+/**
+ * Default scale snap value. in percent.
+ * @internal
+ */
+export declare const DefaultScaleSnap = 0.25;
+/**
+ * Used for transform control (gizmo).
+ * @internal
+ */
+export declare enum CoordinateSpace {
+    Local = "local",
+    World = "world"
+}
+/**
+ * Transform control mode.
+ * @internal
+ */
+export declare enum TransformMode {
+    Translate = "translate",
+    Rotate = "rotate",
+    Scale = "scale"
+}
+/**
+ * @internal
+ */
+export declare enum SnapType {
+    None = 0,
+    Floor = 1,
+    Wall = 2,
+    Entity = 4,
+    All = 65535
+}
+/**
+ * Snap config
+ * @internal
+ */
+export interface SnapConfig {
+    snapEnabled?: boolean;
+    snapType?: SnapType;
+    snapRadius?: number;
+    gizmoTranslationSnap?: number;
+    gizmoScaleSnap?: number;
+    gizmoRotationSnap?: number;
+}
+/**
+ * @internal
+ */
+export declare class Gizmo {
+    private viewer;
+    private scene;
+    private transformControl;
+    private dragStartPosition;
+    private dragStartRotation;
+    private dragStartScale;
+    private entity;
+    active: boolean;
+    private space;
+    private snapConfig;
+    private isShiftPressing;
+    constructor(viewer: BaseViewer);
+    attach(entity: THREE.Object3D): void;
+    detach(): void;
+    isActive(): boolean;
+    private keyDownEvent;
+    private keyUpEvent;
+    private changedEvent;
+    private draggingStartEvent;
+    private draggingEvent;
+    private draggingEndEvent;
+    /**
+     * Enables or disable snap.
+     * @internal
+     */
+    enableSnap(enabled: boolean): void;
+    /**
+     * Is snap enabled.
+     * @internal
+     */
+    isSnapEnabled(): boolean;
+    /**
+     * Gets transform coordinate space, which should be "local" or "world".
+     * @internal
+     */
+    getSpace(): CoordinateSpace;
+    /**
+     * Sets transform coordinate space, which should be "local" or "world".
+     * @internal
+     */
+    setSpace(space: CoordinateSpace): void;
+    /**
+     * @internal
+     */
+    getTransformMode(): TransformMode;
+    /**
+     * @internal
+     */
+    setTransformMode(mode: TransformMode): void;
+    /**
+     * @internal
+     */
+    getTranslationSnap(): number;
+    /**
+     * @internal
+     */
+    setTranslationSnap(snap: number): void;
+    /**
+     * @internal
+     */
+    getRotationSnap(): number;
+    /**
+     * @internal
+     */
+    setRotationSnap(snap: number): void;
+    /**
+     * @internal
+     */
+    getScaleSnap(): number;
+    /**
+     * @internal
+     */
+    setScaleSnap(snap: number): void;
+    /**
+     * Set snap config.
+     */
+    getSnapConfig(): SnapConfig;
+    /**
+     * Set snap config.
+     */
+    setSnapConfig(config: SnapConfig): void;
+    destroy(): void;
+}

package/dist/types/gizmo/TransformControls.d.ts

@@ -0,0 +1,291 @@
+import { THREE } from "@x-viewer/core";
+export type TransformControlsMode = "translate" | "rotate" | "scale";
+export type PropertyName = "camera" | "object" | "enabled" | "axis" | "mode" | "translationSnap" | "rotationSnap" | "scaleSnap" | "space" | "size" | "dragging" | "showX" | "showY" | "showZ" | "minX" | "maxX" | "minY" | "maxY" | "minZ" | "maxZ" | "worldPosition" | "worldPositionStart" | "worldQuaternion" | "worldQuaternionStart" | "cameraPosition" | "cameraQuaternion" | "pointStart" | "pointEnd" | "rotationAxis" | "rotationAngle" | "eye";
+export type EventName = "camera-changed" | "object-changed" | "enabled-changed" | "axis-changed" | "mode-changed" | "translationSnap-changed" | "rotationSnap-changed" | "scaleSnap-changed" | "space-changed" | "size-changed" | "dragging-changed" | "showX-changed" | "showY-changed" | "showZ-changed" | "minX-changed" | "maxX-changed" | "minY-changed" | "maxY-changed" | "minZ-changed" | "maxZ-changed" | "worldPosition-changed" | "worldPositionStart-changed" | "worldQuaternion-changed" | "worldQuaternionStart-changed" | "cameraPosition-changed" | "cameraQuaternion-changed" | "pointStart-changed" | "pointEnd-changed" | "rotationAxis-changed" | "rotationAngle-changed" | "eye-changed";
+export interface TransformControlsEventMap {
+    /**
+     * Fires if any type of change (object or property change) is performed. Property changes are separate events you
+     * can add event listeners to. The event type is "propertyname-changed".
+     */
+    change: object;
+    /**
+     * Fires if a pointer (mouse/touch) becomes active.
+     */
+    mouseDown: {
+        mode: TransformControlsMode;
+    };
+    /**
+     * Fires if a pointer (mouse/touch) is no longer active.
+     */
+    mouseUp: {
+        mode: TransformControlsMode;
+    };
+    /**
+     * Fires if the controlled 3D object is changed.
+     */
+    objectChange: object;
+    /**
+     * start dragging.
+     */
+    draggingStart: object;
+    /**
+     * dragging.
+     */
+    dragging: object;
+    /**
+     * end dragging.
+     */
+    draggingEnd: object;
+    "camera-changed": {
+        value: unknown;
+    };
+    "object-changed": {
+        value: unknown;
+    };
+    "enabled-changed": {
+        value: unknown;
+    };
+    "axis-changed": {
+        value: unknown;
+    };
+    "mode-changed": {
+        value: unknown;
+    };
+    "translationSnap-changed": {
+        value: unknown;
+    };
+    "rotationSnap-changed": {
+        value: unknown;
+    };
+    "scaleSnap-changed": {
+        value: unknown;
+    };
+    "space-changed": {
+        value: unknown;
+    };
+    "size-changed": {
+        value: unknown;
+    };
+    "dragging-changed": {
+        value: unknown;
+    };
+    "showX-changed": {
+        value: unknown;
+    };
+    "showY-changed": {
+        value: unknown;
+    };
+    "showZ-changed": {
+        value: unknown;
+    };
+    "minX-changed": {
+        value: unknown;
+    };
+    "maxX-changed": {
+        value: unknown;
+    };
+    "minY-changed": {
+        value: unknown;
+    };
+    "maxY-changed": {
+        value: unknown;
+    };
+    "minZ-changed": {
+        value: unknown;
+    };
+    "maxZ-changed": {
+        value: unknown;
+    };
+    "worldPosition-changed": {
+        value: unknown;
+    };
+    "worldPositionStart-changed": {
+        value: unknown;
+    };
+    "worldQuaternion-changed": {
+        value: unknown;
+    };
+    "worldQuaternionStart-changed": {
+        value: unknown;
+    };
+    "cameraPosition-changed": {
+        value: unknown;
+    };
+    "cameraQuaternion-changed": {
+        value: unknown;
+    };
+    "pointStart-changed": {
+        value: unknown;
+    };
+    "pointEnd-changed": {
+        value: unknown;
+    };
+    "rotationAxis-changed": {
+        value: unknown;
+    };
+    "rotationAngle-changed": {
+        value: unknown;
+    };
+    "eye-changed": {
+        value: unknown;
+    };
+}
+/**
+ * This class can be used to transform objects in 3D space by adapting a similar interaction model of DCC tools like
+ * Blender. Unlike other controls, it is not intended to transform the scene's camera.
+ *
+ * TransformControls expects that its attached 3D object is part of the scene graph.
+ */
+declare class TransformControls extends THREE.Controls<TransformControlsEventMap> {
+    object: any;
+    enabled: any;
+    camera: any;
+    axis: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
+    mode: any;
+    translationSnap: any;
+    rotationSnap: any;
+    scaleSnap: any;
+    space: any;
+    size: any;
+    dragging: any;
+    showX: any;
+    showY: any;
+    showZ: any;
+    minX: any;
+    maxX: any;
+    minY: any;
+    maxY: any;
+    minZ: any;
+    maxZ: any;
+    worldPosition: any;
+    worldPositionStart: any;
+    worldQuaternion: any;
+    worldQuaternionStart: any;
+    cameraPosition: any;
+    cameraQuaternion: any;
+    pointStart: any;
+    pointEnd: any;
+    rotationAxis: any;
+    rotationAngle: any;
+    eye: any;
+    _root: any;
+    _gizmo: any;
+    _plane: any;
+    _offset: any;
+    _startNorm: any;
+    _endNorm: any;
+    _cameraScale: any;
+    _parentPosition: any;
+    _parentQuaternion: any;
+    _parentQuaternionInv: any;
+    _parentScale: any;
+    _worldScaleStart: any;
+    _worldQuaternionInv: any;
+    _worldScale: any;
+    _positionStart: any;
+    _quaternionStart: any;
+    _scaleStart: any;
+    _getPointer: any;
+    _onPointerDown: any;
+    _onPointerHover: any;
+    _onPointerMove: any;
+    _onPointerUp: any;
+    constructor(camera: any, domElement?: any);
+    connect(): void;
+    disconnect(): void;
+    getHelper(): any;
+    pointerHover(pointer: any): void;
+    pointerDown(pointer: any): void;
+    pointerMove(pointer: any): void;
+    pointerUp(pointer: any): void;
+    dispose(): void;
+    attach(object: THREE.Object3D): this;
+    detach(): this;
+    reset(): void;
+    getRaycaster(): THREE.Raycaster;
+    getMode(): any;
+    setMode(mode: any): void;
+    setTranslationSnap(translationSnap: any): void;
+    setRotationSnap(rotationSnap: any): void;
+    setScaleSnap(scaleSnap: any): void;
+    setSize(size: any): void;
+    setSpace(space: any): void;
+}
+declare class TransformControlsGizmo extends THREE.Object3D {
+    object: any;
+    enabled: any;
+    camera: any;
+    axis: any;
+    mode: any;
+    translationSnap: any;
+    rotationSnap: any;
+    scaleSnap: any;
+    space: any;
+    size: any;
+    dragging: any;
+    showX: any;
+    showY: any;
+    showZ: any;
+    minX: any;
+    maxX: any;
+    minY: any;
+    maxY: any;
+    minZ: any;
+    maxZ: any;
+    worldPosition: any;
+    worldPositionStart: any;
+    worldQuaternion: any;
+    worldQuaternionStart: any;
+    cameraPosition: any;
+    cameraQuaternion: any;
+    pointStart: any;
+    pointEnd: any;
+    rotationAxis: any;
+    rotationAngle: any;
+    eye: any;
+    isTransformControlsGizmo: any;
+    readonly type: string;
+    gizmo: any;
+    picker: any;
+    helper: any;
+    constructor();
+    updateMatrixWorld(force: boolean): void;
+}
+declare class TransformControlsPlane extends THREE.Mesh {
+    object: any;
+    enabled: any;
+    camera: any;
+    axis: any;
+    mode: any;
+    translationSnap: any;
+    rotationSnap: any;
+    scaleSnap: any;
+    space: any;
+    size: any;
+    dragging: any;
+    showX: any;
+    showY: any;
+    showZ: any;
+    minX: any;
+    maxX: any;
+    minY: any;
+    maxY: any;
+    minZ: any;
+    maxZ: any;
+    worldPosition: any;
+    worldPositionStart: any;
+    worldQuaternion: any;
+    worldQuaternionStart: any;
+    cameraPosition: any;
+    cameraQuaternion: any;
+    pointStart: any;
+    pointEnd: any;
+    rotationAxis: any;
+    rotationAngle: any;
+    eye: any;
+    isTransformControlsPlane: boolean;
+    readonly type: string;
+    constructor();
+    updateMatrixWorld(force: boolean): void;
+}
+export { TransformControls, TransformControlsGizmo, TransformControlsPlane };

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./Editor";

package/dist/types/interactions/BaseDrawInteraction.d.ts

@@ -0,0 +1,32 @@
+import { Drawable, EventInfo, InputManager, Interaction, THREE } from "@x-viewer/core";
+import { Object2dDrawable } from "../drawables/Object2dDrawable";
+import type { EditorViewer2d } from "../viewers/EditorViewer2d";
+export declare class BaseDrawInteraction extends Interaction {
+    inputManager: InputManager;
+    viewer: EditorViewer2d;
+    currentMousePoint: THREE.Vector2;
+    currentPoints: THREE.Vector3[];
+    mouseMoved: boolean;
+    drawStarted: boolean;
+    isDrawing: boolean;
+    clickLimit: number;
+    hostObject?: Object2dDrawable;
+    currentDrawingDrawable?: Drawable;
+    drawAssetId: string;
+    drawConfig: any;
+    constructor(viewer: EditorViewer2d, drawConfig: any);
+    handle_pointerdown(e: EventInfo): void;
+    handle_pointermove(e: EventInfo): void;
+    handle_pointerup(e: EventInfo): void;
+    getCurrentPoints(): THREE.Vector3[];
+    getCurrentMousePoint(): THREE.Vector2;
+    showHostObject(e: EventInfo): void;
+    removeHostObject(): void;
+    setHostObject(object: Object2dDrawable): void;
+    getHostObject(): Object2dDrawable | undefined;
+    handleMouseRightClick(e: EventInfo): void;
+    drawStart(e: EventInfo): void;
+    drawing(e: EventInfo): void;
+    drawEnd(e: EventInfo): void;
+    destroy(): void;
+}

package/dist/types/interactions/DrawObject2dInteraction.d.ts

@@ -0,0 +1,15 @@
+import { EventInfo, InputManager } from "@x-viewer/core";
+import { BaseDrawInteraction } from "./BaseDrawInteraction";
+import { Object2dDrawable } from "../drawables/Object2dDrawable";
+import type { EditorViewer2d } from "../viewers/EditorViewer2d";
+export declare class DrawObject2dInteraction extends BaseDrawInteraction {
+    inputManager: InputManager;
+    viewer: EditorViewer2d;
+    clickLimit: number;
+    lastDrawable?: Object2dDrawable;
+    currentDrawingDrawable?: Object2dDrawable;
+    constructor(viewer: EditorViewer2d, drawConfig: any);
+    drawStart(e: EventInfo): void;
+    drawing(e: EventInfo): void;
+    drawEnd(e: EventInfo): void;
+}

package/dist/types/interactions/DrawWall2dInteraction.d.ts

@@ -0,0 +1,16 @@
+import { EventInfo, InputManager } from "@x-viewer/core";
+import { BaseDrawInteraction } from "./BaseDrawInteraction";
+import { Room2dDrawable } from "../drawables/Room2dDrawable";
+import type { EditorViewer2d } from "../viewers/EditorViewer2d";
+export declare class DrawWall2dInteraction extends BaseDrawInteraction {
+    inputManager: InputManager;
+    viewer: EditorViewer2d;
+    clickLimit: number;
+    lastDrawable?: Room2dDrawable;
+    currentDrawingDrawable?: Room2dDrawable;
+    constructor(viewer: EditorViewer2d, drawConfig: any);
+    handle_pointerup(e: EventInfo): void;
+    drawStart(e: EventInfo): void;
+    drawing(e: EventInfo): void;
+    drawEnd(e: EventInfo): void;
+}

package/dist/types/interactions/Editor2dInteraction.d.ts

@@ -0,0 +1,21 @@
+import { Drawable, EventInfo, InputManager, Interaction } from "@x-viewer/core";
+import type { EditorViewer2d } from "../viewers/EditorViewer2d";
+export declare class Editor2dInteraction extends Interaction {
+    inputManager: InputManager;
+    viewer: EditorViewer2d;
+    mouseDowned: boolean;
+    dragStarted: boolean;
+    lastDrawable?: Drawable;
+    selectedDrawable?: Drawable;
+    selectedWallPointIndex: number;
+    selectedWallEdgeIndex: number;
+    constructor(viewer: EditorViewer2d);
+    handle_pointerdown(e: EventInfo): void;
+    handle_pointermove(e: EventInfo): void;
+    handle_pointerup(e: EventInfo): void;
+    dragStart(e: EventInfo): void;
+    dragging(e: EventInfo): void;
+    dragEnd(e: EventInfo): void;
+    selectDrawable(e: EventInfo): void;
+    hoverObject(e: EventInfo): void;
+}

package/dist/types/interactions/Editor3dInteraction.d.ts

@@ -0,0 +1,18 @@
+import { EventInfo, InputManager, Interaction, THREE } from "@x-viewer/core";
+import { Gizmo } from "../gizmo/Gizmo";
+import type { EditorViewer3d } from "../viewers/EditorViewer3d";
+export declare class Editor3dInteraction extends Interaction {
+    inputManager: InputManager;
+    interactionObject?: THREE.Object3D;
+    edgeMesh?: THREE.BoxHelper;
+    gizmo?: Gizmo;
+    constructor(viewer: EditorViewer3d);
+    handle_pointerdown(e: EventInfo): void;
+    handle_pointermove(e: EventInfo): void;
+    handle_pointerup(e: EventInfo): void;
+    private showGizmo;
+    private hideGizmo;
+    private initGizmo;
+    private gizmoDragging;
+    destroy(): void;
+}

package/dist/types/viewers/EditorModel3d.d.ts

@@ -0,0 +1,4 @@
+import { Model3d } from "@x-viewer/core";
+export declare class EditorModel3d extends Model3d {
+    constructor();
+}

package/dist/types/viewers/EditorViewer2d.d.ts

@@ -0,0 +1,28 @@
+import { BaseViewer, Drawable, DrawableList, THREE } from "@x-viewer/core";
+export declare class EditorViewer2d extends BaseViewer {
+    groundPlane: THREE.Mesh;
+    drawList: DrawableList;
+    constructor(viewerCfg: any);
+    protected initEvents(): void;
+    private setDefaultBackground;
+    /**
+     * Gets if selection is enabled.
+     */
+    get enableSelection(): boolean;
+    /**
+     * Sets if selection is enabled.
+     */
+    set enableSelection(enable: boolean);
+    addDrawable(drawable: Drawable): void;
+    removeDrawable(drawable: Drawable): void;
+    loadModel(): Promise<void>;
+    initGroundPlane(): void;
+    pickPosition(vec2: {
+        x: number;
+        y: number;
+    }): THREE.Vector3 | undefined;
+    setDrawMode(mode: string, drawConfig: any): void;
+    exitDrawMode(): void;
+    setObjectHighlight(object: THREE.Object3D): void;
+    clearHighlight(): void;
+}