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

package/lib/definitions/packages/common-core/src/utils/threejs-utils.d.ts

@@ -0,0 +1,135 @@
+import type { Dimensioning, KernelCube, KernelEnum } from '../../../typings/kernel';
+import type { AssetUrl, RapiMaterial, RapiMaterialShading, RapiTexture } from '../../../typings/rapi-types';
+import type { Position2, Position3 } from '../common-interfaces';
+import type WallPlanElementViewModel from '../../../planner-core/src/view-model/wall-plan-element-view-model';
+import { type Camera, type Intersection, type Material, Matrix4, type MeshPhysicalMaterial, type MeshStandardMaterial, type NormalBufferAttributes, type Object3D, type Object3DEventMap, Quaternion, type Texture, type Vector2 } from 'three';
+import { Scene } from 'three';
+import { Box3, BufferGeometry, Color, CubeTexture, DataTexture, Layers, Mesh, MeshBasicMaterial, Vector3 } from 'three';
+import { GUI } from 'dat.gui';
+import type { OBJECT_EVENT } from '../../../configurator-core/src/utils/raycast-helper';
+import type { INPUT_EVENT_TYPE } from '../input/input-manager';
+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 animateMeshMatrix: (mesh: Mesh, fromMatrix: Matrix4, toMatrix: Matrix4, onProgressUpdate?: () => void) => void;
+export declare const calculateBaseMatrix: (matrixFrom: Matrix4, matrixTo: Matrix4) => Matrix4;
+export declare const getAxisAndAngleFromQuaternion: (quaternion: Quaternion) => {
+    axis: Vector3;
+    angleRad: number;
+};
+export declare const setMeshMatrix: (mesh: Mesh, 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) => string[];
+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/lib/definitions/packages/common-core/src/utils/ui-callback.d.ts

@@ -0,0 +1,16 @@
+import type { 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;
+}

package/lib/definitions/packages/common-core/src/utils/url-shortener.d.ts

@@ -0,0 +1,6 @@
+export declare const enum SHORT_TYPES {
+    UNKNOWN = 0,
+    PLAN = 1,
+    USER = 2,
+    CONFIGURATION = 3
+}

package/lib/definitions/packages/common-core/src/utils/waiter.d.ts

