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

package/packages/web-sdk/packages/common-core/src/webgl/renderer/scene-renderer.d.ts

@@ -0,0 +1,122 @@
+import { SceneVolume } from './render-utility';
+import { GBufferParameters, GBufferRenderPass } from './pass/gbuffer-render-pass';
+import { ShadowGroundPlane } from './objects/shadow-ground-plane';
+import { BakedGroundContactShadowParameters, BakedGroundContactShadowPass } from './pass/baked-ground-contact-shadow-pass';
+import { GroundReflectionParameters, GroundReflectionPass } from './pass/ground-reflection-pass';
+import { ScreenSpaceShadowMapParameters, ScreenSpaceShadowMapPass } from './pass/screen-space-shadow-map-pass';
+import { ShadowAndAoPassParameters, ShadowBlurType, ShadowAndAoPass } from './pass/shadow-and-ao-pass';
+import { OutlineParameters, OutlineRenderer } from './outline-renderer';
+import { DebugPass } from './pass/debug-pass';
+import { LightSource } from './light-source-detection';
+import { CustomShadingParameters, SceneShadingType } from './shading-settings';
+import { RenderCacheManager } from './render-cache';
+import { LutPassParameters } from './render-pass-manager';
+import { SceneRenderPass } from './pass/scene-render-pass';
+import { Enumify } from '../../types';
+import { Box3, Camera, Object3D, PerspectiveCamera, RectAreaLight, Scene, WebGLRenderer, Group } from 'three';
+
+export { type BakedGroundContactShadowParameters } from './pass/baked-ground-contact-shadow-pass';
+export { type OutlineParameters } from './outline-renderer';
+export { type ShadowParameters, type ShadowAndAoPassParameters, } from './pass/shadow-and-ao-pass';
+export { type AORenderPassParameters } from './pass/ao-pass';
+export { type GroundReflectionParameters } from './pass/ground-reflection-pass';
+export declare const QUALITY_LEVELS: {
+    readonly HIGHEST: "highest";
+    readonly HIGH: "high";
+    readonly MEDIUM: "medium";
+    readonly LOW: "low";
+};
+export type QualityLevel = Enumify<typeof QUALITY_LEVELS>;
+export type QualityMap = Map<QualityLevel, any>;
+export interface LutImageDefinition {
+    name: string;
+    url: string;
+    type: string;
+}
+export interface SceneRendererParameters {
+    gBufferRenderTargetParameters: GBufferParameters;
+    shAndAoPassParameters: ShadowAndAoPassParameters;
+    screenSpaceShadowMapParameters: ScreenSpaceShadowMapParameters;
+    groundReflectionParameters: GroundReflectionParameters;
+    bakedGroundContactShadowParameters: BakedGroundContactShadowParameters;
+    outlineParameters: OutlineParameters;
+    effectSuspendFrames: number;
+    effectFadeInFrames: number;
+    suspendGroundReflection: boolean;
+    shadowOnCameraChange: ShadowBlurType;
+}
+export interface SceneRendererChangeParameters {
+    shadowType?: string;
+    shAndAoPassParameters?: ShadowAndAoPassParameters;
+    screenSpaceShadowMapParameters?: ScreenSpaceShadowMapParameters;
+    groundReflectionParameters?: GroundReflectionParameters;
+    bakedGroundContactShadowParameters?: BakedGroundContactShadowParameters;
+    outlineParameters?: OutlineParameters;
+    effectSuspendFrames?: number;
+    effectFadeInFrames?: number;
+    suspendGroundReflection?: boolean;
+    shadowOnCameraChange?: ShadowBlurType;
+}
+export declare class SceneRenderer {
+    parameters: SceneRendererParameters;
+    debugOutput: string;
+    outputColorSpace: string;
+    toneMapping: string;
+    linearAoFilter: boolean;
+    environmentLights: boolean;
+    enableObjectSelection: boolean;
+    groundLevel: number;
+    uiInteractionMode: boolean;
+    renderer: WebGLRenderer;
+    width: number;
+    height: number;
+    boundingVolume: SceneVolume;
+    boundingVolumeSet: boolean;
+    renderCacheManager: RenderCacheManager;
+    private _renderPassManager;
+    private _shadowAndAoGroundPlane;
+    outlineRenderer: OutlineRenderer;
+    selectedObjects: Object3D[];
+    private _copyMaterial?;
+    readonly groundGroup: Group;
+    private _shadingType;
+    private _qualityLevel;
+    private _qualityMap;
+    private _customShadingParameters;
+    get sceneRenderPass(): SceneRenderPass;
+    get bakedGroundContactShadowPass(): BakedGroundContactShadowPass;
+    get gBufferRenderPass(): GBufferRenderPass;
+    get groundReflectionPass(): GroundReflectionPass;
+    get screenSpaceShadowMapPass(): ScreenSpaceShadowMapPass;
+    get shadowAndAoPass(): ShadowAndAoPass;
+    get lutPassParameters(): LutPassParameters;
+    get lutMaps(): string[];
+    get debugPass(): DebugPass;
+    get shadowAndAoGroundPlane(): ShadowGroundPlane;
+    constructor(renderer: WebGLRenderer, width: number, height: number, linearAoFilter?: boolean);
+    private _addEventListeners;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    loadLutImages(luts: LutImageDefinition[]): void;
+    getQualityLevel(): QualityLevel;
+    setShadingType(shadingType: SceneShadingType): void;
+    setQualityLevel(qualityLevel: QualityLevel): void;
+    setQualityMap(qualityMap: QualityMap): void;
+    setCustomShadingParameters(customShadingParameters: CustomShadingParameters): void;
+    setQualityMapAndShadingParameters(qualityMap: QualityMap, customShadingParameters: CustomShadingParameters): void;
+    applyCurrentParameters(): void;
+    requestUpdateOfPasses(): void;
+    clearCache(): void;
+    forceShadowUpdates(updateBakedGroundShadow: boolean): void;
+    forceLutPassUpdate(): void;
+    updateParameters(parameters: SceneRendererChangeParameters): void;
+    addRectAreaLight(rectAreaLight: RectAreaLight, parent: Object3D): void;
+    updateRectAreaLights(rectAreaLights: RectAreaLight[], parent: Object3D): void;
+    createShadowFromLightSources(parent: Object3D, lightSources: LightSource[]): void;
+    selectObjects(selectedObjects: Object3D[]): void;
+    updateBounds(bounds: Box3, scaleShadowAndAo: boolean): void;
+    updateNearAndFarPlaneOfPerspectiveCamera(camera: PerspectiveCamera, minimumFar?: number): void;
+    private _forceEnvironmentMapUpdate;
+    private _updateEnvironment;
+    render(scene: Scene, camera: Camera): void;
+}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/shader-utility.d.ts

