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

package/src/controls/OrbitControls.ts

@@ -1,211 +0,0 @@
-import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
-import DIVEPerspectiveCamera from '../camera/PerspectiveCamera.ts';
-import { DIVERenderer } from '../renderer/Renderer.ts';
-import { type Box3, MathUtils, Vector3, Vector3Like } from 'three';
-import { Easing } from '@tweenjs/tween.js';
-import { type DIVEAnimationSystem } from '../animation/AnimationSystem.ts';
-
-export type DIVEOrbitControlsSettings = {
-    enableDamping: boolean;
-    dampingFactor: number;
-};
-
-export const DIVEOrbitControlsDefaultSettings: DIVEOrbitControlsSettings = {
-    enableDamping: true,
-    dampingFactor: 0.04,
-};
-
-/**
- * Orbit Controls. Basic functionality to orbit around a given target point in the scene.
- *
- * @module
- */
-
-export default class DIVEOrbitControls extends OrbitControls {
-    public static readonly DEFAULT_ZOOM_FACTOR = 1;
-
-    private _animationSystem: DIVEAnimationSystem;
-
-    private last: { pos: Vector3Like; target: Vector3Like } | null = null;
-
-    private animating: boolean = false;
-    private locked: boolean = false;
-
-    private stopMoveTo: () => void = () => {};
-    private stopRevertLast: () => void = () => {};
-
-    public object: DIVEPerspectiveCamera;
-    public domElement: HTMLCanvasElement;
-
-    private _removePreRenderCallback: () => void = () => {};
-
-    constructor(
-        camera: DIVEPerspectiveCamera,
-        renderer: DIVERenderer,
-        animationSystem: DIVEAnimationSystem,
-        settings: Partial<DIVEOrbitControlsSettings> = DIVEOrbitControlsDefaultSettings,
-    ) {
-        super(camera, renderer.domElement);
-
-        this._animationSystem = animationSystem;
-
-        this.domElement = renderer.domElement;
-
-        this.object = camera;
-
-        const id = renderer.AddPreRenderCallback(() => {
-            this.preRenderCallback();
-        });
-
-        this._removePreRenderCallback = () => {
-            renderer.RemovePreRenderCallback(id);
-        };
-
-        this.enableDamping =
-            settings.enableDamping ||
-            DIVEOrbitControlsDefaultSettings.enableDamping;
-        this.dampingFactor =
-            settings.dampingFactor ||
-            DIVEOrbitControlsDefaultSettings.dampingFactor;
-
-        // initialize camera transformation
-        this.object.position.set(0, 2, 2);
-        this.target.copy({ x: 0, y: 0.5, z: 0 });
-        this.update();
-    }
-
-    public Dispose(): void {
-        this._removePreRenderCallback();
-        this.dispose();
-    }
-
-    public ComputeEncompassingView(bb: Box3): {
-        position: Vector3Like;
-        target: Vector3Like;
-    } {
-        const center = bb.getCenter(new Vector3());
-        const size = bb.getSize(new Vector3());
-        const distance = Math.max(size.x, size.y, size.z) * 1.25;
-        const direction = this.object.position.clone().normalize();
-
-        return {
-            position: direction.multiplyScalar(distance),
-            target: center,
-        };
-    }
-
-    public ZoomIn(by?: number): void {
-        const zoomBy = by || DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
-        const { minDistance, maxDistance } = this;
-        this.minDistance = this.maxDistance = MathUtils.clamp(
-            this.getDistance() - zoomBy,
-            minDistance + zoomBy,
-            maxDistance - zoomBy,
-        );
-        this.update();
-        this.minDistance = minDistance;
-        this.maxDistance = maxDistance;
-    }
-
-    public ZoomOut(by?: number): void {
-        const zoomBy = by || DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
-        const { minDistance, maxDistance } = this;
-        this.minDistance = this.maxDistance = MathUtils.clamp(
-            this.getDistance() + zoomBy,
-            minDistance + zoomBy,
-            maxDistance - zoomBy,
-        );
-        this.update();
-        this.minDistance = minDistance;
-        this.maxDistance = maxDistance;
-    }
-
-    public MoveTo(
-        pos: Vector3Like | undefined,
-        target: Vector3Like | undefined,
-        duration: number,
-        lock: boolean,
-    ): void {
-        if (this.animating) return;
-
-        const toPosition = pos || this.object.position.clone();
-        const toTarget = target || this.target.clone();
-
-        this.stopRevertLast();
-
-        if (!this.locked)
-            this.last = {
-                pos: this.object.position.clone(),
-                target: this.target.clone(),
-            };
-
-        this.animating = duration > 0;
-        this.locked = lock;
-        this.enabled = false;
-
-        const tweenPos = this._animationSystem
-            .Animate(this.object.position)
-            .to(toPosition, duration)
-            .easing(Easing.Quadratic.Out)
-            .start();
-
-        const tweenQuat = this._animationSystem
-            .Animate(this.target)
-            .to(toTarget, duration)
-            .easing(Easing.Quadratic.Out)
-            .onUpdate(() => {
-                this.object.lookAt(this.target);
-            })
-            .onComplete(() => {
-                this.animating = false;
-                this.enabled = !lock;
-            })
-            .start();
-
-        this.stopMoveTo = () => {
-            tweenPos.stop();
-            tweenQuat.stop();
-        };
-    }
-
-    public RevertLast(duration: number): void {
-        if (this.animating || !this.locked) return;
-
-        this.stopMoveTo();
-
-        this.animating = duration > 0;
-        this.enabled = false;
-
-        const { pos, target } = this.last!;
-
-        const tweenPos = this._animationSystem
-            .Animate(this.object.position)
-            .to(pos, duration)
-            .easing(Easing.Quadratic.Out)
-            .start();
-
-        const tweenQuat = this._animationSystem
-            .Animate(this.target)
-            .to(target, duration)
-            .easing(Easing.Quadratic.Out)
-            .onUpdate(() => {
-                this.object.lookAt(this.target);
-            })
-            .onComplete(() => {
-                this.animating = false;
-                this.locked = false;
-                this.enabled = true;
-            })
-            .start();
-
-        this.stopRevertLast = () => {
-            tweenPos.stop();
-            tweenQuat.stop();
-        };
-    }
-
-    private preRenderCallback = (): void => {
-        if (this.locked) return;
-        this.update();
-    };
-}

