@roomle/web-sdk 2.60.0-alpha.2 → 2.60.0-alpha.3

package/lib/definitions/common-core/src/webgl/renderer/shadow-and-ao-pass.d.ts

@@ -0,0 +1,123 @@
+import { GBufferRenderTargets, GBufferTextures } from './gbuffer-render-target';
+import { DenoisePass, RenderPass, SceneVolume } from './render-utility';
+import { HBAOEffect, HBAOEffectParameters, PoisonDenoiseParameters, PoissonDenoiseEffect, SSAOEffect, SSAOEffectParameters } from './effect-pass';
+import { Camera, Matrix4, Scene, ShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare enum ShadowBlurType {
+    OFF = 0,
+    HARD = 1,
+    POISSON = 2,
+    FULL = 3
+}
+export declare enum AmbientOcclusionType {
+    NONE = 0,
+    SSAO = 1,
+    EffectsSSAO = 2,
+    EffectsHBAO = 3
+}
+export interface ShadowAndAoParameters {
+    [key: string]: any;
+    aoKernelRadius: number;
+    aoDepthBias: number;
+    aoMaxDistance: number;
+    aoMaxDepth: number;
+    aoFadeout: number;
+    shadowRadius: number;
+}
+export interface ShadowAndAoPassParameters {
+    enabled: boolean;
+    aoType: AmbientOcclusionType;
+    aoIntensity: number;
+    shadowIntensity: number;
+    aoOnGround: boolean;
+    alwaysUpdate: boolean;
+    shAndAo: ShadowAndAoParameters;
+    ssao: SSAOEffectParameters;
+    hbao: HBAOEffectParameters;
+    poissonDenoise: PoisonDenoiseParameters;
+}
+export declare const defaultShadowAndAoParameters: ShadowAndAoParameters;
+export declare const defaultPassParameters: {
+    enabled: boolean;
+    aoType: AmbientOcclusionType;
+    aoIntensity: number;
+    aoOnGround: boolean;
+    shadowIntensity: number;
+    alwaysUpdate: boolean;
+};
+export declare class ShadowAndAoPass {
+    static shadowTransform: Matrix4;
+    parameters: ShadowAndAoPassParameters;
+    needsUpdate: boolean;
+    private width;
+    private height;
+    private samples;
+    protected renderPass: RenderPass;
+    private _sharedGBufferRenderTarget?;
+    private _gBufferRenderTarget?;
+    shadowAndAoRenderTargets: ShadowAndAoRenderTargets;
+    private _ssaoEffect?;
+    private _hbaoEffect?;
+    private _fadeRenderTarget?;
+    poissonDenoiseEffect?: PoissonDenoiseEffect;
+    private _copyMaterial;
+    private _blendMaterial;
+    private _renderOverrideVisibility;
+    private cameraUpdate;
+    get gBufferRenderTarget(): GBufferRenderTargets;
+    get SSAOEffect(): SSAOEffect;
+    get HBAOEffect(): HBAOEffect;
+    get fadeRenderTarget(): WebGLRenderTarget;
+    get denoisePass(): DenoisePass;
+    get denoiseRenderTargetTexture(): Texture | null;
+    constructor(width: number, height: number, samples: number, parameters?: any);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: any): void;
+    private updatePassParameters;
+    updateBounds(sceneBounds: SceneVolume, shadowAndAoScale: number): void;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera, shadowMapTexture: Texture, shadowBlurType?: ShadowBlurType, shadowFadeInBlurType?: ShadowBlurType, shadowFadeInMix?: number): void;
+    private setRenderState;
+    private evaluateIfUpdateIsNeeded;
+    private renderShadowAndAo;
+    private renderAoEffect;
+    protected renderDynamicShadow(renderer: WebGLRenderer, passTexture: Texture | null, shadowMapTexture: Texture | null, shadowFadeInMix?: number): Texture;
+    private renderDenoise;
+    protected renderToTarget(renderer: WebGLRenderer, finalTexture: Texture | null, onlyHardShadow: boolean): void;
+}
+export declare class ShadowAndAoRenderTargets {
+    shadowAndAoParameters: ShadowAndAoParameters;
+    parametersNeedsUpdate: boolean;
+    aoEnabled: boolean;
+    shadowEnabled: boolean;
+    private width;
+    private height;
+    private samples;
+    private shadowAndAoScale;
+    private aoTargetSamples;
+    private depthAndNormalTextures;
+    private _noiseTexture?;
+    private _sampleKernel;
+    private _passRenderMaterial?;
+    private _passRenderTarget?;
+    private renderPass;
+    get passRenderTarget(): WebGLRenderTarget;
+    private get passRenderMaterial();
+    private get noiseTexture();
+    private get sampleKernel();
+    constructor(depthAndNormalTextures: GBufferTextures, parameters?: any);
+    private getShadowAndAoParameters;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateBounds(sceneBounds: SceneVolume, shadowAndAoScale: number): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+    updateSSAOMaterial(camera: Camera): ShaderMaterial;
+    updateShadowTexture(shadowTexture: Texture): void;
+}
+export declare class ShadowAndAoRenderMaterial extends ShaderMaterial {
+    static kernelSize: number;
+    private static shader;
+    constructor(parameters?: any);
+    update(parameters?: any): ShadowAndAoRenderMaterial;
+    updateDependencies(parameters?: any): void;
+    updateSettings(parameters?: any): void;
+}

