@shopware-ag/dive 1.19.1-beta.0 → 1.19.1-beta.2

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

@@ -1,143 +0,0 @@
-import DIVEToolbox, { type ToolType } from '../Toolbox';
-import type DIVEOrbitControls from '../../controls/OrbitControls';
-import { type DIVEScene } from '../../scene/Scene';
-
-/**
- * @jest-environment jsdom
- */
-
-jest.mock('../select/SelectTool.ts', () => {
-    return {
-        DIVESelectTool: jest.fn(function () {
-            this.Activate = jest.fn();
-            this.Deactivate = jest.fn();
-            this.onPointerDown = jest.fn();
-            this.onPointerMove = jest.fn();
-            this.onPointerUp = jest.fn();
-            this.onWheel = jest.fn();
-            this.SetGizmoMode = jest.fn();
-            this.SetGizmoVisibility = jest.fn();
-            this.SetGizmoScaleLinked = jest.fn();
-            return this;
-        }),
-    };
-});
-
-const mockController = {
-    domElement: {
-        width: 0,
-        height: 0,
-        addEventListener: jest.fn((type, callback) => {
-            callback();
-        }),
-        getContext: jest.fn(),
-        removeEventListener: jest.fn((type, callback) => {
-            callback();
-        }),
-        clientWidth: 0,
-        clientHeight: 0,
-        offsetLeft: 0,
-        offsetTop: 0,
-    },
-    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();
-    });
-
-    it('should dispose', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        toolBox.Dispose();
-    });
-
-    it('should throw with incorrect tool', () => {
-        const spy = jest.spyOn(console, 'warn').mockImplementation();
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() =>
-            toolBox.UseTool('not a real tool' as unknown as ToolType),
-        ).not.toThrow();
-        expect(spy).toHaveBeenCalled();
-    });
-
-    it('should use no tool', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() => toolBox.UseTool('none')).not.toThrow();
-    });
-
-    it('should use select tool', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.UseTool(DIVEToolbox.DefaultTool)).not.toThrow();
-    });
-
-    it('should execute pointer down event on tool', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() =>
-            toolBox.onPointerDown({ type: 'pointerdown' } as PointerEvent),
-        ).not.toThrow();
-        expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() =>
-            toolBox.onPointerDown({ type: 'pointerdown' } as PointerEvent),
-        ).not.toThrow();
-    });
-
-    it('should execute pointer move event on tool', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() =>
-            toolBox.onPointerMove({ type: 'pointermove' } as PointerEvent),
-        ).not.toThrow();
-        expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() =>
-            toolBox.onPointerMove({ type: 'pointermove' } as PointerEvent),
-        ).not.toThrow();
-    });
-
-    it('should execute pointer up event on tool', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() =>
-            toolBox.onPointerUp({ type: 'pointerup' } as PointerEvent),
-        ).not.toThrow();
-        expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() =>
-            toolBox.onPointerUp({ type: 'pointerup' } as PointerEvent),
-        ).not.toThrow();
-    });
-
-    it('should execute wheel event on tool', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() =>
-            toolBox.onWheel({ type: 'wheel' } as WheelEvent),
-        ).not.toThrow();
-        expect(() => toolBox.UseTool('select')).not.toThrow();
-        expect(() =>
-            toolBox.onWheel({ type: 'wheel' } as WheelEvent),
-        ).not.toThrow();
-    });
-
-    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);
-        expect(() => toolBox.SetGizmoMode('translate')).not.toThrow();
-    });
-
-    it('should set gizmo active', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.SetGizmoVisibility(true)).not.toThrow();
-    });
-
-    it('should set gizmo unified scale', () => {
-        const toolBox = new DIVEToolbox({} as DIVEScene, mockController);
-        expect(() => toolBox.SetGizmoScaleLinked(true)).not.toThrow();
-    });
-});

package/src/toolbox/select/SelectTool.ts

