@roomle/embedding-lib 5.24.0 → 5.25.0-alpha.10

package/packages/web-sdk/packages/common-core/src/utils/shims.d.ts

@@ -0,0 +1,495 @@
+import { CanvasOffset } from '../common-interfaces';
+import { ROOMLE_COLORS, ROOMLE_HIGHLIGHTNG } from './common-utils';
+import { HexColorNumber, HexColorString, RapiId, RapiServerUrlType } from '../../../typings/rapi-types';
+import { CAMERA_TYPE } from '../cameracontrol/camera-type';
+import { Enumify } from '../types';
+import { DefaultEnvironmentSceneType } from '../webgl/renderer/environment-scene';
+import { CustomShadingParameters, SceneShadingType } from '../webgl/renderer/shading-settings';
+import { Color } from 'three';
+import { HomagIntelligenceInitData } from '../../../homag-intelligence/src/loader';
+
+export declare const enum WINDOW_EVENT {
+    RESIZE = "resize",
+    KEY_DOWN = "keydown",
+    KEY_UP = "keyup",
+    VISIBILITY_CHANGE = "visibilitychange"
+}
+export declare const DRAW_PREVIEW_MODES: {
+    readonly DEFAULT: "default";
+    readonly VECTOR: "vector";
+};
+/**
+ * Init data parameters which are not context specific
+ */
+export interface GlobalInitDataDefinition {
+    /**
+     * @description locale to use for the
+     * embedding instance
+     */
+    locale?: string;
+    /**
+     * @internal
+     * @deprecated
+     * @description Can be used for content testing
+     */
+    overrideTenant?: number;
+    /**
+     * @description Set country to use for the Roomle price service. If not used the customer IP address will be used to determine the location. usage: overrideCountry=de
+     */
+    overrideCountry?: string;
+    /**
+     * @internal
+     * @description Set which RAPI (Roomle API) backend should be used options: live, test
+     */
+    overrideRapi?: RapiServerUrlType;
+    /**
+     * @internal
+     * @description The id which should be used for this embedding instance. When this id is set all InitData parameter can be set and changed in Rubens Admin. This is the way we recommend to set init data params. Ask your Roomle contact for your configuratorId.
+     */
+    configuratorId?: string;
+    /**
+     * @deprecated
+     * @description when set to true and assets were prechaced by the asset loader they are returned from cache. Otherwise we always return a fresh copy from network usage: alwaysUseCache=true default: not set -> assets fetched from url, set -> assets from cache
+     */
+    alwaysUseCache?: boolean;
+    /**
+     * @internal
+     * @description Set which RAPI (Roomle API) backend should be used usage: customApiUrl=https://www.roomle.com/api/v2
+     */
+    customApiUrl?: string;
+    /**
+     * @internal
+     * @description Can be set to true if started as an end-to-end test. This will disable post-processing
+     */
+    e2e?: boolean;
+    /**
+     * @internal
+     * @description If set to true, the Roomle Renderer is used for perspective and top images this should help the E2E tests of Joe to migrate from comparing Roomle Renderer images to Three.js Renderer images
+     */
+    e2eRoomleRendererForImages?: boolean;
+    /**
+     * @internal
+     * @description When loading a plan, the external objects from the plan XML are discarded
+     */
+    discardExternalObjectsWhenLoadingPlan?: boolean;
+    /**
+     * @description If set to true, the plan will be locked and no changes can be made to walls, floors or construction elements.
+     * @default false
+     */
+    lockPlan?: boolean;
+}
+export interface FeatureFlags {
+    pulsePreview?: boolean;
+    reDock?: boolean;
+    /**
+     * @description If set to true we will not hide other items while configuring in the planner
+     */
+    configureInRoom?: boolean;
+    /**
+     * @internal
+     * @description If true, the advanced docking behavior is enabled (for test purposes only)
+     */
+    advancedDocking?: boolean;
+    /**
+     * @internal
+     * @description If “vector”, the vector preview is activated when drawing walls (for test purposes only).
+     * By default, the walls are immediately drawn with their actual thickness,
+     * but this leads to problems when displaying the dimensions of the walls,
+     * as it is not possible to guess which side of the wall of the room currently being entered is the inside of the wall.
+     */
+    drawPreviewMode?: Enumify<typeof DRAW_PREVIEW_MODES>;
+    /**
+     * @internal
+     * @description TO BE REMOVED ONCE RML-13218 IS RESOLVED.
+     * Forces new thumbnails to be generated on configuration save
+     */
+    forceSaveThumbnails?: boolean;
+    /**
+     * @internal
+     * @description Enables dynamically placed interior lights in the room planner.
+     */
+    interiorLights?: boolean;
+    /**
+     * @internal
+     * @description If true, the advanced dimensioning is enabled (for test purposes only)
+     */
+    advancedDimensioning?: boolean;
+}
+export type RoomleColors = keyof typeof ROOMLE_COLORS;
+export type ColorsIn3dScene = Record<RoomleColors, HexColorString | HexColorNumber>;
+export type ThreeJsColorsIn3dScene = Record<keyof typeof ROOMLE_COLORS, Color>;
+/**
+ * Init data parameter which can be used in configurator AND planner
+ */
+export interface CommonInitData {
+    /**
+     * @description If set to true the configurator will make sure every device has great user experience  with fluid frame rate.
+     * If set to false the configurator will always show the highest quality possible.
+     * That could lead to stutter and other problems on low-end devices. We advise you to only turn off "autoQuality" if you really know what you are doing.
+     * usage: autoQuality=false
+     * @groups scene-settings
+     */
+    autoQuality?: boolean;
+    /**
+     * @description Can be used to personalize colors used in the 3D scene
+     * @groups scene-settings
+     */
+    colors?: ColorsIn3dScene;
+    /**
+     * @deprecated
+     * @description Set if the currently loaded id is an item or a configuration.
+     * In the new configurator UI this is determined automatically based on the id.
+     */
+    isItem?: boolean;
+    /**
+     * @description The item id or configuration id of the item which should be loaded.
+     * Examples:
+     * Configuration id: usm:frame:2449773A7F54278EBB61A67A10EF6A10E8BB6F38BE775B028AC050B438414507
+     * Item id: usm:frame
+     */
+    id?: RapiId;
+    /**
+     * @deprecated
+     * @internal
+     * @description Same as preloadHint, both call getPreloadForItem or getPreloadForConfiguration to pre load things needed
+     * for the configuration so that there are less XHR calls and the cache is pre-warmed
+     * Will no longer be used in the new configurator UI.
+     */
+    preloadId?: RapiId;
+    /**
+     * @deprecated
+     * @description Set if the AR button should be shown.
+     * In the new configurator UI this is in the configurator settings object called buttons.
+     */
+    showArButton?: boolean;
+    /**
+     * @internal
+     * @deprecated
+     * @description Use prices which are hardcoded in the configuration script.
+     * Only used for trade show demos.
+     */
+    useRoomlePrice?: boolean;
+    /**
+     * @description Set how many positions after the decimal point should be shown.
+     * For example:
+     * 8' 1.68" -> precisionCm=2 -> 8' 1.68"
+     * 8' 1.68" -> precisionCm=1 -> 8' 1.7"
+     * 8' 1.68" -> precisionCm=0 -> 8' 2"
+     */
+    precisionInch?: string;
+    /**
+     * @description Set how many positions after the decimal point should be shown.
+     * For example:
+     * 123,45 -> precisionCm=2 -> 123,45
+     * 123,45 -> precisionCm=1 -> 123,5
+     * 123,45 -> precisionCm=0 -> 124
+     */
+    precisionCm?: string;
+    /**
+     * @description Defines which unit should be used for measurements/dimensions
+     * Options: 'cm', 'mm', 'inchfeet'
+     */
+    unit?: string;
+    /**
+     * @description How the current unit should be formatted
+     * Options:
+     *   - 'none': No unit string added, for example '200'
+     *   - 'long': Long unit string, for example '200 meters'
+     *   - 'short': Short unit string, for example '200 m'
+     */
+    unitStringType?: string;
+    /**
+     * @description Add a tag id which is used to show different variations for the current item/configuration
+     * @deprecated
+     */
+    typeChangeTag?: RapiId;
+    /**
+     * @deprecated
+     * @internal
+     * @description Same as preloadId, both call getPreloadForItem or getPreloadForConfiguration to pre load things needed
+     * for the configuration so that there are less XHR calls and the cache is pre-warmed
+     * Will no longer be used in the new configurator UI.
+     */
+    preloadHint?: RapiId;
+    /**
+     * @deprecated
+     * @description Change the offset of the camera. For example if you add a margin left (0.1 means 10%) then
+     * the item moves to the right.
+     * This value is overridden in the new configurator UI.
+     * */
+    offset?: CanvasOffset;
+    /**
+     * @deprecated
+     * @description Add a tag id which is used to show different variations when opening the configurator
+     */
+    startTag?: RapiId;
+    /**
+     * @description When mesh selection is enabled, the meshes of the object are used directly for highlighting.
+     * Setting it to false could be useful for square/rectangular (shelf) items.
+     */
+    meshSelection?: boolean;
+    /**
+     * @description if set to true it shows a little overlay with performance stats
+     */
+    stats?: boolean;
+    /**
+     * @internal
+     * @description Enable service worker which tracks performance and request size (content, materials, etc)
+     */
+    _measureTraffic?: boolean;
+    /**
+     * @description This flag enables:
+     *   - Scripter debug logs (e.g. which parameter is not assigned to a parameter group)
+     *   - Free camera movement (no restrictions, camera stays after reload, panning using Shift key)
+     */
+    debug?: boolean;
+    /**
+     * @description This flag enables:
+     *   - External object docking vector debug geometry
+     */
+    debugGeometry?: boolean;
+    /**
+     * @description If set to true, prices are calculated using the Roomle price service.
+     * For more information ask your Roomle contact.
+     */
+    usePriceService?: boolean;
+    /**
+     * @internal
+     * @description If set to true, it will disable the environment map completely
+     */
+    disableEnvMap?: boolean;
+    /**
+     * @description Url to an exr or hdr env map
+     * @groups scene-settings
+     */
+    envMapUrl?: string;
+    /**
+     * @description Set the intensity of the environment map
+     * @groups scene-settings
+     */
+    envMapIntensity?: number;
+    /**
+     * @description Set the rotation of the environment map in radians, between 0 and 2 * PI, rotates counter-clockwise
+     * @groups scene-settings
+     */
+    envMapRotation?: number;
+    /**
+     * @description Set the maximum number of light sources extracted from the environment map
+     * @groups scene-settings
+     */
+    maxLightSources?: number;
+    /**
+     * @description Use old light setting instead of env maps
+     * @groups scene-settings
+     */
+    legacyLight?: boolean;
+    /**
+     * @description Generate environment map from a scene instead of env maps
+     * use all_around for an surrounding light
+     * use front for a mainly frontal light
+     * @groups scene-settings
+     */
+    sceneLight?: DefaultEnvironmentSceneType;
+    /**
+     * @description General shading properties for the overall appearance
+     * default: for planner and a configurator with colorful, metallic or wooden materials
+     * bright: for a configurator with white and bright materials
+     * @groups scene-settings
+     */
+    shading?: SceneShadingType;
+    /**
+     * @description Customized shading properties for the overall appearance
+     * @groups scene-settings
+     */
+    customShading?: CustomShadingParameters;
+    /**
+     * @description Activates the linear AO filter mode to reduce AO anti-aliasing artifacts
+     * @groups scene-settings
+     */
+    linearAoFilter?: boolean;
+    /**
+     * @description Customized shading properties for the overall appearance in MOC
+     * @groups scene-settings
+     */
+    customShadingMoc?: CustomShadingParameters;
+    /**
+     * @description restrictionLevel defines visibility of parameters and possible children
+     */
+    restrictionLevel?: number;
+    /**
+     * @description Settings for Homag Intelligence
+     * @internal
+     */
+    hi?: HomagIntelligenceInitData;
+}
+export interface ConfiguratorInitData {
+    /**
+     * @deprecated
+     * @description Download all necessary files to run the configurator in offline mode
+     */
+    offlineSync?: string;
+    /**
+     * @description Sets the behavior of the highlighting of a hovered component.
+     * usage: highlighting=smart
+     */
+    highlighting?: Enumify<typeof ROOMLE_HIGHLIGHTNG>;
+    /**
+     * @description Set the floor material which is used when loading the configurator
+     * For different options see {@link @roomle/web-sdk/configurator-core/src/environment/dynamic-environment-setting-loader#EnvironmentSetting}
+     */
+    initialFloorMaterial?: string;
+    /**
+     * @internal
+     * @description Load a light setting using an URL.
+     * Check lights in {@link @roomle/web-sdk/configurator-core/src/scene-settings-loader#SceneSettings} for an example.
+     * value is a dynamic light setting url
+     */
+    dls?: string;
+    /**
+     * @description Load a predefined light setting, eg: ls=sofa
+     * @groups scene-settings
+     */
+    ls?: string;
+    /**
+     * @deprecated
+     * @description define which floors to load
+     */
+    floorMaterialsTag?: RapiId;
+    /**
+     * @description Set the distance to which the user can zoom (in centimeters).
+     * default: object size divided by 10 or 10 cm
+     * usage: zoomDistance=3
+     * @groups scene-settings
+     */
+    zoomDistance?: number;
+    /**
+     * @description When set this param restricts the camera rotation to the given angle (e.g. 45 degree), this overrides minHorizontalCameraAngle and maxHorizontalCameraAngle
+     * default: not set -> no camera restriction
+     * usage: cameraRestriction=45
+     * @groups scene-settings
+     */
+    cameraRestriction?: number;
+    /**
+     * @description Sets the default/initial vertical camera angle (pitch)
+     * default: 10
+     * usage: verticalCameraAngle=45
+     * @groups scene-settings
+     */
+    verticalCameraAngle?: number;
+    /**
+     * @description When set this param restricts the down/vertical camera rotation to the given angle (e.g. 45 degree)
+     * default: not set -> no camera angle restriction
+     * usage: minVerticalCameraAngle=45
+     * @groups scene-settings
+     */
+    minVerticalCameraAngle?: number;
+    /**
+     * @description When set this param restricts the up/vertical camera rotation to the given angle (e.g. 45 degree)
+     * default: not set -> no camera angle restriction
+     * usage: maxVerticalCameraAngle=45
+     * @groups scene-settings
+     */
+    maxVerticalCameraAngle?: number;
+    /**
+     * @description Sets the default/initial horizontal camera angle (yaw)
+     * default: -30
+     * usage: horizontalCameraAngle=45
+     * @groups scene-settings
+     */
+    horizontalCameraAngle?: number;
+    /**
+     * @description When set this param restricts the left/horizontal camera rotation to the given angle (e.g. 45 degree)
+     * default: not set -> no camera angle restriction
+     * usage: minHorizontalCameraAngle=45
+     * @groups scene-settings
+     */
+    minHorizontalCameraAngle?: number;
+    /**
+     * @description When set this param restricts the right/horizontal camera rotation to the given angle (e.g. 45 degree)
+     * default: not set -> no camera angle restriction
+     * usage: maxHorizontalCameraAngle=45
+     * @groups scene-settings
+     */
+    maxHorizontalCameraAngle?: number;
+    /**
+     * @description If set to false the camera will just jump to a new position
+     * default: true
+     * usage: animateCamera=false
+     * @groups scene-settings
+     */
+    animateCamera?: boolean;
+    /**
+     * @internal
+     * @description Easter Egg
+     * */
+    bananaForScale?: boolean;
+    /**
+     * @description If set to true, components which are between the camera and the selected component/preview will be rendered transparent
+     * usage: transparentHighlighting=true
+     * @groups scene-settings
+     */
+    transparentHighlighting?: boolean;
+    /**
+     * @description If set to true, the background is transparent and allows elements behind the configurator to be visible through the scene.
+     * usage: transparentBackground=true
+     * @groups scene-settings
+     */
+    transparentBackground?: boolean;
+    /**
+     * @deprecated
+     * @description Shows partlist if there are no prices
+     */
+    showInfos?: boolean;
+    /**
+     * @deprecated
+     * @description Show price label using prices from configuration script
+     */
+    showPrice?: boolean;
+    /**
+     * @description If set to true it will try to apply all current global parameters to the loaded object
+     */
+    applyCurrentGlobalParameters?: boolean;
+    /**
+     * @description Adds the given spacing (in centimeters) to the loaded object. This is then used to calculate the initial camera distance
+     * default: 0
+     * usage:
+     *  cameraSpacing=100, zoom out further by increasing camera spacing by 100 centimeters
+     *  cameraSpacing=-30, zoom in further by decreasing camera spacing by 30 centimeters
+     * @groups scene-settings
+     */
+    cameraSpacing?: number;
+    /**
+     * @internal
+     * @description If set to true, screen space reflections are enabled
+     */
+    ssr?: boolean;
+    /**
+     * @internal
+     * @description features that can be enabled/disabled
+     */
+    featureFlags?: FeatureFlags;
+}
+export interface PlannerInitData {
+    /**
+     * @description Select with which camera mode to start initially.
+     * usage: mode=2D
+     * options: 2D, 3D, FP
+     */
+    mode?: Enumify<typeof CAMERA_TYPE>;
+    /**
+     * @internal
+     * @description If set to true the plan can be edited.
+     */
+    edit?: boolean;
+    /**
+     * @internal
+     * @description If set to true it will treat the planner as a multi object configurator (moc).
+     * This means:
+     *  - do not merge geometries
+     *  - set configurator environment & lights in planner
+     *  - reduce initial spacing of camera (higher zoom)
+     */
+    moc?: boolean;
+}
+export interface InitDataDefinition extends CommonInitData, ConfiguratorInitData, PlannerInitData {
+}

