@shopware-ag/dive 1.0.7 → 1.0.9

package/src/scene/root/Root.ts

@@ -0,0 +1,107 @@
+import { Object3D } from "three";
+import DIVELightRoot from "./lightroot/LightRoot.ts";
+import DIVEModelRoot from "./modelroot/ModelRoot.ts";
+import { COMLight, COMModel, COMEntity } from "../../com/types.ts";
+import DIVEFloor from "../../primitive/floor/Floor.ts";
+import DIVEGrid from "../../grid/Grid.ts";
+
+/**
+ * A basic scene node to hold grid, floor and all lower level roots.
+ *
+ * @module
+ */
+
+export default class DIVERoot extends Object3D {
+    private lightRoot: DIVELightRoot;
+    private modelRoot: DIVEModelRoot;
+    private floor: DIVEFloor;
+    private grid: DIVEGrid;
+
+    public get Floor(): DIVEFloor {
+        return this.floor;
+    }
+
+    public get Grid(): DIVEGrid {
+        return this.grid;
+    }
+
+    constructor() {
+        super();
+        this.name = "Root";
+
+        this.lightRoot = new DIVELightRoot();
+        this.add(this.lightRoot);
+        this.modelRoot = new DIVEModelRoot();
+        this.add(this.modelRoot);
+        this.floor = new DIVEFloor();
+        this.add(this.floor);
+        this.grid = new DIVEGrid();
+        this.add(this.grid);
+    }
+
+    public GetSceneObject(object: Partial<COMEntity>): Object3D | undefined {
+        switch (object.entityType) {
+            case "pov": {
+                return undefined;
+            }
+            case "light": {
+                return this.lightRoot.GetLight(object as COMLight);
+            }
+            case "model": {
+                return this.modelRoot.GetModel(object as COMModel);
+            }
+        }
+    }
+
+    public AddSceneObject(object: COMEntity): void {
+        switch (object.entityType) {
+            case "pov": {
+                break;
+            }
+            case "light": {
+                this.lightRoot.UpdateLight(object as COMLight);
+                break;
+            }
+            case "model": {
+                this.modelRoot.UpdateModel(object as COMModel);
+                break;
+            }
+        }
+    }
+
+    public UpdateSceneObject(object: Partial<COMEntity>): void {
+        switch (object.entityType) {
+            case "pov": {
+                break;
+            }
+            case "light": {
+                this.lightRoot.UpdateLight(object as COMLight);
+                break;
+            }
+            case "model": {
+                this.modelRoot.UpdateModel(object as COMModel);
+                break;
+            }
+        }
+    }
+
+    public DeleteSceneObject(object: Partial<COMEntity>): void {
+        switch (object.entityType) {
+            case "pov": {
+                break;
+            }
+            case "light": {
+                this.lightRoot.DeleteLight(object as COMLight);
+                break;
+            }
+            case "model": {
+                this.modelRoot.DeleteModel(object as COMModel);
+                break;
+            }
+        }
+    }
+
+    public PlaceOnFloor(object: Partial<COMModel>): void {
+        this.modelRoot.PlaceOnFloor(object);
+    }
+}

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

