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

package/src/mediacreator/__test__/MediaCreator.test.ts

@@ -1,155 +0,0 @@
-import { DIVEMediaCreator } from '../MediaCreator';
-import { DIVERenderer } from '../../renderer/Renderer';
-import { DIVEScene } from '../../scene/Scene';
-import DIVEPerspectiveCamera, {
-    DIVEPerspectiveCameraDefaultSettings,
-} from '../../camera/PerspectiveCamera';
-import { type COMPov } from '../../com/types';
-import DIVEOrbitControls from '../../controls/OrbitControls';
-import { DIVEAnimationSystem } from '../../animation/AnimationSystem';
-
-/**
- * @jest-environment jsdom
- */
-
-const mock_render = jest.fn();
-const mock_toDataURL = jest.fn();
-
-jest.mock('../../scene/Scene', () => {
-    return {
-        DIVEScene: jest.fn(function () {
-            this.add = jest.fn();
-            this.children = [];
-            this.Root = {
-                children: [],
-            };
-            return this;
-        }),
-    };
-});
-
-jest.mock('../../camera/PerspectiveCamera', () => {
-    return jest.fn(function () {
-        this.position = {
-            clone: jest.fn(),
-            copy: jest.fn(),
-        };
-        this.quaternion = {
-            clone: jest.fn(),
-            copy: jest.fn(),
-        };
-        this.orbitControls = {
-            target: {
-                clone: jest.fn(),
-                copy: jest.fn(),
-            },
-            update: jest.fn(),
-        };
-        this.layers = {
-            mask: 0,
-        };
-        return this;
-    });
-});
-
-jest.mock('../../controls/OrbitControls', () => {
-    return jest.fn(function () {
-        this.object = {
-            position: {
-                clone: jest.fn(),
-                copy: jest.fn(),
-            },
-            quaternion: {
-                clone: jest.fn(),
-                copy: jest.fn(),
-            },
-            layers: {
-                mask: 0,
-            },
-            OnResize: jest.fn(),
-        };
-
-        this.target = {
-            clone: jest.fn(),
-            copy: jest.fn(),
-        };
-
-        this.update = jest.fn();
-
-        return this;
-    });
-});
-
-jest.mock('../../renderer/Renderer', () => {
-    return {
-        DIVERenderer: jest.fn(function () {
-            this.domElement = {
-                toDataURL: mock_toDataURL,
-            };
-            this.render = mock_render;
-            this.OnResize = jest.fn();
-            return this;
-        }),
-    };
-});
-
-jest.mock('../../animation/AnimationSystem', () => {
-    return {
-        DIVEAnimationSystem: jest.fn(function () {
-            this.domElement = {
-                toDataURL: mock_toDataURL,
-            };
-            this.render = mock_render;
-            this.OnResize = jest.fn();
-            this.AddPreRenderCallback = jest.fn((callback) => {
-                callback();
-                return 'id';
-            });
-            return this;
-        }),
-    };
-});
-
-let mediaCreator: DIVEMediaCreator;
-
-describe('dive/mediacreator/DIVEMediaCreator', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mediaCreator = new DIVEMediaCreator(
-            new DIVERenderer(),
-            new DIVEScene(),
-            new DIVEOrbitControls(
-                new DIVEPerspectiveCamera(DIVEPerspectiveCameraDefaultSettings),
-                new DIVERenderer(),
-                new DIVEAnimationSystem(new DIVERenderer()),
-            ),
-        );
-    });
-
-    it('should instantiate', () => {
-        expect(mediaCreator).toBeDefined();
-    });
-
-    it('should generate media', () => {
-        const mock_POV = {
-            position: { x: 0, y: 0, z: 0 },
-            target: { x: 0, y: 0, z: 0 },
-        } as COMPov;
-        expect(() => {
-            mediaCreator.GenerateMedia(
-                mock_POV.position,
-                mock_POV.target,
-                800,
-                600,
-            );
-        }).not.toThrow();
-        expect(mock_render).toHaveBeenCalledTimes(1);
-        expect(mock_toDataURL).toHaveBeenCalledTimes(1);
-    });
-
-    it('should draw canvas with custom canvas', () => {
-        const canvas = document.createElement('canvas');
-        mediaCreator.DrawCanvas(canvas);
-        expect(mock_render).toHaveBeenCalledTimes(1);
-    });
-});

