@shopware-ag/dive 1.16.7 → 1.16.9

package/src/node/Node.ts

@@ -1,4 +1,4 @@
-import { Box3, Object3D, type Vector3Like } from 'three';
+import { Box3, Object3D, Vector3, type Vector3Like } from 'three';
 import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask';
 import { DIVECommunication } from '../com/Communication';
 
@@ -14,6 +14,7 @@ export class DIVENode extends Object3D implements DIVESelectable, DIVEMovable {
 
     public gizmo: TransformControls | null = null;
 
+    protected _positionWorldBuffer: Vector3;
     protected _boundingBox: Box3;
 
     constructor() {
@@ -21,11 +22,24 @@ export class DIVENode extends Object3D implements DIVESelectable, DIVEMovable {
 
         this.layers.mask = PRODUCT_LAYER_MASK;
 
+        this._positionWorldBuffer = new Vector3();
         this._boundingBox = new Box3();
     }
 
     public SetPosition(position: Vector3Like): void {
-        this.position.set(position.x, position.y, position.z);
+        // if there is no parent, the object will be attached later and keep it's world position
+        if (!this.parent) {
+            this.position.set(position.x, position.y, position.z);
+            return;
+        }
+
+        // if we have a parent, we have to calculate the position in the parent's coordinate system to keep the world position
+        const newPosition = new Vector3(position.x, position.y, position.z);
+        this.position.copy(this.parent.worldToLocal(newPosition));
+
+        if ('isDIVEGroup' in this.parent) {
+            (this.parent as unknown as DIVEGroup).UpdateLineTo(this);
+        }
     }
 
     public SetRotation(rotation: Vector3Like): void {
@@ -46,27 +60,26 @@ export class DIVENode extends Object3D implements DIVESelectable, DIVEMovable {
             'UPDATE_OBJECT',
             {
                 id: this.userData.id,
-                position: this.position,
+                position: this.getWorldPosition(this._positionWorldBuffer),
                 rotation: this.rotation,
                 scale: this.scale,
             },
         );
     }
 
+    /**
+     * Can be called when the object is moved from a foreign object (gizmo, parent, etc.) to update the object's position.
+     */
     public onMove(): void {
         DIVECommunication.get(this.userData.id)?.PerformAction(
             'UPDATE_OBJECT',
             {
                 id: this.userData.id,
-                position: this.position,
+                position: this.getWorldPosition(this._positionWorldBuffer),
                 rotation: this.rotation,
                 scale: this.scale,
             },
         );
-
-        if (this.parent && 'isDIVEGroup' in this.parent) {
-            (this.parent as unknown as DIVEGroup).UpdateLineTo(this);
-        }
     }
 
     public onSelect(): void {

package/src/node/__test__/Node.test.ts

@@ -1,13 +1,17 @@
 import { DIVENode } from '../Node';
 import { DIVECommunication } from '../../com/Communication';
-import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
 import { Vector3, Box3, Mesh, Color, Euler } from 'three';
+import { type DIVEGroup } from '../../group/Group';
 
 const intersectObjectsMock = jest.fn();
 
 jest.mock('three', () => {
     return {
-        Vector3: jest.fn(function (x: number, y: number, z: number) {
+        Vector3: jest.fn(function (
+            x: number = 0,
+            y: number = 0,
+            z: number = 0,
+        ) {
             this.x = x;
             this.y = y;
             this.z = z;
@@ -92,6 +96,9 @@ jest.mock('three', () => {
             this.traverse = jest.fn((callback) => {
                 callback(this.children[0]);
             });
+            this.getWorldPosition = jest.fn(() => {
+                return new Vector3();
+            });
             return this;
         }),
         Box3: jest.fn(function () {
@@ -177,7 +184,32 @@ describe('dive/node/DIVENode', () => {
     });
 
     it('should set position', () => {
-        expect(() => node.SetPosition({ x: 0, y: 0, z: 0 })).not.toThrow();
+        const spySet = jest.spyOn(node.position, 'set');
+        const spyCopy = jest.spyOn(node.position, 'copy');
+
+        // without a parent, the node should only set it's local position
+        node.parent = null;
+        expect(() => node.SetPosition({ x: 1, y: 2, z: 3 })).not.toThrow();
+        expect(spySet).toHaveBeenCalledWith(1, 2, 3);
+        expect(spyCopy).not.toHaveBeenCalled();
+
+        // with a parent, the node should set it's position relative to the parent
+        spySet.mockClear();
+        spyCopy.mockClear();
+        node.parent = {
+            worldToLocal: jest.fn(() => new Vector3(4, 5, 6)),
+            isDIVEGroup: true,
+            UpdateLineTo: jest.fn(),
+        } as unknown as DIVENode;
+        const spyUpdateLineTo = jest.spyOn(
+            node.parent as DIVEGroup,
+            'UpdateLineTo',
+        );
+        expect(() => node.SetPosition({ x: 4, y: 5, z: 6 })).not.toThrow();
+        expect(spySet).not.toHaveBeenCalled();
+        expect(spyCopy).toHaveBeenCalledWith(
+            expect.objectContaining({ x: 4, y: 5, z: 6 }),
+        );
     });
 
     it('should set rotation', () => {

package/src/primitive/Primitive.ts

@@ -1,5 +1,6 @@
 import {
     BoxGeometry,
+    BufferAttribute,
     BufferGeometry,
     Color,
     ConeGeometry,
@@ -14,6 +15,7 @@ import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask';
 import { findSceneRecursive } from '../helper/findSceneRecursive/findSceneRecursive';
 import { DIVENode } from '../node/Node';
 import { type COMGeometry, type COMMaterial } from '../com/types';
+import { DIVECommunication } from '../com/Communication';
 
 /**
  * A basic model class.
@@ -24,7 +26,6 @@ import { type COMGeometry, type COMMaterial } from '../com/types';
  *
  * @module
  */
-
 export class DIVEPrimitive extends DIVENode {
     readonly isDIVEPrimitive: true = true;
 
@@ -106,11 +107,25 @@ export class DIVEPrimitive extends DIVENode {
     }
 
     public PlaceOnFloor(): void {
-        const oldPos = this.position.clone();
-        this.position.y = -this._boundingBox.min.y * this.scale.y;
-        if (this.position.y === oldPos.y) return;
-
-        this.onMove();
+        // calculate and temporary save world position
+        const worldPos = this.getWorldPosition(this._positionWorldBuffer);
+        const oldWorldPos = worldPos.clone();
+
+        // calculate the bottom center of the bounding box and set it to world posion
+        worldPos.y = -this._boundingBox.min.y * this.scale.y;
+
+        // skip any action when the position did not change
+        if (worldPos.y === oldWorldPos.y) return;
+
+        DIVECommunication.get(this.userData.id)?.PerformAction(
+            'UPDATE_OBJECT',
+            {
+                id: this.userData.id,
+                position: worldPos,
+                rotation: this.rotation,
+                scale: this.scale,
+            },
+        );
     }
 
     public DropIt(): void {
@@ -159,12 +174,18 @@ export class DIVEPrimitive extends DIVENode {
     }
 
     private assembleGeometry(geometry: COMGeometry): BufferGeometry | null {
+        // reset material to smooth shading
+        (this._mesh.material as MeshStandardMaterial).flatShading = false;
+
         switch (geometry.name.toLowerCase()) {
             case 'cylinder':
                 return this.createCylinderGeometry(geometry);
             case 'sphere':
                 return this.createSphereGeometry(geometry);
             case 'pyramid':
+                // set material to flat shading for pyramid
+                (this._mesh.material as MeshStandardMaterial).flatShading =
+                    true;
                 return this.createPyramidGeometry(geometry);
             case 'cube':
             case 'box':
@@ -202,16 +223,36 @@ export class DIVEPrimitive extends DIVENode {
     }
 
     private createPyramidGeometry(geometry: COMGeometry): BufferGeometry {
-        const geo = new ConeGeometry(
-            geometry.width / 2,
-            geometry.height,
-            4,
-            1,
-            true,
+        // prettier-multiline-arrays-next-line-pattern: 3
+        const vertices = new Float32Array([
+            -geometry.width / 2, 0, -geometry.depth / 2, // 0
+            geometry.width / 2, 0, -geometry.depth / 2, // 1
+            geometry.width / 2, 0, geometry.depth / 2, // 2
+            -geometry.width / 2, 0, geometry.depth / 2, // 3
+            0, geometry.height, 0,
+        ]);
+
+        // prettier-multiline-arrays-next-line-pattern: 3
+        const indices = new Uint16Array([
+            0, 1, 2,
+            0, 2, 3,
+            0, 4, 1,
+            1, 4, 2,
+            2, 4, 3,
+            3, 4, 0,
+        ]);
+
+        const geometryBuffer = new BufferGeometry();
+        geometryBuffer.setAttribute(
+            'position',
+            new BufferAttribute(vertices, 3),
         );
-        geo.rotateY(Math.PI / 4);
-        geo.translate(0, geometry.height / 2, 0);
-        return geo;
+        geometryBuffer.setIndex(new BufferAttribute(indices, 1));
+        geometryBuffer.computeVertexNormals();
+
+        geometryBuffer.computeBoundingBox();
+        geometryBuffer.computeBoundingSphere();
+        return geometryBuffer;
     }
 
     private createBoxGeometry(geometry: COMGeometry): BufferGeometry {

package/src/primitive/__test__/Primitive.test.ts

@@ -18,7 +18,11 @@ const intersectObjectsMock = jest.fn();
 
 jest.mock('three', () => {
     return {
-        Vector3: jest.fn(function (x: number, y: number, z: number) {
+        Vector3: jest.fn(function (
+            x: number = 0,
+            y: number = 0,
+            z: number = 0,
+        ) {
             this.x = x;
             this.y = y;
             this.z = z;
@@ -109,6 +113,9 @@ jest.mock('three', () => {
             this.traverse = jest.fn((callback) => {
                 callback(this.children[0]);
             });
+            this.getWorldPosition = jest.fn(() => {
+                return this.position.clone();
+            });
             return this;
         }),
         Box3: jest.fn(function () {
@@ -152,6 +159,12 @@ jest.mock('three', () => {
             this.setAttribute = jest.fn();
             this.setIndex = jest.fn();
             this.translate = jest.fn();
+            this.computeVertexNormals = jest.fn();
+            this.computeBoundingBox = jest.fn();
+            this.computeBoundingSphere = jest.fn();
+            return this;
+        }),
+        BufferAttribute: jest.fn(function () {
             return this;
         }),
         CylinderGeometry: jest.fn(function () {
@@ -241,12 +254,37 @@ describe('dive/primitive/DIVEPrimitive', () => {
     });
 
     it('should place on floor', () => {
+        const com = DIVECommunication.get('id')!;
+        const spyPerformAction = jest.spyOn(com, 'PerformAction');
+
         primitive.userData.id = 'something';
 
+        primitive['_boundingBox'] = {
+            min: new Vector3(0, -1, 0),
+        } as unknown as Box3;
+
+        expect(() => primitive.PlaceOnFloor()).not.toThrow();
+        expect(spyPerformAction).toHaveBeenCalledWith(
+            'UPDATE_OBJECT',
+            expect.objectContaining({
+                position: expect.objectContaining({
+                    y: 1,
+                }),
+            }),
+        );
+
+        // skip any action when the position did not change
+        spyPerformAction.mockClear();
+        primitive.position.y = 1;
         expect(() => primitive.PlaceOnFloor()).not.toThrow();
+        expect(spyPerformAction).not.toHaveBeenCalled();
 
+        // mock that the communication is not available
+        spyPerformAction.mockClear();
         jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
+        primitive.position.y = 0;
         expect(() => primitive.PlaceOnFloor()).not.toThrow();
+        expect(spyPerformAction).not.toHaveBeenCalled();
     });
 
     it('should drop it', () => {

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

@@ -413,6 +413,8 @@ jest.mock('../../../group/Group.ts', () => {
 
 let root: DIVERoot;
 
+let spyConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
 describe('DIVE/scene/root/DIVERoot', () => {
     beforeEach(() => {
         root = new DIVERoot();
@@ -422,6 +424,10 @@ describe('DIVE/scene/root/DIVERoot', () => {
         jest.clearAllMocks();
     });
 
+    afterAll(() => {
+        spyConsoleWarn.mockRestore();
+    });
+
     it('should instantiate', () => {
         expect(root).toBeDefined();
     });
@@ -474,6 +480,7 @@ describe('DIVE/scene/root/DIVERoot', () => {
             } as COMPov),
         ).not.toThrow();
 
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.AddSceneObject({
                 id: 'id',
@@ -482,6 +489,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMLight),
         ).not.toThrow();
+        expect(spyConsoleWarn).toHaveBeenCalled();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.AddSceneObject({
                 id: 'id_scene',
@@ -491,6 +501,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 type: 'scene',
             } as COMLight),
         ).not.toThrow();
+        expect(spyConsoleWarn).not.toHaveBeenCalled();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.AddSceneObject({
                 id: 'id_ambient',
@@ -500,6 +513,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 type: 'ambient',
             } as COMLight),
         ).not.toThrow();
+        expect(spyConsoleWarn).not.toHaveBeenCalled();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.AddSceneObject({
                 id: 'id_point',
@@ -514,6 +530,7 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 parentId: 'id',
             } as COMLight),
         ).not.toThrow();
+        expect(spyConsoleWarn).not.toHaveBeenCalled();
 
         expect(() =>
             root.AddSceneObject({
@@ -754,6 +771,7 @@ describe('DIVE/scene/root/DIVERoot', () => {
             } as unknown as Object3D,
         ];
 
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'does_not_exist',
@@ -762,6 +780,8 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMPov),
         ).not.toThrow();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'id',
@@ -770,7 +790,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMPov),
         ).not.toThrow();
+        expect(spyConsoleWarn).not.toHaveBeenCalled();
 
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'does_not_exist',
@@ -780,6 +802,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 type: 'scene',
             } as COMLight),
         ).not.toThrow();
+        expect(spyConsoleWarn).toHaveBeenCalled();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'id',
@@ -789,7 +814,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 type: 'scene',
             } as COMLight),
         ).not.toThrow();
+        expect(spyConsoleWarn).not.toHaveBeenCalled();
 
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'does_not_exist',
@@ -798,6 +825,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMModel),
         ).not.toThrow();
+        expect(spyConsoleWarn).toHaveBeenCalled();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'id',
@@ -815,6 +845,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMPrimitive),
         ).not.toThrow();
+        expect(spyConsoleWarn).toHaveBeenCalled();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'id',
@@ -823,7 +856,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMPrimitive),
         ).not.toThrow();
+        expect(spyConsoleWarn).not.toHaveBeenCalled();
 
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'does_not_exist',
@@ -832,6 +867,9 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMGroup),
         ).not.toThrow();
+        expect(spyConsoleWarn).toHaveBeenCalled();
+
+        spyConsoleWarn.mockClear();
         expect(() =>
             root.DeleteSceneObject({
                 id: 'id',
@@ -840,6 +878,7 @@ describe('DIVE/scene/root/DIVERoot', () => {
                 visible: true,
             } as COMGroup),
         ).not.toThrow();
+        expect(spyConsoleWarn).not.toHaveBeenCalled();
 
         const firstFind = root.GetSceneObject({ id: 'id' });
         jest.spyOn(root, 'GetSceneObject').mockReturnValueOnce({

package/src/types/SceneData.ts

@@ -0,0 +1,26 @@
+import type { Vector3Like } from 'three';
+import type {
+    COMGroup,
+    COMLight,
+    COMModel,
+    COMPov,
+    COMPrimitive,
+} from '../dive';
+
+export type DIVESceneData = {
+    name: string;
+    mediaItem: null;
+    backgroundColor: string;
+    floorEnabled: boolean;
+    floorColor: string;
+    userCamera: {
+        position: Vector3Like;
+        target: Vector3Like;
+    };
+    spotmarks: object[];
+    lights: COMLight[];
+    objects: COMModel[];
+    cameras: COMPov[];
+    primitives: COMPrimitive[];
+    groups: COMGroup[];
+};

package/src/types/index.ts

@@ -1,4 +1,5 @@
 import { type DIVESceneObject } from './SceneObjects';
 import { type DIVESceneFileType } from './SceneType';
+import { type DIVESceneData } from './SceneData';
 
-export { type DIVESceneObject, type DIVESceneFileType };
+export { type DIVESceneObject, type DIVESceneFileType, type DIVESceneData };