@@ -0,0 +1,129 @@
+import { COMLight, COMModel, COMPov } from '../../../com';
+import DIVERoot from '../Root';
+
+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();
+const mock_PlaceOnFloor = jest.fn();
+
+jest.mock('../../../primitive/floor/Floor', () => {
+    return jest.fn(function () {
+        this.isObject3D = true;
+        this.parent = null;
+        this.dispatchEvent = jest.fn();
+        this.removeFromParent = jest.fn();
+        return this;
+    });
+});
+
+jest.mock('../../../grid/Grid', () => {
+    return jest.fn(function () {
+        this.isObject3D = true;
+        this.parent = null;
+        this.dispatchEvent = jest.fn();
+        this.removeFromParent = jest.fn();
+        return this;
+    });
+});
+
+jest.mock('../lightroot/LightRoot', () => {
+    return jest.fn(function () {
+        this.isObject3D = true;
+        this.parent = null;
+        this.dispatchEvent = jest.fn();
+        this.UpdateLight = mock_UpdateLight;
+        this.DeleteLight = mock_DeleteLight;
+        this.GetLight = mock_GetLight;
+        this.removeFromParent = jest.fn();
+        return this;
+    });
+});
+
+jest.mock('../modelroot/ModelRoot', () => {
+    return jest.fn(function () {
+        this.isObject3D = true;
+        this.parent = null;
+        this.dispatchEvent = jest.fn();
+        this.UpdateModel = mock_UpdateModel;
+        this.DeleteModel = mock_DeleteModel;
+        this.PlaceOnFloor = mock_PlaceOnFloor;
+        this.GetModel = mock_GetModel;
+        this.removeFromParent = jest.fn();
+        return this;
+    });
+});
+
+describe('DIVE/scene/root/DIVERoot', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should instantiate', () => {
+        const root = new DIVERoot();
+        expect(root).toBeDefined();
+        expect(root.children).toHaveLength(4);
+    });
+
+    it('should have Floor', () => {
+        const root = new DIVERoot();
+        expect(root.Floor).toBeDefined();
+    });
+
+    it('should have Grid', () => {
+        const root = new DIVERoot();
+        expect(root.Grid).toBeDefined();
+    });
+
+    it('should add object', () => {
+        const root = new DIVERoot();
+        root.AddSceneObject({ entityType: 'light' } as COMLight);
+        expect(mock_UpdateLight).toHaveBeenCalledTimes(1);
+
+        root.AddSceneObject({ entityType: 'model' } as COMModel);
+        expect(mock_UpdateModel).toHaveBeenCalledTimes(1);
+
+        expect(() => root.AddSceneObject({ entityType: 'pov' } as COMPov)).not.toThrow();
+    });
+
+    it('should update object', () => {
+        const root = new DIVERoot();
+
+        root.UpdateSceneObject({ entityType: 'light' });
+        expect(mock_UpdateLight).toHaveBeenCalledTimes(1);
+
+        root.UpdateSceneObject({ entityType: 'model' });
+        expect(mock_UpdateModel).toHaveBeenCalledTimes(1);
+
+        expect(() => root.UpdateSceneObject({ entityType: 'pov' })).not.toThrow();
+    });
+
+    it('should delete object', () => {
+        const root = new DIVERoot();
+
+        root.DeleteSceneObject({ entityType: 'light' });
+        expect(mock_DeleteLight).toHaveBeenCalledTimes(1);
+
+        root.DeleteSceneObject({ entityType: 'model' });
+        expect(mock_DeleteModel).toHaveBeenCalledTimes(1);
+
+        expect(() => root.DeleteSceneObject({ entityType: 'pov' })).not.toThrow();
+    });
+
+    it('should place model on floor', () => {
+        const root = new DIVERoot();
+        root.PlaceOnFloor({ entityType: 'model' });
+        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(1);
+    });
+
+    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();
+    });
+});

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