package/src/model/Model.ts

@@ -1,185 +0,0 @@
-import { Mesh, MeshStandardMaterial, Raycaster, Vector3 } from 'three';
-import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask';
-import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-import { findSceneRecursive } from '../helper/findSceneRecursive/findSceneRecursive';
-import { type COMMaterial } from '../com/types';
-import { DIVENode } from '../node/Node';
-import { DIVECommunication } from '../com/Communication';
-
-/**
- * A basic model class.
- *
- * It does calculate it's own bounding box which is used for positioning on the floor.
- *
- * Can be moved and selected.
- *
- * @module
- */
-
-export class DIVEModel extends DIVENode {
-    readonly isDIVEModel: true = true;
-
-    private _mesh: Mesh | null = null;
-    private _material: MeshStandardMaterial | null = null;
-
-    public SetModel(gltf: GLTF): void {
-        this.clear();
-        this._boundingBox.makeEmpty();
-
-        gltf.scene.traverse((child) => {
-            child.castShadow = true;
-            child.receiveShadow = true;
-
-            child.layers.mask = this.layers.mask;
-            this._boundingBox.expandByObject(child);
-
-            // only search for first mesh for now
-            if (!this._mesh && 'isMesh' in child) {
-                this._mesh = child as Mesh;
-
-                // if the material is already set, use it, otherwise set it from the model's material
-                if (this._material) {
-                    this._mesh.material = this._material;
-                } else {
-                    this._material = (child as Mesh)
-                        .material as MeshStandardMaterial;
-                }
-            }
-        });
-
-        this.add(gltf.scene);
-    }
-
-    public SetMaterial(material: Partial<COMMaterial>): void {
-        // if there is no material, create a new one
-        if (!this._material) {
-            this._material = new MeshStandardMaterial();
-        }
-
-        if (material.vertexColors !== undefined) {
-            this._material.vertexColors = material.vertexColors;
-        }
-
-        // apply color if supplied
-        if (material.color !== undefined) {
-            this._material.color.set(material.color);
-        }
-
-        // apply albedo map if supplied
-        if (material.map !== undefined) {
-            this._material.map = material.map;
-        }
-
-        // apply normal map
-        if (material.normalMap !== undefined) {
-            this._material.normalMap = material.normalMap;
-        }
-
-        // set roughness value
-        // if supplied, apply roughness map
-        // if we applied a roughness map, set roughness to 1.0
-        if (material.roughness !== undefined) {
-            this._material.roughness = material.roughness;
-        }
-
-        if (material.roughnessMap !== undefined) {
-            this._material.roughnessMap = material.roughnessMap;
-
-            if (this._material.roughnessMap) {
-                this._material.roughness = 1.0;
-            }
-        }
-
-        // set metalness value
-        // if supplied, apply metalness map
-        // if we applied a metalness map, set metalness to 1.0
-        if (material.metalness !== undefined) {
-            this._material.metalness = material.metalness;
-        }
-
-        if (material.metalnessMap !== undefined) {
-            this._material.metalnessMap = material.metalnessMap;
-
-            if (this._material.metalnessMap) {
-                this._material.metalness = 1.0;
-            }
-        }
-
-        // if the mesh is already set, update the material
-        if (this._mesh) {
-            this._mesh.material = this._material;
-        }
-    }
-
-    public PlaceOnFloor(): void {
-        // calculate and temporary save world position
-        const worldPos = this.getWorldPosition(this._positionWorldBuffer);
-        const oldWorldPos = worldPos.clone();
-
-        // compute the bounding box
-        this._mesh?.geometry?.computeBoundingBox();
-        const meshBB = this._mesh?.geometry?.boundingBox;
-
-        // subtract the bounding box min y axis value from the world position y value
-        if (!meshBB || !this._mesh) return;
-        worldPos.y = worldPos.y - this._mesh.localToWorld(meshBB.min.clone()).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 {
-        if (!this.parent) {
-            console.warn(
-                'DIVEModel: DropIt() called on a model that is not in the scene.',
-                this,
-            );
-            return;
-        }
-
-        // calculate the bottom center of the bounding box
-        const bottomY = this._boundingBox.min.y * this.scale.y;
-        const bbBottomCenter = this.localToWorld(
-            this._boundingBox.getCenter(new Vector3()).multiply(this.scale),
-        );
-        bbBottomCenter.y = bottomY + this.position.y;
-
-        // set up raycaster and raycast all scene objects (product layer)
-        const raycaster = new Raycaster(bbBottomCenter, new Vector3(0, -1, 0));
-        raycaster.layers.mask = PRODUCT_LAYER_MASK;
-        const intersections = raycaster.intersectObjects(
-            findSceneRecursive(this).Root.children,
-            true,
-        );
-
-        // if we hit something, move the model to the top on the hit object's bounding box
-        if (intersections.length > 0) {
-            const mesh = intersections[0].object as Mesh;
-            mesh.geometry.computeBoundingBox();
-            const meshBB = mesh.geometry.boundingBox!;
-            const worldPos = mesh.localToWorld(meshBB.max.clone());
-
-            const oldPos = this.position.clone();
-            const newPos = this.position
-                .clone()
-                .setY(worldPos.y)
-                .sub(new Vector3(0, bottomY, 0));
-            this.position.copy(newPos);
-
-            // if the position changed, update the object in communication
-            if (this.position.y === oldPos.y) return;
-
-            this.onMove();
-        }
-    }
-}

package/src/model/__test__/Model.test.ts

@@ -1,222 +0,0 @@
-import { RaycasterIntersectObjectMock } from '../../../__mocks__/three';
-
-import { DIVEModel } from '../Model';
-import { DIVECommunication } from '../../com/Communication';
-import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-import { DIVEScene } from '../../scene/Scene';
-import {
-    Vector3,
-    Box3,
-    Mesh,
-    MeshStandardMaterial,
-    type Texture,
-    Object3D,
-} from 'three';
-import { type COMMaterial } from '../../com/types';
-
-jest.mock('../../com/Communication.ts', () => {
-    return {
-        DIVECommunication: {
-            get: jest.fn(() => {
-                return {
-                    PerformAction: jest.fn(),
-                };
-            }),
-        },
-    };
-});
-
-const object = new Object3D();
-object.children.push(new Mesh());
-
-const gltf = {
-    scene: {
-        ...object,
-    },
-} as unknown as GLTF;
-
-jest.spyOn(DIVECommunication, 'get').mockReturnValue({
-    PerformAction: jest.fn(),
-} as unknown as DIVECommunication);
-
-let model: DIVEModel;
-
-describe('dive/model/DIVEModel', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        RaycasterIntersectObjectMock.mockClear();
-        model = new DIVEModel();
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should instantiate', () => {
-        expect(model).toBeDefined();
-    });
-
-    it('should set model', () => {
-        expect(() => model.SetModel(gltf)).not.toThrow();
-    });
-
-    it('should place on floor', () => {
-        model.SetModel(gltf);
-
-        const com = DIVECommunication.get('id')!;
-        const spyPerformAction = jest.spyOn(com, 'PerformAction');
-
-        model.userData.id = 'something';
-        model.position.set(0, 4, 0);
-
-        jest.spyOn(model['_mesh']!, 'localToWorld').mockReturnValueOnce(
-            new Vector3(0, 2, 0),
-        );
-
-        const scene = {
-            parent: null,
-            Root: {
-                children: [
-                    model,
-                ],
-            },
-        } as unknown as DIVEScene;
-        scene.Root.parent = scene;
-        model.parent = scene.Root;
-
-        expect(() => model.PlaceOnFloor()).not.toThrow();
-        expect(spyPerformAction).toHaveBeenCalledWith(
-            'UPDATE_OBJECT',
-            expect.objectContaining({
-                position: expect.objectContaining({
-                    y: 2,
-                }),
-            }),
-        );
-    });
-
-    it('should drop it', () => {
-        const comMock = {
-            PerformAction: jest.fn(),
-        } as unknown as DIVECommunication;
-        jest.spyOn(DIVECommunication, 'get').mockReturnValue(comMock);
-
-        const spy = jest.spyOn(model, 'onMove').mockImplementation(() => {});
-
-        const size = {
-            x: 1,
-            y: 1,
-            z: 1,
-        };
-
-        model.userData.id = 'something';
-        model.position.set(0, 4, 0);
-        model['_boundingBox'] = {
-            min: new Vector3(-size.x / 2, -size.y / 2, -size.z / 2),
-            max: new Vector3(size.x / 2, size.y / 2, size.z / 2),
-            getCenter: jest.fn(() => {
-                return new Vector3(0, 0, 0);
-            }),
-        } as unknown as Box3;
-
-        const hitObject = new Mesh();
-        hitObject.geometry.boundingBox = new Box3();
-        hitObject.geometry.boundingBox.max = new Vector3(0, 2, 0);
-        RaycasterIntersectObjectMock.mockReturnValue([
-            {
-                object: hitObject,
-            },
-        ]);
-
-        const scene = {
-            parent: null,
-            Root: {
-                children: [
-                    model,
-                ],
-            },
-        } as unknown as DIVEScene;
-        scene.Root.parent = scene;
-
-        // test when parent is not set
-        console.warn = jest.fn();
-        expect(() => model.DropIt()).not.toThrow();
-        expect(console.warn).toHaveBeenCalledTimes(1);
-
-        model.parent = scene.Root;
-
-        expect(() => model.DropIt()).not.toThrow();
-        expect(model.position.y).toBe(2.5);
-        expect(spy).toHaveBeenCalledTimes(1);
-
-        expect(() => model.DropIt()).not.toThrow();
-        expect(spy).toHaveBeenCalledTimes(1);
-
-        // alter position so onMove will be called again
-        model.position.y = 2;
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => model.DropIt()).not.toThrow();
-        expect(spy).toHaveBeenCalledTimes(2);
-    });
-
-    it('should set material', () => {
-        // apply invalid material should not crash
-        expect(() => model.SetMaterial({} as COMMaterial)).not.toThrow();
-        expect(model['_material']).not.toBeNull();
-
-        expect(() =>
-            model.SetMaterial({
-                color: 0xffffff,
-                roughness: 0,
-                metalness: 1,
-            } as COMMaterial),
-        ).not.toThrow();
-        expect((model['_material'] as MeshStandardMaterial).roughness).toBe(0);
-        expect(
-            (model['_material'] as MeshStandardMaterial).roughnessMap,
-        ).toBeUndefined();
-        expect((model['_material'] as MeshStandardMaterial).metalness).toBe(1);
-        expect(
-            (model['_material'] as MeshStandardMaterial).metalnessMap,
-        ).toBeUndefined();
-
-        expect(() =>
-            model.SetMaterial({
-                color: 0xff00ff,
-                vertexColors: true,
-                map: 'This_Is_A_Texture' as unknown as Texture,
-                normalMap: 'This_Is_A_Texture' as unknown as Texture,
-                roughness: 0,
-                roughnessMap: 'This_Is_A_Texture' as unknown as Texture,
-                metalness: 1,
-                metalnessMap: 'This_Is_A_Texture' as unknown as Texture,
-            } as COMMaterial),
-        ).not.toThrow();
-        expect((model['_material'] as MeshStandardMaterial).roughness).toBe(1);
-        expect(
-            (model['_material'] as MeshStandardMaterial).roughnessMap,
-        ).toBeDefined();
-        expect((model['_material'] as MeshStandardMaterial).metalness).toBe(1);
-        expect(
-            (model['_material'] as MeshStandardMaterial).metalnessMap,
-        ).toBeDefined();
-    });
-
-    it('should set model material when material already set before', () => {
-        model.SetMaterial({ roughness: 0.5 } as COMMaterial);
-        expect(() => model.SetModel(gltf)).not.toThrow();
-        expect(
-            (model['_mesh']?.material as MeshStandardMaterial).roughness,
-        ).toBe(0.5);
-    });
-
-    it('should set material to model when model already set before', () => {
-        model.SetModel(gltf);
-        expect(() =>
-            model.SetMaterial({ roughness: 0.5 } as COMMaterial),
-        ).not.toThrow();
-        expect(
-            (model['_mesh']?.material as MeshStandardMaterial).roughness,
-        ).toBe(0.5);
-    });
-});

