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

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

@@ -0,0 +1,84 @@
+import type { Camera, Material, Object3D, ShaderMaterialParameters, Texture, WebGLRenderer, WebGLRenderTarget, ColorRepresentation } from 'three';
+import { Box3, Color, CubeTexture, DataTexture, OrthographicCamera, PerspectiveCamera, Scene, 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;
+export declare const loadAndSetTexture: (setTexture: (texture: Texture) => void, resource: string, color?: Color) => void;
+export declare const setOrthographicViewVolumeFromBox: (camera: OrthographicCamera, viewBox: Box3) => void;
+export declare const setPerspectiveViewVolumeFromBox: (camera: PerspectiveCamera, viewBox: Box3) => void;
+export declare class SceneVolume {
+    bounds: Box3;
+    size: Vector3;
+    center: Vector3;
+    maxSceneDistanceFromCenter: number;
+    maxSceneDistanceFrom0: number;
+    copyFrom(other: SceneVolume): void;
+    updateFromObject(sceneObject: Object3D): void;
+    updateFromBox(boundingBox: Box3): void;
+    updateCameraViewVolumeFromBounds(camera: Camera): void;
+    getNearAndFarForPerspectiveCamera(cameraPosition: Vector3, backScale?: number): number[];
+}
+export declare const getMaxSamples: (renderTarget: WebGLRenderer) => number;
+export declare class BoxUpdateHelper {
+    box: Box3;
+    color: ColorRepresentation;
+    opacity: number;
+    private _group;
+    private _boxMesh;
+    private _boxWire;
+    get visible(): boolean;
+    set visible(isVisible: boolean);
+    get object(): Object3D;
+    constructor(box: Box3, parameters?: {
+        color?: number;
+        opacity?: number;
+    });
+    update(): void;
+    addTo(scene: Object3D): void;
+    removeFrom(scene: Object3D): void;
+}
+export declare const boxFromOrthographicViewVolume: (camera: OrthographicCamera) => Box3;
+export declare const boundingBoxInViewSpace: (worldBox: Box3, camera: Camera) => Box3;
+export declare class CameraUpdate {
+    private _lastCameraProjection;
+    private _lastCameraWorld;
+    changed(camera: Camera): boolean;
+}
+export declare const viewSpacePositionFromAltitudeAndAzimuth: (distance: number, altitudeDeg: number, azimuthDeg: number) => Vector3;
+export declare const viewSpacePositionFromUV: (distance: number, u: number, v: number) => Vector3;
+export declare const spiralQuadraticSampleKernel: (kernelSize: number) => Vector3[];
+export declare const generateUniformKernelRotations: () => DataTexture;
+export declare const generateMagicSquare: (size: number) => number[];
+export declare const generateMagicSquareDistributedKernelRotations: (size: number) => DataTexture;
+export declare class PassRenderer {
+    private _originalClearColor;
+    private _originalClearAlpha;
+    private _originalAutoClear;
+    private _originalRenderTarget;
+    private _screenSpaceQuad;
+    private _emptyScene;
+    private _defaultCamera;
+    renderWithOverrideMaterial(renderer: WebGLRenderer, scene: Scene, camera: Camera, overrideMaterial: Material | null, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    clear(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    renderScreenSpace(renderer: WebGLRenderer, passMaterial: Material, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
+    private _prepareRenderer;
+    private _backup;
+    private _restore;
+}
+export declare class BlurPass {
+    private _passRenderer;
+    private _blurMaterial;
+    constructor(blurShaderParameters?: ShaderMaterialParameters, parameters?: {
+        passRenderer?: PassRenderer;
+    });
+    dispose(): void;
+    render(renderer: WebGLRenderer, renderTargets: WebGLRenderTarget[], uvMin: number[], uvMax: number[]): void;
+}
+export interface DenoisePass {
+    get texture(): Texture | null;
+    set inputTexture(texture: Texture | null);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+}

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

@@ -0,0 +1,16 @@
+import type { SceneRenderer } from './scene-renderer';
+import type { GUI } from 'dat.gui';
+export declare class SceneRendererGUI {
+    private _sceneRenderer;
+    private _qualityLevel;
+    private _ambientOcclusionType;
+    constructor(sceneRenderer: SceneRenderer);
+    addGUI(gui: GUI, updateCallback: () => void): void;
+    private _addRepresentationalGUI;
+    private _addDebugGUI;
+    private _addShadowTypeGUI;
+    private _addShadowAndAoGUI;
+    private _addGroundReflectionGUI;
+    private _addBakedGroundContactShadowGUI;
+    private _addOutlineGUI;
+}

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

@@ -0,0 +1,117 @@
+import { SceneVolume } from './render-utility';
+import type { GBufferParameters } from './pass/gbuffer-render-pass';
+import type { GBufferRenderPass } from './pass/gbuffer-render-pass';
+import { ShadowGroundPlane } from './objects/shadow-ground-plane';
+import type { BakedGroundContactShadowParameters } from './pass/baked-ground-contact-shadow-pass';
+import type { BakedGroundContactShadowPass } from './pass/baked-ground-contact-shadow-pass';
+import type { GroundReflectionParameters } from './pass/ground-reflection-pass';
+import type { GroundReflectionPass } from './pass/ground-reflection-pass';
+import type { ScreenSpaceShadowMapParameters } from './pass/screen-space-shadow-map-pass';
+import type { ScreenSpaceShadowMapPass } from './pass/screen-space-shadow-map-pass';
+import type { ShadowAndAoPassParameters, ShadowBlurType } from './pass/shadow-and-ao-pass';
+import type { ShadowAndAoPass } from './pass/shadow-and-ao-pass';
+import type { OutlineParameters } from './outline-renderer';
+import { OutlineRenderer } from './outline-renderer';
+import type { DebugPass } from './pass/debug-pass';
+import type { LightSource } from './light-source-detection';
+import type { CustomShadingParameters, SceneShadingType } from './shading-settings';
+import { RenderCacheManager } from './render-cache';
+import type { SceneRenderPass } from './pass/scene-render-pass';
+import type { Enumify } from '../../types';
+import type { Box3, Camera, Object3D, PerspectiveCamera, RectAreaLight, Scene, WebGLRenderer } from 'three';
+import { 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 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;
+    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 debugPass(): DebugPass;
+    get shadowAndAoGroundPlane(): ShadowGroundPlane;
+    constructor(renderer: WebGLRenderer, width: number, height: number);
+    private _addEventListeners;
+    dispose(): void;
+    setSize(width: number, height: number): 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;
+    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/lib/definitions/packages/common-core/src/webgl/renderer/shader-utility.d.ts

@@ -0,0 +1,112 @@
+import type { Enumify } from '../../types';
+import type { Blending, BlendingDstFactor, BlendingEquation, BlendingSrcFactor, 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;
+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/lib/definitions/packages/common-core/src/webgl/renderer/shaders/ao-shader.d.ts

@@ -0,0 +1,84 @@
+import type { Enumify } from '../../../types';
+import type { Texture } from 'three';
+import { 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/lib/definitions/packages/common-core/src/webgl/renderer/shaders/poisson-denoise-shader.d.ts

@@ -0,0 +1,74 @@
+import type { Texture } from 'three';
+import { 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) => Vector3[];
+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/lib/definitions/packages/common-core/src/webgl/renderer/shading-settings.d.ts

@@ -0,0 +1,49 @@
+import type { Nullable } from '../../../../typings/helper';
+import type { 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/lib/definitions/packages/common-core/src/webgl/roomle-component-factory.d.ts

@@ -0,0 +1,103 @@
+import type { RoomleEventedMesh, RoomleEventedObject3D } from '../utils/threejs-utils';
+import type { CanvasOffset } from '../common-interfaces';
+import type { KernelCube, KernelVector3 } from '../../../typings/kernel';
+import type { Euler } from 'three';
+import { Box3, Mesh, OrthographicCamera, PerspectiveCamera, Vector3 } from 'three';
+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;
+    animationValues?: Map<string, string>;
+    replaceMeshes(meshes: Mesh[]): void;
+    addMesh(mesh: Mesh, transform?: Float32Array): void;
+    removeMesh(mesh: Mesh): void;
+    removeMeshById(meshId: number): 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(aniamtion: string, from: string, to: string, 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;
+    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 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/lib/definitions/packages/common-core/src/webgl/roomle-webgl-renderer-quality-levels.d.ts

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