@@ -0,0 +1,84 @@
+import { Color, Object3D } from "three";
+import { type COMLight } from "../../../com/types.ts";
+import DIVEAmbientLight from "../../../light/AmbientLight.ts";
+import DIVEPointLight from "../../../light/PointLight.ts";
+import type { DIVEMoveable } from "../../../interface/Moveable.ts";
+import DIVESceneLight from "../../../light/SceneLight.ts";
+
+/**
+ * A basic scene node to hold all lights.
+ *
+ * @module
+ */
+
+export default class DIVELightRoot extends Object3D {
+    constructor() {
+        super();
+        this.name = "LightRoot";
+    }
+
+    public GetLight(object: Partial<COMLight>): Object3D | undefined {
+        if (object.id === undefined) {
+            console.warn('LightRoot.GetLight: object.id is undefined')
+            return undefined;
+        }
+        return this.children.find(object3D => object3D.userData.id === object.id);
+    }
+
+    public UpdateLight(light: Partial<COMLight>): void {
+        // update scene here for light
+        if (light.id === undefined) {
+            console.warn(`LightRoot.UpdateLight: light.id is undefined`)
+            return;
+        }
+
+        let sceneObject = this.children.find(object3D => object3D.userData.id === light.id);
+        if (!sceneObject) {
+            switch (light.type) {
+                case 'scene': {
+                    sceneObject = new DIVESceneLight();
+                    break;
+                }
+                case 'ambient': {
+                    sceneObject = new DIVEAmbientLight();
+                    break;
+                }
+                case 'point': {
+                    sceneObject = new DIVEPointLight();
+                    break;
+                }
+                default: {
+                    console.warn(`LightRoot.UpdateLight: Unknown light type: ${light.type}`);
+                    return;
+                }
+            }
+            sceneObject.userData.id = light.id;
+            this.add(sceneObject);
+        }
+
+        if (light.name !== undefined && light.name !== null) sceneObject.name = light.name;
+        if (light.position !== undefined && light.position !== null) sceneObject.position.set(light.position.x, light.position.y, light.position.z);
+        if (light.intensity !== undefined && light.intensity !== null) (sceneObject as (DIVEAmbientLight | DIVEPointLight)).SetIntensity(light.intensity);
+        if (light.enabled !== undefined && light.enabled !== null) (sceneObject as (DIVEAmbientLight | DIVEPointLight)).SetEnabled(light.enabled);
+        if (light.color !== undefined && light.color !== null) (sceneObject as (DIVEAmbientLight | DIVEPointLight)).SetColor(new Color(light.color));
+    }
+
+    public DeleteLight(light: Partial<COMLight>): void {
+        if (light.id === undefined) {
+            console.warn('LightRoot.DeleteLight: light.id is undefined')
+            return;
+        }
+
+        const sceneObject = this.children.find(object3D => object3D.userData.id === light.id);
+        if (!sceneObject) {
+            console.warn(`LightRoot.DeleteLight: Light with id ${light.id} not found`);
+            return;
+        }
+
+        if ('isMoveable' in sceneObject) {
+            (sceneObject as unknown as DIVEMoveable).gizmo?.detach();
+        }
+
+        this.remove(sceneObject);
+    }
+}

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