@@ -0,0 +1,10 @@
+export interface PromiseExecutor<T> {
+    resolve: (value?: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}
+export default class Waiter<T> {
+    private _promiseExecutors;
+    create(): Promise<T>;
+    resolve(value: T | PromiseLike<T>): Promise<T>;
+    reject(reason: Error): Promise<T>;
+}

package/lib/definitions/packages/common-core/src/view-model/configurable-construction-plan-object-view-model.d.ts

@@ -0,0 +1,21 @@
+import type { ConstructionPlanObject, PlanObject } from '../../../typings/planner';
+import { type Vector3 } from 'three';
+import ConfiguratorPlanObjectViewModel from './configurator-plan-object-view-model';
+import { type ConstructionMeasurements } from '../../../planner-core/src/utils/measurements';
+import type { Nullable } from '../../../typings/helper';
+import ConstructionTopView from '../../../planner-core/src/webgl/construction-top-view';
+import { type RoomleEventedMesh } from '../utils/threejs-utils';
+import { type RapiItem } from '../../../typings/rapi-types';
+export default class ConfigurableConstructionPlanObjectViewModel extends ConfiguratorPlanObjectViewModel {
+    private _constructionTopView;
+    private _rapiItem;
+    constructor(planObject: PlanObject);
+    getConstructionElementMeasurements(zoomFactor: number, clientWidth: number, clientHeight: number): Nullable<ConstructionMeasurements>;
+    setRapiItem(rapiItem: RapiItem): void;
+    protected _updateBoundingBox(): void;
+    setTopView(enabled: boolean): Promise<void>;
+    getTopViewContainer(): ConstructionTopView;
+    update(): void;
+    getPlanElement(): ConstructionPlanObject;
+    protected _setPositionOfBoundingBox(size: Vector3, mesh: RoomleEventedMesh): void;
+}

package/lib/definitions/packages/common-core/src/view-model/configurator-plan-object-view-model.d.ts

@@ -0,0 +1,19 @@
+import type { PlanObject } from '../../../typings/planner';
+import type { RoomleComponent } from '../webgl/roomle-component-factory';
+import PlanObjectViewModel from './plan-object-view-model';
+export default class ConfiguratorPlanObjectViewModel extends PlanObjectViewModel {
+    private _rootComponentRuntimeId;
+    private _rootComponentId;
+    constructor(planObject: PlanObject);
+    addRootComponent(component: RoomleComponent): void;
+    addChildEntityComponent(component: RoomleComponent): void;
+    getConfigurationRuntimeId(): number;
+    getRootComponentId(): number;
+    getRootComponentRuntimeId(): number;
+    finishConstruction(): Promise<void>;
+    failConstruction(): Promise<void>;
+    toJSON(): {
+        rootComponentRuntimeId: number;
+        rootElementId: number;
+    };
+}

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

@@ -0,0 +1,122 @@
+import type { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type { PreviewComponent, PreviewLineComponent, RoomleComponentFactory } from '../../../common-core/src/webgl/roomle-component-factory';
+import type { ConfiguratorKernelCallbackI } from '../configurator-kernel-access';
+import type { KernelComponent, KernelEnum, KernelMeshAttributes, KernelMeshBuffer, KernelParameter, KernelVector3, PlanObject } from '../../../typings/kernel';
+import type { ConfigurationString } from '../../../typings/rapi-types';
+import type { Context } from '../di/context';
+import type ConfiguratorContext from '../webgl/configurator-context';
+import type { PromiseQueue } from '../utils/promise-queue';
+import type InitData from '../utils/init-data';
+import type MeshGenerator from '../webgl/mesh-generator';
+import type PlannerKernelAccess from '../../../planner-core/src/services/planner-kernel-access';
+import { Box3, Mesh } from 'three';
+export interface ConfiguratorViewModelCallbackI {
+    componentUpdated(component: RoomleComponent, kernelComponent: KernelComponent): void;
+    componentDeleted(component: RoomleComponent): void;
+    planObjectUpdated(planObject: PlanObject, geometryChanged: boolean, pendingDocking: boolean): void;
+    planObjectConstructionDone(planObject: PlanObject): void;
+    previewConstructionDone(component: RoomleComponent, hasPreviews: boolean): void;
+    configurationLoaded(component: RoomleComponent, isFreeFlying: boolean): void;
+    clearScene(): void;
+    display(component: RoomleComponent): void;
+    addComponentHandlers(component: RoomleComponent): void;
+    addPreviewLineHandlers(previewLineComponent: PreviewLineComponent): void;
+    addPreviewHandlers(previewComponent: PreviewComponent): void;
+}
+export default class ConfiguratorViewModel implements ConfiguratorKernelCallbackI, Context {
+    _creator_: string;
+    private _configuratorMeshGenerator;
+    protected _configuratorContext: ConfiguratorContext;
+    private _cacheHolder;
+    protected _initData: InitData;
+    private _listener;
+    private _mergeThreshold;
+    private _componentsToMerge;
+    private _mergeInProgress;
+    private _geometriesMerged;
+    private _subPartObject;
+    private _subPartGuard;
+    protected _components: Map<number, RoomleComponent>;
+    private _previews;
+    protected _componentNumberOfPossibleChildren: Map<number, number>;
+    protected _componentFactory: RoomleComponentFactory;
+    private _requestRenderCallback;
+    private _requestRenderSceneUpdateCallback;
+    private _invalidateRenderCallback;
+    constructor(creator: string);
+    get materialQueue(): PromiseQueue<void>;
+    protected _getKernelAccess(): PlannerKernelAccess;
+    private _applyMeshTransform;
+    private _applyMeshUVTransform;
+    private _addMeshAnimations;
+    private _setComponentAnimationMatrix;
+    private _animateComponent;
+    updateAnimationParameters(elementId: number | number[], parameters: KernelParameter[]): void;
+    changeAnimationValue(elementId: number, parameterKey: string, value: string, applyToChildren: boolean, animate: boolean): void;
+    _changeAnimationValue(component: RoomleComponent, parameterKey: string, value: string, animate: boolean): void;
+    private getComponentFromElementId;
+    private _addMeshToSubPart;
+    private _addMeshToComponent;
+    private _changeMeshOfComponent;
+    private _removeMeshFromComponent;
+    getComponent(componentId: number): RoomleComponent;
+    getNumberOfPossibleChildrenForComponent(componentId: number): number;
+    tryToMergeComponents(): void;
+    private _requestMergeComponents;
+    private _mergeNextComponent;
+    private _mergeComponent;
+    protected _addComponent(component: RoomleComponent): void;
+    removeDockingComponent(): void;
+    protected dockComponent(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    dockComponentWithPosition(previewComponent: PreviewLineComponent, component?: RoomleComponent): void;
+    removePreviews(): void;
+    private _updatePlanObject;
+    Editor3dAddDockPreview(componentId: number, previewId: number): void;
+    Editor3dAddMesh(runtimeComponentId: number, meshId: number, geometryName: string, environmentGeometry: boolean, meshAttributes: KernelMeshAttributes, meshBuffer: KernelMeshBuffer): void;
+    Editor3ChangedMesh(runtimeComponentId: number, meshId: number, geometryName: string, meshAttributes: KernelMeshAttributes): void;
+    Editor3dRemoveMesh(runtimeComponentId: number, meshId: number): void;
+    Editor3dBeginConstruction(componentId: number, isDeltaUpdate: boolean): void;
+    Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentObjectRuntimeId: number): void;
+    Editor3dComponentDocked(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    Editor3dEndConstruction(id: number): void;
+    Editor3dGeometryReady(id: number): void;
+    Editor3dGeometryNotReady(id: number): void;
+    Editor3dPlanObjectConstructionDone(planObjectId: number): void;
+    Editor3dPreviewConstructionDone(componentId: number, _objectId: number): void;
+    Editor3dSetPreviewLineAssociations(dockLines: any, previewId: number): void;
+    Editor3dSetPreviewPointAssociations(dockPairs: any, previewId: number): void;
+    componentDeleted(componentId: number): void;
+    componentMetaUpdated(kernelComponent: KernelComponent): void;
+    componentConfigurationUpdated(runtimeComponentId: number, geometryChanged: boolean): void;
+    private _getRuntimeComponent;
+    configurationLoaded(conversationId: number, objectId: number, componentId: number, _hash: string, _errors: any): void;
+    finishParameterChange(resolve: () => void, _reject: () => void): void;
+    planObjectConfigurationUpdated(planObjectId: number, _configuration: ConfigurationString, _hash: string, pendingDocking: boolean): void;
+    planObjectCreated(conversationId: number, planObjectId: number): void;
+    planObjectUpdated(planObject: PlanObject, pendingDocking: boolean): void;
+    sceneCleared(): void;
+    setListener(listener: ConfiguratorViewModelCallbackI): void;
+    getBoundingBox(): Box3;
+    getBoundingBoxOfGeometry(): Box3;
+    getBoundingBoxWithPreviews(): Box3;
+    hasPreviews(): boolean;
+    clearRootComponent(): void;
+    debugSceneGraph(id?: number): void;
+    getComponentsForIds(ids: number[]): RoomleComponent[];
+    getComponents(): RoomleComponent[];
+    getPreviews(): PreviewComponent[];
+    hasPreviewLines(): boolean;
+    isPreviewLine(obj: RoomleComponent): boolean;
+    isPreview(obj: RoomleComponent): boolean;
+    setGeometriesMergedListener(fun: () => void): void;
+    removeGeometriesMergedListener(): void;
+    setMergeThreshold(threshold: number): void;
+    protected _generateMesh(runtimeComponentId: number, geometryId: string, materialId: string, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, _type?: KernelEnum, _newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
+    protected _setMaterial(mesh: Mesh, material: any, _type?: KernelEnum): void;
+    constructComponents(planObjectId: number): void;
+    requestSubPartConstruction(partId: number): Promise<Mesh>;
+    protected getMeshGenerator(): MeshGenerator;
+    setRequestRenderCallback(requestRenderCallback: () => void): void;
+    setRequestRenderSceneUpdateCallback(requestRenderSceneUpdateCallback: () => void): void;
+    setInvalidateRenderCallback(invalidateRenderCallback: () => void): void;
+}

package/lib/definitions/packages/common-core/src/view-model/helpers/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DOCKING_CONVERSATION_ID = 10;
+export declare const DEFAULT_CONVERSATION_ID = 9;

package/lib/definitions/packages/common-core/src/view-model/kernel-view-model.d.ts

@@ -0,0 +1,7 @@
+import type { KernelObject } from '../../../typings/planner';
+export default class KernelViewModel {
+    protected _coreReference: KernelObject;
+    constructor(reference: KernelObject);
+    clearReference(): void;
+    getKernelObject(): KernelObject;
+}

package/lib/definitions/packages/common-core/src/view-model/plan-element-view-model.d.ts

@@ -0,0 +1,46 @@
+import KernelViewModel from './kernel-view-model';
+import type { PlanObject } from '../../../typings/planner';
+import { type RoomleEventedObject3D } from '../utils/threejs-utils';
+import { type RoomleEventedMesh } from '../utils/threejs-utils';
+import { Box3, Mesh, Object3D, Vector3 } from 'three';
+export declare const WALL_SELECTION_COLOR = 10526880;
+export default class PlanElementViewModel extends KernelViewModel {
+    protected _container: Object3D;
+    protected _boundingBox: RoomleEventedMesh;
+    private _object;
+    private _selectionMesh;
+    protected _isSelected: boolean;
+    private _objectWaiter;
+    protected _topView: boolean;
+    isActivatedDuringDragIn: boolean;
+    constructor(planObject: PlanObject);
+    getSize(): Vector3;
+    update(): void;
+    protected _updateBoundingBox(): void;
+    getPosition(): Vector3;
+    getRotation(): number;
+    getBounds(): Box3;
+    getBoundingBox(): RoomleEventedMesh;
+    getPlanElement(): PlanObject;
+    setObject(object: RoomleEventedObject3D): void;
+    getObject(): RoomleEventedObject3D;
+    getObjectAsync(): Promise<Object3D<import("three").Object3DEventMap>>;
+    addMesh(mesh: Object3D): void;
+    getMesh(material: any): Mesh;
+    getContainer(): Object3D;
+    getId(): number;
+    clear(): void;
+    remove(): void;
+    hidePreviewBox(): void;
+    protected _generateBoundingBox(): RoomleEventedMesh;
+    protected _setPositionOfBoundingBox(size: Vector3, mesh: RoomleEventedMesh): void;
+    select(): void;
+    deselect(): void;
+    hoverOn(): void;
+    hoverOff(): void;
+    setTopView(enabled: boolean): void;
+    toJSON(): {
+        rootElementId: number;
+    };
+    getName(): string;
+}

package/lib/definitions/packages/common-core/src/view-model/plan-object-view-model.d.ts

@@ -0,0 +1,33 @@
+import type { DimensionDefinition } from '../../../planner-core/src/utils/measurements';
+import type { Nullable } from '../../../typings/helper';
+import type { PlanObject } from '../../../typings/planner';
+import type { Position2, Position3 } from '../common-interfaces';
+import PlanElementViewModel from './plan-element-view-model';
+import { Vector3 } from 'three';
+export type ObjectWallDimension = DimensionDefinition<Vector3, Vector3>;
+export type ObjectToWallDimensionTransferable = DimensionDefinition<Position2, Position3>;
+interface ObjectMeasurements {
+    rectMeasurements: ObjectWallDimension[];
+    objectMeasurements: ObjectWallDimension[];
+    objectToWallsMeasurements: ObjectWallDimension[];
+}
+export interface ObjectMeasurementsTransferable {
+    rectMeasurements: ObjectToWallDimensionTransferable[];
+    objectMeasurements: ObjectToWallDimensionTransferable[];
+    objectToWallsMeasurements: ObjectToWallDimensionTransferable[];
+}
+export declare const objectToWallDimensionToTransferable: (objectWallDimension: ObjectWallDimension) => ObjectToWallDimensionTransferable;
+export default class PlanObjectViewModel extends PlanElementViewModel {
+    private _initDone;
+    private _initFailed;
+    private _initWaiter;
+    constructor(planObject: PlanObject);
+    protected finishInit(): Promise<void>;
+    protected failInit(error: Error): Promise<void>;
+    isInitDone(): Promise<void>;
+    getPlanObject(): PlanObject;
+    getSize(): Vector3;
+    getObjectMeasurements(zoomFactor: number, clientWidth: number, clientHeight: number): Nullable<ObjectMeasurements>;
+    update(): void;
+}
+export {};

package/lib/definitions/packages/common-core/src/wasm-loader.d.ts

@@ -0,0 +1 @@
+export declare const loadWebAssemblyFromFile: (wasmUrl: string, importObject: any, receiveInstanceCallback: (instance: any) => void) => void;

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

@@ -0,0 +1,18 @@
+export declare class EnvMapReader {
+    private _cubeTextures;
+    private _lightDirection;
+    private _size;
+    private _maxLod;
+    private _colorSpace;
+    private _type;
+    private _format;
+    private _cubeTexture;
+    private _path;
+    constructor();
+    setPath(path: string): void;
+    load(fileName: string): Promise<unknown>;
+    private parseHeader_;
+    private parseBufferData_;
+    private convertToRGBABuffer;
+    private parseData_;
+}

package/lib/definitions/packages/common-core/src/webgl/baked-shadow-plane.d.ts

@@ -0,0 +1,14 @@
+import { Mesh, Object3D } from 'three';
+export default class BakedShadowPlane {
+    private _innerPlaneMesh;
+    private _outerPlaneMesh;
+    private _plane;
+    private _innerSize;
+    private _outerSize;
+    constructor(size: number);
+    getRootNode(): Object3D<import("three").Object3DEventMap>;
+    getInnerPlane(): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>;
+    getOuterPlane(): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>;
+    updateSize(innerSize: number): void;
+    private _updatePlane;
+}

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

@@ -0,0 +1,19 @@
+import { SELECTION_MODE } from '../../../configurator-core/src/utils/selection-handler';
+import type { UiPossibleChild } from '../../../typings/kernel';
+import type { RapiId } from '../../../typings/rapi-types';
+import type { BASE_CONTEXT } from '../main';
+export default class ConfiguratorContext {
+    planObjectId: number;
+    planElementId: number;
+    rootComponentId: number;
+    dockingRootComponentId: number;
+    baseContext: BASE_CONTEXT;
+    lastPossibleChild: UiPossibleChild;
+    rootComponentParametersAsGlobal: boolean;
+    requestPreviewsIsUserInitiated: boolean;
+    lastLoadedRapiId: RapiId;
+    lastLoadedPlanId: RapiId;
+    selectedRuntimeComponentIds: number[];
+    selectionMode: SELECTION_MODE;
+    get selectedRuntimeComponentId(): number;
+}

package/lib/definitions/packages/common-core/src/webgl/hdr-env-map-reader.d.ts

@@ -0,0 +1,18 @@
+export declare class HdrEnvMapReader {
+    private _cubeTextures;
+    private _lightDirection;
+    private _size;
+    private _maxLod;
+    private _colorSpace;
+    private _type;
+    private _format;
+    private _cubeTexture;
+    private _path;
+    constructor();
+    setPath(path: string): void;
+    load(fileName: string): Promise<unknown>;
+    private parseHeader_;
+    private parseBufferData_;
+    private convertToRGBABuffer;
+    private parseData_;
+}

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

@@ -0,0 +1,36 @@
+import type { Base64Image } from '../common-interfaces';
+import { type Box3, type Camera, type PerspectiveCamera, type Scene } from 'three';
+import { Vector3 } from 'three';
+import type GlobalInitData from '../utils/global-init-data';
+declare const DEFAULT_RENDER_OPTIONS: {
+    /**
+     * if true we use the current camera perspective
+     */
+    useCurrentPerspective: boolean;
+};
+export type RenderOptions = Partial<typeof DEFAULT_RENDER_OPTIONS>;
+export interface PrepareImageOptions {
+    size?: number;
+    showDimensions?: boolean;
+}
+export interface CameraTarget {
+    center: Vector3;
+    bounds: Vector3;
+    diagonal: number;
+}
+export default class ImageRenderer {
+    private _roomleRenderer;
+    private _imageRenderer;
+    protected _globalInitData: GlobalInitData;
+    private _getRenderer;
+    switchToPlannerSettings(): void;
+    switchToConfiguratorSettings(): void;
+    updateBounds(bounds: Box3): void;
+    static getCameraTargetForBBox(bbox: Box3, spacing?: number): CameraTarget;
+    preparePerspectiveImage(scene: Scene, uiScene: Scene, camera: PerspectiveCamera, cameraTarget: CameraTarget, options?: PrepareImageOptions, objectRotation?: number, onBeforeRender?: (camera: Camera) => void): Promise<Base64Image>;
+    renderPerspectiveImage(scene: Scene, camera: PerspectiveCamera, cameraTarget: CameraTarget, size?: number): Promise<Base64Image>;
+    static placeCameraForPerspectiveImage(camera: PerspectiveCamera, cameraTarget: CameraTarget, angleX: number, angleY: number): void;
+    prepareTopImage(scene: Scene, uiScene: Scene, cameraTarget: CameraTarget, options?: PrepareImageOptions): Promise<Base64Image>;
+    private _render;
+}
+export {};

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

@@ -0,0 +1,14 @@
+export declare const enum LAYER {
+    DEFAULT = 0,
+    LIGHTING = 1,
+    BACKGROUND = 2,
+    OBJECT = 3,
+    COMPONENT = 4,
+    PREVIEW = 5,
+    UI = 6,
+    GIZMO = 7,
+    DIMENSIONS = 8,
+    CONSTRUCTION = 9
+}
+declare const _default: {};
+export default _default;

package/lib/definitions/packages/common-core/src/webgl/mesh-generator.d.ts

@@ -0,0 +1,49 @@
+import type RapiAccess from '../../../common-core/src/rapi-access';
+import type DataSyncer from '../../../common-core/src/services/data-syncer';
+import type SinglePromiseFactory from '../utils/single-promise-factory';
+import type { RapiMaterial } from '../../../typings/rapi-types';
+import type CacheHolder from '../services/cache-holder';
+import type { Context } from '../di/context';
+import { PromiseQueue } from '../utils/promise-queue';
+import type { Material } from 'three';
+import { BufferGeometry, Mesh, MeshPhysicalMaterial, MeshStandardMaterial, TextureLoader } from 'three';
+export default class MeshGenerator implements Context {
+    _creator_: string;
+    materialQueue: PromiseQueue<void>;
+    protected _geometryComponentMaterialCache: Map<string, string>;
+    private _initData;
+    protected _rapiAccess: RapiAccess;
+    protected _dataSyncer: DataSyncer;
+    protected _singlePromiseFactory: SinglePromiseFactory;
+    protected _cacheHolder: CacheHolder;
+    private _plannerMeshGenerator;
+    protected _materialLoaded: (material: Material) => void;
+    protected _maxAnisotropy: number;
+    protected _maxTextures: number;
+    protected _textureLoader: TextureLoader;
+    protected _previewMaterial: MeshStandardMaterial;
+    protected _configuratorPreviewMaterial: MeshStandardMaterial;
+    constructor(creator: string);
+    getGeometry(meshId: string): BufferGeometry;
+    protected _generateGeometry(meshId: string, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): BufferGeometry;
+    changeMaterialOfMesh(mesh: Mesh, material: Material, materialAttributes?: Record<string, string>): void;
+    private _updateMaterialProperties;
+    private _updateStandardMaterialProperties;
+    private _updatePhysicalMaterialProperties;
+    protected _createMaterial(materialId: string, resolve: () => void, reject: (error: Error) => void, width?: number, height?: number): void;
+    private _loadBenchmarkTextures;
+    protected _loadTextures(rapiMaterial: RapiMaterial, material: MeshPhysicalMaterial, width?: number, height?: number): Promise<void>;
+    protected _loadMaterial(materialId: string, width?: number, height?: number): Promise<Material>;
+    protected _assignMaterial(mesh: Mesh, materialId: string, materialAttributes?: Record<string, string>): Promise<void>;
+    get maxAnisotropy(): number;
+    set maxAnisotropy(maxAnisotropy: number);
+    get maxTextures(): number;
+    set maxTextures(maxTextures: number);
+    clear(): void;
+    protected _assignRGB(mesh: Mesh, rgbValue: number): Promise<void>;
+    protected _assignItem(mesh: Mesh, catalogItemId: string): Promise<void>;
+    setMaterialLoadedListener(fun: () => void): void;
+    removeMaterialLoadedListener(): void;
+    protected _createMesh(runtimeComponentId: number, geometryId: string, geometry: BufferGeometry): Mesh<BufferGeometry<import("three").NormalBufferAttributes>, Material, import("three").Object3DEventMap>;
+    protected _getComponentMeshId(runtimeComponentId: number, geometryId: string): string;
+}