@roomle/web-sdk 2.91.0-alpha.1 → 2.91.0-alpha.2

package/lib/definitions/packages/common-core/src/webgl/roomle-webgl-renderer.d.ts

@@ -0,0 +1,67 @@
+import type { BakedGroundContactShadowParameters, GroundReflectionParameters, OutlineParameters, QualityMap, ShadowAndAoPassParameters, QualityLevel } from './renderer/scene-renderer';
+import { SceneRenderer } from './renderer/scene-renderer';
+import type { Camera, Object3D, Scene, WebGLRenderer } from 'three';
+import { Box3 } from 'three';
+import { type ScreenSpaceShadowMapParameters } from './renderer/pass/screen-space-shadow-map-pass';
+import type { CustomShadingParameters, SceneShadingType } from './renderer/shading-settings';
+import { CAMERA_TYPE } from '../cameracontrol/camera-type';
+import type { Enumify } from '../types';
+export declare enum RenderMode {
+    Mode3D = 0,
+    Mode2D = 1
+}
+export declare class RoomleWebGLRenderer {
+    static enableRectAreaLightShadow: boolean;
+    private static rectAreaLightsNeedsUpdate;
+    private static updateNearAndFarPlaneOfPerspectiveCamera;
+    private _renderer;
+    private _sceneRenderer;
+    private SceneRendererGUI;
+    private configuratorMode;
+    private uiInteractionMode;
+    private _movingCamera;
+    private _cameraType;
+    private _boundingBox;
+    private _boundingBoxNeedsUpdate;
+    private _cacheNeedsUpdate;
+    private _shadowNeedsUpdate;
+    private _bakedGroundShadowNeedsUpdate;
+    private _customShadingParameters;
+    private _customShadingParametersMoc;
+    private _fpsCounter;
+    get renderer(): WebGLRenderer;
+    get sceneRenderer(): SceneRenderer;
+    get isConfiguring(): boolean;
+    get screenSpaceShadowParameters(): ScreenSpaceShadowMapParameters;
+    get shadowAndAoPassParameters(): ShadowAndAoPassParameters;
+    get bakedGroundContactShadowParameters(): BakedGroundContactShadowParameters;
+    get groundReflectionParameters(): GroundReflectionParameters;
+    get outlineParameters(): OutlineParameters;
+    constructor(renderer: WebGLRenderer, width: number, height: number);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    setCameraType(cameraType: Enumify<typeof CAMERA_TYPE>): void;
+    setShadingType(shadingType: SceneShadingType): void;
+    setAutoQuality(autoQuality: boolean): void;
+    setQualityLevel(qualityLevel: QualityLevel): void;
+    setQualityMap(qualityMap: QualityMap): void;
+    setCustomShadingParameters(customShadingParameters?: CustomShadingParameters, customShadingParametersMoc?: CustomShadingParameters): void;
+    enableUiInteractionMode(): void;
+    disableUiInteractionMode(): void;
+    private loadRectAreLight;
+    private updateRectAreaLight;
+    clearCache(): void;
+    forceShadowUpdates(updateBakedGroundShadow: boolean): void;
+    setGroundShadow(enabled: boolean): void;
+    switchToConfigurator(): void;
+    switchToPlanner(renderMode: RenderMode): void;
+    updateBounds(geometryBounds?: Box3): void;
+    movingCameraStarts(): void;
+    movingCameraStops(): void;
+    highlightObjects(selectedMeshes: Object3D[]): void;
+    render(scene: Scene, camera: Camera): void;
+    private _doUpdatesBeforeRender;
+    private createRenderCamera;
+    showGUI(updateCallback: () => void): void;
+    clear(): void;
+}

package/lib/definitions/packages/common-core/src/webgl/scene-event-handler.d.ts