@@ -0,0 +1,137 @@
+import { TransformControls } from 'three/examples/jsm/Addons';
+import { COMLight } from '../../../../com';
+import { DIVEMoveable } from '../../../../interface/Moveable';
+import DIVELightRoot from '../LightRoot';
+
+const mock_SetPosition = jest.fn();
+const mock_SetIntensity = jest.fn();
+const mock_SetEnabled = jest.fn();
+const mock_SetColor = jest.fn();
+
+jest.mock('../../../../light/AmbientLight.ts', () => {
+    return jest.fn(function () {
+        this.isObject3D = true;
+        this.parent = null;
+        this.dispatchEvent = jest.fn();
+        this.position = {
+            set: mock_SetPosition,
+        }
+        this.SetIntensity = mock_SetIntensity;
+        this.SetEnabled = mock_SetEnabled;
+        this.SetColor = mock_SetColor;
+        this.userData = {
+            id: undefined,
+        }
+        this.removeFromParent = jest.fn();
+        return this;
+    });
+});
+
+jest.mock('../../../../light/PointLight.ts', () => {
+    return jest.fn(function () {
+        this.isObject3D = true;
+        this.parent = null;
+        this.dispatchEvent = jest.fn();
+        this.position = {
+            set: mock_SetPosition,
+        }
+        this.SetIntensity = mock_SetIntensity;
+        this.SetEnabled = mock_SetEnabled;
+        this.SetColor = mock_SetColor;
+        this.userData = {
+            id: undefined,
+        }
+        this.removeFromParent = jest.fn();
+        return this;
+    });
+});
+
+const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+
+describe('dive/scene/root/lightroot/DIVELightRoot', () => {
+    beforeEach(() => {
+        consoleWarnSpy.mockClear();
+    });
+
+    it('should instantiate', () => {
+        const lightRoot = new DIVELightRoot();
+        expect(lightRoot).toBeDefined();
+    });
+
+    it('should not add incorrect light without id', () => {
+        const lightRoot = new DIVELightRoot();
+        expect(() => lightRoot.UpdateLight({ id: undefined })).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(lightRoot.children).toHaveLength(0);
+    });
+
+    it('should not add incorrect light', () => {
+        const lightRoot = new DIVELightRoot();
+        expect(() => lightRoot.UpdateLight(({ id: 'test_id', name: 'test', type: 'this not a real light type' }) as unknown as COMLight)).not.toThrow();
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(lightRoot.children).toHaveLength(0);
+    });
+
+    it('should update basic scene light', () => {
+        const lightRoot = new DIVELightRoot();
+        lightRoot.UpdateLight({ id: 'test_id', type: 'scene', name: 'test', position: undefined, enabled: true });
+        expect(lightRoot.children).toHaveLength(1);
+        expect(lightRoot.children[0].userData.id).toBe('test_id');
+    });
+
+    it('should update basic ambient light', () => {
+        const lightRoot = new DIVELightRoot();
+        lightRoot.UpdateLight({ id: 'test_id', type: 'ambient', position: undefined });
+        expect(lightRoot.children).toHaveLength(1);
+        expect(lightRoot.children[0].userData.id).toBe('test_id');
+    });
+
+    it('should update basic point light', () => {
+        const lightRoot = new DIVELightRoot();
+        lightRoot.UpdateLight({ id: 'test_id', type: 'point', position: undefined });
+        expect(lightRoot.children).toHaveLength(1);
+        expect(lightRoot.children[0].userData.id).toBe('test_id');
+    });
+
+    it('should update configured light', () => {
+        const lightRoot = new DIVELightRoot();
+        lightRoot.UpdateLight({ id: 'test_id', type: 'point', position: { x: 1, y: 2, z: 3 }, intensity: 0.5, color: 0x123456 });
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(lightRoot.children).toHaveLength(1);
+        expect(lightRoot.children[0].userData.id).toBe('test_id');
+        expect(mock_SetIntensity).toHaveBeenCalledTimes(1);
+        expect(mock_SetColor).toHaveBeenCalledTimes(1);
+        expect(mock_SetPosition).toHaveBeenCalledTimes(1);
+    });
+
+    it('should get light', () => {
+        const lightRoot = new DIVELightRoot();
+        expect(() => lightRoot.GetLight({ id: undefined })).not.toThrow();
+        expect(lightRoot.GetLight({ id: 'test_id' })).toBeUndefined();
+        lightRoot.UpdateLight({ id: 'test_id', type: 'point', position: { x: 1, y: 2, z: 3 }, intensity: 0.5, color: 0x123456 });
+        expect(consoleWarnSpy).toHaveBeenCalled();
+        expect(lightRoot.GetLight({ id: 'test_id' })).toBeDefined();
+    });
+
+    it('should delete light', () => {
+        const lightRoot = new DIVELightRoot();
+        expect(() => lightRoot.DeleteLight({ id: undefined })).not.toThrow();
+
+        expect(() => lightRoot.DeleteLight({ id: 'test_id' })).not.toThrow();
+
+        lightRoot.UpdateLight({ id: 'test_id', type: 'point', position: { x: 1, y: 2, z: 3 }, intensity: 0.5, color: 0x123456 });
+        expect(() => lightRoot.DeleteLight({ id: 'test_id' })).not.toThrow();
+
+        lightRoot.UpdateLight({ id: 'test_id', type: 'point', position: { x: 1, y: 2, z: 3 }, intensity: 0.5, color: 0x123456 });
+        (lightRoot.children[0] as unknown as DIVEMoveable).isMoveable = true;
+        expect(() => lightRoot.DeleteLight({ id: 'test_id' })).not.toThrow();
+
+        lightRoot.UpdateLight({ id: 'test_id', type: 'point', position: { x: 1, y: 2, z: 3 }, intensity: 0.5, color: 0x123456 });
+        (lightRoot.children[0] as unknown as DIVEMoveable).isMoveable = true;
+        (lightRoot.children[0] as unknown as DIVEMoveable).gizmo = {
+            detach: jest.fn(),
+        } as unknown as TransformControls;
+        expect(() => lightRoot.DeleteLight({ id: 'test_id' })).not.toThrow();
+        expect(lightRoot.children).toHaveLength(0);
+    });
+});

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

