@shopware-ag/dive 1.1.2 → 1.3.0

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

@@ -3,7 +3,8 @@ 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';
+import { DIVESelectable, isSelectable } from '../../../interface/Selectable';
+import { type Object3D } from 'three';
 
 jest.mock('../../../renderer/Renderer', () => {
     return jest.fn(function () {
@@ -11,14 +12,6 @@ jest.mock('../../../renderer/Renderer', () => {
     });
 });
 
-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;
@@ -62,6 +55,9 @@ jest.mock('three', () => {
         Vector2: jest.fn(function () {
             return this;
         }),
+        Vector3: jest.fn(function () {
+            return this;
+        }),
         Raycaster: jest.fn(function () {
             this.setFromCamera = jest.fn();
             this.intersectObjects = mock_intersectObjects;
@@ -120,8 +116,6 @@ 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', () => {
@@ -129,21 +123,23 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
         expect(() => selectTool.Activate()).not.toThrow();
     });
 
-    it('should execute onPointerUp without hit', () => {
+    it('should execute onClick without hit', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);
-        expect(() => selectTool.onPointerUp({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+        selectTool['_gizmo'].object = {} as unknown as Object3D & DIVESelectable;
+        expect(() => selectTool.onClick({ 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 } } }]);
+    it('should execute onClick with hit', () => {
+        mock_intersectObjects.mockReturnValueOnce([{ object: { uuid: 'test', 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(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
     });
 
-    it('should execute onPointerUp with ISelectable hit', () => {
+    it('should execute onClick with same ISelectable hit', () => {
         const mock_onSelect = jest.fn();
 
         mock_intersectObjects.mockReturnValueOnce([{
+
             object: {
                 isSelectable: true,
                 onSelect: mock_onSelect,
@@ -151,14 +147,41 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
                     name: 'this is the test scene root!!!',
                     parent: null,
                 },
+                uuid: 'test0',
             },
         }]);
         const selectTool = new DIVESelectTool(mockScene, mockController);
-        expect(() => selectTool.onPointerUp({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
-        expect(mock_onSelect).toHaveBeenCalledTimes(1);
+        selectTool['_gizmo'].object = {
+            isSelectable: true,
+            uuid: 'test0',
+        } as unknown as Object3D & DIVESelectable;
+        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
     });
 
-    it('should execute onPointerUp with IMovable hit', () => {
+    it('should execute onClick 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,
+                },
+                uuid: 'test0',
+            },
+        }]);
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        selectTool['_gizmo'].object = {
+            isSelectable: true,
+            uuid: 'test1',
+        } as unknown as Object3D & DIVESelectable;
+        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
+    });
+
+    it('should execute onClick with IMovable hit', () => {
         const mock_onSelect = jest.fn();
 
         mock_intersectObjects.mockReturnValueOnce([{
@@ -173,15 +196,24 @@ describe('dive/toolbox/select/DIVESelectTool', () => {
             },
         }]);
         const selectTool = new DIVESelectTool(mockScene, mockController);
-        expect(() => selectTool.onPointerUp({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
-        expect(mock_attach).toHaveBeenCalledTimes(1);
+        expect(() => selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent)).not.toThrow();
     });
 
-    it('should deselect', () => {
+    it('should Select', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);
+        const mock_onSelect = jest.fn();
+        expect(() => selectTool.Select({ isSelectable: true })).not.toThrow();
+        expect(() => selectTool.Select({ isMoveable: true, onSelect: mock_onSelect } as unknown as DIVESelectable)).not.toThrow();
+        expect(mock_onSelect).toHaveBeenCalledTimes(1);
+    });
+
+    it('should Deselect', () => {
+        const selectTool = new DIVESelectTool(mockScene, mockController);
+        const mock_onDeselect = jest.fn();
         expect(() => selectTool.Deselect({ isSelectable: true })).not.toThrow();
-        expect(() => selectTool.Deselect({ isMoveable: true, onDeselect: jest.fn() } as unknown as DIVESelectable)).not.toThrow();
-    })
+        expect(() => selectTool.Deselect({ isMoveable: true, onDeselect: mock_onDeselect } as unknown as DIVESelectable)).not.toThrow();
+        expect(mock_onDeselect).toHaveBeenCalledTimes(1);
+    });
 
     it('should set gizmo mode', () => {
         const selectTool = new DIVESelectTool(mockScene, mockController);

package/src/toolbox/transform/TransformTool.ts

@@ -0,0 +1,48 @@
+import DIVEBaseTool from "../BaseTool.ts";
+import DIVEScene from "../../scene/Scene.ts";
+import DIVEOrbitControls from "../../controls/OrbitControls.ts";
+import { TransformControls } from "three/examples/jsm/Addons";
+
+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 DIVETransformTool extends DIVEBaseTool {
+    protected _gizmo: TransformControls;
+
+    constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
+        super(scene, controller);
+        this.name = "DIVETransformTool";
+
+        this._gizmo = new TransformControls(this._controller.object, this._controller.domElement);
+        this._gizmo.mode = 'translate';
+
+        scene.add(this._gizmo);
+    }
+
+    public Activate(): void { }
+
+    public SetGizmoMode(mode: 'translate' | 'rotate' | 'scale'): void {
+        this._gizmo.mode = mode;
+    }
+
+    // public onPointerDown(e: PointerEvent): void {
+    //     super.onPointerDown(e);
+
+    //     // if (this._hovered) {
+    //     //     this._dragRaycastOnObjects = this._gizmo.gizmoPlane.children;
+    //     // }
+    // }
+
+    // protected raycast(): Intersection[] {
+    //     return super.raycast(this._gizmo.gizmoNode.children);
+    // }
+}