package/src/controls/__test__/OrbitControls.test.ts

@@ -1,256 +0,0 @@
-import DIVEOrbitControls from '../OrbitControls';
-import type DIVEPerspectiveCamera from '../../camera/PerspectiveCamera';
-import { DIVERenderer } from '../../renderer/Renderer';
-import { Box3 } from 'three';
-import { DIVEAnimationSystem } from '../../animation/AnimationSystem';
-import { Tween } from '@tweenjs/tween.js';
-
-jest.mock('../../renderer/Renderer', () => {
-    return jest.fn(function () {
-        this.domElement = {
-            style: {},
-        };
-        this.AddPreRenderCallback = (callback: () => void) => {
-            callback();
-        };
-
-        return this;
-    });
-});
-
-jest.mock('../../animation/AnimationSystem', () => {
-    return {
-        DIVEAnimationSystem: jest.fn(function () {
-            this.domElement = {
-                style: {},
-            };
-            this.Animate = <T extends object>(obj: T) => {
-                return new Tween<T>(obj);
-            };
-
-            return this;
-        }),
-    };
-});
-
-const moveToPos = { x: 10, y: 0, z: 0 };
-const moveToQuat = { x: 0, y: 0, z: 0 };
-const moveToDuration = 1000;
-
-const mockCamera = {
-    position: {
-        clone: jest.fn(() => {
-            return mockCamera.position;
-        }),
-        normalize: jest.fn(() => {
-            return mockCamera.position;
-        }),
-        multiplyScalar: jest.fn(() => {
-            return mockCamera.position;
-        }),
-        set: jest.fn(() => {
-            return mockCamera.position;
-        }),
-    },
-    lookAt: jest.fn(),
-} as unknown as DIVEPerspectiveCamera;
-const mockRenderer = {
-    render: jest.fn(),
-    OnResize: jest.fn(),
-    getViewport: jest.fn(),
-    setViewport: jest.fn(),
-    AddPreRenderCallback: jest.fn((callback) => {
-        callback();
-    }),
-    AddPostRenderCallback: jest.fn((callback) => {
-        callback();
-    }),
-    RemovePreRenderCallback: jest.fn(),
-    RemovePostRenderCallback: jest.fn(),
-} as unknown as DIVERenderer;
-
-const mockAnimSystem = new DIVEAnimationSystem(mockRenderer);
-
-describe('dive/controls/DIVEOrbitControls', () => {
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should instantiate', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-            {},
-        );
-        expect(controller).toBeDefined();
-    });
-
-    it('should instantiate with settings', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-            {
-                enableDamping: false,
-                dampingFactor: 0.5,
-            },
-        );
-        expect(controller).toBeDefined();
-    });
-
-    it('should dispose', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() => controller.Dispose()).not.toThrow();
-    });
-
-    it('should compute encompassing view', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() =>
-            controller.ComputeEncompassingView(new Box3()),
-        ).not.toThrow();
-    });
-
-    it('should zoom in with default value', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() => controller.ZoomIn()).not.toThrow();
-    });
-
-    it('should zoom in with custom value', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() => controller.ZoomIn(10)).not.toThrow();
-    });
-
-    it('should zoom out with default value', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() => controller.ZoomOut()).not.toThrow();
-    });
-
-    it('should zoom out with custom value', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() => controller.ZoomOut(10)).not.toThrow();
-    });
-
-    it('should move to', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() =>
-            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, false),
-        ).not.toThrow();
-    });
-
-    it('should revert move to', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
-        expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
-    });
-
-    it('should revert move to without values', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        expect(() =>
-            controller.MoveTo(undefined, undefined, moveToDuration, true),
-        ).not.toThrow();
-    });
-
-    it('should revert move to with lock', async () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
-        expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
-    });
-
-    it('should move after revert with lock', async () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
-        controller.RevertLast(moveToDuration);
-        expect(() =>
-            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
-        ).not.toThrow();
-    });
-
-    it('should catch multiple move tos', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
-        controller.RevertLast(moveToDuration);
-        expect(() =>
-            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
-        ).not.toThrow();
-        controller['animating'] = true;
-        expect(() =>
-            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
-        ).not.toThrow();
-        expect(() =>
-            controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true),
-        ).not.toThrow();
-    });
-
-    it('should catch multiple reverts', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
-        expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
-        expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
-        expect(() => controller.RevertLast(moveToDuration)).not.toThrow();
-    });
-
-    it('should execute preRenderCallback', () => {
-        const controller = new DIVEOrbitControls(
-            mockCamera,
-            mockRenderer,
-            mockAnimSystem,
-        );
-        controller.MoveTo(moveToPos, moveToQuat, moveToDuration, true);
-        expect(() => controller['preRenderCallback']()).not.toThrow();
-        controller['locked'] = true;
-        expect(() => controller['preRenderCallback']()).not.toThrow();
-    });
-});