@@ -0,0 +1,82 @@
+import { Object3D } from "three";
+import { COMModel } from "../../../com/types.ts";
+import Model from "../../../model/Model.ts";
+import DIVELoadingManager from "../../../loadingmanager/LoadingManager.ts";
+import DIVECommunication from "../../../com/Communication.ts";
+import type { DIVEMoveable } from "../../../interface/Moveable.ts";
+
+/**
+ * A basic scene node to hold all models.
+ *
+ * @module
+ */
+export default class DIVEModelRoot extends Object3D {
+    private loadingManager: DIVELoadingManager;
+
+    constructor() {
+        super();
+        this.name = "ModelRoot";
+
+        this.loadingManager = new DIVELoadingManager();
+    }
+
+    public GetModel(object: Partial<COMModel>): Object3D | undefined {
+        if (object.id === undefined) {
+            console.warn('ModelRoot.GetModel: object.id is undefined')
+            return undefined;
+        }
+        return this.children.find(object3D => object3D.userData.id === object.id);
+    }
+
+    public UpdateModel(object: Partial<COMModel>): void {
+        if (object.id === undefined) {
+            console.warn('ModelRoot.UpdateModel: object.id is undefined')
+            return;
+        }
+
+        let sceneObject = this.children.find(object3D => object3D.userData.id === object.id);
+        if (!sceneObject && object.uri !== undefined) {
+            const model = new Model();
+            sceneObject = model;
+            sceneObject.userData.id = object.id;
+            this.add(sceneObject);
+
+            this.loadingManager.LoadGLTF(object.uri).then((gltf) => {
+                model.SetModel(gltf);
+                DIVECommunication.get(object.id!)?.PerformAction('MODEL_LOADED', { id: object.id! });
+            });
+        }
+
+        if (object.position !== undefined) (sceneObject as Model).SetPosition(object.position);
+        if (object.rotation !== undefined) (sceneObject as Model).SetRotation(object.rotation);
+        if (object.scale !== undefined) (sceneObject as Model).SetScale(object.scale);
+    }
+
+    public DeleteModel(object: Partial<COMModel>): void {
+        if (object.id === undefined) {
+            console.warn(`ModelRoot.DeleteModel: object.id is undefined`)
+            return;
+        }
+
+        const sceneObject = this.children.find(object3D => object3D.userData.id === object.id);
+        if (!sceneObject) {
+            console.warn(`ModelRoot.DeleteModel: Model with id ${object.id} not found`);
+            return;
+        }
+
+        if ('isMoveable' in sceneObject) {
+            (sceneObject as unknown as DIVEMoveable).gizmo?.detach();
+        }
+
+        this.remove(sceneObject);
+    }
+
+    public PlaceOnFloor(object: Partial<COMModel>): void {
+        if (object.id === undefined) console.warn('ModelRoot.PlaceOnFloor: object.id is undefined');
+
+        const sceneObject = this.children.find(object3D => object3D.userData.id === object.id);
+        if (!sceneObject) return;
+
+        (sceneObject as Model).PlaceOnFloor();
+    }
+}