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

package/src/math/toFixed/__test__/toFixedExp.test.ts

@@ -1,14 +0,0 @@
-import toFixedExp from '../toFixedExp';
-
-describe('dive/math/toFixed/toFixedExp', () => {
-    it('should toFixedExp', () => {
-        expect(toFixedExp(-0.5)).toBe('0');
-        expect(toFixedExp(0.5)).toBe('1');
-        expect(toFixedExp(0.55)).toBe('1');
-        expect(toFixedExp(0.49)).toBe('0');
-        expect(toFixedExp(1.49)).toBe('1');
-        expect(toFixedExp(0.49, 2)).toBe('0.49');
-        expect(toFixedExp(1.49, 2)).toBe('1.49');
-        expect(toFixedExp(-1.49, 2)).toBe('-1.49');
-    });
-});

package/src/math/toFixed/toFixedExp.ts

@@ -1,9 +0,0 @@
-import shift from '../helper/shift.ts';
-
-export default function toFixedExp(
-    number: number,
-    decimals: number = 0,
-): string {
-    const n = shift(number, +decimals);
-    return shift(Math.round(n), -decimals).toFixed(decimals);
-}

package/src/math/truncate/__test__/truncateExp.test.ts

@@ -1,14 +0,0 @@
-import truncateExp from '../truncateExp';
-
-describe('dive/math/truncate/truncateExp', () => {
-    it('should truncateExp', () => {
-        expect(truncateExp(-0.5)).toBe(0);
-        expect(truncateExp(0.5)).toBe(0);
-        expect(truncateExp(0.55)).toBe(0);
-        expect(truncateExp(0.49)).toBe(0);
-        expect(truncateExp(1.49)).toBe(1);
-        expect(truncateExp(0.49, 2)).toBe(0.49);
-        expect(truncateExp(1.49, 2)).toBe(1.49);
-        expect(truncateExp(-1.49, 2)).toBe(-1.49);
-    });
-});

package/src/math/truncate/truncateExp.ts

@@ -1,9 +0,0 @@
-import shift from '../helper/shift.ts';
-
-export default function truncateExp(
-    number: number,
-    decimals: number = 0,
-): number {
-    const n = shift(number, +decimals);
-    return shift(Math.trunc(n), -decimals);
-}

package/src/mediacreator/MediaCreator.ts

@@ -1,75 +0,0 @@
-import DIVEPerspectiveCamera from '../camera/PerspectiveCamera.ts';
-import { type DIVEScene } from '../scene/Scene.ts';
-import { type DIVERenderer } from '../renderer/Renderer.ts';
-import type DIVEOrbitControls from '../controls/OrbitControls.ts';
-import { type Vector3Like } from 'three';
-
-/**
- * Creates renderings of the current scene
- *
- * @module
- */
-
-export class DIVEMediaCreator {
-    private renderer: DIVERenderer;
-    private scene: DIVEScene;
-    private controller: DIVEOrbitControls;
-
-    constructor(
-        renderer: DIVERenderer,
-        scene: DIVEScene,
-        controller: DIVEOrbitControls,
-    ) {
-        this.renderer = renderer;
-        this.scene = scene;
-        this.controller = controller;
-    }
-
-    public GenerateMedia(
-        position: Vector3Like,
-        target: Vector3Like,
-        width: number,
-        height: number,
-    ): string {
-        const resetPosition = this.controller.object.position.clone();
-        const resetRotation = this.controller.object.quaternion.clone();
-
-        this.renderer.OnResize(width, height);
-        this.controller.object.OnResize(width, height);
-
-        this.controller.object.position.copy(position);
-        this.controller.target.copy(target);
-        this.controller.update();
-
-        const dataUri = this.DrawCanvas().toDataURL();
-
-        this.controller.object.position.copy(resetPosition);
-        this.controller.object.quaternion.copy(resetRotation);
-
-        return dataUri;
-    }
-
-    public DrawCanvas(canvasElement?: HTMLCanvasElement): HTMLCanvasElement {
-        // save current canvas
-        const restore = this.renderer.domElement;
-        if (canvasElement) {
-            this.renderer.domElement = canvasElement;
-        }
-
-        // draw canvas
-        this.controller.object.layers.mask =
-            DIVEPerspectiveCamera.LIVE_VIEW_LAYER_MASK;
-        this.renderer.render(this.scene, this.controller.object);
-        this.controller.object.layers.mask =
-            DIVEPerspectiveCamera.EDITOR_VIEW_LAYER_MASK;
-
-        const returnCanvas = this.renderer.domElement;
-
-        // restore canvas
-        if (canvasElement) {
-            this.renderer.domElement = restore;
-        }
-
-        return returnCanvas;
-    }
-}

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,190 +0,0 @@
-import {
-    Mesh,
-    MeshStandardMaterial,
-    type Object3D,
-    Raycaster,
-    Vector3,
-} from 'three';
-import { PRODUCT_LAYER_MASK } from '../constant/VisibilityLayerMask';
-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: Object3D): void {
-        this.clear();
-        this._boundingBox.makeEmpty();
-
-        gltf.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);
-    }
-
-    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,215 +0,0 @@
-import { RaycasterIntersectObjectMock } from '../../../__mocks__/three';
-
-import { DIVEModel } from '../Model';
-import { DIVECommunication } from '../../com/Communication';
-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());
-
-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(object)).not.toThrow();
-    });
-
-    it('should place on floor', () => {
-        model.SetModel(object);
-
-        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(object)).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(object);
-        expect(() =>
-            model.SetMaterial({ roughness: 0.5 } as COMMaterial),
-        ).not.toThrow();
-        expect(
-            (model['_mesh']?.material as MeshStandardMaterial).roughness,
-        ).toBe(0.5);
-    });
-});