@@ -0,0 +1,112 @@
+import { Enumify } from '../../types';
+import { Blending, BlendingDstFactor, BlendingEquation, BlendingSrcFactor, Texture, 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;
+export declare const RED_TRANSFORM: Matrix4;
+export declare const BLUE_TRANSFORM: Matrix4;
+export declare const GREEN_TRANSFORM: Matrix4;
+export declare const GRAYSCALE_TRANSFORM: Matrix4;
+export declare const ZERO_RGBA: Vector4;
+export declare const ALPHA_RGBA: Vector4;
+export declare const DEFAULT_UV_TRANSFORM: Matrix3;
+export declare const FLIP_Y_UV_TRANSFORM: Matrix3;
+export declare const interpolationMatrix: (r: number, g: number, b: number, a: number) => Matrix4;
+export declare const COLOR_COPY_BLEND_MODES: {
+    readonly DEFAULT: "default";
+    readonly ADDITIVE: "additive";
+};
+export type CopyMaterialBlendMode = Enumify<typeof COLOR_COPY_BLEND_MODES>;
+export interface CopyTransformMaterialParameters {
+    texture?: Texture | null;
+    colorTransform?: Matrix4;
+    colorBase?: Vector4;
+    multiplyChannels?: number;
+    uvTransform?: Matrix3;
+    blending?: Blending;
+    blendSrc?: BlendingSrcFactor | BlendingDstFactor;
+    blendDst?: BlendingDstFactor;
+    blendEquation?: BlendingEquation;
+    blendSrcAlpha?: number;
+    blendDstAlpha?: number;
+    blendEquationAlpha?: number;
+}
+export declare class CopyTransformMaterial extends ShaderMaterial {
+    constructor(parameters?: CopyTransformMaterialParameters, copyBlendMode?: CopyMaterialBlendMode, linearToSrgb?: boolean, premultipliedALpha?: boolean);
+    update(parameters?: CopyTransformMaterialParameters): CopyTransformMaterial;
+}
+export declare const BlurShader: {
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        rangeMin: {
+            value: Vector2;
+        };
+        rangeMax: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const MixShadowShader: {
+    uniforms: {
+        tShadow1: {
+            value: Texture;
+        };
+        tShadow2: {
+            value: Texture;
+        };
+        shadowScale1: {
+            value: number;
+        };
+        shadowScale2: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const HorizontalBlurShadowShader: {
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        blur: {
+            value: number;
+        };
+        shadowRange: {
+            value: Vector2;
+        };
+    };
+    defines: {
+        DEBUG_BLUR_AREA: number;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const VerticalBlurShadowShader: {
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        blur: {
+            value: number;
+        };
+        shadowRange: {
+            value: Vector2;
+        };
+    };
+    defines: {
+        DEBUG_BLUR_AREA: number;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare class LinearDepthRenderMaterial extends ShaderMaterial {
+    private static _linearDepthShader;
+    constructor(parameters: Record<string, any>);
+    update(parameters?: Record<string, any>): LinearDepthRenderMaterial;
+}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/shaders/ao-shader.d.ts

@@ -0,0 +1,84 @@
+import { Enumify } from '../../../types';
+import { Texture, Matrix4, Vector2, Vector3 } from 'three';
+
+export declare const AO_ALGORITHMS: {
+    readonly SSAO: 0;
+    readonly SAO: 1;
+    readonly N8AO: 2;
+    readonly HBAO: 3;
+    readonly GTAO: 4;
+};
+export type AoAlgorithmType = Enumify<typeof AO_ALGORITHMS> | null;
+export declare const generateAoSampleKernelInitializer: (samples: number, cosineWeighted: boolean) => string;
+export declare const AOShader: {
+    name: string;
+    defines: {
+        PERSPECTIVE_CAMERA: number;
+        SAMPLES: number;
+        SAMPLE_VECTORS: string;
+        NORMAL_VECTOR_TYPE: number;
+        DEPTH_SWIZZLING: string;
+        AO_ALGORITHM: 4;
+        NV_ALIGNED_SAMPLES: number;
+        SCREEN_SPACE_RADIUS: number;
+        SCREEN_SPACE_RADIUS_SCALE: number;
+        SCENE_CLIP_BOX: number;
+        NORMAL_VECTOR_ANTIALIAS: number;
+        DEPTH_BUFFER_ANTIALIAS: number;
+    };
+    uniforms: {
+        tNormal: {
+            value: Texture;
+        };
+        tDepth: {
+            value: Texture;
+        };
+        tNoise: {
+            value: Texture;
+        };
+        resolution: {
+            value: Vector2;
+        };
+        cameraNear: {
+            value: Texture;
+        };
+        cameraFar: {
+            value: Texture;
+        };
+        cameraProjectionMatrix: {
+            value: Matrix4;
+        };
+        cameraProjectionMatrixInverse: {
+            value: Matrix4;
+        };
+        cameraWorldMatrix: {
+            value: Matrix4;
+        };
+        radius: {
+            value: number;
+        };
+        distanceExponent: {
+            value: number;
+        };
+        thickness: {
+            value: number;
+        };
+        distanceFallOff: {
+            value: number;
+        };
+        bias: {
+            value: number;
+        };
+        scale: {
+            value: number;
+        };
+        sceneBoxMin: {
+            value: Vector3;
+        };
+        sceneBoxMax: {
+            value: Vector3;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/packages/web-sdk/packages/common-core/src/webgl/renderer/shaders/poisson-denoise-shader.d.ts

@@ -0,0 +1,74 @@
+import { Texture, Matrix4, Vector3, Vector2 } from 'three';
+
+export declare const generatePdSamplePointInitializer: (samples: number, rings: number, radius: number, radiusExponent: number) => string;
+export declare const generateDenoiseSamples: (numSamples: number, numRings: number, radius: number, radiusExponent: number) => any[];
+export declare const poissonDenoiseShader: {
+    name: string;
+    defines: {
+        SAMPLES: number;
+        SAMPLE_VECTORS: string;
+        NV_ALIGNED_SAMPLES: number;
+        SAMPLE_DISTRIBUTION: number;
+        DEPTH_VALUE_SOURCE: number;
+        LUMINANCE_WEIGHTED: number;
+        LUMINANCE_TYPE: string;
+        SAMPLE_LUMINANCE: string;
+        SCENE_CLIP_BOX: number;
+        FRAGMENT_OUTPUT: string;
+    };
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        tNormal: {
+            value: Texture;
+        };
+        tDepth: {
+            value: Texture;
+        };
+        tNoise: {
+            value: Texture;
+        };
+        resolution: {
+            value: Vector2;
+        };
+        cameraProjectionMatrix: {
+            value: Matrix4;
+        };
+        cameraProjectionMatrixInverse: {
+            value: Matrix4;
+        };
+        cameraWorldMatrix: {
+            value: Matrix4;
+        };
+        lumaPhi: {
+            value: number;
+        };
+        depthPhi: {
+            value: number;
+        };
+        normalPhi: {
+            value: number;
+        };
+        radius: {
+            value: number;
+        };
+        radiusExponent: {
+            value: number;
+        };
+        iteration: {
+            value: number;
+        };
+        noOfIterations: {
+            value: number;
+        };
+        sceneBoxMin: {
+            value: Vector3;
+        };
+        sceneBoxMax: {
+            value: Vector3;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/packages/web-sdk/packages/common-core/src/webgl/renderer/shading-settings.d.ts

@@ -0,0 +1,50 @@
+import { Nullable } from '../../../../typings/helper';
+import { Enumify } from '../../types';
+
+export declare const SCENE_SHADING_TYPES: {
+    readonly DEFAULT: "default";
+    readonly BRIGHT: "bright";
+};
+export type SceneShadingType = Enumify<typeof SCENE_SHADING_TYPES>;
+export interface CustomShadingParameters {
+    aoIntensity?: number;
+    aoExtent?: number;
+    shBakedOnGround?: boolean;
+    shadowIntensity?: number;
+    shadowSoftening?: number;
+    grReflectIntensity?: number;
+    grReflectFadeOut?: number;
+}
+type ObjectType = Record<string, object>;
+export declare const mergeRendererParameters: (...args: ObjectType[]) => Nullable<ObjectType>;
+export declare const getInteractionParameters: (uiInteractionMode: boolean) => Nullable<ObjectType>;
+export declare const getShadingParameters: (shadingType: SceneShadingType) => Nullable<ObjectType>;
+interface ShadingMapParameters {
+    shAndAoPassParameters: {
+        aoIntensity?: number;
+        shadowIntensity?: number;
+        ao: {
+            radius?: number;
+            thickness?: number;
+        };
+        shadow: {
+            shadowRadius?: number;
+        };
+    };
+    groundReflectionParameters: {
+        enabled?: boolean;
+        intensity?: number;
+        fadeOutDistance?: number;
+    };
+    bakedGroundContactShadowParameters: {
+        enabled?: boolean;
+        opacity?: number;
+        blurMin?: number;
+        blurMax?: number;
+    };
+}
+export declare const mapCustomShadingParameters: (customShadingParameters: CustomShadingParameters) => Record<string, object>;
+export declare const _mapCustomAoParameters: (parameters: ShadingMapParameters, customShadingParameters: CustomShadingParameters) => void;
+export declare const _mapCustomShadowParameters: (parameters: ShadingMapParameters, customShadingParameters: CustomShadingParameters) => void;
+export declare const _mapCustomGroundReflectionParameters: (parameters: ShadingMapParameters, customShadingParameters: CustomShadingParameters) => void;
+export {};

package/packages/web-sdk/packages/common-core/src/webgl/roomle-component-factory.d.ts

@@ -0,0 +1,116 @@
+import { RoomleEventedMesh, RoomleEventedObject3D } from '../utils/threejs-utils';
+import { CanvasOffset } from '../common-interfaces';
+import { KernelCube, KernelVector3 } from '../../../typings/kernel';
+import { Euler, Box3, Mesh, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
+import { AnimationValueMap } from '../../../configurator-core/src/utils/animation/animation-value-map';
+import { RoomleLightSource } from '../light/light-source';
+import { DragInsertAnimation } from '../../../configurator-core/src/utils/animation/drag-insert-animation';
+
+export declare const PULSE_DURATION = 1500;
+export declare const PULSE_LOOPS = 5;
+export interface RoomleComponent extends RoomleEventedObject3D {
+    runtimeId: number;
+    parentObjectId: number;
+    isRootComponent: boolean;
+    isChildPlanObject: boolean;
+    meshes: RoomleEventedMesh[];
+    boundingBox: Box3;
+    boundingBoxMesh: RoomleEventedMesh;
+    loadingMesh: Mesh;
+    roomlePosition: KernelVector3;
+    roomleRotation: KernelVector3;
+    hash: string;
+    geometryChanged: boolean;
+    animationValueMap?: AnimationValueMap;
+    replaceMeshes(meshes: Mesh[]): void;
+    addMesh(mesh: Mesh, transform?: Float32Array): void;
+    removeMesh(mesh: Mesh): void;
+    removeMeshById(meshId: number): void;
+    getLightSourceById(lightSourceId: number): RoomleLightSource | null;
+    removeLightSourceById(lightSourceId: number): void;
+    addLightSource(lightSource: RoomleLightSource): void;
+    getMeshById(meshId: number): Mesh;
+    removeAllMeshes(): void;
+    select(): void;
+    deselect(): void;
+    hoverOn(): void;
+    hoverOff(): void;
+    loading(): void;
+    loadingFinished(): void;
+    computeBoundingBox(boxForMeasurements?: KernelCube, useMeshes?: boolean): void;
+    recursiveMeshes(): Mesh[];
+    isChild(componentId: number): boolean;
+    getKernelPosition(newParent: RoomleComponent): KernelVector3;
+    animateMeshes(animationName: string, animationTransition: AnimationTransition, animate: boolean, onProgressUpdate?: () => void): void;
+}
+export interface StaticComponent extends RoomleComponent {
+    glbUrl: string;
+}
+export interface PreviewComponent extends RoomleComponent {
+    parentId: number;
+    parentDockId: number;
+    childId: number;
+    childDockId: number;
+    stringId: string;
+    receivedPointAssociation: boolean;
+    dockInsertAnimation?: DragInsertAnimation;
+    clonePreview(numberOfDuplication: number): PreviewComponent;
+    preparePreview(): void;
+    startPulsating(): void;
+}
+export interface PreviewLineSegment {
+    from: number;
+    to: number;
+}
+export interface PreviewLineComponent extends PreviewComponent {
+    lineFrom: Vector3;
+    lineTo: Vector3;
+    lineSegments: PreviewLineSegment[];
+    positionFrom: Vector3;
+    positionTo: Vector3;
+    roomleLineFrom: KernelVector3;
+    roomleLineTo: KernelVector3;
+    roomlePositionFrom: KernelVector3;
+    roomlePositionTo: KernelVector3;
+    docklineRotation: Euler;
+    lineMesh: Mesh;
+    boundingLineMesh: RoomleEventedMesh;
+    clonePreviewLine(numberOfDuplication: number): PreviewLineComponent;
+    getPositionForIntersectionPoint(intersectionPoint: Vector3): Vector3;
+    updatePreviewPosition(intersectionPoint: Vector3): void;
+    hideSelectionLine(): void;
+}
+export interface OffsetCamera {
+    offset: CanvasOffset;
+    resetOffset(): void;
+}
+export interface OrthographicOffsetCamera extends OrthographicCamera, OffsetCamera {
+}
+export interface PerspectiveOffsetCamera extends PerspectiveCamera, OffsetCamera {
+}
+export interface RoomleComponentFactory {
+    create(id: number, position: KernelVector3, eulerAngles: KernelVector3, parentObjectId: number, isRootComponent: boolean): RoomleComponent;
+    createStatic(id: number, url: string): StaticComponent;
+    createPreview(id: number, parentObjectId: number, creator: string): PreviewComponent;
+    createPreviewLine(previewComponent: PreviewComponent, creator: string): PreviewLineComponent;
+    isPreview(obj: RoomleComponent): boolean;
+    isPreviewLine(obj: RoomleComponent): boolean;
+    createOrthographicCamera(left: number, right: number, top: number, bottom: number, near?: number, far?: number, offset?: CanvasOffset): OrthographicOffsetCamera;
+    createPerspectiveCamera(fov: number, aspect: number, near: number, far: number, offset?: CanvasOffset): PerspectiveOffsetCamera;
+}
+export interface AnimationTransition {
+    from: string;
+    to: string;
+    priorAnimations: string[];
+    subsequentAnimations: string[];
+}
+export default function (): {
+    create: (id: number, position: KernelVector3, rotation: KernelVector3, parentObjectId: number, isRootComponent: boolean) => RoomleComponent;
+    createPreview: (id: number, parentObjectId: number, creator: string) => PreviewComponent;
+    createStatic: (id: number, url: string) => StaticComponent;
+    createPreviewLine: (previewComponent: PreviewComponent, creator: string) => PreviewLineComponent;
+    isPreview: (obj: RoomleComponent) => boolean;
+    isPreviewLine: (obj: RoomleComponent) => boolean;
+    createPerspectiveCamera: (fov: number, aspect: number, near: number, far: number, offset?: CanvasOffset) => PerspectiveOffsetCamera;
+    createOrthographicCamera: (left: number, right: number, top: number, bottom: number, near?: number, far?: number, offset?: CanvasOffset) => OrthographicOffsetCamera;
+};

package/packages/web-sdk/packages/common-core/src/webgl/roomle-webgl-renderer-quality-levels.d.ts

@@ -0,0 +1,6 @@
+import { QualityMap } from './renderer/scene-renderer';
+
+export declare const standaloneConfiguratorQualityLevels: QualityMap;
+export declare const plannerConfiguratorQualityLevels: QualityMap;
+export declare const planner3dQualityLevels: QualityMap;
+export declare const planner2dQualityLevels: QualityMap;

package/packages/web-sdk/packages/common-core/src/webgl/roomle-webgl-renderer.d.ts

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

package/packages/web-sdk/packages/common-core/src/webgl/scene-event-handler.d.ts

@@ -0,0 +1,17 @@
+import { default as EventDispatcher } from '../../../configurator-core/src/utils/event-dispatcher';
+import { default as RaycastHelper } from '../../../configurator-core/src/utils/raycast-helper';
+import { Context } from '../di/context';
+import { default as 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: Scene, camera: Camera, inputManager: InputManager);
+    protected abstract _interaction(): void;
+    isDragIn(): boolean;
+    setDragIn(dragIn: boolean, dragEvent?: DragEvent): void;
+}