package/src/module/Module.ts

@@ -1,45 +0,0 @@
-export class DIVEModule<T> {
-    constructor(
-        private _path: string,
-        private _ctor: string,
-    ) {}
-
-    private _promise: Promise<T> | null = null;
-    private _instance: T | null = null;
-
-    public async get(): Promise<T> {
-        // if we already have an instance, return it
-        if (this._instance) {
-            return Promise.resolve(this._instance);
-        }
-
-        // if we already have a loading process ongoing, return the already created promise
-        if (this._promise) {
-            return this._promise;
-        }
-
-        // if we don't have a promise yet, it means that we are not already loading the module
-        this._promise = (async () => {
-            const module = await import(this._path);
-
-            const ModuleConstructor = module[this._ctor];
-
-            if (!ModuleConstructor) {
-                throw new Error(
-                    `DIVE: Module class ${this._ctor} not found in ${this._path}`,
-                );
-            }
-
-            if (typeof ModuleConstructor !== 'function') {
-                throw new Error(
-                    `DIVE: Module at ${this._path} does not export a valid constructor (${this._ctor} wanted)`,
-                );
-            }
-
-            this._instance = new ModuleConstructor() as T;
-            return this._instance;
-        })();
-
-        return this._promise;
-    }
-}

package/src/module/__test__/Module.test.ts

