@shopware-ag/dive 1.0.7 → 1.0.8

package/src/scene/root/modelroot/__test__/ModelRoot.test.ts

@@ -0,0 +1,185 @@
+import DIVEModelRoot from '../ModelRoot';
+import DIVECommunication from '../../../../com/Communication';
+import { TransformControls } from 'three/examples/jsm/Addons';
+import { DIVEMoveable } from '../../../../interface/Moveable';
+
+const mock_LoadGLTF = jest.fn().mockResolvedValue({});
+const mock_SetPosition = jest.fn();
+const mock_SetRotation = jest.fn();
+const mock_SetScale = jest.fn();
+const mock_PlaceOnFloor = jest.fn();
+const mock_SetModel = jest.fn();
+
+jest.mock('../../../../com/types.ts', () => {
+    return {
+        COMModel: {},
+    }
+});
+
+jest.mock('../../../../loadingmanager/LoadingManager.ts', () => {
+    return jest.fn(function () {
+        this.LoadGLTF = mock_LoadGLTF;
+        return this;
+    });
+});
+
+jest.mock('../../../../com/Communication.ts', () => {
+    return {
+        get: jest.fn(() => {
+            return {
+                PerformAction: jest.fn(),
+            }
+        }),
+    }
+});
+
+jest.mock('../../../../model/Model.ts', () => {
+    return jest.fn(function () {
+        this.isObject3D = true;
+        this.parent = null;
+        this.dispatchEvent = jest.fn();
+        this.userData = {
+            id: undefined,
+        };
+        this.SetModel = mock_SetModel;
+        this.SetPosition = mock_SetPosition;
+        this.SetRotation = mock_SetRotation;
+        this.SetScale = mock_SetScale;
+        this.PlaceOnFloor = mock_PlaceOnFloor;
+        this.removeFromParent = jest.fn();
+        return this;
+    });
+});
+
+jest.spyOn(DIVECommunication, 'get').mockReturnValue({ PerformAction: jest.fn() } as unknown as DIVECommunication);
+
+const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+
+describe('dive/scene/root/modelroot/DIVEModelRoot', () => {
+    beforeEach(() => {
+        consoleWarnSpy.mockClear();
+    });
+
+    it('should instantiate', () => {
+        const modelRoot = new DIVEModelRoot();
+        expect(modelRoot).toBeDefined();
+    });
+
+    it('should not add incorrect model', async () => {
+        const modelRoot = new DIVEModelRoot();
+        await expect(() => modelRoot.UpdateModel({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(modelRoot.children).toHaveLength(0);
+    });
+
+    it('should add basic model', async () => {
+        const modelRoot = new DIVEModelRoot();
+        await expect(() => modelRoot.UpdateModel({
+            id: 'test_id',
+            uri: 'not a real uri',
+        })).not.toThrow();
+        expect(mock_LoadGLTF).toHaveBeenCalledTimes(1);
+        expect(mock_SetModel).toHaveBeenCalledTimes(1);
+        expect(modelRoot.children).toHaveLength(1);
+        expect(modelRoot.children[0].userData.id).toBe('test_id');
+    });
+
+    it('should add configured model', async () => {
+        const modelRoot = new DIVEModelRoot();
+        modelRoot.userData.id = 'something';
+        await expect(() => modelRoot.UpdateModel({
+            id: 'test_id',
+            uri: 'not a real uri',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+        })).not.toThrow();
+
+        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
+        await expect(() => modelRoot.UpdateModel({
+            id: 'test_id',
+            uri: 'not a real uri',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+        })).not.toThrow();
+
+        expect(modelRoot.children).toHaveLength(1);
+        expect(mock_SetPosition).toHaveBeenCalledTimes(2);
+        expect(mock_SetRotation).toHaveBeenCalledTimes(2);
+        expect(mock_SetScale).toHaveBeenCalledTimes(2);
+    });
+
+    it('should not place incorrect model on floor', async () => {
+        const modelRoot = new DIVEModelRoot();
+        expect(() => modelRoot.PlaceOnFloor({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(0);
+    });
+
+    it('should not place non-existing model on floor', async () => {
+        const modelRoot = new DIVEModelRoot();
+        modelRoot.PlaceOnFloor({ id: 'test_id' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(0);
+    });
+
+    it('should place model on floor', async () => {
+        const modelRoot = new DIVEModelRoot();
+        await modelRoot.UpdateModel({
+            id: 'test_id',
+            uri: 'not a real uri',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+        });
+        modelRoot.PlaceOnFloor({ id: 'test_id' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(1);
+    });
+
+    it('should get model', async () => {
+        const modelRoot = new DIVEModelRoot();
+        expect(() => modelRoot.GetModel({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(modelRoot.GetModel({ id: 'test_id' })).toBeUndefined();
+        await expect(() => modelRoot.UpdateModel({
+            id: 'test_id',
+            uri: 'not a real uri',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+        })).not.toThrow();
+        expect(modelRoot.GetModel({ id: 'test_id' })).toBeDefined();
+    });
+
+    it('should delete model', async () => {
+        const modelRoot = new DIVEModelRoot();
+        expect(() => modelRoot.DeleteModel({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        consoleWarnSpy.mockClear();
+        expect(() => modelRoot.DeleteModel({ id: 'test_id' })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        await expect(() => modelRoot.UpdateModel({
+            id: 'test_id',
+            uri: 'not a real uri',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+        })).not.toThrow();
+        (modelRoot.children[0] as unknown as DIVEMoveable).isMoveable = true;
+        expect(() => modelRoot.DeleteModel({ id: 'test_id' })).not.toThrow();
+
+        await expect(() => modelRoot.UpdateModel({
+            id: 'test_id',
+            uri: 'not a real uri',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+        })).not.toThrow();
+        (modelRoot.children[0] as unknown as DIVEMoveable).isMoveable = true;
+        (modelRoot.children[0] as unknown as DIVEMoveable).gizmo = {
+            detach: jest.fn(),
+        } as unknown as TransformControls;
+        expect(() => modelRoot.DeleteModel({ id: 'test_id' })).not.toThrow();
+        expect(modelRoot.children).toHaveLength(0);
+    });
+});

package/src/toolbox/BaseTool.ts

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export default abstract class DIVEBaseTool {
+    protected name: string;
+
+    protected constructor() {
+        this.name = "BaseTool";
+    }
+
+    public Activate(): void { }
+
+    public Deactivate(): void { }
+
+    public onPointerDown(e: PointerEvent): void { }
+
+    public onPointerUp(e: PointerEvent): void { }
+
+    public onWheel(e: WheelEvent): void { }
+}

package/src/toolbox/Toolbox.ts

@@ -0,0 +1,76 @@
+import DIVEOrbitControls from "../controls/OrbitControls.ts";
+import DIVEScene from "../scene/Scene.ts";
+import DIVEBaseTool from "./BaseTool.ts";
+import DIVESelectTool from "./select/SelectTool.ts";
+
+/**
+ * A Toolbox to activate and deactivate tools to use with the pointer.
+ *
+ * @module
+ */
+
+export default class DIVEToolbox {
+    public static readonly DefaultTool = 'select';
+
+    private activeTool: DIVEBaseTool;
+
+    private selectTool: DIVESelectTool;
+
+    private removeListenersCallback: () => void = () => { };
+
+    constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
+        this.selectTool = new DIVESelectTool(scene, controller);
+
+        controller.domElement.addEventListener('pointerdown', this.onPointerDown.bind(this));
+        controller.domElement.addEventListener('pointerup', this.onPointerUp.bind(this));
+        controller.domElement.addEventListener('wheel', this.onWheel.bind(this));
+
+        this.removeListenersCallback = () => {
+            controller.domElement.removeEventListener('pointerdown', this.onPointerDown.bind(this));
+            controller.domElement.removeEventListener('pointerup', this.onPointerUp.bind(this));
+            controller.domElement.removeEventListener('wheel', this.onWheel.bind(this));
+        };
+
+        // default tool
+        this.activeTool = this.selectTool;
+        this.activeTool.Activate();
+    }
+
+    public dispose(): void {
+        this.removeListenersCallback();
+    }
+
+    public GetActiveTool(): DIVEBaseTool {
+        return this.activeTool;
+    }
+
+    public UseTool(tool: string): void {
+        this.activeTool.Deactivate();
+        switch (tool) {
+            case "select": {
+                this.selectTool.Activate();
+                this.activeTool = this.selectTool;
+                break;
+            }
+            default: {
+                throw new Error(`ToolBox.UseTool: Unknown tool: ${tool}`);
+            }
+        }
+    }
+
+    public SetGizmoMode(mode: 'translate' | 'rotate' | 'scale'): void {
+        this.selectTool.SetGizmoMode(mode);
+    }
+
+    public onPointerDown(e: PointerEvent): void {
+        this.activeTool.onPointerDown(e);
+    }
+
+    public onPointerUp(e: PointerEvent): void {
+        this.activeTool.onPointerUp(e);
+    }
+
+    public onWheel(e: WheelEvent): void {
+        this.activeTool.onWheel(e);
+    }
+}

package/src/toolbox/__test__/Toolbox.test.ts

@@ -0,0 +1,109 @@
+import DIVEOrbitControls from '../../controls/OrbitControls';
+import DIVEScene from '../../scene/Scene';
+import DIVEToolbox from '../Toolbox';
+
+/**
+ * @jest-environment jsdom
+ */
+
+const mock_addEventListener = jest.fn();
+const mock_removeEventListener = jest.fn();
+
+const mock_Canvas = {
+    width: 0,
+    height: 0,
+    addEventListener: mock_addEventListener,
+    getContext: jest.fn(),
+    removeEventListener: mock_removeEventListener,
+    clientWidth: 0,
+    clientHeight: 0,
+    offsetLeft: 0,
+    offsetTop: 0,
+};
+
+const mock_Activate = jest.fn();
+const mock_Deactivate = jest.fn();
+const mock_onPointerDown = jest.fn();
+const mock_onPointerUp = jest.fn();
+const mock_onWheel = jest.fn();
+const mock_SetGizmoMode = jest.fn();
+
+jest.mock('../select/SelectTool.ts', () => {
+    return jest.fn(function () {
+        this.Activate = mock_Activate;
+        this.Deactivate = mock_Deactivate;
+        this.onPointerDown = mock_onPointerDown;
+        this.onPointerUp = mock_onPointerUp;
+        this.onWheel = mock_onWheel;
+        this.SetGizmoMode = mock_SetGizmoMode;
+        return this;
+    });
+});
+
+const mockController = {
+    domElement: mock_Canvas,
+    object: {}
+} as unknown as DIVEOrbitControls;
+
+
+describe('dive/toolbox/DIVEToolBox', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should instantiate', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        expect(toolBox).toBeDefined();
+        expect(mock_Activate).toHaveBeenCalledTimes(1);
+        expect(mock_addEventListener).toHaveBeenCalled();
+    });
+
+    it('should dispose', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        toolBox.dispose();
+        expect(mock_removeEventListener).toHaveBeenCalled();
+    });
+
+    it('should throw with incorrect tool', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        expect(() => toolBox.UseTool('not a real tool')).toThrow();
+        expect(mock_Deactivate).toHaveBeenCalledTimes(1);
+    });
+
+    it('should use select tool', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        expect(mock_Activate).toHaveBeenCalledTimes(1);
+        toolBox.UseTool(DIVEToolbox.DefaultTool);
+        expect(mock_Deactivate).toHaveBeenCalledTimes(1);
+        expect(mock_Activate).toHaveBeenCalledTimes(2);
+    });
+
+    it('should execute pointer down event on tool', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        toolBox.onPointerDown({ type: 'pointerdown' } as PointerEvent);
+        expect(mock_onPointerDown).toHaveBeenCalledTimes(1);
+    });
+
+    it('should execute pointer up event on tool', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        toolBox.onPointerUp({ type: 'pointerup' } as PointerEvent);
+        expect(mock_onPointerUp).toHaveBeenCalledTimes(1);
+    });
+
+    it('should execute wheel event on tool', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        toolBox.onWheel({ type: 'wheel' } as WheelEvent);
+        expect(mock_onWheel).toHaveBeenCalledTimes(1);
+    });
+
+    it('should get active tool', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        expect(toolBox.GetActiveTool()).toBeDefined();
+    });
+
+    it('should set gizmo mode', () => {
+        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
+        toolBox.SetGizmoMode('translate');
+        expect(mock_SetGizmoMode).toHaveBeenCalledTimes(1);
+    });
+});

package/src/toolbox/select/SelectTool.ts

@@ -0,0 +1,123 @@
+import { Intersection, Object3D, Raycaster, Vector2 } from "three";
+import { TransformControls } from "three/examples/jsm/Addons.js";
+import DIVEBaseTool from "../BaseTool.ts";
+import { DIVESelectable } from "../../interface/Selectable.ts";
+import DIVEScene from "../../scene/Scene.ts";
+import { HELPER_LAYER_MASK, PRODUCT_LAYER_MASK, UI_LAYER_MASK } from "../../constant/VisibilityLayerMask.ts";
+import { DIVEMoveable } from "../../interface/Moveable.ts";
+import DIVEOrbitControls from "../../controls/OrbitControls.ts";
+
+export interface DIVEObjectEventMap {
+    select: object
+}
+
+/**
+ * A Tool to select and move objects in the scene.
+ *
+ * Objects have to implement the DIVESelectable interface to be selectable and DIVEMoveable to be moveable.
+ *
+ * @module
+ */
+
+export default class DIVESelectTool extends DIVEBaseTool {
+    private canvas: HTMLElement;
+    private scene: DIVEScene;
+    private controller: DIVEOrbitControls;
+    private raycaster: Raycaster;
+    private gizmo: TransformControls;
+
+
+    constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
+        super();
+        this.name = "SelectTool";
+
+        this.canvas = controller.domElement;
+        this.scene = scene;
+        this.controller = controller;
+        this.raycaster = new Raycaster();
+        this.raycaster.layers.mask = PRODUCT_LAYER_MASK | HELPER_LAYER_MASK;
+
+        this.gizmo = new TransformControls(this.controller.object, this.canvas);
+
+        this.gizmo.layers.mask = UI_LAYER_MASK;
+        this.gizmo.getRaycaster().layers.mask = UI_LAYER_MASK & this.controller.object.layers.mask;
+        this.gizmo.traverse((child) => {
+            child.layers.mask = UI_LAYER_MASK;
+        });
+        this.gizmo.addEventListener('objectChange', () => {
+            if (!this.gizmo.object) return;
+            if (!('onMove' in this.gizmo.object)) return;
+            if (typeof this.gizmo.object.onMove !== 'function') return;
+            this.gizmo.object.onMove();
+        });
+
+        this.controller.object.onSetCameraLayer = (mask: number) => {
+            this.gizmo.getRaycaster().layers.mask = UI_LAYER_MASK & mask;
+        };
+
+        this.gizmo.addEventListener('dragging-changed', function (event) {
+            controller.enabled = !event.value;
+        });
+
+        this.scene.add(this.gizmo);
+    }
+
+    public Activate(): void { }
+
+    public SetGizmoMode(mode: 'translate' | 'rotate' | 'scale'): void {
+        this.gizmo.setMode(mode);
+    }
+
+    public Select(selectable: DIVESelectable): void {
+        if (selectable.onSelect) selectable.onSelect();
+
+        if ('isMoveable' in selectable) {
+            const movable = selectable as (Object3D & DIVESelectable & DIVEMoveable);
+            movable.gizmo = this.gizmo;
+            this.gizmo.attach(movable);
+        }
+    }
+
+    public Deselect(selectable: DIVESelectable): void {
+        if (selectable.onDeselect) selectable.onDeselect();
+        if (('isMoveable' in selectable)) (selectable as unknown as DIVEMoveable).gizmo = null;
+        this.gizmo.detach();
+    }
+
+    public onPointerUp(e: PointerEvent): void {
+        const pointerPos: Vector2 = new Vector2(e.offsetX / this.canvas.clientWidth * 2 - 1, e.offsetY / this.canvas.clientHeight * -2 + 1);
+        this.raycaster.setFromCamera(pointerPos, this.controller.object);
+
+        const first = this.raycastFirst();
+        const selectable = this.findSelectableInterface(first?.object);
+        if (!first || !selectable) {
+            if (this.gizmo.object) this.Deselect(this.gizmo.object as (Object3D & DIVESelectable));
+            return;
+        }
+
+        this.Select(selectable);
+    }
+
+    private findSelectableInterface(child: Object3D): (Object3D & DIVESelectable) | undefined {
+        if (child === undefined) return undefined;
+
+        if (child.parent === null) {
+            // in this case it is the scene itself
+            return undefined;
+        }
+
+        if ('isSelectable' in child) {
+            return child as (Object3D & DIVESelectable);
+        }
+
+        return this.findSelectableInterface(child.parent);
+    }
+
+    private raycastFirst(): Intersection {
+        return this.raycastAll()[0];
+    }
+
+    private raycastAll(): Intersection[] {
+        return this.raycaster.intersectObjects(this.scene.Root.children, true);
+    }
+}

package/src/toolbox/select/__test__/SelectTool.test.ts

@@ -0,0 +1,190 @@
+import DIVESelectTool from '../SelectTool';
+import DIVEScene from '../../../scene/Scene';
+import DIVEOrbitControls from '../../../controls/OrbitControls';
+import DIVEPerspectiveCamera from '../../../camera/PerspectiveCamera';
+import DIVERenderer, { DIVERendererDefaultSettings } from '../../../renderer/Renderer';
+import { DIVESelectable } from '../../../interface/Selectable';
+
+jest.mock('../../../renderer/Renderer', () => {
+    return jest.fn(function () {
+        return this;
+    });
+});
+
+jest.mock('../../../toolbox/BaseTool', () => {
+    return jest.fn(function (cam) {
+        this.cam = cam;
+        this.add = jest.fn();
+        return this;
+    });
+});
+
+jest.mock('../../../camera/PerspectiveCamera', () => {
+    return jest.fn(function () {
+        this.isPerspectiveCamera = true;
+        this.layers = {
+            mask: 0,
+        };
+        return this;
+    });
+});
+
+jest.mock('../../../controls/OrbitControls', () => {
+    return jest.fn(function () {
+        this.enabled = true;
+        this.domElement = {
+            clientWIdth: 0,
+            clientHeight: 0,
+        };
+        this.object = {
+            layers: {
+                mask: 0,
+            }
+        };
+        return this;
+    });
+});
+
+jest.mock('../../../scene/Scene', () => {
+    return jest.fn(function () {
+        this.add = jest.fn();
+        this.Root = {
+            children: [],
+        }
+        return this;
+    });
+});
+
+const mock_intersectObjects = jest.fn().mockReturnValue([]);
+
+jest.mock('three', () => {
+    return {
+        Vector2: jest.fn(function () {
+            return this;
+        }),
+        Raycaster: jest.fn(function () {
+            this.setFromCamera = jest.fn();
+            this.intersectObjects = mock_intersectObjects;
+            this.layers = {
+                mask: 0,
+            };
+            return this;
+        }),
+    };
+});
+
+const mock_attach = jest.fn();
+const mock_detach = jest.fn();
+
+jest.mock('three/examples/jsm/Addons.js', () => {
+    return {
+        TransformControls: jest.fn(function () {
+            this.addEventListener = (type: string, callback: (e: object) => void) => {
+                callback({ value: false });
+                this.object = {};
+                callback({ value: false });
+                this.object = {
+                    onMove: 'hello',
+                };
+                callback({ value: false });
+                this.object = {
+                    onMove: jest.fn(),
+                };
+                callback({ value: false });
+            },
+                this.attach = mock_attach,
+                this.detach = mock_detach,
+                this.traverse = function (callback: (obj: object) => void) {
+                    callback(this);
+                };
+            this.setMode = jest.fn();
+            this.getRaycaster = jest.fn().mockReturnValue({
+                layers: {
+                    mask: 0,
+                },
+            });
+            this.layers = {
+                mask: 0,
+            };
+            return this;
+        }),
+    };
+});
+
+const mockCamera: DIVEPerspectiveCamera = {} as DIVEPerspectiveCamera;
+const mockRenderer: DIVERenderer = new DIVERenderer(DIVERendererDefaultSettings);
+const mockScene: DIVEScene = new DIVEScene();
+const mockController: DIVEOrbitControls = new DIVEOrbitControls(mockCamera, mockRenderer);
+
+describe('dive/toolbox/select/DIVESelectTool', () => {
+    it('should instantiate', () => {
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(selectTool).toBeDefined();
+        expect(mockController.object.onSetCameraLayer).toBeDefined();
+        expect(() => mockController.object.onSetCameraLayer(0)).not.toThrow();
+    });
+
+    it('should activate', () => {
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(() => selectTool.Activate()).not.toThrow();
+    });
+
+    it('should execute onPointerUp without hit', () => {
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(() => selectTool.onPointerUp({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onPointerUp with hit', () => {
+        mock_intersectObjects.mockReturnValueOnce([{ object: { parent: { name: 'this is the test scene root!!!', parent: null } } }]);
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(() => selectTool.onPointerUp({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onPointerUp with ISelectable hit', () => {
+        const mock_onSelect = jest.fn();
+
+        mock_intersectObjects.mockReturnValueOnce([{
+            object: {
+                isSelectable: true,
+                onSelect: mock_onSelect,
+                parent: {
+                    name: 'this is the test scene root!!!',
+                    parent: null,
+                },
+            },
+        }]);
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(() => selectTool.onPointerUp({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        expect(mock_onSelect).toHaveBeenCalledTimes(1);
+    });
+
+    it('should execute onPointerUp with IMovable hit', () => {
+        const mock_onSelect = jest.fn();
+
+        mock_intersectObjects.mockReturnValueOnce([{
+            object: {
+                isSelectable: true,
+                isMoveable: true,
+                onSelect: mock_onSelect,
+                parent: {
+                    name: 'this is the test scene root!!!',
+                    parent: null,
+                },
+            },
+        }]);
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(() => selectTool.onPointerUp({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        expect(mock_attach).toHaveBeenCalledTimes(1);
+    });
+
+    it('should deselect', () => {
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(() => selectTool.Deselect({ isSelectable: true })).not.toThrow();
+        expect(() => selectTool.Deselect({ isMoveable: true, onDeselect: jest.fn() } as unknown as DIVESelectable)).not.toThrow();
+    })
+
+    it('should set gizmo mode', () => {
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        expect(() => selectTool.SetGizmoMode('translate')).not.toThrow();
+    });
+});