package/packages/web-sdk/packages/common-core/src/utils/single-promise-factory.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '../di/context';
+
+export declare const enum PROMISE_CATEGORY {
+    OFFLINE_CATALOG_SYNC = 0,
+    OFFLINE_FLOOR_TAG_SYNC = 1,
+    OFFLINE_TPYE_CHANGE_TAG_SYNC = 2,
+    START_HSC = 3,
+    START_GLB = 4,
+    FETCH_SCRIPT = 5,
+    ASSIGN_MATERIAL = 6
+}
+export default class SinglePromiseFactory implements Context {
+    _creator_: string;
+    private _promises;
+    constructor(creator: string);
+    create<T>(promiseCategory: PROMISE_CATEGORY, promiseIdentifier: string, workToDo: (resolve: (data?: T) => void, reject: (error: Error) => void) => void): Promise<T>;
+}

package/packages/web-sdk/packages/common-core/src/utils/stats-helper.d.ts

@@ -0,0 +1,18 @@
+import { default as CacheHolder } from '../services/cache-holder';
+import { WebGLInfo } from 'three';
+import { QualityLevel } from '../webgl/renderer/scene-renderer';
+
+export default class StatsHelper {
+    protected _cacheHolder: CacheHolder;
+    private _statPanels;
+    private _drawPanel;
+    private _trianglesPanel;
+    private _geometryPanel;
+    private _texturePanel;
+    private _materialPanel;
+    private _qualityPanel;
+    constructor();
+    private _init;
+    updateRenderInfo(info: WebGLInfo): void;
+    updateQualityInfo(qualityLevel: QualityLevel): void;
+}

