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

package/packages/web-sdk/packages/common-core/src/utils/url-shortener.d.ts

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

package/packages/web-sdk/packages/common-core/src/utils/waiter.d.ts

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

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

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

package/packages/web-sdk/packages/common-core/src/view-model/configurator-plan-object-view-model.d.ts

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

package/packages/web-sdk/packages/common-core/src/view-model/configurator-view-model.d.ts

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

package/packages/web-sdk/packages/common-core/src/view-model/helpers/constants.d.ts

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

package/packages/web-sdk/packages/common-core/src/view-model/kernel-view-model.d.ts

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

package/packages/web-sdk/packages/common-core/src/view-model/plan-element-view-model.d.ts

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

package/packages/web-sdk/packages/common-core/src/view-model/plan-object-view-model.d.ts

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

package/packages/web-sdk/packages/common-core/src/wasm-loader.d.ts

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

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

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

package/packages/web-sdk/packages/common-core/src/webgl/baked-shadow-plane.d.ts

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

package/packages/web-sdk/packages/common-core/src/webgl/configurator-context.d.ts

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

package/packages/web-sdk/packages/common-core/src/webgl/hdr-env-map-reader.d.ts

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

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

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

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

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

package/packages/web-sdk/packages/common-core/src/webgl/mesh-generator.d.ts

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

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

@@ -0,0 +1,44 @@
+import { LightSource } from './light-source-detection';
+import { WebGLRenderer, CubeTexture, Scene, Texture } from 'three';
+
+export interface EnvironmentDefinitionTextureData {
+    _width: number;
+    _height: number;
+    data: number[];
+}
+interface EnvironmentDefinitionParameters {
+    textureData?: EnvironmentDefinitionTextureData;
+    rotation?: number;
+    intensity?: number;
+    maxNoOfLightSources?: number;
+}
+export declare abstract class EnvironmentSceneGenerator {
+    abstract generateScene(intensity: number, rotation: number): Scene;
+}
+export declare class EnvironmentDefinition {
+    needsUpdate: boolean;
+    readonly environmentSceneGenerator?: EnvironmentSceneGenerator;
+    readonly equirectangularTexture?: Texture;
+    readonly cubeTexture?: CubeTexture;
+    readonly textureData?: EnvironmentDefinitionTextureData;
+    private _rotation;
+    private _intensity;
+    private _maxNoOfLightSources?;
+    private _lightSources;
+    private _debugScene?;
+    private _parameters?;
+    private _environment;
+    get lightSources(): LightSource[];
+    set rotation(rotation: number);
+    set intensity(intensity: number);
+    set maxNoOfLightSources(maxNoOfLightSources: number);
+    get maxNoOfLightSources(): number | undefined;
+    constructor(environment: EnvironmentSceneGenerator | CubeTexture | Texture, parameters?: EnvironmentDefinitionParameters);
+    clone(): EnvironmentDefinition;
+    createNewEnvironment(renderer: WebGLRenderer): Texture | null;
+    private _getTextureOffset;
+    private _createPmremTexture;
+    private _detectLightSources;
+    createDebugScene(renderer: WebGLRenderer, scene: Scene, maxNoOfLightSources?: number): Scene | null;
+}
+export {};

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

@@ -0,0 +1,41 @@
+import { EnvironmentSceneGenerator } from './environment-definition';
+import { Enumify } from '../../types';
+import { Scene } from 'three';
+
+export declare const DEFAULT_ENVIRONMENT_SCENE_TYPES: {
+    readonly ALL_AROUND: "all_around";
+    readonly FRONT: "front";
+};
+export type DefaultEnvironmentSceneType = Enumify<typeof DEFAULT_ENVIRONMENT_SCENE_TYPES> | null;
+export interface DefaultEnvironmentSceneParameters {
+    type?: DefaultEnvironmentSceneType;
+    lightIntensity?: number;
+    topLightIntensity?: number;
+    sidLightIntensity?: number;
+    ambientLightIntensity?: number;
+    colorVariation?: number;
+}
+export declare class DefaultEnvironmentSceneGenerator extends EnvironmentSceneGenerator {
+    private _parameters;
+    constructor(parameters?: DefaultEnvironmentSceneParameters);
+    generateScene(intensity: number, rotation: number): Scene;
+}
+export declare class DefaultEnvironmentScene extends Scene {
+    private _type;
+    private _topLightIntensity;
+    private _sideLightIntensity;
+    private _sideReflectorIntensity;
+    private _ambientLightIntensity;
+    private _colorVariation;
+    private _lightGeometry;
+    private _reflectorLightGeometry;
+    constructor(parameters?: DefaultEnvironmentSceneParameters);
+    generateScene(scene: Scene): void;
+    dispose(): void;
+    private _createAllAroundSceneLight;
+    private _createFrontSceneLight;
+    private _createAreaLightMaterial;
+    private _createTopLight;
+    private _createSideLight;
+    private _createReflector;
+}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/light-source-detection-debug.d.ts

