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

package/src/renderer/__test__/Renderer.test.ts

@@ -1,228 +0,0 @@
-import {
-    WebGLRendererRenderMock,
-    WebGLRendererSetSizeMock,
-} from '../../../__mocks__/three';
-import type DIVEPerspectiveCamera from '../../camera/PerspectiveCamera';
-import { type DIVEScene } from '../../scene/Scene';
-import { DIVERenderer, DIVERendererDefaultSettings } from '../Renderer';
-
-/**
- * @jest-environment jsdom
- */
-
-const test_uuid = 'test_uuid';
-
-let renderer: DIVERenderer;
-
-describe('dive/renderer/DIVERenderer', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        renderer = new DIVERenderer();
-    });
-
-    it('should instantiate', () => {
-        renderer = new DIVERenderer({});
-        expect(renderer).toBeDefined();
-    });
-
-    it('should instantiate', () => {
-        renderer = new DIVERenderer({
-            alpha: true,
-            shadowMapEnabled: true,
-            shadowMapType: 1,
-            toneMapping: 1,
-            antialias: true,
-        });
-    });
-
-    it('should instantiate with settings parameter', () => {
-        renderer = new DIVERenderer(DIVERendererDefaultSettings);
-        expect(renderer).toBeDefined();
-    });
-
-    it('should dispose', () => {
-        renderer.Dispose();
-    });
-
-    it('should start render', () => {
-        expect(() => {
-            renderer.StartRenderer(
-                {} as DIVEScene,
-                {} as DIVEPerspectiveCamera,
-            );
-        }).not.toThrow();
-        expect(renderer['running']).toBe(true);
-    });
-
-    it('should pause render', () => {
-        renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        expect(() => {
-            renderer.PauseRenderer();
-        }).not.toThrow();
-        expect(renderer['paused']).toBe(true);
-    });
-
-    it('should resume render', () => {
-        renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        renderer.PauseRenderer();
-        expect(() => {
-            renderer.ResumeRenderer();
-        }).not.toThrow();
-        expect(renderer['paused']).toBe(false);
-    });
-
-    it('should stop render', () => {
-        expect(() => {
-            renderer.StopRenderer();
-        }).not.toThrow();
-        expect(renderer['running']).toBe(false);
-    });
-
-    it('should resize renderer', () => {
-        expect(() => {
-            renderer.OnResize(500, 500);
-        }).not.toThrow();
-        expect(WebGLRendererSetSizeMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('should render', () => {
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(0);
-
-        renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        expect(() => {
-            renderer['internal_render'](
-                {} as DIVEScene,
-                {} as DIVEPerspectiveCamera,
-                0.016,
-                {} as XRFrame,
-            );
-        }).not.toThrow();
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('should force render', () => {
-        expect(() => {
-            renderer.ForceRendering();
-        }).not.toThrow();
-    });
-
-    it('should not render when not started', () => {
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(0);
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(0);
-    });
-
-    it('should not render when stopped', () => {
-        renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(1);
-
-        renderer.StopRenderer();
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not render when paused', () => {
-        renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(1);
-
-        renderer.PauseRenderer();
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('should resume render when running', () => {
-        renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        renderer.PauseRenderer();
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(0);
-
-        renderer.ResumeRenderer();
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(WebGLRendererRenderMock).toHaveBeenCalledTimes(1);
-    });
-
-    it('should add pre render callback', () => {
-        expect(renderer.AddPreRenderCallback(() => {})).toBe(test_uuid);
-        expect(renderer['preRenderCallbacks'].size).toBe(1);
-    });
-
-    it('should remove pre render callback', () => {
-        const uuid = renderer.AddPreRenderCallback(() => {});
-        expect(renderer.RemovePreRenderCallback(uuid)).toBe(true);
-    });
-
-    it('should not crash while removing non-existing pre render callback', () => {
-        expect(() => {
-            renderer.RemovePreRenderCallback(test_uuid);
-        }).not.toThrow();
-    });
-
-    it('should add post render callback', () => {
-        expect(renderer.AddPostRenderCallback(() => {})).toBe(test_uuid);
-        expect(renderer['postRenderCallbacks'].size).toBe(1);
-    });
-
-    it('should remove post render callback', () => {
-        const uuid = renderer.AddPostRenderCallback(() => {});
-        expect(renderer.RemovePostRenderCallback(uuid)).toBe(true);
-    });
-
-    it('should not crash while removing non-existing post render callback', () => {
-        expect(() => {
-            renderer.RemovePostRenderCallback(test_uuid);
-        }).not.toThrow();
-    });
-
-    it('should execute pre and post render callbacks', () => {
-        renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        const precallback = jest.fn();
-        const postcallback = jest.fn();
-        renderer.AddPreRenderCallback(precallback);
-        renderer.AddPostRenderCallback(postcallback);
-        renderer['internal_render'](
-            {} as DIVEScene,
-            {} as DIVEPerspectiveCamera,
-            0.016,
-            {} as XRFrame,
-        );
-        expect(precallback).toHaveBeenCalledTimes(1);
-        expect(postcallback).toHaveBeenCalledTimes(1);
-    });
-});

package/src/scene/Scene.ts

@@ -1,106 +0,0 @@
-import { Color, Scene, type Box3, type ColorRepresentation } from 'three';
-import { type COMModel, type COMEntity } from '../com/types';
-import { DIVERoot } from './root/Root';
-import { DIVEGrid } from '../grid/Grid';
-import { DIVEFloor } from '../primitive/floor/Floor';
-import { type DIVESceneObject } from '../types';
-import { DIVEXRRoot } from './xrroot/XRRoot';
-import { type DIVERenderer } from '../renderer/Renderer';
-
-/**
- * A basic scene class.
- *
- * Comes with a root object that contains all the scene objects.
- *
- * @module
- */
-
-export class DIVEScene extends Scene {
-    private _root: DIVERoot;
-    private _floor: DIVEFloor;
-    private _grid: DIVEGrid;
-
-    public get Root(): DIVERoot {
-        return this._root;
-    }
-
-    private _xrRoot: DIVEXRRoot;
-    public get XRRoot(): DIVEXRRoot {
-        return this._xrRoot;
-    }
-
-    public get Floor(): DIVEFloor {
-        return this._floor;
-    }
-
-    public get Grid(): DIVEGrid {
-        return this._grid;
-    }
-
-    constructor() {
-        super();
-
-        this.background = new Color(0xffffff);
-
-        this._root = new DIVERoot();
-        this.add(this._root);
-
-        this._floor = new DIVEFloor();
-        this.add(this._floor);
-
-        this._grid = new DIVEGrid();
-        this.add(this._grid);
-
-        this._xrRoot = new DIVEXRRoot(this);
-        this._xrRoot.visible = false;
-        this.add(this._xrRoot);
-    }
-
-    public InitXR(renderer: DIVERenderer): void {
-        this._root.visible = false;
-        this._xrRoot.visible = true;
-        this._xrRoot.InitLightEstimation(renderer);
-    }
-
-    public DisposeXR(): void {
-        this._root.visible = true;
-        this._xrRoot.visible = false;
-        this._xrRoot.DisposeLightEstimation();
-    }
-
-    public SetBackground(color: ColorRepresentation): void {
-        this.background = new Color(color);
-    }
-
-    public ComputeSceneBB(): Box3 {
-        return this.Root.ComputeSceneBB();
-    }
-
-    public GetSceneObject<T extends DIVESceneObject>(
-        object: Partial<COMEntity> & { id: string },
-    ): T | undefined {
-        return this.Root.GetSceneObject<T>(object);
-    }
-
-    public AddSceneObject(object: COMEntity): void {
-        this.Root.AddSceneObject(object);
-    }
-
-    public UpdateSceneObject(
-        object: Partial<COMEntity> & { id: string; entityType: string },
-    ): void {
-        this.Root.UpdateSceneObject(object);
-    }
-
-    public DeleteSceneObject(
-        object: Partial<COMEntity> & { id: string; entityType: string },
-    ): void {
-        this.Root.DeleteSceneObject(object);
-    }
-
-    public PlaceOnFloor(
-        object: Partial<COMModel> & { id: string; entityType: string },
-    ): void {
-        this.Root.PlaceOnFloor(object);
-    }
-}

package/src/scene/__test__/Scene.test.ts

@@ -1,124 +0,0 @@
-import { DIVEScene } from '../Scene';
-import { type Color } from 'three';
-import { type COMEntity } from '../../com/types';
-import { DIVERenderer } from '../../renderer/Renderer';
-
-const mock_AddSceneObject = jest.fn();
-const mock_UpdateSceneObject = jest.fn();
-const mock_DeleteSceneObject = jest.fn();
-const mock_PlaceOnFloor = jest.fn();
-const mock_GetSceneObject = jest.fn();
-
-jest.mock('../root/Root', () => {
-    return {
-        DIVERoot: jest.fn(function () {
-            this.isObject3D = true;
-            this.parent = null;
-            this.dispatchEvent = jest.fn();
-            this.AddSceneObject = mock_AddSceneObject;
-            this.UpdateSceneObject = mock_UpdateSceneObject;
-            this.DeleteSceneObject = mock_DeleteSceneObject;
-            this.PlaceOnFloor = mock_PlaceOnFloor;
-            this.GetSceneObject = mock_GetSceneObject;
-            this.removeFromParent = jest.fn();
-            this.ComputeSceneBB = jest.fn();
-            return this;
-        }),
-    };
-});
-
-jest.mock('../xrroot/XRRoot', () => {
-    return {
-        DIVEXRRoot: jest.fn(function (scene: DIVEScene) {
-            this.visible = true;
-            this.isObject3D = true;
-            this.parent = null;
-            this.dispatchEvent = jest.fn();
-            this.removeFromParent = jest.fn();
-            this.visible = true;
-            this.InitLightEstimation = jest.fn();
-            this.DisposeLightEstimation = jest.fn();
-            return this;
-        }),
-    };
-});
-
-jest.mock('../../renderer/Renderer.ts', () => {
-    return {
-        DIVERenderer: jest.fn(function () {}),
-    };
-});
-
-const mockRenderer = new DIVERenderer();
-let scene: DIVEScene;
-
-describe('dive/scene/DIVEScene', () => {
-    beforeEach(() => {
-        scene = new DIVEScene();
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should instantiate', () => {
-        expect(scene).toBeDefined();
-    });
-
-    it('should have Root', () => {
-        expect(scene.Root).toBeDefined();
-    });
-
-    it('should have XRRoot', () => {
-        expect(scene.XRRoot).toBeDefined();
-    });
-
-    it('should have Floor', () => {
-        expect(scene.Floor).toBeDefined();
-    });
-
-    it('should have Grid', () => {
-        expect(scene.Grid).toBeDefined();
-    });
-
-    it('should InitXR', () => {
-        expect(() => scene.InitXR(mockRenderer)).not.toThrow();
-    });
-
-    it('should DisposeXR', () => {
-        expect(() => scene.DisposeXR()).not.toThrow();
-    });
-
-    it('should set background color', () => {
-        expect(() => scene.SetBackground(0x123456)).not.toThrow();
-    });
-
-    it('should ComputeSceneBB', () => {
-        expect(() => scene.ComputeSceneBB()).not.toThrow();
-    });
-
-    it('should add object', () => {
-        scene.AddSceneObject({} as COMEntity);
-        expect(mock_AddSceneObject).toHaveBeenCalledTimes(1);
-    });
-
-    it('should update object', () => {
-        scene.UpdateSceneObject({} as COMEntity);
-        expect(mock_UpdateSceneObject).toHaveBeenCalledTimes(1);
-    });
-
-    it('should remove object', () => {
-        scene.DeleteSceneObject({} as COMEntity);
-        expect(mock_DeleteSceneObject).toHaveBeenCalledTimes(1);
-    });
-
-    it('should place object on floor', () => {
-        scene.PlaceOnFloor({} as COMEntity);
-        expect(mock_PlaceOnFloor).toHaveBeenCalledTimes(1);
-    });
-
-    it('should get scene object', () => {
-        scene.GetSceneObject({} as COMEntity);
-        expect(mock_GetSceneObject).toHaveBeenCalledTimes(1);
-    });
-});