@shopware-ag/dive 1.19.0 → 1.19.1-beta.1

package/src/scene/xrroot/XRRoot.ts

@@ -1,56 +0,0 @@
-import { Mesh, Object3D, PlaneGeometry, ShadowMaterial } from 'three';
-import { DIVERoot } from '../root/Root';
-import { type DIVERenderer } from '../../renderer/Renderer';
-import { DIVEXRLightRoot } from './xrlightroot/XRLightRoot';
-import { type DIVEScene } from '../Scene';
-
-export class DIVEXRRoot extends Object3D {
-    private _xrLightRoot: DIVEXRLightRoot;
-    private _xrModelRoot: DIVERoot;
-    private _xrHandNode: Object3D;
-
-    public get XRModelRoot(): DIVERoot {
-        return this._xrModelRoot;
-    }
-
-    public get XRLightRoot(): DIVEXRLightRoot {
-        return this._xrLightRoot;
-    }
-
-    public get XRHandNode(): Object3D {
-        return this._xrHandNode;
-    }
-
-    private _xrShadowPlane: Mesh;
-
-    constructor(scene: DIVEScene) {
-        super();
-        this.name = 'XRRoot';
-
-        this._xrModelRoot = new DIVERoot();
-        this._xrModelRoot.name = 'XRModelRoot';
-        this.add(this._xrModelRoot);
-
-        this._xrShadowPlane = new Mesh(
-            new PlaneGeometry(100, 100),
-            new ShadowMaterial({ opacity: 1, transparent: true }),
-        );
-        this._xrModelRoot.add(this._xrShadowPlane);
-
-        this._xrLightRoot = new DIVEXRLightRoot(scene);
-        this._xrLightRoot.name = 'XRLightRoot';
-        this.add(this._xrLightRoot);
-
-        this._xrHandNode = new Object3D();
-        this._xrHandNode.name = 'XRHandNode';
-        this.add(this._xrHandNode);
-    }
-
-    public InitLightEstimation(renderer: DIVERenderer): void {
-        this._xrLightRoot.InitLightEstimation(renderer);
-    }
-
-    public DisposeLightEstimation(): void {
-        this._xrLightRoot.DisposeLightEstimation();
-    }
-}

package/src/scene/xrroot/xrlightroot/XRLightRoot.ts

@@ -1,80 +0,0 @@
-import { XREstimatedLight } from 'three/examples/jsm/webxr/XREstimatedLight';
-import { type DIVERenderer } from '../../../renderer/Renderer';
-import { Object3D } from 'three';
-import { type DIVEScene } from '../../Scene';
-import { PRODUCT_LAYER_MASK } from '../../../constant/VisibilityLayerMask';
-import { DIVERoot } from '../../root/Root';
-
-export class DIVEXRLightRoot extends Object3D {
-    private _scene: DIVEScene;
-
-    private _xrLight: XREstimatedLight | null;
-    private _lightRoot: DIVERoot;
-
-    constructor(scene: DIVEScene) {
-        super();
-        this.name = 'XRLightRoot';
-
-        this._scene = scene;
-
-        // placeholder for XR light
-        this._xrLight = null;
-
-        // add scene
-        this._lightRoot = new DIVERoot();
-        this._lightRoot.UpdateSceneObject({
-            id: 'XRSceneLight',
-            entityType: 'light',
-            name: 'XRSceneLight',
-            type: 'scene',
-            color: 0xffffff,
-            intensity: 1,
-            enabled: true,
-            visible: true,
-        });
-        this.add(this._lightRoot);
-    }
-
-    public InitLightEstimation(renderer: DIVERenderer): void {
-        if (!this._xrLight) {
-            this._xrLight = new XREstimatedLight(renderer, true);
-            this._xrLight.layers.mask = PRODUCT_LAYER_MASK;
-            this.add(this._xrLight);
-        }
-
-        this._xrLight.addEventListener('estimationstart', () => {
-            this.onEstimationStart();
-        });
-        this._xrLight.addEventListener('estimationend', () => {
-            this.onEstimationEnd();
-        });
-    }
-
-    public DisposeLightEstimation(): void {
-        if (!this._xrLight) return;
-
-        this._xrLight.removeEventListener('estimationstart', () => {
-            this.onEstimationStart();
-        });
-        this._xrLight.removeEventListener('estimationend', () => {
-            this.onEstimationEnd();
-        });
-    }
-
-    private onEstimationStart(): void {
-        this._lightRoot.visible = false;
-
-        if (!this._xrLight) return;
-
-        if (this._xrLight.environment) {
-            this._scene.environment = this._xrLight.environment;
-        }
-    }
-
-    private onEstimationEnd(): void {
-        this._lightRoot.visible = true;
-        this._scene.environment = null;
-
-        if (!this._xrLight) return;
-    }
-}

