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

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

@@ -1,281 +0,0 @@
-import { DIVEPrimitive } from '../Primitive';
-import { DIVECommunication } from '../../com/Communication';
-import {
-    Vector3,
-    Box3,
-    Mesh,
-    type Texture,
-    type MeshStandardMaterial,
-} from 'three';
-import type { DIVEScene } from '../../scene/Scene';
-import {
-    type COMMaterial,
-    type COMGeometry,
-    type COMGeometryType,
-} from '../../com/types';
-import { RaycasterIntersectObjectMock } from '../../../__mocks__/three';
-
-jest.mock('../../com/Communication.ts', () => {
-    return {
-        DIVECommunication: {
-            get: jest.fn(() => {
-                return {
-                    PerformAction: jest.fn(),
-                };
-            }),
-        },
-    };
-});
-
-jest.spyOn(DIVECommunication, 'get').mockReturnValue({
-    PerformAction: jest.fn(),
-} as unknown as DIVECommunication);
-
-let primitive: DIVEPrimitive;
-
-describe('dive/primitive/DIVEPrimitive', () => {
-    beforeEach(() => {
-        primitive = new DIVEPrimitive();
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should instantiate', () => {
-        expect(primitive).toBeDefined();
-    });
-
-    it('should set geometry', () => {
-        jest.spyOn(console, 'warn');
-        const geometry = {
-            name: 'cube' as COMGeometryType,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(geometry)).not.toThrow();
-        expect(console.warn).not.toHaveBeenCalled();
-    });
-
-    it('should warn when geometry is invalid', () => {
-        jest.spyOn(console, 'warn').mockImplementation(() => {});
-        const geometry = {
-            name: 'INVALID' as COMGeometryType,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(geometry)).not.toThrow();
-        expect(console.warn).toHaveBeenCalled();
-    });
-
-    it('should place on floor', () => {
-        const com = DIVECommunication.get('id')!;
-        const spyPerformAction = jest.spyOn(com, 'PerformAction');
-
-        jest.spyOn(primitive['_mesh']!, 'localToWorld').mockReturnValueOnce(
-            new Vector3(0, 2, 0),
-        );
-
-        primitive.userData.id = 'something';
-        primitive.position.set(0, 2, 0);
-        primitive['_boundingBox'] = {
-            min: new Vector3(0, -2, 0),
-            setFromObject: jest.fn(),
-        } as unknown as Box3;
-
-        const scene = {
-            parent: null,
-            Root: {
-                children: [
-                    primitive,
-                ],
-            },
-        } as unknown as DIVEScene;
-        scene.Root.parent = scene;
-
-        primitive.parent = scene.Root;
-
-        expect(() => primitive.PlaceOnFloor()).not.toThrow();
-        expect(spyPerformAction).toHaveBeenCalledWith(
-            'UPDATE_OBJECT',
-            expect.objectContaining({
-                position: expect.objectContaining({
-                    y: 0,
-                }),
-            }),
-        );
-    });
-
-    it('should drop it', () => {
-        const comMock = {
-            PerformAction: jest.fn(),
-        } as unknown as DIVECommunication;
-        jest.spyOn(DIVECommunication, 'get').mockReturnValue(comMock);
-
-        const spy = jest
-            .spyOn(primitive, 'onMove')
-            .mockImplementation(() => {});
-
-        const size = {
-            x: 1,
-            y: 1,
-            z: 1,
-        };
-
-        primitive.userData.id = 'something';
-        primitive.position.set(0, 4, 0);
-        primitive['_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: [
-                    primitive,
-                ],
-            },
-        } as unknown as DIVEScene;
-        scene.Root.parent = scene;
-
-        // test when parent is not set
-        console.warn = jest.fn();
-        expect(() => primitive.DropIt()).not.toThrow();
-        expect(console.warn).toHaveBeenCalledTimes(1);
-
-        primitive.parent = scene.Root;
-
-        expect(() => primitive.DropIt()).not.toThrow();
-        expect(primitive.position.y).toBe(2.5);
-        expect(spy).toHaveBeenCalledTimes(1);
-
-        expect(() => primitive.DropIt()).not.toThrow();
-        expect(spy).toHaveBeenCalledTimes(1);
-
-        // alter position so onMove will be called again
-        primitive.position.y = 2;
-        jest.spyOn(DIVECommunication, 'get').mockReturnValueOnce(undefined);
-        expect(() => primitive.DropIt()).not.toThrow();
-        expect(spy).toHaveBeenCalledTimes(2);
-    });
-
-    it('should set geometry', () => {
-        primitive.userData.id = 'something';
-
-        // cylinder
-        const cylinder = {
-            name: 'cylinder',
-            width: 1,
-            height: 1.5,
-            depth: 1,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(cylinder)).not.toThrow();
-
-        // sphere
-        const sphere = {
-            name: 'sphere',
-            width: 1,
-            height: 1,
-            depth: 1,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(sphere)).not.toThrow();
-
-        // pyramid
-        const pyramid = {
-            name: 'pyramid',
-            width: 1,
-            height: 1.5,
-            depth: 1,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(pyramid)).not.toThrow();
-
-        // box
-        const box = {
-            name: 'box',
-            width: 1,
-            height: 1,
-            depth: 1,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(box)).not.toThrow();
-
-        // cone
-        const cone = {
-            name: 'cone',
-            width: 1,
-            height: 1.5,
-            depth: 1,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(cone)).not.toThrow();
-
-        // wall
-        const wall = {
-            name: 'wall',
-            width: 1,
-            height: 1.5,
-            depth: 0.1,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(wall)).not.toThrow();
-
-        const wallWithoutDepth = {
-            name: 'wall',
-            width: 1,
-            height: 1.5,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(wallWithoutDepth)).not.toThrow();
-
-        // plane
-        const plane = {
-            name: 'plane',
-            width: 1,
-            height: 0.1,
-            depth: 1,
-        } as COMGeometry;
-        expect(() => primitive.SetGeometry(plane)).not.toThrow();
-    });
-
-    it('should set material', () => {
-        const material = primitive['_mesh'].material as MeshStandardMaterial;
-
-        // apply invalid material should not crash
-        expect(() => primitive.SetMaterial({} as COMMaterial)).not.toThrow();
-        expect(material).toBeDefined();
-
-        expect(() =>
-            primitive.SetMaterial({
-                color: 0xffffff,
-                roughness: 0,
-                metalness: 1,
-            } as COMMaterial),
-        ).not.toThrow();
-        expect((material as MeshStandardMaterial).roughness).toBe(0);
-        expect((material as MeshStandardMaterial).roughnessMap).toBeUndefined();
-        expect((material as MeshStandardMaterial).metalness).toBe(1);
-        expect((material as MeshStandardMaterial).metalnessMap).toBeUndefined();
-
-        expect(() =>
-            primitive.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((material as MeshStandardMaterial).roughness).toBe(1);
-        expect((material as MeshStandardMaterial).roughnessMap).toBeDefined();
-        expect((material as MeshStandardMaterial).metalness).toBe(0);
-        expect((material as MeshStandardMaterial).metalnessMap).toBeDefined();
-    });
-});

