@shopware-ag/dive 1.16.0 → 1.16.2

package/src/primitive/floor/Floor.ts

@@ -1,5 +1,11 @@
-import { Color, ColorRepresentation, Mesh, MeshStandardMaterial, PlaneGeometry } from "three";
-import { PRODUCT_LAYER_MASK } from "../../constant/VisibilityLayerMask.ts";
+import {
+    Color,
+    ColorRepresentation,
+    Mesh,
+    MeshStandardMaterial,
+    PlaneGeometry,
+} from 'three';
+import { PRODUCT_LAYER_MASK } from '../../constant/VisibilityLayerMask.ts';
 
 /**
  * A basic floor geometry.
@@ -13,7 +19,12 @@ export class DIVEFloor extends Mesh {
     public isFloor: true = true;
 
     constructor() {
-        super(new PlaneGeometry(10000, 10000), new MeshStandardMaterial({ color: new Color(150 / 255, 150 / 255, 150 / 255) }));
+        super(
+            new PlaneGeometry(10000, 10000),
+            new MeshStandardMaterial({
+                color: new Color(150 / 255, 150 / 255, 150 / 255),
+            }),
+        );
 
         this.name = 'Floor';
 

package/src/primitive/floor/__test__/Floor.test.ts

@@ -9,13 +9,19 @@ describe('dive/primitive/floor/DIVEFloor', () => {
 
     it('should set visibility', () => {
         const floor = new DIVEFloor();
-        expect(() => { floor.SetVisibility(false) }).not.toThrow();
+        expect(() => {
+            floor.SetVisibility(false);
+        }).not.toThrow();
         expect(floor.visible).toBe(false);
     });
 
     it('should set color', () => {
         const floor = new DIVEFloor();
-        expect(() => { floor.SetColor('#ff00ff') }).not.toThrow();
-        expect('#' + (floor.material as MeshStandardMaterial).color.getHexString()).toBe('#ff00ff');
+        expect(() => {
+            floor.SetColor('#ff00ff');
+        }).not.toThrow();
+        expect(
+            '#' + (floor.material as MeshStandardMaterial).color.getHexString(),
+        ).toBe('#ff00ff');
     });
-});
+});

package/src/renderer/Renderer.ts

@@ -1,4 +1,13 @@
-import { Camera, MathUtils, NoToneMapping, PCFSoftShadowMap, Scene, ShadowMapType, ToneMapping, WebGLRenderer } from "three";
+import {
+    Camera,
+    MathUtils,
+    NoToneMapping,
+    PCFSoftShadowMap,
+    Scene,
+    ShadowMapType,
+    ToneMapping,
+    WebGLRenderer,
+} from 'three';
 
 export type DIVERendererSettings = {
     antialias: boolean;
@@ -8,7 +17,7 @@ export type DIVERendererSettings = {
     shadowMapType: ShadowMapType;
     toneMapping: ToneMapping;
     canvas?: HTMLCanvasElement;
-}
+};
 
 export const DIVERendererDefaultSettings: DIVERendererSettings = {
     antialias: true,
@@ -18,7 +27,7 @@ export const DIVERendererDefaultSettings: DIVERendererSettings = {
     shadowMapType: PCFSoftShadowMap,
     toneMapping: NoToneMapping,
     canvas: undefined,
-}
+};
 
 /**
  * A changed version of the WebGLRenderer.
@@ -35,22 +44,38 @@ export class DIVERenderer extends WebGLRenderer {
     private force: boolean = false;
 
     // pre- and post-render callbacks
-    private preRenderCallbacks: Map<string, () => void> = new Map<string, () => void>();
-    private postRenderCallbacks: Map<string, () => void> = new Map<string, () => void>();
-
-    constructor(rendererSettings: Partial<DIVERendererSettings> = DIVERendererDefaultSettings) {
+    private preRenderCallbacks: Map<string, () => void> = new Map<
+        string,
+        () => void
+    >();
+    private postRenderCallbacks: Map<string, () => void> = new Map<
+        string,
+        () => void
+    >();
+
+    constructor(
+        rendererSettings: Partial<DIVERendererSettings> = DIVERendererDefaultSettings,
+    ) {
         super({
-            antialias: rendererSettings.antialias || DIVERendererDefaultSettings.antialias,
+            antialias:
+                rendererSettings.antialias ||
+                DIVERendererDefaultSettings.antialias,
             alpha: rendererSettings.alpha || DIVERendererDefaultSettings.alpha,
             preserveDrawingBuffer: true,
             canvas: rendererSettings.canvas,
         });
         this.setPixelRatio(window.devicePixelRatio);
 
-        this.shadowMap.enabled = rendererSettings.shadowMapEnabled || DIVERendererDefaultSettings.shadowMapEnabled;
-        this.shadowMap.type = rendererSettings.shadowMapType || DIVERendererDefaultSettings.shadowMapType;
+        this.shadowMap.enabled =
+            rendererSettings.shadowMapEnabled ||
+            DIVERendererDefaultSettings.shadowMapEnabled;
+        this.shadowMap.type =
+            rendererSettings.shadowMapType ||
+            DIVERendererDefaultSettings.shadowMapType;
 
-        this.toneMapping = rendererSettings.toneMapping || DIVERendererDefaultSettings.toneMapping;
+        this.toneMapping =
+            rendererSettings.toneMapping ||
+            DIVERendererDefaultSettings.toneMapping;
 
         this.debug.checkShaderErrors = false;
     }
@@ -63,7 +88,9 @@ export class DIVERenderer extends WebGLRenderer {
 
     // Starts the renderer with the given scene and camera.
     public StartRenderer(scene: Scene, cam: Camera): void {
-        this.setAnimationLoop(() => { this.internal_render(scene, cam) });
+        this.setAnimationLoop(() => {
+            this.internal_render(scene, cam);
+        });
         this.running = true;
     }
 
@@ -163,12 +190,16 @@ export class DIVERenderer extends WebGLRenderer {
         if ((this.paused || !this.running) && !this.force) return;
 
         // execute render loop callbacks
-        this.preRenderCallbacks.forEach((callback) => { callback(); });
+        this.preRenderCallbacks.forEach((callback) => {
+            callback();
+        });
 
         this.render(scene, cam);
 
-        this.postRenderCallbacks.forEach((callback) => { callback(); });
+        this.postRenderCallbacks.forEach((callback) => {
+            callback();
+        });
 
         this.force = false;
     }
-}
+}

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

@@ -34,9 +34,11 @@ jest.mock('three', () => {
             return this;
         }),
         MathUtils: {
-            generateUUID: () => { return test_uuid; },
+            generateUUID: () => {
+                return test_uuid;
+            },
         },
-    }
+    };
 });
 
 let renderer: DIVERenderer;
@@ -72,30 +74,43 @@ describe('dive/renderer/DIVERenderer', () => {
     });
 
     it('should start render', () => {
-        expect(() => { renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera) }).not.toThrow();
+        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.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.ResumeRenderer();
+        }).not.toThrow();
         expect(renderer['paused']).toBe(false);
     });
 
     it('should stop render', () => {
-        expect(() => { renderer.StopRenderer() }).not.toThrow();
+        expect(() => {
+            renderer.StopRenderer();
+        }).not.toThrow();
         expect(renderer['running']).toBe(false);
     });
 
     it('should resize renderer', () => {
-        expect(() => { renderer.OnResize(500, 500) }).not.toThrow();
+        expect(() => {
+            renderer.OnResize(500, 500);
+        }).not.toThrow();
         expect(mock_setSize).toHaveBeenCalledTimes(1);
     });
 
@@ -103,77 +118,109 @@ describe('dive/renderer/DIVERenderer', () => {
         expect(mock_render).toHaveBeenCalledTimes(0);
 
         renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        expect(() => { renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera) }).not.toThrow();
+        expect(() => {
+            renderer['internal_render'](
+                {} as DIVEScene,
+                {} as DIVEPerspectiveCamera,
+            );
+        }).not.toThrow();
         expect(mock_render).toHaveBeenCalledTimes(1);
     });
 
     it('should force render', () => {
-        expect(() => { renderer.ForceRendering() }).not.toThrow();
+        expect(() => {
+            renderer.ForceRendering();
+        }).not.toThrow();
     });
 
     it('should not render when not started', () => {
         expect(mock_render).toHaveBeenCalledTimes(0);
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(mock_render).toHaveBeenCalledTimes(0);
     });
 
     it('should not render when stopped', () => {
         renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(mock_render).toHaveBeenCalledTimes(1);
 
         renderer.StopRenderer();
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(mock_render).toHaveBeenCalledTimes(1);
     });
 
     it('should not render when paused', () => {
         renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(mock_render).toHaveBeenCalledTimes(1);
 
         renderer.PauseRenderer();
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(mock_render).toHaveBeenCalledTimes(1);
     });
 
     it('should resume render when running', () => {
         renderer.StartRenderer({} as DIVEScene, {} as DIVEPerspectiveCamera);
         renderer.PauseRenderer();
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(mock_render).toHaveBeenCalledTimes(0);
 
         renderer.ResumeRenderer();
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(mock_render).toHaveBeenCalledTimes(1);
     });
 
     it('should add pre render callback', () => {
-        expect(renderer.AddPreRenderCallback(() => { })).toBe(test_uuid);
+        expect(renderer.AddPreRenderCallback(() => {})).toBe(test_uuid);
         expect(renderer['preRenderCallbacks'].size).toBe(1);
     });
 
     it('should remove pre render callback', () => {
-        const uuid = renderer.AddPreRenderCallback(() => { });
+        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();
+        expect(() => {
+            renderer.RemovePreRenderCallback(test_uuid);
+        }).not.toThrow();
     });
 
     it('should add post render callback', () => {
-        expect(renderer.AddPostRenderCallback(() => { })).toBe(test_uuid);
+        expect(renderer.AddPostRenderCallback(() => {})).toBe(test_uuid);
         expect(renderer['postRenderCallbacks'].size).toBe(1);
     });
 
     it('should remove post render callback', () => {
-        const uuid = renderer.AddPostRenderCallback(() => { });
+        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();
+        expect(() => {
+            renderer.RemovePostRenderCallback(test_uuid);
+        }).not.toThrow();
     });
 
     it('should execute pre and post render callbacks', () => {
@@ -182,8 +229,11 @@ describe('dive/renderer/DIVERenderer', () => {
         const postcallback = jest.fn();
         renderer.AddPreRenderCallback(precallback);
         renderer.AddPostRenderCallback(postcallback);
-        renderer['internal_render']({} as DIVEScene, {} as DIVEPerspectiveCamera);
+        renderer['internal_render'](
+            {} as DIVEScene,
+            {} as DIVEPerspectiveCamera,
+        );
         expect(precallback).toHaveBeenCalledTimes(1);
         expect(postcallback).toHaveBeenCalledTimes(1);
     });
-});
+});

package/src/scene/Scene.ts

@@ -53,7 +53,9 @@ export class DIVEScene extends Scene {
         return this.Root.ComputeSceneBB();
     }
 
-    public GetSceneObject<T extends DIVESceneObject>(object: Partial<COMEntity> & { id: string }): T | undefined {
+    public GetSceneObject<T extends DIVESceneObject>(
+        object: Partial<COMEntity> & { id: string },
+    ): T | undefined {
         return this.Root.GetSceneObject<T>(object);
     }
 
@@ -61,11 +63,15 @@ export class DIVEScene extends Scene {
         this.Root.AddSceneObject(object);
     }
 
-    public UpdateSceneObject(object: Partial<COMEntity> & { id: string }): void {
+    public UpdateSceneObject(
+        object: Partial<COMEntity> & { id: string },
+    ): void {
         this.Root.UpdateSceneObject(object);
     }
 
-    public DeleteSceneObject(object: Partial<COMEntity> & { id: string }): void {
+    public DeleteSceneObject(
+        object: Partial<COMEntity> & { id: string },
+    ): void {
         this.Root.DeleteSceneObject(object);
     }
 

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

@@ -22,7 +22,7 @@ jest.mock('../root/Root', () => {
             this.removeFromParent = jest.fn();
             this.ComputeSceneBB = jest.fn();
             return this;
-        })
+        }),
     };
 });
 
@@ -87,4 +87,4 @@ describe('dive/scene/DIVEScene', () => {
         scene.GetSceneObject({} as COMEntity);
         expect(mock_GetSceneObject).toHaveBeenCalledTimes(1);
     });
-});
+});