package/src/toolbox/BaseTool.ts

@@ -1,319 +0,0 @@
-import {
-    type Intersection,
-    type Object3D,
-    Raycaster,
-    Vector2,
-    Vector3,
-} from 'three';
-import {
-    PRODUCT_LAYER_MASK,
-    UI_LAYER_MASK,
-} from '../constant/VisibilityLayerMask';
-import { type DIVEScene } from '../scene/Scene';
-import type DIVEOrbitControls from '../controls/OrbitControls';
-import { type DIVEDraggable } from '../interface/Draggable';
-import { type DIVEHoverable } from '../interface/Hoverable';
-import { findInterface } from '../helper/findInterface/findInterface';
-
-export type DraggableEvent = {
-    dragStart: Vector3;
-    dragCurrent: Vector3;
-    dragEnd: Vector3;
-    dragDelta: Vector3;
-};
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export abstract class DIVEBaseTool {
-    readonly POINTER_DRAG_THRESHOLD: number = 0.001;
-
-    public name: string;
-
-    protected _canvas: HTMLElement;
-    protected _scene: DIVEScene;
-    protected _controller: DIVEOrbitControls;
-
-    // general pointer members
-    protected _pointer: Vector2;
-
-    protected get _pointerAnyDown(): boolean {
-        return (
-            this._pointerPrimaryDown ||
-            this._pointerMiddleDown ||
-            this._pointerSecondaryDown
-        );
-    }
-    protected _pointerPrimaryDown: boolean;
-    protected _pointerMiddleDown: boolean;
-    protected _pointerSecondaryDown: boolean;
-    protected _lastPointerDown: Vector2;
-    protected _lastPointerUp: Vector2;
-
-    // raycast members
-    protected _raycaster: Raycaster;
-    protected _intersects: Intersection[];
-
-    // hovering members
-    protected _hovered: (Object3D & DIVEHoverable) | null;
-
-    // dragging members
-    protected _dragging: boolean;
-    protected _dragStart: Vector3;
-    protected _dragCurrent: Vector3;
-    protected _dragEnd: Vector3;
-    protected _dragDelta: Vector3;
-    protected _draggable: DIVEDraggable | null;
-    protected _dragRaycastOnObjects: Object3D[] | null;
-
-    protected constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
-        this.name = 'BaseTool';
-
-        this._canvas = controller.domElement;
-        this._scene = scene;
-        this._controller = controller;
-
-        this._pointer = new Vector2();
-
-        this._pointerPrimaryDown = false;
-        this._pointerMiddleDown = false;
-        this._pointerSecondaryDown = false;
-
-        this._lastPointerDown = new Vector2();
-        this._lastPointerUp = new Vector2();
-
-        this._raycaster = new Raycaster();
-        this._raycaster.layers.mask = PRODUCT_LAYER_MASK | UI_LAYER_MASK;
-        this._intersects = [];
-
-        this._hovered = null;
-
-        this._dragging = false;
-        this._dragStart = new Vector3();
-        this._dragCurrent = new Vector3();
-        this._dragEnd = new Vector3();
-        this._dragDelta = new Vector3();
-        this._draggable = null;
-        this._dragRaycastOnObjects = null;
-    }
-
-    public Activate(): void {}
-
-    public Deactivate(): void {}
-
-    public onPointerDown(e: PointerEvent): void {
-        switch (e.button) {
-            case 0: {
-                this._pointerPrimaryDown = true;
-                break;
-            }
-            case 1: {
-                this._pointerMiddleDown = true;
-                break;
-            }
-            case 2: {
-                this._pointerSecondaryDown = true;
-                break;
-            }
-            default: {
-                console.warn(
-                    'DIVEBaseTool.onPointerDown: Unknown button: ' + e.button,
-                );
-            }
-        }
-
-        this._lastPointerDown.copy(this._pointer);
-
-        this._draggable =
-            findInterface<DIVEDraggable>(
-                this._intersects[0]?.object,
-                'isDraggable',
-            ) || null;
-    }
-
-    public onDragStart(e: PointerEvent): void {
-        if (!this._draggable) return;
-
-        if (this._dragRaycastOnObjects !== null) {
-            this._intersects = this._raycaster.intersectObjects(
-                this._dragRaycastOnObjects,
-                true,
-            );
-        }
-
-        if (this._intersects.length === 0) return;
-
-        this._dragStart.copy(this._intersects[0].point.clone());
-        this._dragCurrent.copy(this._intersects[0].point.clone());
-        this._dragEnd.copy(this._dragStart.clone());
-        this._dragDelta.set(0, 0, 0);
-
-        if (this._draggable && this._draggable.onDragStart) {
-            this._draggable.onDragStart({
-                dragStart: this._dragStart,
-                dragCurrent: this._dragCurrent,
-                dragEnd: this._dragEnd,
-                dragDelta: this._dragDelta,
-            });
-
-            this._dragging = true;
-            this._controller.enabled = false;
-        }
-    }
-
-    public onPointerMove(e: PointerEvent): void {
-        // update pointer
-        this._pointer.x = (e.offsetX / this._canvas.clientWidth) * 2 - 1;
-        this._pointer.y = -(e.offsetY / this._canvas.clientHeight) * 2 + 1;
-
-        // set raycaster
-        this._raycaster.setFromCamera(this._pointer, this._controller.object);
-
-        // refresh intersects
-        this._intersects = this.raycast(this._scene.children);
-
-        // handle hover
-        const hoverable = findInterface<DIVEHoverable>(
-            this._intersects[0]?.object,
-            'isHoverable',
-        );
-        if (this._intersects[0] && hoverable) {
-            if (!this._hovered) {
-                if (hoverable.onPointerEnter)
-                    hoverable.onPointerEnter(this._intersects[0]);
-                this._hovered = hoverable;
-                return;
-            }
-
-            if (this._hovered.uuid !== hoverable.uuid) {
-                if (this._hovered.onPointerLeave)
-                    this._hovered.onPointerLeave();
-                if (hoverable.onPointerEnter)
-                    hoverable.onPointerEnter(this._intersects[0]);
-                this._hovered = hoverable;
-                return;
-            }
-
-            if (hoverable.onPointerOver)
-                hoverable.onPointerOver(this._intersects[0]);
-            this._hovered = hoverable;
-        } else {
-            if (this._hovered) {
-                if (this._hovered.onPointerLeave)
-                    this._hovered.onPointerLeave();
-            }
-
-            this._hovered = null;
-        }
-
-        // handle drag
-        if (this._pointerAnyDown) {
-            if (!this._dragging) {
-                this.onDragStart(e);
-            }
-
-            this.onDrag(e);
-        }
-    }
-
-    public onDrag(e: PointerEvent): void {
-        if (this._dragRaycastOnObjects !== null) {
-            this._intersects = this._raycaster.intersectObjects(
-                this._dragRaycastOnObjects,
-                true,
-            );
-        }
-        const intersect = this._intersects[0];
-        if (!intersect) return;
-
-        this._dragCurrent.copy(intersect.point.clone());
-        this._dragEnd.copy(intersect.point.clone());
-        this._dragDelta.subVectors(
-            this._dragCurrent.clone(),
-            this._dragStart.clone(),
-        );
-
-        if (this._draggable && this._draggable.onDrag) {
-            this._draggable.onDrag({
-                dragStart: this._dragStart,
-                dragCurrent: this._dragCurrent,
-                dragEnd: this._dragEnd,
-                dragDelta: this._dragDelta,
-            });
-        }
-    }
-
-    public onPointerUp(e: PointerEvent): void {
-        if (this.pointerWasDragged() || this._dragging) {
-            if (this._draggable) {
-                this.onDragEnd(e);
-            }
-        } else {
-            this.onClick(e);
-        }
-
-        switch (e.button) {
-            case 0:
-                this._pointerPrimaryDown = false;
-                break;
-            case 1:
-                this._pointerMiddleDown = false;
-                break;
-            case 2:
-                this._pointerSecondaryDown = false;
-                break;
-        }
-
-        this._lastPointerUp.copy(this._pointer);
-    }
-
-    public onClick(e: PointerEvent): void {}
-
-    public onDragEnd(e: PointerEvent): void {
-        const intersect = this._intersects[0];
-        if (intersect) {
-            this._dragEnd.copy(intersect.point.clone());
-            this._dragCurrent.copy(intersect.point.clone());
-            this._dragDelta.subVectors(
-                this._dragCurrent.clone(),
-                this._dragStart.clone(),
-            );
-        }
-
-        if (this._draggable && this._draggable.onDragEnd) {
-            this._draggable.onDragEnd({
-                dragStart: this._dragStart,
-                dragCurrent: this._dragCurrent,
-                dragEnd: this._dragEnd,
-                dragDelta: this._dragDelta,
-            });
-        }
-
-        this._draggable = null;
-        this._dragging = false;
-
-        this._dragStart.set(0, 0, 0);
-        this._dragCurrent.set(0, 0, 0);
-        this._dragEnd.set(0, 0, 0);
-        this._dragDelta.set(0, 0, 0);
-
-        this._controller.enabled = true;
-    }
-
-    public onWheel(e: WheelEvent): void {}
-
-    protected raycast(objects?: Object3D[]): Intersection[] {
-        if (objects !== undefined)
-            return this._raycaster
-                .intersectObjects(objects, true)
-                .filter((i) => i.object.visible);
-        return this._raycaster
-            .intersectObjects(this._scene.children, true)
-            .filter((i) => i.object.visible);
-    }
-
-    private pointerWasDragged(): boolean {
-        return (
-            this._lastPointerDown.distanceTo(this._pointer) >
-            this.POINTER_DRAG_THRESHOLD
-        );
-    }
-}