package/src/primitive/floor/Floor.ts

@@ -1,45 +0,0 @@
-import {
-    Color,
-    ColorRepresentation,
-    Mesh,
-    MeshStandardMaterial,
-    PlaneGeometry,
-} from 'three';
-import { PRODUCT_LAYER_MASK } from '../../constant/VisibilityLayerMask.ts';
-
-/**
- * A basic floor geometry.
- *
- * Can change the color and visibility of the floor.
- *
- * @module
- */
-
-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),
-            }),
-        );
-
-        this.name = 'Floor';
-
-        this.layers.mask = PRODUCT_LAYER_MASK;
-
-        this.receiveShadow = true;
-
-        this.rotateX(-Math.PI / 2);
-    }
-
-    public SetVisibility(visible: boolean): void {
-        this.visible = visible;
-    }
-
-    public SetColor(color: ColorRepresentation): void {
-        (this.material as MeshStandardMaterial).color = new Color(color);
-    }
-}

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

@@ -1,24 +0,0 @@
-import { MeshStandardMaterial } from 'three';
-import { DIVEFloor } from '../Floor';
-
-describe('dive/primitive/floor/DIVEFloor', () => {
-    it('should instantiate', () => {
-        const floor = new DIVEFloor();
-        expect(floor).toBeDefined();
-    });
-
-    it('should set visibility', () => {
-        const floor = new DIVEFloor();
-        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();
-    });
-});

package/src/renderer/Renderer.ts