@@ -0,0 +1,15 @@
+import { LightSourceDetector } from './light-source-detection';
+import { Material, Scene, Mesh } from 'three';
+
+export declare class LightSourceDetectorDebug {
+    private _lightSourceDetector;
+    private _scene?;
+    constructor(lightSourceDetector: LightSourceDetector);
+    static createPlane(scene: Scene, material?: Material): Mesh;
+    createDebugScene(scene: Scene, maxNoOfLightSources?: number): void;
+    private _createLightGraphInMap;
+    private _createSamplePointsInMap;
+    private _createCirclesInMap;
+    private _createClusterLinesInMap;
+    private _uvToMapPosition;
+}

package/packages/web-sdk/packages/common-core/src/webgl/renderer/light-source-detection.d.ts

@@ -0,0 +1,87 @@
+import { WebGLRenderer, OrthographicCamera, ShaderMaterial, Texture, Vector2, Vector3, WebGLRenderTarget } from 'three';
+import { EnvironmentDefinitionTextureData } from './environment-definition';
+
+export declare const sphereToEquirectangular: (pointOnSphere: Vector3) => Vector2;
+export declare const equirectangularToSphere: (uv: Vector2) => Vector3;
+export interface TextureConverterResult {
+    texture: Texture;
+    pixels: Uint8Array | Float32Array;
+    sRgbaPixels: boolean;
+}
+export declare class TextureConverter {
+    private _colorRenderTarget?;
+    private _environmentMapDecodeTarget?;
+    private _equirectangularDecodeMaterial?;
+    private _pmremDecodeMaterial?;
+    private _camera?;
+    private _planeMesh?;
+    get colorRenderTarget(): WebGLRenderTarget;
+    environmentMapDecodeTarget(renderer: WebGLRenderer): WebGLRenderTarget;
+    environmentMapDecodeMaterial(decodePmrem: boolean): EnvironmentMapDecodeMaterial;
+    get camera(): OrthographicCamera;
+    scaleTexture(renderer: WebGLRenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
+    newGrayscaleTexture(renderer: WebGLRenderer, texture: Texture, targetWidth: number, targetHeight: number): TextureConverterResult;
+}
+export declare class EnvironmentMapDecodeMaterial extends ShaderMaterial {
+    constructor(decodePmrem: boolean, grayscale: boolean);
+    setSourceTexture(map: Texture): void;
+}
+export interface LightSourceDetectorParameters {
+    numberOfSamples?: number;
+    width?: number;
+    height?: number;
+    sampleThreshold?: number;
+}
+export declare class LightSourceDetector {
+    private _numberOfSamples;
+    private _width;
+    private _height;
+    private _sampleThreshold;
+    readonly pointDistance: number;
+    readonly pixelDistance: number;
+    readonly samplePoints: Vector3[];
+    readonly sampleUVs: Vector2[];
+    textureData?: any;
+    grayscaleTexture: TextureConverterResult;
+    detectorTexture: Texture;
+    detectorArray: Float32Array;
+    private _textureConverter?;
+    lightSamples: LightSample[];
+    lightGraph: LightGraph;
+    lightSources: LightSource[];
+    private _grayScale;
+    constructor(parameters?: LightSourceDetectorParameters);
+    detectLightSources(renderer: WebGLRenderer, equirectangularTexture: Texture, textureData?: EnvironmentDefinitionTextureData): void;
+    private _createEquirectangularSamplePoints;
+    private _redFromRgbaToNormalizedFloatArray;
+    private _grayscaleTextureFromFloatArray;
+    private _filterLightSamples;
+    private _detectorTextureLuminanceValueFromUV;
+    private _originalLuminanceValueFromUV;
+    private _findClusterSegments;
+    private createLightSourcesFromLightGraph;
+}
+export declare class LightSample {
+    readonly position: Vector3;
+    readonly uv: Vector2;
+    constructor(position: Vector3, uv: Vector2);
+}
+export declare class LightGraph {
+    readonly noOfNodes: number;
+    edges: number[][];
+    adjacent: number[][];
+    components: number[][];
+    constructor(noOfNodes: number);
+    findConnectedComponents(): void;
+    private _dfs;
+}
+export declare class LightSource {
+    readonly lightSamples: LightSample[];
+    position: Vector3;
+    uv: Vector2;
+    averageIntensity: number;
+    maxIntensity: number;
+    size: number;
+    constructor(lightSamples: LightSample[]);
+    calculateLightSourceProperties(luminanceFunction: (uv: Vector2) => number): void;
+}