@@ -1,92 +0,0 @@
-import { type Object3D } from 'three';
-import { type DIVEScene } from '../../scene/Scene.ts';
-import DIVETransformTool from '../transform/TransformTool.ts';
-import { findInterface } from '../../helper/findInterface/findInterface.ts';
-import type DIVEOrbitControls from '../../controls/OrbitControls.ts';
-import { type DIVESelectable } from '../../interface/Selectable.ts';
-import { type DIVEMovable } from '../../interface/Movable.ts';
-import { type DIVEBaseTool } from '../BaseTool.ts';
-
-export const isSelectTool = (tool: DIVEBaseTool): tool is DIVESelectTool => {
-    return (tool as DIVESelectTool).isSelectTool !== undefined;
-};
-
-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 DIVEMovable to be movable.
- *
- * @module
- */
-
-export class DIVESelectTool extends DIVETransformTool {
-    readonly isSelectTool: boolean = true;
-
-    constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
-        super(scene, controller);
-        this.name = 'SelectTool';
-    }
-
-    public Activate(): void {}
-
-    public Select(selectable: DIVESelectable): void {
-        this.AttachGizmo(selectable);
-
-        if (selectable.onSelect) selectable.onSelect();
-    }
-
-    public Deselect(selectable: DIVESelectable): void {
-        this.DetachGizmo();
-
-        if (selectable.onDeselect) selectable.onDeselect();
-    }
-
-    public AttachGizmo(selectable: DIVESelectable): void {
-        if ('isMovable' in selectable) {
-            const movable = selectable as Object3D &
-                DIVESelectable &
-                DIVEMovable;
-            this._gizmo.attach(movable);
-            this.SetGizmoVisibility(movable.visible);
-        }
-    }
-
-    public DetachGizmo(): void {
-        this._gizmo.detach();
-    }
-
-    public onClick(e: PointerEvent): void {
-        super.onClick(e);
-
-        const first = this._raycaster
-            .intersectObjects(this._scene.Root.children, true)
-            .filter((intersect) => intersect.object.visible)[0];
-        const selectable = findInterface<DIVESelectable>(
-            first?.object,
-            'isSelectable',
-        );
-
-        // if nothing is hit
-        if (!first || !selectable) {
-            if (this._gizmo.object) {
-                this.Deselect(this._gizmo.object as Object3D & DIVESelectable);
-            }
-            return;
-        }
-
-        if (this._gizmo.object) {
-            // do not reselect if the same object was clicked
-            if (this._gizmo.object.uuid === selectable.uuid) return;
-
-            // deselect previous object
-            this.Deselect(this._gizmo.object as Object3D & DIVESelectable);
-        }
-
-        // select clicked object
-        this.Select(selectable);
-    }
-}

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