@@ -1,215 +0,0 @@
-import {
-    Camera,
-    MathUtils,
-    NoToneMapping,
-    PCFSoftShadowMap,
-    Scene,
-    ShadowMapType,
-    ToneMapping,
-    WebGLRenderer,
-} from 'three';
-
-export type DIVERendererSettings = {
-    antialias: boolean;
-    alpha: boolean;
-    stencil: boolean;
-    shadowMapEnabled: boolean;
-    shadowMapType: ShadowMapType;
-    toneMapping: ToneMapping;
-    canvas?: HTMLCanvasElement;
-};
-
-export const DIVERendererDefaultSettings: DIVERendererSettings = {
-    antialias: true,
-    alpha: true,
-    stencil: false,
-    shadowMapEnabled: true,
-    shadowMapType: PCFSoftShadowMap,
-    toneMapping: NoToneMapping,
-    canvas: undefined,
-};
-
-export type DIVERenderCallback = (
-    time: DOMHighResTimeStamp,
-    frame: XRFrame,
-) => void;
-
-/**
- * A changed version of the WebGLRenderer.
- *
- * Has to be started manually by calling StartRenderer().
- *
- * @module
- */
-
-export class DIVERenderer extends WebGLRenderer {
-    // basic functionality members
-    private paused: boolean = false;
-    private running: boolean = false;
-    private force: boolean = false;
-
-    // pre- and post-render callbacks
-    private preRenderCallbacks: Map<string, DIVERenderCallback> = new Map<
-        string,
-        DIVERenderCallback
-    >();
-    private postRenderCallbacks: Map<string, DIVERenderCallback> = new Map<
-        string,
-        DIVERenderCallback
-    >();
-
-    constructor(
-        rendererSettings: Partial<DIVERendererSettings> = DIVERendererDefaultSettings,
-    ) {
-        super({
-            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.toneMapping =
-            rendererSettings.toneMapping ||
-            DIVERendererDefaultSettings.toneMapping;
-
-        this.debug.checkShaderErrors = false;
-    }
-
-    // Stops renderings and disposes the renderer.
-    public Dispose(): void {
-        this.StopRenderer();
-        this.dispose();
-    }
-
-    // Starts the renderer with the given scene and camera.
-    public StartRenderer(scene: Scene, cam: Camera): void {
-        this.setAnimationLoop((time: DOMHighResTimeStamp, frame: XRFrame) => {
-            this.internal_render(scene, cam, time, frame);
-        });
-        this.running = true;
-    }
-
-    // Pauses the renderer.
-    public PauseRenderer(): void {
-        this.paused = true;
-    }
-
-    // Resumes the renderer after pausing.
-    public ResumeRenderer(): void {
-        this.paused = false;
-    }
-
-    // Stops the renderer completely. Has to be started again with StartRenderer().
-    public StopRenderer(): void {
-        this.setAnimationLoop(null);
-        this.running = false;
-    }
-
-    // Resizes the renderer to the given width and height.
-    public OnResize(width: number, height: number): void {
-        this.setSize(width, height);
-    }
-
-    /**
-     * Adds a callback to the render loop before actual render call.
-     * @param callback Executed before rendering.
-     * @returns uuid to remove the callback.
-     */
-    public AddPreRenderCallback(callback: DIVERenderCallback): string {
-        // add callback to renderloop
-        const newUUID = MathUtils.generateUUID();
-        this.preRenderCallbacks.set(newUUID, callback);
-
-        return newUUID;
-    }
-
-    /**
-     * Removes a callback from the render loop before actual render call.
-     * @param uuid of callback to remove.
-     * @returns if removing was successful.
-     */
-    public RemovePreRenderCallback(uuid: string): boolean {
-        // check if callback exists
-        if (!this.preRenderCallbacks.has(uuid)) return false;
-
-        // remove callback from renderloop
-        this.preRenderCallbacks.delete(uuid);
-
-        return true;
-    }
-
-    /**
-     * Adds a callback to the render loop after actual render call.
-     * @param callback Executed after rendering.
-     * @returns uuid to remove the callback.
-     */
-    public AddPostRenderCallback(callback: DIVERenderCallback): string {
-        // add callback to renderloop
-        const newUUID = MathUtils.generateUUID();
-        this.postRenderCallbacks.set(newUUID, callback);
-
-        return newUUID;
-    }
-
-    /**
-     * Removes a callback from the render loop after actual render call.
-     * @param uuid of callback to remove.
-     * @returns if removing was successful.
-     */
-    public RemovePostRenderCallback(uuid: string): boolean {
-        // check if callback exists
-        if (!this.postRenderCallbacks.has(uuid)) return false;
-
-        // remove callback from renderloop
-        this.postRenderCallbacks.delete(uuid);
-
-        return true;
-    }
-
-    /**
-     * Forces the renderer to render the next frame.
-     */
-    public ForceRendering(): void {
-        this.force = true;
-    }
-
-    /**
-     * Internal render loop.
-     *
-     * To control renderloop you can add callbacks via AddPreRenderCallback() and AddPostRenderCallback().
-     * @param scene Scene to render.
-     * @param cam Camera to render with.
-     */
-    private internal_render(
-        scene: Scene,
-        cam: Camera,
-        time: DOMHighResTimeStamp,
-        frame: XRFrame,
-    ): void {
-        // execute background render loop callbacks
-        if ((this.paused || !this.running) && !this.force) return;
-
-        // execute render loop callbacks
-        this.preRenderCallbacks.forEach((callback) => {
-            callback(time, frame);
-        });
-
-        this.render(scene, cam);
-
-        this.postRenderCallbacks.forEach((callback) => {
-            callback(time, frame);
-        });
-
-        this.force = false;
-    }
-}