@shopware-ag/dive 1.8.0 → 1.9.0

package/src/scene/root/__test__/Root.test.ts

@@ -1,13 +1,10 @@
 import DIVERoot from '../Root';
 import { type Vector3, type Object3D } from 'three';
-import { type COMLight, type COMModel, type COMPov } from '../../../com';
-
-const mock_UpdateLight = jest.fn();
-const mock_UpdateModel = jest.fn();
-const mock_GetLight = jest.fn();
-const mock_GetModel = jest.fn();
-const mock_DeleteLight = jest.fn();
-const mock_DeleteModel = jest.fn();
+import { type COMPrimitive, type COMLight, type COMModel, type COMPov } from '../../../com/types';
+
+const mock_UpdateObject = jest.fn();
+const mock_DeleteObject = jest.fn();
+const mock_GetObject = jest.fn();
 const mock_PlaceOnFloor = jest.fn();
 
 jest.mock('three', () => {
@@ -91,9 +88,9 @@ jest.mock('../lightroot/LightRoot', () => {
         this.isObject3D = true;
         this.parent = null;
         this.dispatchEvent = jest.fn();
-        this.UpdateLight = mock_UpdateLight;
-        this.DeleteLight = mock_DeleteLight;
-        this.GetLight = mock_GetLight;
+        this.UpdateLight = mock_UpdateObject;
+        this.DeleteLight = mock_DeleteObject;
+        this.GetLight = mock_GetObject;
         this.removeFromParent = jest.fn();
         return this;
     });
@@ -104,10 +101,10 @@ jest.mock('../modelroot/ModelRoot', () => {
         this.isObject3D = true;
         this.parent = null;
         this.dispatchEvent = jest.fn();
-        this.UpdateModel = mock_UpdateModel;
-        this.DeleteModel = mock_DeleteModel;
+        this.UpdateModel = mock_UpdateObject;
+        this.DeleteModel = mock_DeleteObject;
         this.PlaceOnFloor = mock_PlaceOnFloor;
-        this.GetModel = mock_GetModel;
+        this.GetModel = mock_GetObject;
         this.removeFromParent = jest.fn();
         this.traverse = jest.fn((callback: (object: Object3D) => void) => {
             callback(this);
@@ -116,6 +113,25 @@ jest.mock('../modelroot/ModelRoot', () => {
     });
 });
 
+jest.mock('../primitiveroot/PrimitiveRoot', () => {
+    return {
+        DIVEPrimitiveRoot: jest.fn(function () {
+            this.isObject3D = true;
+            this.parent = null;
+            this.dispatchEvent = jest.fn();
+            this.UpdatePrimitive = mock_UpdateObject;
+            this.DeletePrimitive = mock_DeleteObject;
+            this.PlaceOnFloor = mock_PlaceOnFloor;
+            this.GetPrimitive = mock_GetObject;
+            this.removeFromParent = jest.fn();
+            this.traverse = jest.fn((callback: (object: Object3D) => void) => {
+                callback(this);
+            });
+            return this;
+        }),
+    };
+});
+
 describe('DIVE/scene/root/DIVERoot', () => {
     afterEach(() => {
         jest.clearAllMocks();
@@ -124,7 +140,7 @@ describe('DIVE/scene/root/DIVERoot', () => {
     it('should instantiate', () => {
         const root = new DIVERoot();
         expect(root).toBeDefined();
-        expect(root.add).toHaveBeenCalledTimes(4);
+        expect(root.add).toHaveBeenCalledTimes(5);
     });
 
     it('should have Floor', () => {
@@ -145,51 +161,79 @@ describe('DIVE/scene/root/DIVERoot', () => {
 
     it('should add object', () => {
         const root = new DIVERoot();
+        expect(() => root.AddSceneObject({ entityType: 'pov' } as COMPov)).not.toThrow();
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(0);
+
         root.AddSceneObject({ entityType: 'light' } as COMLight);
-        expect(mock_UpdateLight).toHaveBeenCalledTimes(1);
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(1);
 
         root.AddSceneObject({ entityType: 'model' } as COMModel);
-        expect(mock_UpdateModel).toHaveBeenCalledTimes(1);
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(2);
 
-        expect(() => root.AddSceneObject({ entityType: 'pov' } as COMPov)).not.toThrow();
+        root.AddSceneObject({ entityType: 'primitive' } as COMPrimitive);
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(3);
     });
 
     it('should update object', () => {
         const root = new DIVERoot();
 
+        expect(() => root.UpdateSceneObject({ entityType: 'pov' })).not.toThrow();
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(0);
+
         root.UpdateSceneObject({ entityType: 'light' });
-        expect(mock_UpdateLight).toHaveBeenCalledTimes(1);
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(1);
 
         root.UpdateSceneObject({ entityType: 'model' });
-        expect(mock_UpdateModel).toHaveBeenCalledTimes(1);
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(2);
 
-        expect(() => root.UpdateSceneObject({ entityType: 'pov' })).not.toThrow();
+        root.UpdateSceneObject({ entityType: 'primitive' });
+        expect(mock_UpdateObject).toHaveBeenCalledTimes(3);
     });
 
     it('should delete object', () => {
         const root = new DIVERoot();
 
         root.DeleteSceneObject({ entityType: 'light' });
-        expect(mock_DeleteLight).toHaveBeenCalledTimes(1);
+        expect(mock_DeleteObject).toHaveBeenCalledTimes(1);
 
         root.DeleteSceneObject({ entityType: 'model' });
-        expect(mock_DeleteModel).toHaveBeenCalledTimes(1);
+        expect(mock_DeleteObject).toHaveBeenCalledTimes(2);
+
+        root.DeleteSceneObject({ entityType: 'primitive' });
+        expect(mock_DeleteObject).toHaveBeenCalledTimes(3);
 
         expect(() => root.DeleteSceneObject({ entityType: 'pov' })).not.toThrow();
     });
 
     it('should place model on floor', () => {
         const root = new DIVERoot();
+
+        root.PlaceOnFloor({ entityType: 'pov' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(0);
+
+        root.PlaceOnFloor({ entityType: 'light' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(0);
+
         root.PlaceOnFloor({ entityType: 'model' });
         expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(1);
+
+        root.PlaceOnFloor({ entityType: 'primitive' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(2);
     });
 
     it('should get scene object', () => {
         const scene = new DIVERoot();
-        scene.GetSceneObject({ entityType: 'model' });
-        expect(mock_GetModel).toHaveBeenCalledTimes(1);
-        scene.GetSceneObject({ entityType: 'light' });
-        expect(mock_GetLight).toHaveBeenCalledTimes(1);
+
         expect(scene.GetSceneObject({ entityType: 'pov' })).toBeUndefined();
+        expect(mock_GetObject).toHaveBeenCalledTimes(0);
+
+        scene.GetSceneObject({ entityType: 'light' });
+        expect(mock_GetObject).toHaveBeenCalledTimes(1);
+
+        scene.GetSceneObject({ entityType: 'model' });
+        expect(mock_GetObject).toHaveBeenCalledTimes(2);
+
+        scene.GetSceneObject({ entityType: 'primitive' });
+        expect(mock_GetObject).toHaveBeenCalledTimes(3);
     });
 });

package/src/scene/root/lightroot/__test__/LightRoot.test.ts

@@ -1,8 +1,7 @@
-import { TransformControls } from 'three/examples/jsm/Addons';
-import { COMLight } from '../../../../com';
-import { DIVEMoveable } from '../../../../interface/Moveable';
 import DIVELightRoot from '../LightRoot';
 import type DIVEScene from '../../../Scene';
+import { type COMLight } from '../../../../com/types';
+import { type DIVEMoveable } from '../../../../interface/Moveable';
 
 const mock_SetPosition = jest.fn();
 const mock_SetIntensity = jest.fn();

package/src/scene/root/primitiveroot/PrimitiveRoot.ts

@@ -0,0 +1,88 @@
+import { Object3D } from "three";
+import { DIVEPrimitive } from "../../../primitive/Primitive.ts";
+import type DIVEScene from "../../Scene.ts";
+import { type COMPrimitive } from "../../../com/types";
+import { type TransformControls } from "three/examples/jsm/controls/TransformControls";
+
+/**
+ * A basic scene node to hold all primitives.
+ *
+ * @module
+ */
+export class DIVEPrimitiveRoot extends Object3D {
+    constructor() {
+        super();
+        this.name = "PrimitiveRoot";
+    }
+
+    public GetPrimitive(object: Partial<COMPrimitive>): Object3D | undefined {
+        if (object.id === undefined) {
+            console.warn('PrimitiveRoot.GetPrimitive: object.id is undefined')
+            return undefined;
+        }
+        return this.children.find(object3D => object3D.userData.id === object.id);
+    }
+
+    public UpdatePrimitive(object: Partial<COMPrimitive>): void {
+        if (object.id === undefined) {
+            console.warn('PrimitiveRoot.UpdatePrimitive: object.id is undefined')
+            return;
+        }
+
+        let sceneObject = this.children.find(object3D => object3D.userData.id === object.id);
+        if (!sceneObject && object.geometry !== undefined) {
+            const primitive = new DIVEPrimitive();
+            primitive.SetGeometry(object.geometry);
+            sceneObject = primitive;
+            sceneObject.userData.id = object.id;
+            this.add(sceneObject);
+        }
+
+        if (object.position !== undefined) (sceneObject as DIVEPrimitive).SetPosition(object.position);
+        if (object.rotation !== undefined) (sceneObject as DIVEPrimitive).SetRotation(object.rotation);
+        if (object.scale !== undefined) (sceneObject as DIVEPrimitive).SetScale(object.scale);
+        if (object.visible !== undefined) (sceneObject as DIVEPrimitive).SetVisibility(object.visible);
+        if (object.material !== undefined) (sceneObject as DIVEPrimitive).SetMaterial(object.material);
+    }
+
+    public DeletePrimitive(object: Partial<COMPrimitive>): void {
+        if (object.id === undefined) {
+            console.warn(`PrimitiveRoot.DeletePrimitive: object.id is undefined`)
+            return;
+        }
+
+        const sceneObject = this.children.find(object3D => object3D.userData.id === object.id);
+        if (!sceneObject) {
+            console.warn(`PrimitiveRoot.DeletePrimitive: Primitive with id ${object.id} not found`);
+            return;
+        }
+
+        // _______________________________________________________
+        // this is only neccessary due to using the old TransformControls instead of the new DIVEGizmo
+        const findScene = (object: Object3D): DIVEScene => {
+            if (object.parent !== null) {
+                return findScene(object.parent);
+            };
+            return object as DIVEScene;
+        }
+
+        const scene = findScene(sceneObject);
+        scene.children.find((object) => {
+            if ('isTransformControls' in object) {
+                (object as TransformControls).detach();
+            }
+        });
+        // _______________________________________________________
+
+        this.remove(sceneObject);
+    }
+
+    public PlaceOnFloor(object: Partial<COMPrimitive>): void {
+        if (object.id === undefined) console.warn('PrimitiveRoot.PlaceOnFloor: object.id is undefined');
+
+        const sceneObject = this.children.find(object3D => object3D.userData.id === object.id);
+        if (!sceneObject) return;
+
+        (sceneObject as DIVEPrimitive).PlaceOnFloor();
+    }
+}

package/src/scene/root/primitiveroot/__test__/PrimitiveRoot.test.ts

@@ -0,0 +1,181 @@
+import DIVECommunication from '../../../../com/Communication';
+import { DIVEPrimitiveRoot } from '../PrimitiveRoot';
+import type DIVEScene from '../../../Scene';
+import { type DIVEMoveable } from '../../../../interface/Moveable';
+import { type COMMaterial, type COMGeometry } from '../../../../com/types';
+
+const mock_SetPosition = jest.fn();
+const mock_SetRotation = jest.fn();
+const mock_SetScale = jest.fn();
+const mock_PlaceOnFloor = jest.fn();
+const mock_SetGeometry = jest.fn();
+const mock_SetMaterial = jest.fn();
+
+jest.mock('../../../../com/types.ts', () => {
+    return {
+        COMPrimitive: {},
+    }
+});
+
+jest.mock('../../../../com/Communication.ts', () => {
+    return {
+        get: jest.fn(() => {
+            return {
+                PerformAction: jest.fn(),
+            }
+        }),
+    }
+});
+
+jest.mock('../../../../primitive/Primitive.ts', () => {
+    return {
+        DIVEPrimitive: jest.fn(function () {
+            this.isObject3D = true;
+            this.parent = null;
+            this.dispatchEvent = jest.fn();
+            this.userData = {
+                id: undefined,
+            };
+            this.SetGeometry = mock_SetGeometry;
+            this.SetMaterial = mock_SetMaterial;
+            this.SetPosition = mock_SetPosition;
+            this.SetRotation = mock_SetRotation;
+            this.SetScale = mock_SetScale;
+            this.SetVisibility = jest.fn();
+            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(() => { });
+let primitiveRoot = new DIVEPrimitiveRoot();
+
+describe('dive/scene/root/primitiveroot/DIVEPrimitiveRoot', () => {
+    beforeEach(() => {
+        consoleWarnSpy.mockClear();
+
+        primitiveRoot = new DIVEPrimitiveRoot();
+    });
+
+    it('should instantiate', () => {
+        expect(primitiveRoot).toBeDefined();
+    });
+
+    it('should not add incorrect primitive', async () => {
+        expect(() => primitiveRoot.UpdatePrimitive({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(primitiveRoot.children).toHaveLength(0);
+    });
+
+    it('should add basic primitive', async () => {
+        expect(() => primitiveRoot.UpdatePrimitive({
+            id: 'test_id',
+            geometry: {} as COMGeometry,
+            visible: false,
+        })).not.toThrow();
+        expect(mock_SetGeometry).toHaveBeenCalledTimes(1);
+        expect(primitiveRoot.children).toHaveLength(1);
+        expect(primitiveRoot.children[0].userData.id).toBe('test_id');
+    });
+
+    it('should add configured primitive', async () => {
+        primitiveRoot.userData.id = 'something';
+        expect(() => primitiveRoot.UpdatePrimitive({
+            id: 'test_id',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+            geometry: {} as COMGeometry,
+            material: {} as COMMaterial,
+        })).not.toThrow();
+
+        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
+        expect(() => primitiveRoot.UpdatePrimitive({
+            id: 'test_id',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+            geometry: {} as COMGeometry,
+            material: {} as COMMaterial,
+        }
+        )).not.toThrow();
+
+        expect(primitiveRoot.children).toHaveLength(1);
+        expect(mock_SetPosition).toHaveBeenCalledTimes(2);
+        expect(mock_SetRotation).toHaveBeenCalledTimes(2);
+        expect(mock_SetScale).toHaveBeenCalledTimes(2);
+        expect(mock_SetGeometry).toHaveBeenCalledTimes(2);
+        expect(mock_SetMaterial).toHaveBeenCalledTimes(2);
+    });
+
+    it('should not place incorrect primitive on floor', async () => {
+        expect(() => primitiveRoot.PlaceOnFloor({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(0);
+    });
+
+    it('should not place non-existing primitive on floor', async () => {
+        primitiveRoot.PlaceOnFloor({ id: 'test_id' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(0);
+    });
+
+    it('should place primitive on floor', async () => {
+        primitiveRoot.UpdatePrimitive({
+            id: 'test_id',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+            geometry: {} as COMGeometry,
+        });
+        primitiveRoot.PlaceOnFloor({ id: 'test_id' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(1);
+    });
+
+    it('should get primitive', async () => {
+        expect(() => primitiveRoot.GetPrimitive({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(primitiveRoot.GetPrimitive({ id: 'test_id' })).toBeUndefined();
+        expect(() => primitiveRoot.UpdatePrimitive({
+            id: 'test_id',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+            geometry: {} as COMGeometry,
+        })).not.toThrow();
+        expect(primitiveRoot.GetPrimitive({ id: 'test_id' })).toBeDefined();
+    });
+
+    it('should delete primitive', async () => {
+
+        const sceneParent = {
+            parent: null,
+            children: [
+                {
+                    isTransformControls: true,
+                    detach: jest.fn(),
+                }
+            ],
+        }
+        primitiveRoot.parent = sceneParent as unknown as DIVEScene;
+
+        expect(() => primitiveRoot.DeletePrimitive({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        consoleWarnSpy.mockClear();
+        expect(() => primitiveRoot.DeletePrimitive({ id: 'test_id' })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(() => primitiveRoot.UpdatePrimitive({
+            id: 'test_id',
+            position: { x: 1, y: 2, z: 3 },
+            rotation: { x: 1, y: 2, z: 3 },
+            scale: { x: 1, y: 2, z: 3 },
+            geometry: {} as COMGeometry,
+        })).not.toThrow();
+        (primitiveRoot.children[0] as unknown as DIVEMoveable).isMoveable = true;
+        expect(() => primitiveRoot.DeletePrimitive({ id: 'test_id' })).not.toThrow();
+        expect(primitiveRoot.children).toHaveLength(0);
+    });
+});