package/packages/web-sdk/packages/common-core/src/utils/string-utils.d.ts

@@ -0,0 +1 @@
+export declare const dashCase: (str: string) => string;

package/packages/web-sdk/packages/common-core/src/utils/threejs-utils.d.ts

@@ -0,0 +1,135 @@
+import { Dimensioning, KernelCube, KernelEnum } from '../../../typings/kernel';
+import { AssetUrl, RapiMaterial, RapiMaterialShading, RapiTexture } from '../../../typings/rapi-types';
+import { Position2, Position3 } from '../common-interfaces';
+import { default as WallPlanElementViewModel } from '../../../planner-core/src/view-model/wall-plan-element-view-model';
+import { Camera, Intersection, Material, Matrix4, MeshPhysicalMaterial, MeshStandardMaterial, NormalBufferAttributes, Object3D, Object3DEventMap, Quaternion, Texture, Vector2, Scene, Box3, BufferGeometry, Color, CubeTexture, DataTexture, Layers, Mesh, MeshBasicMaterial, Vector3 } from 'three';
+import { GUI } from 'dat.gui';
+import { OBJECT_EVENT } from '../../../configurator-core/src/utils/raycast-helper';
+import { INPUT_EVENT_TYPE } from '../input/input-manager';
+import { Tween } from '@tweenjs/tween.js';
+
+export declare const PREVIEW_LINE_MATERIAL_OPACITY = 0.4;
+export declare const PREVIEW_MATERIAL_COLOR = "#DDDDDD";
+export declare const PREVIEW_MATERIAL_ROUGHNESS = 1;
+export declare const PREVIEW_MATERIAL_METALNESS = 0;
+export declare const PREVIEW_MATERIAL_OPACITY = 1;
+export declare const DOOR_WINDOW_MATERIAL_OPACITY = 1;
+export declare const DOOR_ARCH_MATERIAL_OPACITY = 0.4;
+export declare const DOOR_ARCH_MATERIAL_OUTLINE_COLOR = "#7B7B7B";
+export declare const DOOR_WINDOW_MATERIAL_COLOR = "#B1B1B1";
+export declare const DOCK_PREVIEW_MATERIAL_ROUGHNESS = 1;
+export declare const DOCK_PREVIEW_MATERIAL_METALNESS = 0;
+export declare const DOCK_PREVIEW_MATERIAL_OPACITY = 0.8;
+export declare const DOCK_PREVIEW_MATERIAL_OPACITY_HOVERED = 0.9;
+export declare const getScreenXY: (obj: Vector3, camera: Camera, clientWidth: number, clientHeight: number) => Vector3;
+export declare const kernelBoxToThreeBox: (kernelCube: KernelCube, margin?: Vector3) => Box3;
+export declare const kernelDimensioningToThree: (dimensions: Dimensioning) => Dimensioning;
+export declare const setShadows: (object: Object3D, receiveShadow: boolean, castShadow: boolean) => void;
+export declare const position3VectorsAreEqual: (a: Vector3, b: Vector3) => boolean;
+export declare const rotationQuaternionsAreEqual: (a: Quaternion, b: Quaternion) => boolean;
+export declare const position2VectorsAreEqual: (a: Vector2, b: Vector2) => boolean;
+export declare const createColorTexture: (red: number, green: number, blue: number, alpha: number) => DataTexture;
+export declare const createColorCubeTexture: (red: number, green: number, blue: number, alpha: number) => CubeTexture;
+export declare const createMaterial: (material: RapiMaterial) => MeshPhysicalMaterial;
+export declare const setMaterial: (meshPhysicalMaterial: MeshPhysicalMaterial, rapiMaterial: RapiMaterial) => MeshPhysicalMaterial;
+export declare const getMaterialShading: (material: MeshPhysicalMaterial, version?: number) => RapiMaterialShading;
+export declare const logColor: (color: Color) => void;
+export declare const createTexture: (texture: Texture, rapiTexture: RapiTexture, width: number, height: number, maxAnisotropy: number) => Texture;
+export declare const addTexture: (assetUrl: AssetUrl, rapiTexture: RapiTexture, material: MeshPhysicalMaterial, maxAnisotropy: number, repeatWidth: number, repeatHeight: number, maxTextures?: number) => Promise<void>;
+export declare const addExistingTexture: (texture: Texture, rapiTexture: RapiTexture, material: MeshPhysicalMaterial, maxAnisotropy: number, repeatWidth: number, repeatHeight: number, maxTextures?: number) => void;
+export declare const getGUI: (autoplace?: boolean) => GUI;
+export declare const setWallTransparencyBasedOnCamera: (camera: Camera, material: Material, animate?: boolean) => void;
+export declare const hideWallsBasedOnCamera: (camera: Camera, wallPlanElementViewModels: WallPlanElementViewModel[]) => boolean;
+export declare const setWallTransparency: (material: Material, transparent: boolean, animate?: boolean) => void;
+export declare const animateObjectMatrix: (object3d: Object3D, priorMatrix: Matrix4, fromMatrix: Matrix4, toMatrix: Matrix4, subsequentTransform: Matrix4, onProgressUpdate?: () => void) => Tween;
+export declare const calculateBaseMatrix: (matrixFrom: Matrix4, matrixTo: Matrix4) => Matrix4;
+export declare const getAxisAndAngleFromQuaternion: (quaternion: Quaternion) => {
+    axis: Vector3;
+    angleRad: number;
+};
+export declare const setObjectMatrix: (object3d: Object3D, matrix: Matrix4) => void;
+export declare const interpolateMatrix: (matrixFrom: Matrix4, matrixTo: Matrix4, t: number) => Matrix4;
+export declare const circularInterpolateMatrix: (matrixFrom: Matrix4, matrixTo: Matrix4, t: number) => Matrix4;
+export declare const getColorFromInt: (combinedColor: number) => Color;
+export declare const TRANSPARENCY_ANIMATION_DURATION = 250;
+export declare const transitionTransparencyOfMaterial: (object: Object3D, toMaterial: {
+    opacity: number;
+    transparent: boolean;
+}) => Promise<void>;
+export declare const fadeIn: (object: Object3D) => void;
+export declare const fadeOut: (object: Object3D, scene?: Scene) => void;
+export declare const checkGLB: (glb: Object3D, url: string) => boolean;
+export declare const dispose: (object: Object3D) => void;
+export declare const disposeObject: (object: Object3D) => void;
+export declare const disposeMesh: (mesh: Mesh) => void;
+export declare const disposeGeometry: (geometry: BufferGeometry) => void;
+export declare const disposeMaterial: (material: MeshStandardMaterial) => void;
+export declare const getBoundingBoxMaterial: () => MeshBasicMaterial;
+export declare const getDebugBoundingBoxMaterial: (colorString?: string) => MeshStandardMaterial;
+export declare const getSelectionGeometry: (position: Vector3, size: Vector3) => BufferGeometry;
+export declare const vectorIsZero: (vector: Vector3) => boolean;
+export declare const getMaterialId: (material: any, type?: KernelEnum) => string;
+export declare const vectorIsEqual: (vector1: Vector3, vector2: Vector3, tolerance?: number) => boolean;
+export declare const getYRotationOfObject: (object: Object3D) => number;
+/**
+ * compares x and z and ignores y
+ * @param box1
+ * @param box2
+ */
+export declare const compareBox3Size: (box1: Box3, box2: Box3) => number;
+export declare const isUVIdentityMatrix: (uvTransform: Float32Array) => boolean;
+export declare const getDrawingMinBounds: (planBounds: Box3, width: number, height: number, marginMultiplier?: number) => Box3;
+export declare const threeVectorToTransferableXY: (vec: Vector2 | Vector3) => Position2;
+export declare const threeVectorToTransferableXYZ: (vec: Vector3) => Position3;
+export declare const getActiveLayers: (layers: Layers) => any[];
+export declare const viewSpacePositionFromAltitudeAndAzimuth: (distance: number, altitudeDeg: number, azimuthDeg: number) => Vector3;
+export declare const viewSpacePositionFromUV: (distance: number, u: number, v: number) => Vector3;
+export declare const createEmptySceneFromCurrent: (currentScene: Scene) => Scene;
+export declare const isBox3InFrustum: (camera: Camera, box3: Box3) => boolean;
+export type RoomleEventedMesh = Mesh<BufferGeometry<NormalBufferAttributes>, Material | Material[], Object3DRoomleEventMap>;
+export type RoomleEventedObject3D = Object3D<Object3DRoomleEventMap>;
+export type RoomleEventedIntersection = Intersection<RoomleEventedObject3D>;
+interface InputEventAttatchment {
+    intersection: RoomleEventedIntersection;
+    type: INPUT_EVENT_TYPE;
+}
+export interface Object3DRoomleEventMap extends Object3DEventMap {
+    [OBJECT_EVENT.CLICK]: {
+        attachment: InputEventAttatchment;
+    };
+    [OBJECT_EVENT.DOUBLE_CLICK]: {
+        attachment: InputEventAttatchment;
+    };
+    [OBJECT_EVENT.DRAG]: {
+        attachment: {
+            position: Vector3;
+        };
+    };
+    [OBJECT_EVENT.DRAG_END]: {
+        attachment: {
+            position: Position2;
+        };
+    };
+    [OBJECT_EVENT.DRAG_START]: object;
+    [OBJECT_EVENT.HOVER_MOVE]: {
+        attachment: InputEventAttatchment;
+    };
+    [OBJECT_EVENT.HOVER_OFF]: {
+        attachment: {
+            type: INPUT_EVENT_TYPE;
+        };
+    };
+    [OBJECT_EVENT.HOVER_ON]: {
+        attachment: InputEventAttatchment;
+    };
+    [OBJECT_EVENT.ROTATE]: {
+        attachment: {
+            rotation: number;
+        };
+    };
+}
+/**
+ * normalize the angle between -PI and PI
+ */
+export declare const normalizeRotation: (angleInRad: number) => number;
+export {};

package/packages/web-sdk/packages/common-core/src/utils/ui-callback.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '../di/context';
+
+export declare class UiCallback implements Context {
+    _creator_: string;
+    private _isMute;
+    private _setMute;
+    mute(): void;
+    unmute(): void;
+    constructor(creator: string);
+    get(target: UiCallback, prop: keyof UiCallback): UiCallback[keyof UiCallback];
+    cameraStartsMoving: () => void;
+    /**
+     * @deprecated has been moved to global callbacks
+     * is called the scene is ready for rendering it as an image
+     */
+    onReadyForRender: () => void;
+}