@shopware-ag/dive 1.18.5-beta.0 → 1.18.5-beta.2

package/build/src/com/actions/media/generatemedia.d.ts

@@ -1,6 +1,6 @@
 import { Vector3Like } from 'three';
 export default interface GENERATE_MEDIA {
-    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and writes the URL into the payload.';
+    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and returns a Promise of a valid URI.';
     PAYLOAD: ({
         position: Vector3Like;
         target: Vector3Like;
@@ -9,7 +9,6 @@ export default interface GENERATE_MEDIA {
     }) & {
         width: number;
         height: number;
-        dataUri: string;
     };
-    RETURN: boolean;
+    RETURN: Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@shopware-ag/dive",
-    "version": "1.18.5-beta.0",
+    "version": "1.18.5-beta.2",
     "description": "Shopware Spatial Framework",
     "type": "module",
     "main": "build/dive.cjs",

package/src/ar/arquicklook/ARQuickLook.ts

@@ -14,7 +14,9 @@ export class DIVEARQuickLook {
         const quickLookScene = new Object3D();
 
         // extract models from scene
-        quickLookScene.add(...this.extractModels(scene));
+        const rootCopy = scene.Root.clone(true);
+
+        quickLookScene.add(...rootCopy.children);
 
         // launch ARQuickLook
         return this.launchARFromNode(quickLookScene, options);

package/src/ar/arquicklook/__test__/ARQuickLook.test.ts

@@ -1,4 +1,4 @@
-import { Box3, Color, Euler, Mesh, Object3D, Vector3 } from 'three';
+import { Object3D } from 'three';
 import { DIVEScene } from '../../../scene/Scene';
 import { DIVEAROptions } from '../../AR';
 import { DIVEARQuickLook } from '../ARQuickLook';

package/src/camera/PerspectiveCamera.ts

@@ -14,7 +14,7 @@ export type DIVEPerspectiveCameraSettings = {
 
 export const DIVEPerspectiveCameraDefaultSettings: DIVEPerspectiveCameraSettings =
     {
-        fov: 80,
+        fov: 70,
         near: 0.1,
         far: 1000,
     };

package/src/com/Communication.ts

@@ -75,37 +75,78 @@ export class DIVECommunication {
     private toolbox: DIVEToolbox;
 
     private _mediaGenerator: DIVEMediaCreator | null;
-    private get mediaGenerator(): DIVEMediaCreator {
+    private get mediaGenerator(): Promise<DIVEMediaCreator> {
         if (!this._mediaGenerator) {
-            const DIVEMediaCreator = require('../mediacreator/MediaCreator.ts')
-                .DIVEMediaCreator as typeof import('../mediacreator/MediaCreator.ts').DIVEMediaCreator;
-            this._mediaGenerator = new DIVEMediaCreator(
-                this.renderer,
-                this.scene,
-                this.controller,
-            );
+            return new Promise((resolve, reject) => {
+                import('../mediacreator/MediaCreator.ts')
+                    .then((module) => {
+                        const DIVEMediaCreator = module.DIVEMediaCreator;
+                        this._mediaGenerator = new DIVEMediaCreator(
+                            this.renderer,
+                            this.scene,
+                            this.controller,
+                        );
+                        resolve(this._mediaGenerator);
+                    })
+                    .catch((error) => {
+                        console.error(
+                            'DIVE: Error while lazy-loading IO module:',
+                            error,
+                        );
+                        reject(error);
+                    });
+            });
         }
-        return this._mediaGenerator;
+        return Promise.resolve(this._mediaGenerator);
     }
 
     private _io: DIVEIO | null;
-    private get io(): DIVEIO {
+    private get io(): Promise<DIVEIO> {
         if (!this._io) {
-            const DIVEIO = require('../io/IO.ts')
-                .DIVEIO as typeof import('../io/IO.ts').DIVEIO;
-            this._io = new DIVEIO(this.scene);
+            return new Promise((resolve, reject) => {
+                import('../io/IO.ts')
+                    .then((module) => {
+                        const DIVEIO = module.DIVEIO;
+                        this._io = new DIVEIO(this.scene);
+                        resolve(this._io);
+                    })
+                    .catch((error) => {
+                        console.error(
+                            'DIVE: Error while lazy-loading IO module:',
+                            error,
+                        );
+                        reject(error);
+                    });
+            });
         }
-        return this._io;
+        return Promise.resolve(this._io);
     }
 
     private _ar: DIVEAR | null;
-    private get ar(): DIVEAR {
+    private get ar(): Promise<DIVEAR> {
         if (!this._ar) {
-            const DIVEAR = require('../ar/AR.ts')
-                .DIVEAR as typeof import('../ar/AR.ts').DIVEAR;
-            this._ar = new DIVEAR(this.renderer, this.scene, this.controller);
+            return new Promise((resolve, reject) => {
+                import('../ar/AR.ts')
+                    .then((module) => {
+                        const DIVEAR = module.DIVEAR;
+                        this._ar = new DIVEAR(
+                            this.renderer,
+                            this.scene,
+                            this.controller,
+                        );
+                        resolve(this._ar);
+                    })
+                    .catch((error) => {
+                        console.error(
+                            'DIVE: Error while lazy-loading AR module:',
+                            error,
+                        );
+                        reject(error);
+                    });
+            });
         }
-        return this._ar;
+
+        return Promise.resolve(this._ar);
     }
 
     private registered: Map<string, COMEntity> = new Map();
@@ -311,9 +352,17 @@ export class DIVECommunication {
                 break;
             }
             case 'LAUNCH_AR': {
-                returnValue = this.ar.Launch(
-                    payload as Actions['LAUNCH_AR']['PAYLOAD'],
-                );
+                returnValue = new Promise<void>((resolve, reject) => {
+                    this.ar
+                        .then((arModule) => {
+                            resolve(
+                                arModule.Launch(
+                                    payload as Actions['LAUNCH_AR']['PAYLOAD'],
+                                ),
+                            );
+                        })
+                        .catch(reject);
+                });
                 break;
             }
             default: {
@@ -735,14 +784,14 @@ export class DIVECommunication {
             target = payload.target;
         }
 
-        payload.dataUri = this.mediaGenerator.GenerateMedia(
-            position,
-            target,
-            payload.width,
-            payload.height,
-        );
-
-        return true;
+        return this.mediaGenerator.then((module) => {
+            return module.GenerateMedia(
+                position,
+                target,
+                payload.width,
+                payload.height,
+            );
+        });
     }
 
     private setParent(
@@ -808,7 +857,13 @@ export class DIVECommunication {
     private exportScene(
         payload: Actions['EXPORT_SCENE']['PAYLOAD'],
     ): Actions['EXPORT_SCENE']['RETURN'] {
-        return this.io.Export(payload.type);
+        return new Promise<string | null>((resolve, reject) => {
+            this.io
+                .then((ioModule) => {
+                    resolve(ioModule.Export(payload.type));
+                })
+                .catch(reject);
+        });
     }
 }
 

package/src/com/__test__/Communication.test.ts

@@ -842,7 +842,14 @@ describe('dive/communication/DIVECommunication', () => {
         expect(success1).toBe(true);
     });
 
-    it('should perform action GENERATE_MEDIA', () => {
+    it('should perform action GENERATE_MEDIA', async () => {
+        const blobUri = 'blob:http://localhost:3000/1234';
+        const mediaGeneratorModule = await testCom['mediaGenerator'];
+
+        jest.spyOn(mediaGeneratorModule, 'GenerateMedia').mockReturnValue(
+            blobUri,
+        );
+
         const mock1 = {
             entityType: 'pov',
             id: 'test1',
@@ -851,22 +858,22 @@ describe('dive/communication/DIVECommunication', () => {
         } as COMPov;
         testCom.PerformAction('ADD_OBJECT', mock1);
 
-        const success0 = testCom.PerformAction('GENERATE_MEDIA', {
+        const success0 = await testCom.PerformAction('GENERATE_MEDIA', {
             id: 'test1',
             width: 800,
             height: 600,
-            dataUri: '',
         });
-        expect(success0).toBe(true);
+        expect(success0).toBe(blobUri);
 
-        const success1 = testCom.PerformAction('GENERATE_MEDIA', {
+        const success1 = await testCom.PerformAction('GENERATE_MEDIA', {
             position: { x: 0, y: 0, z: 0 },
             target: { x: 0, y: 0, z: 0 },
             width: 800,
             height: 600,
-            dataUri: '',
         });
-        expect(success1).toBe(true);
+        expect(success1).toBe(blobUri);
+
+        jest.restoreAllMocks();
     });
 
     it('should perform action SET_PARENT', () => {
@@ -955,8 +962,9 @@ describe('dive/communication/DIVECommunication', () => {
 
     it('should perform action EXPORT_SCENE', async () => {
         const url = 'https://example.com';
+        const ioModule = await testCom['io'];
 
-        jest.spyOn(testCom['io'], 'Export').mockResolvedValueOnce(url);
+        jest.spyOn(ioModule, 'Export').mockResolvedValueOnce(url);
 
         const result = await testCom.PerformAction('EXPORT_SCENE', {
             type: 'glb',
@@ -965,8 +973,9 @@ describe('dive/communication/DIVECommunication', () => {
     });
 
     it('should perform action LAUNCH_AR', async () => {
+        const arModule = await testCom['ar'];
         const arLaunchSpy = jest
-            .spyOn(testCom['ar'], 'Launch')
+            .spyOn(arModule, 'Launch')
             .mockResolvedValueOnce();
 
         const result = await testCom.PerformAction('LAUNCH_AR', undefined);

package/src/com/actions/media/generatemedia.ts

@@ -1,7 +1,7 @@
 import { Vector3Like } from 'three';
 
 export default interface GENERATE_MEDIA {
-    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and writes the URL into the payload.';
+    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and returns a Promise of a valid URI.';
     PAYLOAD: (
         | {
               position: Vector3Like;
@@ -13,7 +13,6 @@ export default interface GENERATE_MEDIA {
     ) & {
         width: number; // image width in pixels
         height: number; // image height in pixels
-        dataUri: string;
     };
-    RETURN: boolean;
+    RETURN: Promise<string>;
 }