package/src/toolbox/Toolbox.ts

@@ -1,129 +0,0 @@
-import type DIVEOrbitControls from '../controls/OrbitControls.ts';
-import { type DIVEScene } from '../scene/Scene.ts';
-import { type DIVEBaseTool } from './BaseTool.ts';
-import { DIVESelectTool } from './select/SelectTool.ts';
-
-export type ToolType = 'select' | 'none';
-
-/**
- * A Toolbox to activate and deactivate tools to use with the pointer.
- *
- * @module
- */
-
-export default class DIVEToolbox {
-    public static readonly DefaultTool = 'select';
-
-    private _scene: DIVEScene;
-    private _controller: DIVEOrbitControls;
-
-    private _activeTool: DIVEBaseTool | null;
-
-    private _selectTool: DIVESelectTool | null;
-    public get selectTool(): DIVESelectTool {
-        if (!this._selectTool) {
-            this._selectTool = new DIVESelectTool(
-                this._scene,
-                this._controller,
-            );
-        }
-        return this._selectTool;
-    }
-
-    constructor(scene: DIVEScene, controller: DIVEOrbitControls) {
-        this._scene = scene;
-        this._controller = controller;
-
-        // toolset
-        this._selectTool = null;
-
-        // default tool
-        this._activeTool = null;
-    }
-
-    public Dispose(): void {
-        this.removeEventListeners();
-    }
-
-    public GetActiveTool(): DIVEBaseTool | null {
-        return this._activeTool;
-    }
-
-    public UseTool(tool: ToolType): void {
-        this._activeTool?.Deactivate();
-        switch (tool) {
-            case 'select': {
-                this.addEventListeners();
-                this.selectTool.Activate();
-                this._activeTool = this.selectTool;
-                break;
-            }
-            case 'none': {
-                this.removeEventListeners();
-                this._activeTool = null;
-                break;
-            }
-            default: {
-                console.warn(`DIVEToolBox.UseTool: Unknown tool: ${tool}`);
-            }
-        }
-    }
-
-    public SetGizmoMode(mode: 'translate' | 'rotate' | 'scale'): void {
-        this.selectTool.SetGizmoMode(mode);
-    }
-
-    public SetGizmoVisibility(active: boolean): void {
-        this.selectTool.SetGizmoVisibility(active);
-    }
-
-    public SetGizmoScaleLinked(linked: boolean): void {
-        this.selectTool.SetGizmoScaleLinked(linked);
-    }
-
-    public onPointerMove(e: PointerEvent): void {
-        this._activeTool?.onPointerMove(e);
-    }
-
-    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);
-    }
-
-    private addEventListeners(): void {
-        this._controller.domElement.addEventListener('pointermove', (e) =>
-            this.onPointerMove(e),
-        );
-        this._controller.domElement.addEventListener('pointerdown', (e) =>
-            this.onPointerDown(e),
-        );
-        this._controller.domElement.addEventListener('pointerup', (e) =>
-            this.onPointerUp(e),
-        );
-        this._controller.domElement.addEventListener('wheel', (e) =>
-            this.onWheel(e),
-        );
-    }
-
-    private removeEventListeners(): void {
-        this._controller.domElement.removeEventListener('pointermove', (e) =>
-            this.onPointerMove(e),
-        );
-        this._controller.domElement.removeEventListener('pointerdown', (e) =>
-            this.onPointerDown(e),
-        );
-        this._controller.domElement.removeEventListener('pointerup', (e) =>
-            this.onPointerUp(e),
-        );
-        this._controller.domElement.removeEventListener('wheel', (e) =>
-            this.onWheel(e),
-        );
-    }
-}