package/lib/definitions/common-core/src/webgl/roomle-component-factory.d.ts

@@ -1,23 +1,24 @@
 import { CanvasOffset } from '../common-interfaces';
 import { KernelCube, KernelVector3 } from '../../../typings/kernel';
+import { Box3, Euler, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
 export declare const PULSE_DURATION = 1500;
 export declare const PULSE_LOOPS = 5;
-export interface RoomleComponent extends THREE.Object3D {
+export interface RoomleComponent extends Object3D {
     runtimeId: number;
     parentObjectId: number;
-    meshes: THREE.Mesh[];
-    boundingBox: THREE.Box3;
-    boundingBoxMesh: THREE.Mesh;
-    loadingMesh: THREE.Mesh;
+    meshes: Mesh[];
+    boundingBox: Box3;
+    boundingBoxMesh: Mesh;
+    loadingMesh: Mesh;
     roomlePosition: KernelVector3;
     roomleRotation: KernelVector3;
     hash: string;
     geometryChanged: boolean;
-    replaceMeshes(meshes: THREE.Mesh[]): void;
-    addMesh(mesh: THREE.Mesh, transform?: Float32Array): void;
-    removeMesh(mesh: THREE.Mesh): void;
+    replaceMeshes(meshes: Mesh[]): void;
+    addMesh(mesh: Mesh, transform?: Float32Array): void;
+    removeMesh(mesh: Mesh): void;
     removeMeshById(meshId: string): void;
-    getMeshById(meshId: string): THREE.Mesh;
+    getMeshById(meshId: string): Mesh;
     removeAllMeshes(): void;
     select(): void;
     deselect(): void;
@@ -26,8 +27,8 @@ export interface RoomleComponent extends THREE.Object3D {
     loading(): void;
     loadingFinished(): void;
     computeBoundingBox(boxForMeasurements?: KernelCube, useMeshes?: boolean): void;
-    removeFromParent(): void;
-    recursiveMeshes(): THREE.Mesh[];
+    removeFromParent(): this;
+    recursiveMeshes(): Mesh[];
     isChild(componentId: number): boolean;
     getKernelPosition(newParent: RoomleComponent): KernelVector3;
 }
@@ -46,28 +47,29 @@ export interface PreviewComponent extends RoomleComponent {
     startPulsating(): void;
 }
 export interface PreviewLineComponent extends PreviewComponent {
-    lineFrom: THREE.Vector3;
-    lineTo: THREE.Vector3;
-    positionFrom: THREE.Vector3;
-    positionTo: THREE.Vector3;
+    lineFrom: Vector3;
+    lineTo: Vector3;
+    positionFrom: Vector3;
+    positionTo: Vector3;
     roomleLineFrom: KernelVector3;
     roomleLineTo: KernelVector3;
     roomlePositionFrom: KernelVector3;
     roomlePositionTo: KernelVector3;
-    docklineRotation: THREE.Euler;
-    lineMesh: THREE.Mesh;
-    boundingLineMesh: THREE.Mesh;
+    docklineRotation: Euler;
+    lineMesh: Mesh;
+    boundingLineMesh: Mesh;
     clonePreviewLine(numberOfDuplication: number): PreviewLineComponent;
-    getPositionForIntersectionPoint(intersectionPoint: THREE.Vector3): THREE.Vector3;
-    updatePreviewPosition(intersectionPoint: THREE.Vector3): void;
+    getPositionForIntersectionPoint(intersectionPoint: Vector3): Vector3;
+    updatePreviewPosition(intersectionPoint: Vector3): void;
     hideSelectionLine(): void;
 }
 export interface OffsetCamera {
     offset: CanvasOffset;
+    resetOffset(): void;
 }
-export interface OrthographicOffsetCamera extends THREE.OrthographicCamera, OffsetCamera {
+export interface OrthographicOffsetCamera extends OrthographicCamera, OffsetCamera {
 }
-export interface PerspectiveOffsetCamera extends THREE.PerspectiveCamera, OffsetCamera {
+export interface PerspectiveOffsetCamera extends PerspectiveCamera, OffsetCamera {
 }
 export interface RoomleComponentFactory {
     create(id: number, position: KernelVector3, eulerAngles: KernelVector3, parentObjectId: number): RoomleComponent;

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

@@ -0,0 +1,42 @@
+import { BakedGroundContactShadowParameters, OutlineParameters, ShadowAndAoParameters } from './renderer/scene-renderer';
+import { Box3, Camera, Object3D, Scene, Texture, WebGLRenderer } from 'three';
+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 _fpsCounter;
+    get renderer(): WebGLRenderer;
+    get shadowAndAoParameters(): ShadowAndAoParameters;
+    get bakedGroundContactShadowParameters(): BakedGroundContactShadowParameters;
+    get outlineParameters(): OutlineParameters;
+    constructor(renderer: WebGLRenderer, width: number, height: number);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    setAutoQuality(autoQuality: boolean): void;
+    private loadRectAreLight;
+    private updateRectAreaLight;
+    enableContactShadow(): void;
+    disableContactShadow(): void;
+    enableShadowAndAo(): void;
+    disableShadowAndAo(): void;
+    forceShadowUpdates(updateBakedGroundShadow: boolean): void;
+    switchToConfigurator(): void;
+    switchToPlanner(renderMode: RenderMode): void;
+    updateBounds(bounds: Box3): void;
+    updateEnvironment(bounds?: Box3, _force?: boolean): void;
+    movingCameraStarts(): void;
+    movingCameraStops(): void;
+    highlightObjects(selectedMeshes: Object3D[]): void;
+    render(scene: Scene, camera: Camera): void;
+    private createRenderCamera;
+    showGUI(updateCallback: () => void): void;
+    createShadowFromEnvironmentMap(parent: Object3D, equirectangularTexture: Texture, textureData?: any): void;
+}

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

@@ -2,13 +2,14 @@ import EventDispatcher from '../../../configurator-core/src/utils/event-dispatch
 import RaycastHelper from '../../../configurator-core/src/utils/raycast-helper';
 import { Context } from '../di/context';
 import InputManager from '../input/input-manager';
+import { 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: THREE.Scene, camera: THREE.Camera, inputManager: InputManager);
+    constructor(creator: string, scene: Scene, camera: Camera, inputManager: InputManager);
     protected abstract _interaction(): void;
     isDragIn(): boolean;
     setDragIn(dragIn: boolean, dragEvent?: DragEvent): void;

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

@@ -10,43 +10,40 @@ import { Context } from '../di/context';
 import { LifeCycleCallbacks } from '../life-cycle-manager';
 import { SceneSettings } from '../scene-settings-loader';
 import Environment from '../environment/environment';
-import { QualitySetting } from '../dynamic-quality-setting-loader';
-import { BakedShadowParams, Pixotron } from '../../../typings/pixotron';
-import EnvironmentLoader from '../services/environment-loader';
-import PixotronUtil from './pixotron-util';
 import { DynamicLightSettingSource } from '../lightsetting/dynamic-light-setting-loader';
 import InitData from '../utils/init-data';
 import { OrthographicOffsetCamera, PerspectiveOffsetCamera } from './roomle-component-factory';
 import PluginSystem from '../../../configurator-core/src/webgl/plugin-system';
 import { Enumify } from '../types';
+import { Box3, Object3D, Scene, Vector3, WebGLRenderer } from 'three';
+import { RoomleWebGLRenderer } from './roomle-webl-renderer';
+import HdrEnvironmentLoader from '../services/hdr-environment-loader';
+import ImageRenderer from './image-renderer';
 export default abstract class SceneManager implements Context, LifeCycleCallbacks, EventListenerObject {
     _creator_: string;
     protected _domHelper: DomHelper;
     protected _scriptLoader: ScriptLoader;
     private _lifeCycleManager;
     private _staticItemLoader;
-    protected _environmentLoader: EnvironmentLoader;
+    protected _hdrEnvironmentLoader: HdrEnvironmentLoader;
     protected _initData: InitData;
     protected _pluginSystem: PluginSystem;
-    protected _scene: THREE.Scene;
-    protected _uiScene: THREE.Scene;
+    protected _imageRenderer: ImageRenderer;
+    protected _scene: Scene;
+    protected _uiScene: Scene;
     private _depthWriteMaterial;
     protected _cameraControl: CameraControl;
     protected _lightSetting: LightSetting;
     protected _environment: Environment;
     protected _maxAnisotropy: number;
-    protected _renderer: THREE.WebGLRenderer;
-    protected _renderTarget: THREE.WebGLRenderTarget | THREE.WebGLMultisampleRenderTarget;
+    protected _renderer: WebGLRenderer;
     private _clock;
     private _delta;
     protected _renderLoopFunction: () => void;
     protected _renderListener: () => void;
     protected _stopRendering: boolean;
-    protected _pixotron: Pixotron;
-    protected _pixotronUtil: PixotronUtil;
+    protected _roomleRenderer: RoomleWebGLRenderer;
     private _forceRender;
-    private _updateShadowsAndAO;
-    private _shadowsAndAoUpdated;
     private _lastChange;
     private _running;
     private _statsHelper;
@@ -56,9 +53,7 @@ export default abstract class SceneManager implements Context, LifeCycleCallback
     protected abstract createCameraControl(mode: Enumify<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
     protected abstract _getInputManager(): InputManager;
     abstract sceneChanged(): void;
-    abstract getPixotronParams(): any;
-    abstract getBounds(): THREE.Box3;
-    abstract getBakedShadowParams(): BakedShadowParams;
+    abstract getBounds(): Box3;
     protected onBeforeRender(): void;
     protected _onAfterRender: () => void;
     protected constructor(creator: string, offset: CanvasOffset, canvasID: string, mode?: Enumify<typeof CAMERA_TYPE>);
@@ -81,19 +76,19 @@ export default abstract class SceneManager implements Context, LifeCycleCallback
     private _animateCamera;
     protected shouldClearShadowsAndAO(): boolean;
     protected _setupScene(offset?: CanvasOffset, transparent?: boolean): void;
+    loadEnvMap(url: string): Promise<void>;
+    private _setEnvMap;
     private _tabVisible;
     updateCamera(_changeCamera?: boolean): void;
     private _onWindowResize;
-    protected _isPartOfScene(object: THREE.Object3D): boolean;
+    protected _isPartOfScene(object: Object3D): boolean;
     cleanUp(): void;
     clearScene(): void;
     enableHD(source?: DynamicLightSettingSource): void;
-    private _enableAutoQuality;
-    private _enableSSR;
-    protected _loadGLTF(gltfJSON: string, position?: THREE.Vector3, rotation?: number, size?: THREE.Vector3, scale?: THREE.Vector3, color?: number, callback?: (percent: number) => void): Promise<THREE.Object3D>;
-    protected _loadGLB(url: string, position?: THREE.Vector3, rotation?: number, size?: THREE.Vector3, scale?: THREE.Vector3, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<THREE.Object3D>;
+    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>;
     private _setCamera;
-    showGUI(): Promise<void>;
+    showGUI(): void;
     protected _guiLoaded(): void;
     protected _addGUIListener(gui: GUI): void;
     protected _guiParamChanged(): void;
@@ -107,21 +102,20 @@ export default abstract class SceneManager implements Context, LifeCycleCallback
     loadSceneSettings(sceneSetting: SceneSettings): Promise<void>;
     setBackgroundColor(hex: string): void;
     setBackgroundImage(url: string): void;
-    setBakedShadow(hex: string, url: string): void;
     protected _setEnvironment(environment: Environment): void;
-    loadQualitySetting(qualitySetting: QualitySetting): void;
     loadDynamicLightSetting(source: DynamicLightSettingSource): Promise<void>;
-    getScene(): THREE.Scene;
+    getScene(): Scene;
     updateScene(): void;
-    protected _updateBounds(bounds: THREE.Box3, geometryChanged?: boolean): void;
+    protected _updateBounds(bounds: Box3, geometryChanged?: boolean): void;
     setCameraOffset(offset: CanvasOffset): void;
     getCameraOffset(): CanvasOffset;
     getOrthographicOffsetCamera(): OrthographicOffsetCamera;
     protected getPerspectiveOffsetCamera(): PerspectiveOffsetCamera;
-    protected updateEnvironment(bounds?: THREE.Box3, force?: boolean): void;
+    protected updateEnvironment(bounds?: Box3, force?: boolean): void;
     protected _onCameraIdle(): boolean;
     protected _onCameraMove(): boolean;
     exportImageFromCamera(filename: string): void;
+    changeEnvironmentMapIntensity(intensity: number): void;
     lockCamera(): void;
     unlockCamera(): void;
 }

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

@@ -1,21 +1,20 @@
 import { Context } from '../di/context';
+import { Box3, Object3D, Vector3 } from 'three';
 export declare const enum STATIC_ITEM_TYPE {
     GLB = "GLB",
     GLTF = "GLTF"
 }
 export interface GLTFScene {
-    scene: THREE.Object3D;
-    boundingBox: THREE.Box3;
+    scene: Object3D;
+    boundingBox: Box3;
 }
 export default abstract class StaticItemLoader implements Context {
-    private _environmentLoader;
-    private _scriptLoader;
     _creator_: string;
     private _gltfLoader;
     private _gltfLoaderGuard;
     constructor(creator: string);
     private _initLoaders;
-    loadGLB(url: string, position?: THREE.Vector3, rotation?: number, size?: THREE.Vector3, scaling?: THREE.Vector3, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<GLTFScene>;
-    loadGLTF(gltfJSON: string, position?: THREE.Vector3, rotation?: number, size?: THREE.Vector3, scale?: THREE.Vector3, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<GLTFScene>;
+    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/configurator-core/src/roomle-configurator.d.ts

@@ -1,7 +1,7 @@
 import { RAPI_PATHS } from '../../common-core/src/rapi-access';
 import UnitFormatter from './services/unit-formatter';
 import { Base64Image, CanvasOffset } from '../../common-core/src/common-interfaces';
-import { KernelParameter, KernelParameterGroup, KernelPartList, KernelPartListPrice, KernelPossibleChild, UiKernelParameter, UiPossibleChild } from '../../typings/kernel';
+import { ExportType, KernelParameter, KernelParameterGroup, KernelPartList, KernelPartListPrice, KernelPossibleChild, UiKernelParameter, UiPossibleChild } from '../../typings/kernel';
 import { DynamicLightSettingSource } from '../../common-core/src/lightsetting/dynamic-light-setting-loader';
 import Main, { ExternalEmbeddable, GlobalAPI, KernelUtilityForUi, RubensAPI } from '../../common-core/src/main';
 import { SceneSettings } from '../../common-core/src/scene-settings-loader';
@@ -15,6 +15,7 @@ import { CameraParameter } from '../../common-core/src/cameracontrol/camera-cont
 import { PrepareImageOptions, RenderOptions } from '../../common-core/src/webgl/image-renderer';
 import { GlobalCallback } from '../../common-core/src/services/global-callback';
 import RoomleToolsCore from '../../tools-core/src/roomle-tools-core';
+import { Scene } from 'three';
 interface ConfigurationLoadedResponse {
     partList: KernelPartList;
     errors: string[];
@@ -42,7 +43,6 @@ export default class RoomleConfigurator implements GlobalAPI, Context, KernelUti
     private _configuratorKernelAccessCallback;
     private _lifeCycleManager;
     private _plannerKernelAccess;
-    private _threeLoader;
     private _scriptLoader;
     private _configuratorContext;
     private _initData;
@@ -64,7 +64,7 @@ export default class RoomleConfigurator implements GlobalAPI, Context, KernelUti
     private _onInitDone;
     constructor(creator: string);
     initSceneManager(sceneManager?: ConfiguratorSceneManager): void;
-    getScene(): THREE.Scene;
+    getScene(): Scene;
     updateScene(): void;
     private _loadWebGlLib;
     private _loadingWebGlSuccess;
@@ -466,13 +466,6 @@ export default class RoomleConfigurator implements GlobalAPI, Context, KernelUti
      * @param url
      */
     setBackgroundImage(url: string): void;
-    /**
-     * Used for test puprose only
-     * @hidden
-     * @param hex color hex code, can be null
-     * @param url can be null
-     */
-    setBakedShadow(hex: string, url: string): void;
     /**
      * Loads a SceneSettings object, currently it can can contain a light setting definition
      * (see {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.loadDynamicLightSetting}) and an environment definition (see {@link @roomle/web-sdk/common-core/src/environment/dynamic-environment-setting-loader#EnvironmentSetting}).
@@ -550,7 +543,6 @@ export default class RoomleConfigurator implements GlobalAPI, Context, KernelUti
      */
     getCurrentConfigurationHash(): Promise<ConfigurationHash>;
     getCurrentSelection(): string[];
-    private _enableHD;
     isReady(): void;
     updatePossibleChildren(elementId: number, children: KernelPossibleChild[], parameterUpdateType?: PARAMETER_UPDATE_TYPE): Promise<void>;
     updateParameters(parameters: KernelParameter[], parameterGroups: KernelParameterGroup[], elementId: number | number[], parameterUpdateType: PARAMETER_UPDATE_TYPE): void;
@@ -660,5 +652,9 @@ export default class RoomleConfigurator implements GlobalAPI, Context, KernelUti
     getTools(): Promise<RoomleToolsCore>;
     exportImageFromCamera(filename?: string): void;
     calcPartsPriceSum(partList: KernelPartList): Promise<KernelPartListPrice>;
+    generateProductionServiceExport(defaultExportDefinition?: string): Promise<any>;
+    generateTCExport(defaultExportDefinition?: string): Promise<any>;
+    generateIMOSiXExport(defaultExportDefinition?: string): Promise<any>;
+    generateExport(exportType: ExportType, defaultExportDefinition?: string): Promise<any>;
 }
 export {};

package/lib/definitions/configurator-core/src/utils/async-dependency-loader.d.ts

@@ -1,4 +1,5 @@
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
 export default class AsyncDependencyLoader {
-    static loadFont(path: string): Promise<THREE.Font>;
+    static loadFont(path: string): Promise<Font>;
     private static _resolveAll;
 }

package/lib/definitions/configurator-core/src/utils/component-dimensioning-helper.d.ts

@@ -1,5 +1,6 @@
 import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
 import { Context } from '../../../common-core/src/di/context';
+import { PerspectiveCamera } from 'three';
 export default class ComponentDimensioningHelper implements Context {
     _creator_: string;
     private _plannerKernelAccess;
@@ -7,7 +8,7 @@ export default class ComponentDimensioningHelper implements Context {
     private _activeComponents;
     private _componentDimensioningsExist;
     constructor(creator: string);
-    setCamera(camera: THREE.PerspectiveCamera): void;
+    setCamera(camera: PerspectiveCamera): void;
     add(component: RoomleComponent): boolean;
     remove(component: RoomleComponent, remove?: boolean): Promise<void>;
     hasComponentDimensions(): boolean;

package/lib/definitions/configurator-core/src/utils/component-dimensioning.d.ts

@@ -1,6 +1,8 @@
 import { Dimensioning } from '../../../typings/kernel';
 import { Position2 } from '../../../common-core/src/common-interfaces';
-export default class ComponentDimensioning extends THREE.Object3D {
+import { Box3, Object3D } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+export default class ComponentDimensioning extends Object3D {
     private _cacheHolder;
     private _unitFormatter;
     private _dimensioning;
@@ -16,7 +18,7 @@ export default class ComponentDimensioning extends THREE.Object3D {
     private _planeMaterial;
     private _textMaterial;
     private _cameraPosition;
-    constructor(dimensioning: Dimensioning, boundingBox: THREE.Box3, font: THREE.Font, cameraPosition: Position2);
+    constructor(dimensioning: Dimensioning, boundingBox: Box3, font: Font, cameraPosition: Position2);
     private _initMaterials;
     private _init;
     private _getXEdge;

package/lib/definitions/configurator-core/src/utils/component-raycast-helper.d.ts

@@ -1,14 +1,15 @@
 import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
 import ConfiguratorSceneEventHandler from '../webgl/configurator-scene-event-handler';
 import ConfiguratorViewModel from '../../../common-core/src/view-model/configurator-view-model';
+import { Object3D, PerspectiveCamera, Scene } from 'three';
 export default class ComponentRaycastHelper {
     private _scene;
     private _camera;
     private _raycaster;
     private _nonTransparentComponent;
     constructor();
-    init(scene: THREE.Scene, camera: THREE.PerspectiveCamera): void;
-    changeMaterialsOnSelect(object: THREE.Object3D, component: RoomleComponent, selected?: boolean): void;
+    init(scene: Scene, camera: PerspectiveCamera): void;
+    changeMaterialsOnSelect(object: Object3D, component: RoomleComponent, selected?: boolean): void;
     private _changeMaterialsOnSelect;
     isComponentVisible(component: RoomleComponent): boolean;
     checkComponentAndPreviewVisibility(sceneEventHandler: ConfiguratorSceneEventHandler, configuratorViewModel: ConfiguratorViewModel): void;

package/lib/definitions/configurator-core/src/utils/dimensioning-helper.d.ts

@@ -1,4 +1,5 @@
 import { ScenePlugin } from '../webgl/plugin-system';
+import { Box3, Scene, Vector3 } from 'three';
 export default class DimensioningHelper implements ScenePlugin {
     _creator_: string;
     private _unitFormatter;
@@ -28,10 +29,10 @@ export default class DimensioningHelper implements ScenePlugin {
     private _updateWidth;
     private _updateHeight;
     private _updateDepth;
-    updateBounds(boxForMeasurements: THREE.Box3): void;
+    updateBounds(boxForMeasurements: Box3): void;
     update(force?: boolean): void;
-    addToScene(scene: THREE.Scene, uiScene: THREE.Scene): void;
-    removeFromScene(scene: THREE.Scene, uiScene: THREE.Scene): void;
+    addToScene(scene: Scene, uiScene: Scene): void;
+    removeFromScene(scene: Scene, uiScene: Scene): void;
     private _getWidthEdge;
     private _getDepthEdge;
     private _getHeightEdge;
@@ -42,13 +43,13 @@ export default class DimensioningHelper implements ScenePlugin {
     disableDimensions(): void;
     private _visibilityChangedCallback;
     _clear(): void;
-    getBoundingBox(): THREE.Box3;
+    getBoundingBox(): Box3;
     private setVisibility;
-    moveCameraStart(position: THREE.Vector3): void;
-    moveCameraEnd(position: THREE.Vector3): void;
-    clearScene(_scene: THREE.Scene): void;
-    setScene(scene: THREE.Scene): void;
-    setUiScene(uiScene: THREE.Scene): void;
+    moveCameraStart(position: Vector3): void;
+    moveCameraEnd(position: Vector3): void;
+    clearScene(_scene: Scene): void;
+    setScene(scene: Scene): void;
+    setUiScene(uiScene: Scene): void;
     needsUiScene(): boolean;
     isInitialized(): Promise<void>;
     areDimensionsEnabled(): boolean;

package/lib/definitions/configurator-core/src/utils/raycast-helper.d.ts

@@ -1,6 +1,7 @@
 import InputManager, { InputEvent } from '../../../common-core/src/input/input-manager';
 import { SceneEventInfo } from '../webgl/configurator-scene-event-handler';
 import EventDispatcher from './event-dispatcher';
+import { Camera, Layers, Mesh, Scene, Vector3 } from 'three';
 export declare const enum OBJECT_EVENT {
     CLICK = "select",
     DOUBLE_CLICK = "double_click",
@@ -36,9 +37,9 @@ export default class RaycastHelper extends EventDispatcher<SceneEventInfo> {
     private _planeFront;
     private _planeBottom;
     private _planeSide;
-    constructor(scene: THREE.Scene, camera: THREE.Camera, generalInput: InputManager, mode?: INTERSECTION_MODE);
-    setLayers(layers: THREE.Layers): void;
-    getLayers(): import("three").Layers;
+    constructor(scene: Scene, camera: Camera, generalInput: InputManager, mode?: INTERSECTION_MODE);
+    setLayers(layers: Layers): void;
+    getLayers(): Layers;
     private _addInputListeners;
     private _findCandidate;
     private _findSelection;
@@ -54,12 +55,12 @@ export default class RaycastHelper extends EventDispatcher<SceneEventInfo> {
     private _onRotate;
     private _positionPlanes;
     private _calculateOffset;
-    update(bounds: THREE.Vector3, rootComponentPosition: THREE.Vector3, backgroundScene: THREE.Scene): void;
+    update(bounds: Vector3, rootComponentPosition: Vector3, backgroundScene: Scene): void;
     clear(): void;
-    enableDragIn(mesh: THREE.Mesh): void;
+    enableDragIn(mesh: Mesh): void;
     setRootComponentId(rootComponentId: number): void;
-    setCamera(camera: THREE.Camera): void;
-    setScene(scene: THREE.Scene): void;
+    setCamera(camera: Camera): void;
+    setScene(scene: Scene): void;
     setMode(mode: INTERSECTION_MODE): void;
     intersectMouseOnScene(event: InputEvent): import("../../../typings/kernel").KernelVector3;
 }

package/lib/definitions/configurator-core/src/utils/text-with-background.d.ts

@@ -1,4 +1,6 @@
-export default class TextWithBackground extends THREE.Object3D {
+import { Object3D, Vector3 } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+export default class TextWithBackground extends Object3D {
     private _cacheHolder;
     private _position;
     private _dimensioningType;
@@ -11,10 +13,10 @@ export default class TextWithBackground extends THREE.Object3D {
     private _planeMaterial;
     private _textMaterial;
     private _cameraPosition;
-    constructor(font: THREE.Font);
+    constructor(font: Font);
     private _initMaterials;
     private _init;
-    update(position: THREE.Vector3, dimensioningType: number, label: string, cameraPosition: THREE.Vector3): void;
+    update(position: Vector3, dimensioningType: number, label: string, cameraPosition: Vector3): void;
     private _update;
     private _updateText;
     private _getXSign;