@@ -0,0 +1,16 @@
+import EventDispatcher from '../../../configurator-core/src/utils/event-dispatcher';
+import RaycastHelper from '../../../configurator-core/src/utils/raycast-helper';
+import type { Context } from '../di/context';
+import type InputManager from '../input/input-manager';
+import type { Camera, Scene } from 'three';
+export default abstract class SceneEventHandler<EventType> extends EventDispatcher<EventType> implements Context {
+    _creator_: string;
+    protected _inputManager: InputManager;
+    protected _raycastHelper: RaycastHelper;
+    protected _debug: boolean;
+    protected _dragIn: boolean;
+    constructor(creator: string, scene: Scene, camera: Camera, inputManager: InputManager);
+    protected abstract _interaction(): void;
+    isDragIn(): boolean;
+    setDragIn(dragIn: boolean, dragEvent?: DragEvent): void;
+}

package/lib/definitions/packages/common-core/src/webgl/scene-manager.d.ts

@@ -0,0 +1,140 @@
+import type { CanvasOffset } from '../common-interfaces';
+import type DomHelper from '../utils/dom-helper';
+import type InputManager from '../input/input-manager';
+import type { GUI } from 'dat.gui';
+import type ScriptLoader from '../script-loader';
+import type LightSetting from '../lightsetting/light-setting';
+import { type CAMERA_TYPE } from '../cameracontrol/camera-type';
+import type { Context } from '../di/context';
+import type { SceneSettings } from '../scene-settings-loader';
+import type Environment from '../environment/environment';
+import type { DynamicLightSettingSource } from '../lightsetting/dynamic-light-setting-loader';
+import type InitData from '../utils/init-data';
+import type { OrthographicOffsetCamera, PerspectiveOffsetCamera } from './roomle-component-factory';
+import type PluginSystem from '../../../configurator-core/src/webgl/plugin-system';
+import type { Enumify } from '../types';
+import type { Object3D } from 'three';
+import { type Box3, Scene, Vector3, WebGLRenderer } from 'three';
+import { RoomleWebGLRenderer } from './roomle-webgl-renderer';
+import type ImageRenderer from './image-renderer';
+import { type LifeCycleCallbacks } from '../life-cycle-manager';
+import type HdrEnvironmentLoader from '../services/hdr-environment-loader';
+import type IdbManager from '../services/idb-manager';
+import type CameraBehaviourState from '../cameracontrol/camera-behaviour-state';
+import type CameraBehaviour from '../cameracontrol/camera-behaviour';
+import type { Nullable } from '../../../typings/helper';
+import type GlobalInitData from '../utils/global-init-data';
+import type { GlobalCallback } from '../services/global-callback';
+export default abstract class SceneManager implements Context, LifeCycleCallbacks, EventListenerObject {
+    _creator_: string;
+    protected _domHelper: DomHelper;
+    protected _scriptLoader: ScriptLoader;
+    private _lifeCycleManager;
+    private _staticItemLoader;
+    protected _hdrEnvironmentLoader: HdrEnvironmentLoader;
+    protected _initData: InitData;
+    protected _globalInitData: GlobalInitData;
+    protected _globalCallback: GlobalCallback;
+    protected _idbManager: IdbManager;
+    protected _pluginSystem: PluginSystem;
+    protected _imageRenderer: ImageRenderer;
+    protected _cameraBehaviourState: CameraBehaviourState;
+    protected _scene: Scene;
+    protected _uiScene: Scene;
+    private _depthWriteMaterial;
+    private _cameraBehaviour;
+    protected _lightSetting: LightSetting;
+    protected _environment: Environment;
+    protected _maxAnisotropy: number;
+    protected _renderer: WebGLRenderer;
+    private _clock;
+    private _delta;
+    protected _renderLoopFunction: () => void;
+    protected _renderListener: () => void;
+    protected _stopRendering: boolean;
+    protected _roomleRenderer: Nullable<RoomleWebGLRenderer>;
+    private _forceRender;
+    private _lastChange;
+    private _running;
+    private _statsHelper;
+    private _canvasID;
+    protected _perspectiveOffsetCamera: PerspectiveOffsetCamera;
+    protected _orthographicOffsetCamera: OrthographicOffsetCamera;
+    protected abstract createCameraControl(mode: Enumify<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
+    protected abstract _getInputManager(): InputManager;
+    protected get cameraBehaviour(): CameraBehaviour;
+    abstract sceneChanged(): void;
+    abstract getBounds(): Box3;
+    abstract getGeometryBounds(): Box3;
+    protected onBeforeRender(): void;
+    protected _onAfterRender: () => void;
+    protected constructor(creator: string, offset: CanvasOffset, canvasID: string, mode: Enumify<typeof CAMERA_TYPE>);
+    addEventListener(_listener: LifeCycleCallbacks): void;
+    removeEventListener(_listener: LifeCycleCallbacks): void;
+    protected _changeCameraBehaviour(cameraBehaviour: CameraBehaviour): void;
+    protected onCameraChanged(): void;
+    cameraBehaviourChanged(): void;
+    protected _addCameraControlListener(): void;
+    /**
+     * Start render loop and update everything (AA, AO, Shadows, etc)
+     * @private
+     */
+    protected _renderEverything(): void;
+    /**
+     * Start render loop and render the scene but keep shadows and AO, needed for material changes
+     * @private
+     */
+    protected _renderWithoutShadowsAndAO(): void;
+    protected _requestRender(): void;
+    protected _shouldRenderUi(): boolean;
+    private _renderUi;
+    private _animateCamera;
+    protected shouldClearShadowsAndAO(): boolean;
+    protected _setupScene(offset?: CanvasOffset, transparent?: boolean): void;
+    loadEnvMap(url: string): Promise<void>;
+    private _setDefaultEnvironmentScene;
+    private _setEnvMap;
+    private _tabVisible;
+    private _releaseKeystrokeStates;
+    updateCamera(_changeCamera?: boolean): void;
+    private _onWindowResize;
+    protected _isPartOfScene(object: Object3D): boolean;
+    cleanUp(): void;
+    clearScene(): void;
+    enableHD(source?: DynamicLightSettingSource): void;
+    protected _loadGLTF(gltfJSON: string, position?: Vector3, rotation?: number, size?: Vector3, scale?: Vector3, color?: number, callback?: (percent: number) => void): Promise<Object3D>;
+    protected _loadGLB(url: string, position?: Vector3, rotation?: number, size?: Vector3, scale?: Vector3, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<Object3D>;
+    showGUI(): void;
+    protected _guiLoaded(): void;
+    protected _addGUIListener(gui: GUI): void;
+    protected _guiParamChanged(): void;
+    showStats(): void;
+    protected _onKeyDown(_event: KeyboardEvent): void;
+    protected _onKeyUp(_event: KeyboardEvent, _cleanup?: boolean): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    handleEvent(evt: Event): void;
+    loadSceneSettings(sceneSetting: SceneSettings): Promise<void>;
+    setBackgroundColor(hex: string): void;
+    setBackgroundImage(url: string): void;
+    protected _setEnvironment(environment: Environment): void;
+    loadDynamicLightSetting(source: DynamicLightSettingSource): Promise<void>;
+    getScene(): Scene;
+    updateScene(): void;
+    protected _updateBounds(bounds: Box3, geometryBounds?: Box3, geometryChanged?: boolean): void;
+    setCameraOffset(offset: CanvasOffset): void;
+    getCameraOffset(): CanvasOffset;
+    getOrthographicOffsetCamera(): OrthographicOffsetCamera;
+    protected getPerspectiveOffsetCamera(): PerspectiveOffsetCamera;
+    protected updateEnvironment(bounds?: Box3, force?: boolean): void;
+    protected _onCameraIdle(): boolean;
+    protected _onCameraMove(): boolean;
+    protected _waitForAssets(): Promise<void>;
+    exportCanvasScreenshot(quality?: number): Promise<string>;
+    exportImageFromCamera(filename: string, shouldWaitForAssets?: boolean): Promise<void>;
+    changeEnvironmentMapIntensity(intensity: number): void;
+    lockCamera(): void;
+    unlockCamera(): void;
+    setEnvironmentMap(url?: string, intensity?: number, rotation?: number, maxLightSources?: number): void;
+}

package/lib/definitions/packages/common-core/src/webgl/static-item-loader.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '../di/context';
+import { Box3, Vector3 } from 'three';
+import type { RoomleEventedObject3D } from '../utils/threejs-utils';
+export declare const enum STATIC_ITEM_TYPE {
+    GLB = "GLB",
+    GLTF = "GLTF"
+}
+export interface GLTFScene {
+    scene: RoomleEventedObject3D;
+    boundingBox: Box3;
+}
+export default abstract class StaticItemLoader implements Context {
+    _creator_: string;
+    private _gltfLoader;
+    private _gltfLoaderGuard;
+    constructor(creator: string);
+    private _initLoaders;
+    loadGLB(url: string, position?: Vector3, rotation?: number, size?: Vector3, scaling?: Vector3, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<GLTFScene>;
+    loadGLTF(gltfJSON: string, position?: Vector3, rotation?: number, size?: Vector3, scale?: Vector3, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<GLTFScene>;
+    private _handleGLTFScene;
+}

package/lib/definitions/packages/configurator-core/__acceptance__/boot.d.ts

@@ -0,0 +1 @@
+import '../../configurator-core/src/utils/global-definitions';

package/lib/definitions/packages/configurator-core/mock/configurator-mock-data.d.ts

@@ -0,0 +1,200 @@
+import type { KernelPossibleChild } from '../../typings/kernel';
+export declare const USM_PARTLIST: any;
+export declare const CUBE_PARTLIST: any;
+export declare const USM_KERNEL_POSSIBLE_CHILD: KernelPossibleChild;
+export declare const USM_KERNEL_IMPOSSIBLE_CHILD: KernelPossibleChild;
+export declare const USM_RAPI_COMPONENT: {
+    externalIdentifier: string;
+    catalog: string;
+    id: string;
+    type: string;
+    detailType: string;
+    configuration: string;
+    active: boolean;
+    updated: string;
+    created: string;
+    perspectiveImage: string;
+    labels: string[];
+    tags: string[];
+    orderable: boolean;
+    label: string;
+    language: string;
+    additionalInfos: {
+        key: string;
+        type: string;
+        tooltip: {
+            en: string;
+            de: string;
+        };
+    }[];
+    translations: {
+        id: string;
+        language: string;
+        label: string;
+        created: string;
+        updated: string;
+    }[];
+    links: {
+        tags: string;
+    };
+    version: number;
+    __rapi_path__: string;
+};
+export declare const USM_IMPOSSIBLE_COMPONENT: {
+    id: string;
+    externalIdentifier: string;
+    catalog: string;
+    type: string;
+    detailType: string;
+    configuration: string;
+    active: boolean;
+    updated: string;
+    created: string;
+    perspectiveImage: string;
+    labels: string[];
+    tags: string[];
+    orderable: boolean;
+    label: string;
+    language: string;
+    additionalInfos: {
+        key: string;
+        type: string;
+        tooltip: {
+            en: string;
+            de: string;
+        };
+    }[];
+    translations: {
+        id: string;
+        language: string;
+        label: string;
+        created: string;
+        updated: string;
+    }[];
+    links: {
+        tags: string;
+    };
+    version: number;
+    __rapi_path__: string;
+};
+export declare const USM_ADDON_TAG: {
+    id: string;
+    global: boolean;
+    created: string;
+    updated: string;
+    sort: number;
+    links: {
+        items: string;
+        materials: string;
+    };
+    catalog: string;
+    label: string;
+    language: string;
+    items: string[];
+    hidden: boolean;
+    __rapi_path__: string;
+};
+export declare const USM_PLAN_OBJECT: {
+    id: number;
+    bounds: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    boxForMeasurement: {
+        origin: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        size: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    boxOfGeometry: {
+        origin: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        size: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    rootPlanComponentId: number;
+    parameters: ({
+        key: string;
+        label: string;
+        type: string;
+        unitType: string;
+        value: string;
+        enabled: boolean;
+        validRange: {
+            valueFrom: number;
+            valueTo: number;
+        };
+        validGroups: string[];
+        validValues: {
+            value: string;
+            label: string;
+        }[];
+        sort: number;
+        highlighted: boolean;
+        valuesAreEqual: boolean;
+    } | {
+        key: string;
+        label: string;
+        type: string;
+        value: string;
+        enabled: boolean;
+        validRange: {
+            valueFrom: number;
+            valueTo: number;
+        };
+        validGroups: string[];
+        validValues: string[];
+        sort: number;
+        highlighted: boolean;
+        valuesAreEqual: boolean;
+        unitType?: undefined;
+    })[];
+    parameterGroups: string[];
+    externalId: string;
+    externalObject: boolean;
+};
+export declare const MATERIALS_WITH_SORT: {
+    key: string;
+    label: string;
+    type: string;
+    unitType: any;
+    value: string;
+    group: string;
+    enabled: boolean;
+    validRange: {
+        type: any;
+        valueFrom: number;
+        valueTo: number;
+        step: number;
+    };
+    validGroups: any;
+    validValues: {
+        value: string;
+        label: string;
+        thumbnail: any;
+    }[];
+    sort: number;
+    highlighted: boolean;
+    valuesAreEqual: boolean;
+    grouping: {
+        key: string;
+        label: string;
+        sort: number;
+        collapsed: boolean;
+    };
+    valueLabel: string;
+    uiType: string;
+}[];

package/lib/definitions/packages/configurator-core/mock/kernel-mock.d.ts

@@ -0,0 +1,29 @@
+declare class MockUnitMeasureFormatter {
+    init(mmLabel: string, cmLabel: string, ftShortLabel: string, ftLongLabel: string, inchShortLabel: string, inchLongLabel: string, sqMLabel: string, sqftLabel: string, showExactValue: boolean, maxPrecision: number, showFractionalUnitString: boolean): void;
+}
+export declare const KERNEL_CONTAINER_MOCK: {
+    UnitMeasureFormatter: typeof MockUnitMeasureFormatter;
+    Unit: {
+        InchFeet: {
+            value: number;
+        };
+        MM: {
+            value: number;
+        };
+        CM: {
+            value: number;
+        };
+    };
+    UnitStringType: {
+        NoUnitString: {
+            value: number;
+        };
+        LongUnitString: {
+            value: number;
+        };
+        ShortUnitString: {
+            value: number;
+        };
+    };
+};
+export {};

package/lib/definitions/packages/configurator-core/src/configurator-debug-api.d.ts

@@ -0,0 +1,7 @@
+import type { DebugValueMapChange } from '../../typings/kernel';
+export interface ConfiguratorDebugAPI {
+    enableDebugging(): void;
+}
+export interface ConfiguratorDebugCallbacks {
+    onValueMapChanged(changes: DebugValueMapChange): void;
+}

package/lib/definitions/packages/configurator-core/src/configurator.d.ts

@@ -0,0 +1,14 @@
+import './utils/global-definitions';
+import Main from '../../common-core/src/main';
+import type { AppState } from '../../common-core/src/utils/app-context';
+import RoomleConfigurator from './roomle-configurator';
+export declare class Configurator extends Main {
+    private _configurator;
+    protected setupDependencies(): void;
+    protected cleanUpGlobals(): void;
+    protected cleanUpDependencies(): void;
+    protected setupGlobals(appState?: AppState): void;
+    getApi(): RoomleConfigurator;
+    protected bootFinished(): void;
+    protected getContextName(): string;
+}

package/lib/definitions/packages/configurator-core/src/input/configurator-input-manager.d.ts

@@ -0,0 +1,3 @@
+import InputManager from '../../../common-core/src/input/input-manager';
+export default class ConfiguratorInputManager extends InputManager {
+}