@roomle/web-sdk 2.60.0-alpha.4 → 2.60.0-alpha.6

package/lib/definitions/common-core/src/webgl/renderer/baked-ground-contact-shadow.d.ts

@@ -1,5 +1,6 @@
-import { SceneVolume } from './render-utility';
-import { Camera, Group, Layers, Mesh, Scene, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { SceneVolume } from './render-utility';
+import type { Camera, Group, Layers, Scene, Texture, WebGLRenderer } from 'three';
+import { Mesh, WebGLRenderTarget } from 'three';
 export interface BakedGroundContactShadowParameters {
     [key: string]: any;
     enabled: boolean;
@@ -20,7 +21,6 @@ export interface BakedGroundContactShadowParameters {
 }
 export declare class BakedGroundContactShadow {
     static addTestMesh: boolean;
-    private testMesh?;
     shadowMapSize: number;
     parameters: BakedGroundContactShadowParameters;
     private renderer;
@@ -29,7 +29,7 @@ export declare class BakedGroundContactShadow {
     blurScale: number;
     private groundGroup;
     private groundShadowFar;
-    private shadowGroundPlane;
+    shadowGroundPlane: ShadowGroundPlane;
     private groundContactCamera;
     private renderTargetBlur;
     private blurPass;
@@ -53,6 +53,9 @@ export declare class BakedGroundContactShadow {
 export declare class ShadowGroundPlane extends Mesh {
     static alphaMap: boolean;
     constructor(shadowMap: Texture | null, parameters?: any);
+    setVisibility(visible: boolean): void;
+    setDepthWrite(write: boolean): void;
+    setReceiveShadow(receive: boolean): void;
     setShadowMap(shadowMap: Texture | null): void;
     updateMaterial(parameters: any): void;
     updateVisibility(visible: boolean): void;

package/lib/definitions/common-core/src/webgl/renderer/effect-pass.d.ts

@@ -1,5 +1,5 @@
-import { DenoisePass } from './render-utility';
-import { Camera, Scene, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { DenoisePass } from './render-utility';
+import type { Camera, Scene, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
 import { SSAOPass } from 'realism-effects/src/ssao/SSAOPass.js';
 import { HBAOPass } from 'realism-effects/src/hbao/HBAOPass.js';
 import { PoissionDenoisePass } from 'realism-effects/src/poissionDenoise/PoissionDenoisePass.js';

package/lib/definitions/common-core/src/webgl/renderer/gbuffer-render-target.d.ts

@@ -1,5 +1,6 @@
 import { NormalAndDepthRenderMaterial } from './shader-utility';
-import { Camera, MeshNormalMaterial, Scene, ShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Camera, Scene, ShaderMaterial, Texture, WebGLRenderer } from 'three';
+import { MeshNormalMaterial, WebGLRenderTarget } from 'three';
 export interface GBufferTextures {
     get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
     get gBufferTexture(): Texture;

package/lib/definitions/common-core/src/webgl/renderer/ground-reflection-pass.d.ts

@@ -1,9 +1,11 @@
-import { Camera, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Camera, Scene, WebGLRenderer } from 'three';
+import { ShaderMaterial, WebGLRenderTarget } from 'three';
 export interface GroundReflectionParameters {
     [key: string]: any;
     enabled: boolean;
     intensity: number;
-    fadeOut: number;
+    fadeOutDistance: number;
+    fadeOutExponent: number;
     brightness: number;
     blurHorizontal: number;
     blurVertical: number;
@@ -15,17 +17,13 @@ export declare class GroundReflectionPass {
     private width;
     private height;
     parameters: GroundReflectionParameters;
-    private _shadowRenderTarget?;
     private _reflectionRenderTarget?;
     private _intensityRenderTarget?;
     private _blurRenderTarget?;
     private renderPass;
     private blurPass;
-    private renderOverrideVisibility;
-    private groundShadowMaterial;
     private reflectionIntensityMaterial;
     private _copyMaterial;
-    get shadowRenderTarget(): WebGLRenderTarget;
     get reflectionRenderTarget(): WebGLRenderTarget;
     get intensityRenderTarget(): WebGLRenderTarget;
     get blurRenderTarget(): WebGLRenderTarget;
@@ -35,8 +33,7 @@ export declare class GroundReflectionPass {
     setSize(width: number, height: number): void;
     updateParameters(parameters: any): void;
     private updateCopyMaterial;
-    render(renderer: WebGLRenderer, scene: Scene, camera: Camera): void;
-    private renderGroundShadow;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera, reflectionFadeInScale?: number): void;
     private renderGroundReflection;
     private renderGroundReflectionIntensity;
     blurReflection(renderer: WebGLRenderer, camera: Camera, renderTargets: WebGLRenderTarget[]): void;
@@ -47,26 +44,3 @@ export declare class GroundReflectionIntensityMaterial extends ShaderMaterial {
     constructor(parameters?: any);
     update(parameters?: any): GroundReflectionIntensityMaterial;
 }
-export declare class GroundShadowMaterial extends ShaderMaterial {
-    private static shader;
-    constructor(parameters?: any);
-    update(parameters?: any): GroundReflectionIntensityMaterial;
-}
-export declare const BlurGroundReflectionShadowShader: {
-    uniforms: {
-        tDiffuse: {
-            value: Texture;
-        };
-        rangeMin: {
-            value: Vector2;
-        };
-        rangeMax: {
-            value: Vector2;
-        };
-        shadowScale: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/lib/definitions/common-core/src/webgl/renderer/light-source-detection.d.ts

@@ -1,4 +1,5 @@
-import { OrthographicCamera, ShaderMaterial, Texture, Vector2, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { WebGLRenderer } from 'three';
+import { OrthographicCamera, ShaderMaterial, Texture, Vector2, Vector3, WebGLRenderTarget } from 'three';
 export declare const sphereToEquirectangular: (pointOnSphere: Vector3) => Vector2;
 export declare const equirectangularToSphere: (uv: Vector2) => Vector3;
 export interface TextureConverterResult {

package/lib/definitions/common-core/src/webgl/renderer/outline-pass.d.ts

@@ -1,5 +1,6 @@
 import { Pass, FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
-import { Camera, Color, Matrix4, MeshDepthMaterial, Object3D, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Camera, Object3D, Scene, Texture, WebGLRenderer } from 'three';
+import { Color, Matrix4, MeshDepthMaterial, ShaderMaterial, Vector2, WebGLRenderTarget } from 'three';
 export declare class OutlinePass extends Pass {
     static BlurDirectionX: Vector2;
     static BlurDirectionY: Vector2;

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

@@ -1,6 +1,6 @@
 import { OutlinePass } from './outline-pass';
-import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
-import { Camera, Object3D, Scene } from 'three';
+import type { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
+import type { Camera, Object3D, Scene } from 'three';
 export interface OutlineParameters {
     [key: string]: any;
     enabled: boolean;

package/lib/definitions/common-core/src/webgl/renderer/render-utility.d.ts

@@ -1,4 +1,5 @@
-import { Box3, Camera, Color, CubeTexture, DataTexture, Material, Object3D, OrthographicCamera, PerspectiveCamera, ShaderMaterialParameters, Scene, Texture, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Camera, Material, Object3D, ShaderMaterialParameters, Scene, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Box3, Color, CubeTexture, DataTexture, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
 export declare const createUniformColorTexture: (color: Color) => Texture;
 export declare const createUniformColorCubeTexture: (color: Color) => CubeTexture;
 export declare const createNoiseTexture: (size: number, min: number, max: number) => Texture;

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

@@ -1,5 +1,5 @@
-import { SceneRenderer } from './scene-renderer';
-import { GUI } from 'dat.gui';
+import type { SceneRenderer } from './scene-renderer';
+import type { GUI } from 'dat.gui';
 export declare class SceneRendererGUI {
     private sceneRenderer;
     private qualityLevel;

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

@@ -1,17 +1,23 @@
 import { SceneVolume } from './render-utility';
-import { GBufferParameters, GBufferRenderTargets } from './gbuffer-render-target';
-import { BakedGroundContactShadow, BakedGroundContactShadowParameters } from './baked-ground-contact-shadow';
-import { OutlineParameters, OutLineRenderer } from './outline-renderer';
-import { ScreenSpaceShadowMap, ScreenSpaceShadowMapParameters } from './screen-space-shadow-map';
-import { ShadowAndAoPass, ShadowAndAoPassParameters, ShadowBlurType } from './shadow-and-ao-pass';
-import { GroundReflectionParameters, GroundReflectionPass } from './ground-reflection-pass';
-import { LightSource } from './light-source-detection';
-import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
-import { Pass } from 'three/examples/jsm/postprocessing/Pass';
-import { Box3, Camera, Group, Object3D, PerspectiveCamera, RectAreaLight, Scene, ShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { GBufferParameters } from './gbuffer-render-target';
+import { GBufferRenderTargets } from './gbuffer-render-target';
+import type { BakedGroundContactShadowParameters } from './baked-ground-contact-shadow';
+import { BakedGroundContactShadow } from './baked-ground-contact-shadow';
+import type { OutlineParameters } from './outline-renderer';
+import { OutLineRenderer } from './outline-renderer';
+import type { ScreenSpaceShadowMapParameters } from './screen-space-shadow-map';
+import { ScreenSpaceShadowMap } from './screen-space-shadow-map';
+import type { ShadowAndAoPassParameters } from './shadow-and-ao-pass';
+import { ShadowAndAoPass, ShadowBlurType } from './shadow-and-ao-pass';
+import type { GroundReflectionParameters } from './ground-reflection-pass';
+import { GroundReflectionPass } from './ground-reflection-pass';
+import type { LightSource } from './light-source-detection';
+import type { Box3, Camera, Object3D, PerspectiveCamera, RectAreaLight, Scene, ShaderMaterial, Texture, WebGLRenderer } from 'three';
+import { Group } from 'three';
 export { BakedGroundContactShadowParameters } from './baked-ground-contact-shadow';
 export { OutlineParameters } from './outline-renderer';
 export { AmbientOcclusionType, ShadowAndAoParameters, ShadowAndAoPassParameters, } from './shadow-and-ao-pass';
+export { GroundReflectionParameters } from './ground-reflection-pass';
 export declare enum SceneGroupType {
     OBJECTS = 0,
     GROUND = 1,
@@ -31,15 +37,15 @@ export interface SceneRendererParameters {
     groundReflectionParameters: GroundReflectionParameters;
     bakedGroundContactShadowParameters: BakedGroundContactShadowParameters;
     outlineParameters: OutlineParameters;
-    deferredShadowAndAoFrame: number;
-    shadowAndAoFadeInFrames: number;
+    effectSuspendFrames: number;
+    effectFadeInFrames: number;
+    deferredGroundReflection: boolean;
     shadowOnCameraChange: ShadowBlurType;
 }
 export declare class SceneRenderer {
     parameters: SceneRendererParameters;
     debugOutput: string;
     private prevDebugOutput;
-    shadowOnGround: boolean;
     outputColorSpace: string;
     toneMapping: string;
     environmentLights: boolean;
@@ -53,6 +59,7 @@ export declare class SceneRenderer {
     private maxSamples;
     private cameraChanged;
     boundingVolume: SceneVolume;
+    private boundingVolumeSet;
     private debugRenderOverrideVisibility;
     private shadowRenderOverrideVisibility;
     private renderPass;
@@ -61,8 +68,6 @@ export declare class SceneRenderer {
     groundReflectionPass: GroundReflectionPass;
     gBufferRenderTarget: GBufferRenderTargets;
     bakedGroundContactShadow: BakedGroundContactShadow;
-    effectComposer: EffectComposer;
-    scenePass: ScenePass;
     outlineRenderer: OutLineRenderer;
     selectedObjects: Object3D[];
     private grayMaterial;
@@ -90,20 +95,17 @@ export declare class SceneRenderer {
     private setRenderState;
     private forceEnvironmentMapUpdate;
     private updateEnvironment;
-    render(scene: Scene, camera: Camera, renderPostEffects: boolean): void;
+    render(scene: Scene, camera: Camera): void;
     private renderGroundContactShadow;
     private renderDebug;
     private renderScene;
     private renderShadowAndAo;
     private evaluateIfShadowAndAoUpdateIsNeeded;
+    private renderGroundReflection;
+    private renderEffectsWithGround;
+    private renderEffectsWithoutGround;
     private renderOutline;
 }
-declare class ScenePass extends Pass {
-    private renderFunction;
-    constructor();
-    setRenderFunction(renderFunction: (renderer: WebGLRenderer) => void): void;
-    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, _readBuffer: WebGLRenderTarget, _deltaTime: number, _maskActive: boolean): void;
-}
 export declare class SceneGroups {
     sceneGroups: Map<SceneGroupType, Object3D<import("three").Event>[]>;
     addToGroup(group: SceneGroupType, object: Object3D): void;

package/lib/definitions/common-core/src/webgl/renderer/screen-space-shadow-map.d.ts

@@ -1,6 +1,7 @@
-import { SceneVolume } from './render-utility';
-import { LightSource } from './light-source-detection';
-import { Camera, Layers, Light, Object3D, RectAreaLight, Scene, ShadowMapType, Texture, Vector2, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { SceneVolume } from './render-utility';
+import type { LightSource } from './light-source-detection';
+import type { Box3, Camera, Layers, Light, Object3D, RectAreaLight, Scene, ShadowMapType, Texture, WebGLRenderer } from 'three';
+import { Vector2, Vector3, WebGLRenderTarget } from 'three';
 export declare enum ShadowLightSourceType {
     DirectionalLightShadow = 0,
     SpotLightShadow = 1
@@ -12,7 +13,10 @@ export interface ScreenSpaceShadowMapParameters {
     layers: Layers | null;
     shadowLightSourceType: ShadowLightSourceType;
     maximumNumberOfLightSources: number;
+    fadeOutDistance: number;
+    fadeOutBlur: number;
 }
+export declare const defaultScreenSpaceShadowMapParameters: ScreenSpaceShadowMapParameters;
 interface ActiveShadowLight {
     light: Light;
     intensity: number;
@@ -66,15 +70,23 @@ export declare class ScreenSpaceShadowMap {
     switchType(type: string): boolean;
 }
 export declare class ShadowMapPassOverrideMaterials {
+    private static shaderChunkChanged;
     static useModifiedMaterial: boolean;
     private renderPass;
-    private shadowObjetMaterial;
+    private shadowObjectMaterial;
     private unlitMaterial;
     private emissiveMaterial;
     private receiveShadowMaterial;
-    constructor();
+    private shadowFadeOut;
+    private boxMin;
+    private boxMax;
+    private viewToWorldMatrix;
+    constructor(parameters?: any);
     dispose(): void;
+    setShadowFadeOut(distance: number, blur: number): void;
+    setBoundingBox(box: Box3): void;
     private createShadowMaterial;
+    private createCustomerShadowMaterial;
     render(renderer: WebGLRenderer, scene: Scene, camera: Camera, renderTarget: WebGLRenderTarget): void;
     private setMeshMaterialAndVisibility;
     private setMeshShadowStandardMaterial;

package/lib/definitions/common-core/src/webgl/renderer/shader-utility.d.ts

@@ -1,4 +1,5 @@
-import { Matrix3, Matrix4, ShaderMaterial, Texture, Vector2, Vector4 } from 'three';
+import type { Texture } from 'three';
+import { Matrix3, Matrix4, ShaderMaterial, Vector2, Vector4 } from 'three';
 export declare const DEFAULT_TRANSFORM: Matrix4;
 export declare const RGB_TRANSFORM: Matrix4;
 export declare const ALPHA_TRANSFORM: Matrix4;

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

@@ -1,7 +1,11 @@
-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';
+import type { GBufferTextures } from './gbuffer-render-target';
+import { GBufferRenderTargets } from './gbuffer-render-target';
+import type { DenoisePass, SceneVolume } from './render-utility';
+import { RenderPass } from './render-utility';
+import type { HBAOEffectParameters, PoisonDenoiseParameters, SSAOEffectParameters } from './effect-pass';
+import { HBAOEffect, PoissonDenoiseEffect, SSAOEffect } from './effect-pass';
+import type { Camera, Scene, Texture, WebGLRenderer } from 'three';
+import { Matrix4, ShaderMaterial, WebGLRenderTarget } from 'three';
 export declare enum ShadowBlurType {
     OFF = 0,
     HARD = 1,
@@ -29,6 +33,7 @@ export interface ShadowAndAoPassParameters {
     aoIntensity: number;
     shadowIntensity: number;
     aoOnGround: boolean;
+    shadowOnGround: boolean;
     alwaysUpdate: boolean;
     shAndAo: ShadowAndAoParameters;
     ssao: SSAOEffectParameters;
@@ -40,8 +45,9 @@ export declare const defaultPassParameters: {
     enabled: boolean;
     aoType: AmbientOcclusionType;
     aoIntensity: number;
-    aoOnGround: boolean;
     shadowIntensity: number;
+    aoOnGround: boolean;
+    shadowOnGround: boolean;
     alwaysUpdate: boolean;
 };
 export declare class ShadowAndAoPass {

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

@@ -1,6 +1,7 @@
-import { CanvasOffset } from '../common-interfaces';
-import { KernelCube, KernelVector3 } from '../../../typings/kernel';
-import { Box3, Euler, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
+import type { CanvasOffset } from '../common-interfaces';
+import type { KernelCube, KernelVector3 } from '../../../typings/kernel';
+import type { Euler } from 'three';
+import { Box3, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
 export declare const PULSE_DURATION = 1500;
 export declare const PULSE_LOOPS = 5;
 export interface RoomleComponent extends Object3D {

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

@@ -1,5 +1,5 @@
-import { BakedGroundContactShadowParameters, OutlineParameters, ShadowAndAoParameters } from './renderer/scene-renderer';
-import { Box3, Camera, Object3D, Scene, Texture, WebGLRenderer } from 'three';
+import type { BakedGroundContactShadowParameters, GroundReflectionParameters, OutlineParameters, ShadowAndAoPassParameters } from './renderer/scene-renderer';
+import type { Box3, Camera, Object3D, Scene, Texture, WebGLRenderer } from 'three';
 export declare enum RenderMode {
     Mode3D = 0,
     Mode2D = 1
@@ -14,8 +14,9 @@ export declare class RoomleWebGLRenderer {
     private configuratorMode;
     private _fpsCounter;
     get renderer(): WebGLRenderer;
-    get shadowAndAoParameters(): ShadowAndAoParameters;
+    get shadowAndAoPassParameters(): ShadowAndAoPassParameters;
     get bakedGroundContactShadowParameters(): BakedGroundContactShadowParameters;
+    get groundReflectionParameters(): GroundReflectionParameters;
     get outlineParameters(): OutlineParameters;
     constructor(renderer: WebGLRenderer, width: number, height: number);
     dispose(): void;
@@ -25,8 +26,10 @@ export declare class RoomleWebGLRenderer {
     private updateRectAreaLight;
     enableContactShadow(): void;
     disableContactShadow(): void;
-    enableShadowAndAo(): void;
+    enableShadowAndAo(onGround: boolean): void;
     disableShadowAndAo(): void;
+    enableGroundReflection(): void;
+    disableGroundReflection(): void;
     forceShadowUpdates(updateBakedGroundShadow: boolean): void;
     switchToConfigurator(): void;
     switchToPlanner(renderMode: RenderMode): void;

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

@@ -1,8 +1,8 @@
 import EventDispatcher from '../../../configurator-core/src/utils/event-dispatcher';
 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';
+import type { Context } from '../di/context';
+import type InputManager from '../input/input-manager';
+import type { Camera, Scene } from 'three';
 export default abstract class SceneEventHandler<EventType> extends EventDispatcher<EventType> implements Context {
     _creator_: string;
     protected _inputManager: InputManager;

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

@@ -1,24 +1,25 @@
-import { CanvasOffset } from '../common-interfaces';
-import DomHelper from '../utils/dom-helper';
-import InputManager from '../input/input-manager';
-import { GUI } from 'dat.gui';
-import ScriptLoader from '../script-loader';
-import CameraControl from '../cameracontrol/camera-control';
-import LightSetting from '../lightsetting/light-setting';
+import type { CanvasOffset } from '../common-interfaces';
+import type DomHelper from '../utils/dom-helper';
+import type InputManager from '../input/input-manager';
+import type { GUI } from 'dat.gui';
+import type ScriptLoader from '../script-loader';
+import type CameraControl from '../cameracontrol/camera-control';
+import type LightSetting from '../lightsetting/light-setting';
 import { CAMERA_TYPE } from '../cameracontrol/camera-type';
-import { Context } from '../di/context';
-import { LifeCycleCallbacks } from '../life-cycle-manager';
-import { SceneSettings } from '../scene-settings-loader';
-import Environment from '../environment/environment';
-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 type { Context } from '../di/context';
+import type { LifeCycleCallbacks } from '../life-cycle-manager';
+import type { SceneSettings } from '../scene-settings-loader';
+import type Environment from '../environment/environment';
+import type { DynamicLightSettingSource } from '../lightsetting/dynamic-light-setting-loader';
+import type InitData from '../utils/init-data';
+import type { OrthographicOffsetCamera, PerspectiveOffsetCamera } from './roomle-component-factory';
+import type PluginSystem from '../../../configurator-core/src/webgl/plugin-system';
+import type { Enumify } from '../types';
+import type { Object3D } from 'three';
+import { Box3, Scene, Vector3, WebGLRenderer } from 'three';
 import { RoomleWebGLRenderer } from './roomle-webl-renderer';
-import HdrEnvironmentLoader from '../services/hdr-environment-loader';
-import ImageRenderer from './image-renderer';
+import type HdrEnvironmentLoader from '../services/hdr-environment-loader';
+import type ImageRenderer from './image-renderer';
 export default abstract class SceneManager implements Context, LifeCycleCallbacks, EventListenerObject {
     _creator_: string;
     protected _domHelper: DomHelper;

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

@@ -1,5 +1,6 @@
-import { Context } from '../di/context';
-import { Box3, Object3D, Vector3 } from 'three';
+import type { Context } from '../di/context';
+import type { Object3D } from 'three';
+import { Box3, Vector3 } from 'three';
 export declare const enum STATIC_ITEM_TYPE {
     GLB = "GLB",
     GLTF = "GLTF"

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

@@ -1,4 +1,4 @@
-import { KernelPossibleChild } from '../../typings/kernel';
+import type { KernelPossibleChild } from '../../typings/kernel';
 export declare const USM_PARTLIST: any;
 export declare const CUBE_PARTLIST: any;
 export declare const USM_KERNEL_POSSIBLE_CHILD: KernelPossibleChild;

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

@@ -1,6 +1,6 @@
 import './utils/global-definitions';
 import Main from '../../common-core/src/main';
-import { AppState } from '../../common-core/src/utils/app-context';
+import type { AppState } from '../../common-core/src/utils/app-context';
 import RoomleConfigurator from './roomle-configurator';
 export declare class Configurator extends Main {
     private _configurator;

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

@@ -1,21 +1,23 @@
 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 { 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';
-import ConfiguratorUiCallbacks from './services/configurator-ui-callback';
-import { AssetUrl, ConfigurationHash, ConfigurationString, RapiAdditionalContent, RapiConfiguration, RapiConfigurationEnhanced, RapiConfiguratorSettings, RapiId, RapiItem, RapiMaterial, RapiTagForUi } from '../../typings/rapi-types';
-import { Context } from '../../common-core/src/di/context';
-import ConfiguratorSceneManager from './webgl/configurator-scene-manager';
-import { ConfiguratorKernelAccessCallbackI } from './services/configurator-kernel-access-callback';
-import { GlobalInitDataDefinition, InitDataDefinition } from '../../common-core/src/utils/shims';
-import { CameraParameter } from '../../common-core/src/cameracontrol/camera-control';
-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';
+import type UnitFormatter from './services/unit-formatter';
+import type { Base64Image, CanvasOffset } from '../../common-core/src/common-interfaces';
+import type { KernelParameter, KernelParameterGroup, KernelPartList, KernelPartListPrice, KernelPossibleChild, UiKernelParameter, UiPossibleChild } from '../../typings/kernel';
+import { ExportType } from '../../typings/kernel';
+import type { DynamicLightSettingSource } from '../../common-core/src/lightsetting/dynamic-light-setting-loader';
+import type { ExternalEmbeddable, GlobalAPI, KernelUtilityForUi, RubensAPI } from '../../common-core/src/main';
+import type Main from '../../common-core/src/main';
+import type { SceneSettings } from '../../common-core/src/scene-settings-loader';
+import type ConfiguratorUiCallbacks from './services/configurator-ui-callback';
+import type { AssetUrl, ConfigurationHash, ConfigurationString, RapiAdditionalContent, RapiConfiguration, RapiConfigurationEnhanced, RapiConfiguratorSettings, RapiId, RapiItem, RapiMaterial, RapiTagForUi } from '../../typings/rapi-types';
+import type { Context } from '../../common-core/src/di/context';
+import type ConfiguratorSceneManager from './webgl/configurator-scene-manager';
+import type { ConfiguratorKernelAccessCallbackI } from './services/configurator-kernel-access-callback';
+import type { GlobalInitDataDefinition, InitDataDefinition } from '../../common-core/src/utils/shims';
+import type { CameraParameter } from '../../common-core/src/cameracontrol/camera-control';
+import type { PrepareImageOptions, RenderOptions } from '../../common-core/src/webgl/image-renderer';
+import type { GlobalCallback } from '../../common-core/src/services/global-callback';
+import type RoomleToolsCore from '../../tools-core/src/roomle-tools-core';
+import type { Scene } from 'three';
 interface ConfigurationLoadedResponse {
     partList: KernelPartList;
     errors: string[];

package/lib/definitions/configurator-core/src/services/configurator-kernel-access-callback.d.ts

@@ -1,7 +1,7 @@
-import { KernelParameter, KernelParameterGroup, KernelPossibleChild } from '../../../typings/kernel';
-import { PARAMETER_UPDATE_TYPE } from '../roomle-configurator';
-import { KernelAccessCallbackI } from '../../../common-core/src/kernel-access-callback';
-import { Context } from '../../../common-core/src/di/context';
+import type { KernelParameter, KernelParameterGroup, KernelPossibleChild } from '../../../typings/kernel';
+import type { PARAMETER_UPDATE_TYPE } from '../roomle-configurator';
+import type { KernelAccessCallbackI } from '../../../common-core/src/kernel-access-callback';
+import type { Context } from '../../../common-core/src/di/context';
 export interface ConfiguratorKernelAccessCallbackI extends KernelAccessCallbackI {
     updatePossibleChildren(elementId: number, children: KernelPossibleChild[], parameterUpdateType?: PARAMETER_UPDATE_TYPE): void;
     updateParameters(parameters: KernelParameter[], parameterGroups: KernelParameterGroup[], elementId: number | number[], parameterUpdateType: PARAMETER_UPDATE_TYPE): void;

package/lib/definitions/configurator-core/src/services/configurator-ui-callback.d.ts

@@ -1,11 +1,11 @@
-import { ConfiguratorKernelClass, KernelComponent, KernelCube, KernelPartList, KernelVector3, UiKernelParameter, UiPossibleChild, UiPossibleChildTag } from '../../../typings/kernel';
-import { UIIntersection } from '../utils/ui-intersection-helper';
-import { RAPI_PATHS } from '../../../common-core/src/rapi-access';
-import { ConfigurationHash, RapiId, RapiTagForUi } from '../../../typings/rapi-types';
+import type { ConfiguratorKernelClass, KernelComponent, KernelCube, KernelPartList, KernelVector3, UiKernelParameter, UiPossibleChild, UiPossibleChildTag } from '../../../typings/kernel';
+import type { UIIntersection } from '../utils/ui-intersection-helper';
+import type { RAPI_PATHS } from '../../../common-core/src/rapi-access';
+import type { ConfigurationHash, RapiId, RapiTagForUi } from '../../../typings/rapi-types';
 import { UiCallback } from '../../../common-core/src/utils/ui-callback';
-import { ConfiguratorKernelContainer } from '../../../typings/configurator-kernel-container';
-import { PlannerKernelContainer } from '../../../typings/planner-kernel-container';
-import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type { ConfiguratorKernelContainer } from '../../../typings/configurator-kernel-container';
+import type { PlannerKernelContainer } from '../../../typings/planner-kernel-container';
+import type { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
 export type ComponentAction = 'edit' | 'add';
 export type ComponentType = 'preview' | 'component';
 export interface UIComponentInfo {
@@ -263,5 +263,24 @@ export default class ConfiguratorUiCallbacks extends UiCallback {
      * @param component RoomleComponent instance of the clicked component
      */
     onClickComponent: (component: RoomleComponent) => void;
+    /**
+     * This function gets called when an external mesh is requested
+     * @param meshId meshId
+     * @param quality number between 0 and 100
+     * @returns void
+     */
+    onRequestExternalMesh: (meshId: string, quality: number) => void;
+    /**
+     * This function gets called when a geometry is ready
+     * @param runtimeId number
+     * @returns void
+     */
+    onGeometryReady: (runtimeId: number) => void;
+    /**
+     * This function gets called when a geometry is not ready
+     * @param runtimeId
+     * @returns
+     */
+    onGeometryNotReady: (runtimeId: number) => void;
     constructor(creator: string);
 }

package/lib/definitions/configurator-core/src/services/unit-formatter.d.ts

@@ -1,5 +1,5 @@
-import { KernelParameter, KernelPartListParameter, UiKernelParameter } from '../../../typings/kernel';
-import { Context } from '../../../common-core/src/di/context';
+import type { KernelParameter, KernelPartListParameter, UiKernelParameter } from '../../../typings/kernel';
+import type { Context } from '../../../common-core/src/di/context';
 export declare const MEASUREMENT_SYSTEM_STRING: {
     IMPERIAL: string;
     METRIC: string;

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

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

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

@@ -1,6 +1,6 @@
-import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
-import { Context } from '../../../common-core/src/di/context';
-import { PerspectiveCamera } from 'three';
+import type { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type { Context } from '../../../common-core/src/di/context';
+import type { PerspectiveCamera } from 'three';
 export default class ComponentDimensioningHelper implements Context {
     _creator_: string;
     private _plannerKernelAccess;