package/src/converter/Converter.ts

@@ -1,117 +0,0 @@
-import { Loader } from '../loader/Loader';
-import { Exporter } from '../exporter/Exporter';
-import {
-    type FileType,
-    SUPPORTED_FILE_TYPES,
-    type ExportOptions,
-} from '../types';
-
-export class ConversionError extends Error {
-    constructor(
-        message: string,
-        public readonly cause?: unknown,
-    ) {
-        super(message);
-        this.name = 'ConversionError';
-    }
-}
-
-export class FileTypeError extends ConversionError {
-    constructor(extension: string) {
-        super(
-            `Unsupported file type: ${extension}. Supported types are: ${SUPPORTED_FILE_TYPES.join(', ')}`,
-        );
-        this.name = 'FileTypeError';
-    }
-}
-
-export class NetworkError extends ConversionError {
-    constructor(uri: string, cause?: unknown) {
-        super(`Failed to fetch file from ${uri}`, cause);
-        this.name = 'NetworkError';
-    }
-}
-
-export class Converter {
-    private _loader: Loader;
-    private _exporter: Exporter;
-
-    constructor(private readonly _uri: string) {
-        this._loader = new Loader();
-        this._exporter = new Exporter();
-    }
-
-    public static convert(uri: string): Converter {
-        return new Converter(uri);
-    }
-
-    public async to<T extends FileType>(
-        type: T,
-        options?: ExportOptions<T>,
-    ): Promise<ArrayBuffer> {
-        try {
-            const sourceType = this._getFileTypeFromUri();
-
-            // If source and target types match, just return the file content
-            if (sourceType === type) {
-                return await this._loadFile();
-            }
-
-            // Otherwise, convert through Object3D
-            const object3D = await this._loader.load(this._uri);
-            return await this._exporter.export(object3D, type, options);
-        } catch (error) {
-            if (error instanceof ConversionError) {
-                throw error;
-            }
-            throw new ConversionError('Failed to convert file', error);
-        }
-    }
-
-    private _getFileTypeFromUri(): FileType {
-        const extension = this._uri.split('.').pop()?.toLowerCase();
-        if (!extension) {
-            throw new FileTypeError('no extension');
-        }
-        if (!SUPPORTED_FILE_TYPES.includes(extension as FileType)) {
-            throw new FileTypeError(extension);
-        }
-        return extension as FileType;
-    }
-
-    private async _loadFile(): Promise<ArrayBuffer> {
-        try {
-            const response = await fetch(this._uri);
-            if (!response.ok) {
-                throw new NetworkError(
-                    this._uri,
-                    `HTTP error! status: ${response.status}`,
-                );
-            }
-            return response.arrayBuffer();
-        } catch (error) {
-            if (error instanceof NetworkError) {
-                throw error;
-            }
-            throw new NetworkError(this._uri, error);
-        }
-    }
-}
-
-// Example usage:
-// Converter.convert('https://example.com/model.glb').to('usdz', {
-//     usdz: {
-//         ar: {
-//             anchoring: { type: 'plane' },
-//             planeAnchoring: { alignment: 'horizontal' }
-//         }
-//     }
-// });
-//
-// Converter.convert('https://example.com/model.usdz').to('gltf', {
-//     gltf: {
-//         onlyVisible: true,
-//         maxTextureSize: 2048,
-//         includeCustomExtensions: true
-//     }
-// });