@@ -1,237 +0,0 @@
-import { DIVESelectTool, isSelectTool } from '../SelectTool';
-import { DIVEScene } from '../../../scene/Scene';
-import DIVEOrbitControls from '../../../controls/OrbitControls';
-import { DIVERenderer } from '../../../renderer/Renderer';
-import { DIVESelectable } from '../../../interface/Selectable';
-import type DIVEPerspectiveCamera from '../../../camera/PerspectiveCamera';
-import { type Object3D } from 'three';
-import { type DIVEBaseTool } from '../../BaseTool';
-import { DIVEAnimationSystem } from '../../../animation/AnimationSystem';
-import { Tween } from '@tweenjs/tween.js';
-
-jest.mock('../../../renderer/Renderer', () => {
-    return jest.fn(function () {
-        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('../../../animation/AnimationSystem', () => {
-    return {
-        DIVEAnimationSystem: jest.fn(function () {
-            this.domElement = {
-                style: {},
-            };
-            this.Animate = <T extends object>(obj: T) => {
-                return new Tween<T>(obj);
-            };
-
-            return this;
-        }),
-    };
-});
-
-jest.mock('../../../scene/Scene', () => {
-    return {
-        DIVEScene: jest.fn(function () {
-            this.add = jest.fn();
-            this.children = [];
-            this.Root = {
-                children: [],
-            };
-            return this;
-        }),
-    };
-});
-
-const mockCamera: DIVEPerspectiveCamera = {} as DIVEPerspectiveCamera;
-const mockRenderer = {
-    render: jest.fn(),
-    OnResize: jest.fn(),
-} as unknown as DIVERenderer;
-const mockScene: DIVEScene = new DIVEScene();
-const mockAnimSystem = new DIVEAnimationSystem(mockRenderer);
-const mockController: DIVEOrbitControls = new DIVEOrbitControls(
-    mockCamera,
-    mockRenderer,
-    mockAnimSystem,
-);
-
-let selectTool: DIVESelectTool;
-let intersectObjectsSpy: jest.SpyInstance;
-
-describe('dive/toolbox/select/DIVESelectTool', () => {
-    beforeEach(() => {
-        selectTool = new DIVESelectTool(mockScene, mockController);
-        intersectObjectsSpy = jest
-            .spyOn(selectTool['_raycaster'], 'intersectObjects')
-            .mockReturnValue([]);
-    });
-
-    it('should test if it is SelectTool', () => {
-        const selectTool = { isSelectTool: true } as unknown as DIVEBaseTool;
-        expect(isSelectTool(selectTool)).toBeDefined();
-    });
-
-    it('should instantiate', () => {
-        expect(selectTool).toBeDefined();
-    });
-
-    it('should activate', () => {
-        expect(() => selectTool.Activate()).not.toThrow();
-    });
-
-    it('should execute onClick without hit', () => {
-        selectTool.AttachGizmo({} as unknown as DIVESelectable);
-        expect(() =>
-            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
-        ).not.toThrow();
-    });
-
-    it('should execute onClick with hit', () => {
-        intersectObjectsSpy.mockReturnValueOnce([
-            {
-                object: {
-                    uuid: 'test',
-                    visible: true,
-                    parent: {
-                        name: 'this is the test scene root!!!',
-                        parent: null,
-                    },
-                },
-            },
-        ]);
-
-        expect(() =>
-            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
-        ).not.toThrow();
-    });
-
-    it('should execute onClick with same ISelectable hit', () => {
-        const mock_onSelect = jest.fn();
-
-        intersectObjectsSpy.mockReturnValueOnce([
-            {
-                object: {
-                    isSelectable: true,
-                    onSelect: mock_onSelect,
-                    visible: true,
-                    parent: {
-                        name: 'this is the test scene root!!!',
-                        parent: null,
-                    },
-                    uuid: 'test0',
-                },
-            },
-        ]);
-        selectTool.AttachGizmo({
-            visible: true,
-            isSelectable: true,
-            uuid: 'test0',
-        } as unknown as Object3D & DIVESelectable);
-        expect(() =>
-            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
-        ).not.toThrow();
-    });
-
-    it('should execute onClick with ISelectable hit', () => {
-        const mock_onSelect = jest.fn();
-
-        intersectObjectsSpy.mockReturnValueOnce([
-            {
-                object: {
-                    isSelectable: true,
-                    onSelect: mock_onSelect,
-                    visible: true,
-                    parent: {
-                        name: 'this is the test scene root!!!',
-                        parent: null,
-                    },
-                    uuid: 'test0',
-                },
-            },
-        ]);
-        selectTool.AttachGizmo({
-            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();
-
-        intersectObjectsSpy.mockReturnValueOnce([
-            {
-                object: {
-                    isSelectable: true,
-                    isMovable: true,
-                    onSelect: mock_onSelect,
-                    parent: {
-                        name: 'this is the test scene root!!!',
-                        parent: null,
-                    },
-                },
-            },
-        ]);
-
-        expect(() =>
-            selectTool.onClick({ offsetX: 0, offsetY: 0 } as PointerEvent),
-        ).not.toThrow();
-    });
-
-    it('should Select', () => {
-        const mock_onSelect = jest.fn();
-        expect(() => selectTool.Select({ isSelectable: true })).not.toThrow();
-        expect(() =>
-            selectTool.Select({
-                isMovable: true,
-                onSelect: mock_onSelect,
-            } as unknown as DIVESelectable),
-        ).not.toThrow();
-        expect(mock_onSelect).toHaveBeenCalledTimes(1);
-    });
-
-    it('should Deselect', () => {
-        const mock_onDeselect = jest.fn();
-        expect(() => selectTool.Deselect({ isSelectable: true })).not.toThrow();
-        expect(() =>
-            selectTool.Deselect({
-                isMovable: true,
-                onDeselect: mock_onDeselect,
-            } as unknown as DIVESelectable),
-        ).not.toThrow();
-        expect(mock_onDeselect).toHaveBeenCalledTimes(1);
-    });
-
-    it('should set gizmo mode', () => {
-        expect(() => selectTool.SetGizmoMode('translate')).not.toThrow();
-    });
-});

package/src/toolbox/transform/TransformTool.ts

@@ -1,166 +0,0 @@
-import { DIVEBaseTool } from '../BaseTool.ts';
-import { type DIVEScene } from '../../scene/Scene.ts';
-import type DIVEOrbitControls from '../../controls/OrbitControls.ts';
-import { TransformControls } from 'three/examples/jsm/controls/TransformControls';
-import { type DIVEMovable } from '../../interface/Movable.ts';
-import { implementsInterface } from '../../helper/isInterface/implementsInterface.ts';
-import { DIVEGizmo } from '../../gizmo/Gizmo.ts';
-import { type Mesh, type MeshBasicMaterial } from 'three';
-import {
-    AxesColorBlue,
-    AxesColorGreen,
-    AxesColorRed,
-} from '../../constant/AxisHelperColors.ts';
-
-export const isTransformTool = (
-    tool: DIVEBaseTool,
-): tool is DIVETransformTool => {
-    return (tool as DIVETransformTool).isTransformTool !== undefined;
-};
-
-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 DIVEMovable to be movable.
- *
- * @module
- */
-
-export default class DIVETransformTool extends DIVEBaseTool {
-    readonly isTransformTool: boolean = true;
-
-    private _scaleLinked: boolean;
-
-    protected _gizmo: TransformControls | DIVEGizmo;
-
-    constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
-        super(scene, controller);
-        this.name = 'DIVETransformTool';
-
-        this._scaleLinked = false;
-
-        this._gizmo = this.initGizmo() as TransformControls;
-
-        this._scene.add(this._gizmo);
-    }
-
-    public Activate(): void {}
-
-    public SetGizmoMode(mode: 'translate' | 'rotate' | 'scale'): void {
-        this._gizmo.mode = mode;
-    }
-
-    public SetGizmoVisibility(active: boolean): void {
-        const contains = this._scene.children.includes(this._gizmo);
-        if (active && !contains) {
-            this._scene.add(this._gizmo);
-            if ('isTransformControls' in this._gizmo) {
-                (this._gizmo as TransformControls)
-                    .getRaycaster()
-                    .layers.enableAll();
-            }
-        } else if (!active && contains) {
-            this._scene.remove(this._gizmo);
-            if ('isTransformControls' in this._gizmo) {
-                (this._gizmo as TransformControls)
-                    .getRaycaster()
-                    .layers.disableAll();
-            }
-        }
-    }
-
-    public SetGizmoScaleLinked(linked: boolean): void {
-        this._scaleLinked = linked;
-    }
-
-    // only used for optimizing pointer events with DIVEGizmo
-    // public onPointerDown(e: PointerEvent): void {
-    //     super.onPointerDown(e);
-
-    //     if (this._hovered) {
-    //         this._dragRaycastOnObjects = (
-    //             this._gizmo as DIVEGizmo
-    //         ).gizmoPlane?.children;
-    //     }
-    // }
-
-    // only used for optimizing pointer events with DIVEGizmo
-    // protected raycast(): Intersection[] {
-    //     return super.raycast((this._gizmo as DIVEGizmo).gizmoNode.children);
-    // }
-
-    private initGizmo(): TransformControls | DIVEGizmo {
-        const g = new TransformControls(
-            // this._controller,
-            this._controller.object,
-            this._controller.domElement,
-        );
-        // g.debug = true;
-        g.mode = 'translate';
-
-        g.traverse((child) => {
-            if (!('isMesh' in child)) return;
-
-            const material = (child as Mesh).material as MeshBasicMaterial;
-
-            if (child.name === 'X') {
-                material.color.set(AxesColorRed);
-            }
-            if (child.name === 'Y') {
-                material.color.set(AxesColorGreen);
-            }
-            if (child.name === 'Z') {
-                material.color.set(AxesColorBlue);
-            }
-            if (child.name === 'XY') {
-                material.color.set(AxesColorBlue);
-            }
-            if (child.name === 'YZ') {
-                material.color.set(AxesColorRed);
-            }
-            if (child.name === 'XZ') {
-                material.color.set(AxesColorGreen);
-            }
-        });
-
-        // happens when pointerDown event is called on gizmo
-        g.addEventListener('mouseDown', () => {
-            this._controller.enabled = false;
-
-            if (!implementsInterface<DIVEMovable>(g.object, 'isMovable'))
-                return;
-            if (!g.object.onMoveStart) return;
-            g.object.onMoveStart();
-        });
-
-        // happens when pointerMove event is called on gizmo
-        g.addEventListener('objectChange', () => {
-            if (!implementsInterface<DIVEMovable>(g.object, 'isMovable'))
-                return;
-            if (!g.object.onMove) return;
-            g.object.onMove();
-
-            if (this._scaleLinked) {
-                const scale = g.object.scale;
-                const averageScale = (scale.x + scale.y + scale.z) / 3;
-                g.object.scale.set(averageScale, averageScale, averageScale);
-            }
-        });
-
-        // happens when pointerUp event is called on gizmo
-        g.addEventListener('mouseUp', () => {
-            this._controller.enabled = true;
-
-            if (!implementsInterface<DIVEMovable>(g.object, 'isMovable'))
-                return;
-            if (!g.object.onMoveEnd) return;
-            g.object.onMoveEnd();
-        });
-
-        return g;
-    }
-}