@@ -1,54 +0,0 @@
-import { DIVEModule } from '../Module';
-
-jest.mock('/mock/path', () => mockModule, { virtual: true });
-
-const mockModule: Record<string, any> = {};
-
-describe('dive/module/DIVEModule', () => {
-    beforeEach(() => {
-        // Reset the mock module before each test
-        Object.keys(mockModule).forEach((key) => delete mockModule[key]);
-    });
-
-    it('should return the same instance on multiple calls to get()', async () => {
-        mockModule.TestClass = class TestClass {};
-        const diveModule = new DIVEModule('/mock/path', 'TestClass');
-
-        const instance1 = await diveModule.get();
-        const instance2 = await diveModule.get();
-
-        expect(instance1).toBe(instance2);
-    });
-
-    it('should throw an error if the constructor is not found', async () => {
-        const diveModule = new DIVEModule('/mock/path', 'NonExistentClass');
-
-        await expect(diveModule.get()).rejects.toThrow(
-            'DIVE: Module class NonExistentClass not found in /mock/path',
-        );
-    });
-
-    it('should throw an error if the constructor is not a function', async () => {
-        mockModule.InvalidClass = {};
-        const diveModule = new DIVEModule('/mock/path', 'InvalidClass');
-
-        await expect(diveModule.get()).rejects.toThrow(
-            'DIVE: Module at /mock/path does not export a valid constructor (InvalidClass wanted)',
-        );
-    });
-
-    it('should only load the module once even with concurrent calls to get()', async () => {
-        mockModule.TestClass = class TestClass {};
-        const diveModule = new DIVEModule('/mock/path', 'TestClass');
-
-        const [
-            instance1,
-            instance2,
-        ] = await Promise.all([
-            diveModule.get(),
-            diveModule.get(),
-        ]);
-
-        expect(instance1).toBe(instance2);
-    });
-});