@roomle/web-sdk 2.59.0-bo-mvp.3 → 2.60.0-alpha.1

package/lib/definitions/common-core/src/utils/threejs-utils.d.ts

@@ -1,9 +1,8 @@
 import { Dimensioning, KernelCube, KernelEnum } from '../../../typings/kernel';
 import { AssetUrl, RapiMaterial, RapiMaterialShading, RapiTexture } from '../../../typings/rapi-types';
+import EnvironmentLoader from '../services/environment-loader';
 import { Position2, Position3 } from '../common-interfaces';
 import WallPlanElementViewModel from '../../../planner-core/src/view-model/wall-plan-element-view-model';
-import { Box3, BufferGeometry, Camera, Color, CubeTexture, DataTexture, Layers, Material, Mesh, MeshBasicMaterial, MeshPhysicalMaterial, MeshStandardMaterial, Object3D, Quaternion, Scene, Texture, Vector2, Vector3 } from 'three';
-import { GUI } from 'dat.gui';
 export declare const PREVIEW_LINE_MATERIAL_OPACITY = 0.4;
 export declare const PREVIEW_MATERIAL_COLOR = "#DDDDDD";
 export declare const PREVIEW_MATERIAL_ROUGHNESS = 1;
@@ -13,55 +12,53 @@ export declare const DOCK_PREVIEW_MATERIAL_ROUGHNESS = 1;
 export declare const DOCK_PREVIEW_MATERIAL_METALNESS = 0;
 export declare const DOCK_PREVIEW_MATERIAL_OPACITY = 0.8;
 export declare const DOCK_PREVIEW_MATERIAL_OPACITY_HOVERED = 0.9;
-export declare const getScreenXY: (obj: Vector3, camera: Camera, clientWidth: number, clientHeight: number) => Vector3;
-export declare const kernelBoxToThreeBox: (kernelCube: KernelCube, margin?: Vector3) => Box3;
+export declare const getScreenXY: (obj: THREE.Vector3, camera: THREE.Camera, clientWidth: number, clientHeight: number) => THREE.Vector3;
+export declare const kernelBoxToThreeBox: (kernelCube: KernelCube, margin?: THREE.Vector3) => THREE.Box3;
 export declare const kernelDimensioningToThree: (dimensions: Dimensioning) => Dimensioning;
-export declare const setShadows: (object: Object3D, receiveShadow: boolean, castShadow: boolean) => void;
-export declare const position3VectorsAreEqual: (a: Vector3, b: Vector3) => boolean;
-export declare const rotationQuaternionsAreEqual: (a: Quaternion, b: Quaternion) => boolean;
-export declare const position2VectorsAreEqual: (a: Vector2, b: Vector2) => boolean;
-export declare const createColorTexture: (red: number, green: number, blue: number, alpha: number) => DataTexture;
-export declare const createColorCubeTexture: (red: number, green: number, blue: number, alpha: number) => CubeTexture;
-export declare const createMaterial: (material: RapiMaterial, envMapIntensity: number) => MeshPhysicalMaterial;
-export declare const setMaterial: (meshPhysicalMaterial: MeshPhysicalMaterial, rapiMaterial: RapiMaterial, envMapIntensity: number) => MeshPhysicalMaterial;
-export declare const getMaterialShading: (material: MeshPhysicalMaterial) => RapiMaterialShading;
-export declare const logColor: (color: Color) => void;
-export declare const createTexture: (texture: Texture, rapiTexture: RapiTexture, width: number, height: number, maxAnisotropy: number) => Texture;
-export declare const addTexture: (assetUrl: AssetUrl, rapiTexture: RapiTexture, material: MeshPhysicalMaterial, maxAnisotropy: number, repeatWidth: number, repeatHeight: number, maxTextures?: number) => Promise<void>;
-export declare const addExistingTexture: (texture: Texture, rapiTexture: RapiTexture, material: MeshPhysicalMaterial, maxAnisotropy: number, repeatWidth: number, repeatHeight: number, maxTextures?: number) => void;
-export declare const getGUI: (autoplace?: boolean) => GUI;
-export declare const setWallTransparencyBasedOnCamera: (camera: Camera, material: Material, animate?: boolean) => void;
-export declare const hideWallsBasedOnCamera: (camera: Camera, wallPlanElementViewModels: WallPlanElementViewModel[]) => boolean;
-export declare const setWallTransparency: (material: Material, transparent: boolean, animate?: boolean) => void;
-export declare const getColorFromInt: (combinedColor: number) => Color;
-export declare const transitionTransparencyOfMaterial: (object: Object3D, toMaterial: {
+export declare const setShadows: (object: THREE.Object3D, receiveShadow: boolean, castShadow: boolean) => void;
+export declare const position3VectorsAreEqual: (a: THREE.Vector3, b: THREE.Vector3) => boolean;
+export declare const rotationQuaternionsAreEqual: (a: THREE.Quaternion, b: THREE.Quaternion) => boolean;
+export declare const position2VectorsAreEqual: (a: THREE.Vector2, b: THREE.Vector2) => boolean;
+export declare const createColorTexture: (red: number, green: number, blue: number, alpha: number) => import("three").DataTexture;
+export declare const createColorCubeTexture: (red: number, green: number, blue: number, alpha: number) => import("three").CubeTexture;
+export declare const createMaterial: (material: RapiMaterial, environmentLoader?: EnvironmentLoader) => THREE.MeshPhysicalMaterial;
+export declare const setMaterial: (meshPhysicalMaterial: THREE.MeshPhysicalMaterial, rapiMaterial: RapiMaterial, environmentLoader?: EnvironmentLoader) => THREE.MeshPhysicalMaterial;
+export declare const getMaterialShading: (material: THREE.MeshPhysicalMaterial) => RapiMaterialShading;
+export declare const logColor: (color: THREE.Color) => void;
+export declare const createTexture: (texture: THREE.Texture, rapiTexture: RapiTexture, width: number, height: number, maxAnisotropy: number) => THREE.Texture;
+export declare const addTexture: (assetUrl: AssetUrl, rapiTexture: RapiTexture, material: THREE.MeshPhysicalMaterial, maxAnisotropy: number, repeatWidth: number, repeatHeight: number, maxTextures?: number) => Promise<void>;
+export declare const addExistingTexture: (texture: THREE.Texture, rapiTexture: RapiTexture, material: THREE.MeshPhysicalMaterial, maxAnisotropy: number, repeatWidth: number, repeatHeight: number, maxTextures?: number) => void;
+export declare const getGUI: (autoplace?: boolean) => dat.GUI;
+export declare const setWallTransparencyBasedOnCamera: (camera: THREE.Camera, material: THREE.Material, animate?: boolean) => void;
+export declare const hideWallsBasedOnCamera: (camera: THREE.Camera, wallPlanElementViewModels: WallPlanElementViewModel[]) => void;
+export declare const setWallTransparency: (material: THREE.Material, transparent: boolean, animate?: boolean) => void;
+export declare const getColorFromInt: (combinedColor: number) => THREE.Color;
+export declare const transitionTransparencyOfMaterial: (object: THREE.Object3D, toMaterial: {
     opacity: number;
     transparent: boolean;
 }) => void;
-export declare const fadeIn: (object: Object3D) => void;
-export declare const fadeOut: (object: Object3D, scene?: Scene) => void;
-export declare const checkGLB: (glb: Object3D, url: string) => boolean;
-export declare const dispose: (object: Object3D) => void;
-export declare const disposeObject: (object: Object3D) => void;
-export declare const disposeMesh: (mesh: Mesh) => void;
-export declare const disposeGeometry: (geometry: BufferGeometry) => void;
-export declare const disposeMaterial: (material: MeshStandardMaterial) => void;
-export declare const getBoundingBoxMaterial: () => MeshBasicMaterial;
-export declare const getSelectionGeometry: (position: Vector3, size: Vector3) => BufferGeometry;
-export declare const vectorIsZero: (vector: Vector3) => boolean;
+export declare const fadeIn: (object: THREE.Object3D) => void;
+export declare const fadeOut: (object: THREE.Object3D, scene?: THREE.Scene) => void;
+export declare const checkGLB: (glb: THREE.Object3D, url: string) => boolean;
+export declare const dispose: (object: THREE.Object3D) => void;
+export declare const disposeObject: (object: THREE.Object3D) => void;
+export declare const disposeMesh: (mesh: THREE.Mesh) => void;
+export declare const disposeGeometry: (geometry: THREE.BufferGeometry) => void;
+export declare const disposeMaterial: (material: THREE.MeshStandardMaterial) => void;
+export declare const getBoundingBoxMaterial: () => THREE.MeshBasicMaterial;
+export declare const getSelectionGeometry: (position: THREE.Vector3, size: THREE.Vector3) => THREE.Geometry;
+export declare const vectorIsZero: (vector: THREE.Vector3) => boolean;
 export declare const getMaterialId: (material: any, type?: KernelEnum) => string;
-export declare const vectorIsEqual: (vector1: Vector3, vector2: Vector3, tolerance?: number) => boolean;
-export declare const getYRotationOfObject: (object: Object3D) => number;
+export declare const vectorIsEqual: (vector1: THREE.Vector3, vector2: THREE.Vector3, tolerance?: number) => boolean;
+export declare const getYRotationOfObject: (object: THREE.Object3D) => number;
 /**
  * compares x and z and ignores y
  * @param box1
  * @param box2
  */
-export declare const compareBox3Size: (box1: Box3, box2: Box3) => number;
+export declare const compareBox3Size: (box1: THREE.Box3, box2: THREE.Box3) => number;
 export declare const isUVIdentityMatrix: (uvTransform: Float32Array) => boolean;
-export declare const getDrawingMinBounds: (planBounds: Box3, width: number, height: number, marginMultiplier?: number) => Box3;
-export declare const threeVectorToTransferableXY: (vec: Vector2 | Vector3) => Position2;
-export declare const threeVectorToTransferableXYZ: (vec: Vector3) => Position3;
-export declare const getActiveLayers: (layers: Layers) => string[];
-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 getDrawingMinBounds: (planBounds: THREE.Box3, width: number, height: number, marginMultiplier?: number) => THREE.Box3;
+export declare const threeVectorToTransferableXY: (vec: THREE.Vector2 | THREE.Vector3) => Position2;
+export declare const threeVectorToTransferableXYZ: (vec: THREE.Vector3) => Position3;
+export declare const getActiveLayers: (layers: THREE.Layers) => string[];

package/lib/definitions/common-core/src/view-model/configurator-view-model.d.ts

@@ -8,7 +8,6 @@ import { PromiseQueue } from '../utils/promise-queue';
 import InitData from '../utils/init-data';
 import MeshGenerator from '../webgl/mesh-generator';
 import PlannerKernelAccess from '../../../planner-core/src/services/planner-kernel-access';
-import { Box3, Mesh } from 'three';
 export declare const DOCKING_CONVERSATION_ID = 10;
 export declare const DEFAULT_CONVERSATION_ID = 9;
 export interface ConfiguratorViewModelCallbackI {
@@ -89,8 +88,8 @@ export default class ConfiguratorViewModel implements ConfiguratorKernelCallback
     planObjectUpdated(planObject: PlanObject): void;
     sceneCleared(): void;
     setListener(listener: ConfiguratorViewModelCallbackI): void;
-    getBoundingBox(): Box3;
-    getBoundingBoxWithPreviews(): Box3;
+    getBoundingBox(): THREE.Box3;
+    getBoundingBoxWithPreviews(): THREE.Box3;
     hasPreviews(): boolean;
     clearRootComponent(): void;
     debugSceneGraph(id?: number): void;
@@ -103,10 +102,10 @@ export default class ConfiguratorViewModel implements ConfiguratorKernelCallback
     setGeometriesMergedListener(fun: () => void): void;
     removeGeometriesMergedListener(): void;
     setMergeThreshold(threshold: number): void;
-    protected _generateMesh(runtimeComponentId: number, geometryId: string, materialId: string, vertices: Int32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, _type?: KernelEnum, _newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
-    protected _setMaterial(mesh: Mesh, material: any, _type?: KernelEnum): void;
+    protected _generateMesh(runtimeComponentId: number, geometryId: string, materialId: string, vertices: Int32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, _type?: KernelEnum, _newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): THREE.Mesh;
+    protected _setMaterial(mesh: THREE.Mesh, material: any, _type?: KernelEnum): void;
     constructComponents(planObjectId: number): void;
-    requestSubPartConstruction(partId: number): Promise<Mesh>;
+    requestSubPartConstruction(partId: number): Promise<THREE.Mesh>;
     protected getMeshGenerator(): MeshGenerator;
     setRequestRenderCallback(requestRenderCallback: () => void): void;
 }

package/lib/definitions/common-core/src/view-model/plan-element-view-model.d.ts

@@ -1,10 +1,9 @@
 import KernelViewModel from './kernel-view-model';
 import { PlanObject } from '../../../typings/planner';
-import { Box3, Mesh, Object3D, Vector3 } from 'three';
 export declare const WALL_SELECTION_COLOR = 10526880;
 export default class PlanElementViewModel extends KernelViewModel {
-    protected _container: Object3D;
-    protected _boundingBox: Mesh;
+    protected _container: THREE.Object3D;
+    protected _boundingBox: THREE.Mesh;
     private _object;
     private _selectionMesh;
     protected _isSelected: boolean;
@@ -12,25 +11,25 @@ export default class PlanElementViewModel extends KernelViewModel {
     private _objectWaiter;
     protected _topView: boolean;
     constructor(planObject: PlanObject);
-    getSize(): Vector3;
+    getSize(): THREE.Vector3;
     update(): void;
     protected _updateBoundingBox(): void;
-    getPosition(): Vector3;
+    getPosition(): THREE.Vector3;
     getRotation(): number;
-    getBounds(): Box3;
-    getBoundingBox(): Mesh;
+    getBounds(): THREE.Box3;
+    getBoundingBox(): THREE.Mesh;
     getPlanElement(): PlanObject;
-    setObject(object: Object3D): void;
-    getObject(): Object3D<import("three").Event>;
-    getObjectAsync(): Promise<Object3D<import("three").Event>>;
-    addMesh(mesh: Object3D): void;
-    getMesh(material: any): Mesh;
-    getContainer(): Object3D;
+    setObject(object: THREE.Object3D): void;
+    getObject(): import("three").Object3D;
+    getObjectAsync(): Promise<import("three").Object3D>;
+    addMesh(mesh: THREE.Object3D): void;
+    getMesh(material: any): THREE.Mesh;
+    getContainer(): THREE.Object3D;
     getId(): number;
     clear(): void;
     remove(): void;
     hidePreviewBox(): void;
-    protected _generateBoundingBox(): Mesh;
+    protected _generateBoundingBox(): THREE.Mesh;
     select(): void;
     deselect(): void;
     hoverOn(): void;

package/lib/definitions/common-core/src/view-model/plan-object-view-model.d.ts

@@ -1,6 +1,5 @@
 import { PlanObject } from '../../../typings/planner';
 import PlanElementViewModel from './plan-element-view-model';
-import { Vector3 } from 'three';
 export default class PlanObjectViewModel extends PlanElementViewModel {
     private _initDone;
     private _initFailed;
@@ -10,6 +9,6 @@ export default class PlanObjectViewModel extends PlanElementViewModel {
     protected failInit(error: Error): Promise<void>;
     isInitDone(): Promise<void>;
     getPlanObject(): PlanObject;
-    getSize(): Vector3;
+    getSize(): THREE.Vector3;
     update(): void;
 }

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

@@ -3,7 +3,7 @@ export declare class EnvMapReader {
     private _lightDirection;
     private _size;
     private _maxLod;
-    private _colorSpace;
+    private _encoding;
     private _type;
     private _format;
     private _cubeTexture;

package/lib/definitions/common-core/src/webgl/baked-shadow-plane.d.ts

@@ -1,4 +1,3 @@
-import { Mesh, Object3D } from 'three';
 export default class BakedShadowPlane {
     private _innerPlaneMesh;
     private _outerPlaneMesh;
@@ -6,9 +5,9 @@ export default class BakedShadowPlane {
     private _innerSize;
     private _outerSize;
     constructor(size: number);
-    getRootNode(): Object3D<import("three").Event>;
-    getInnerPlane(): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[]>;
-    getOuterPlane(): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[]>;
+    getRootNode(): import("three").Object3D;
+    getInnerPlane(): import("three").Mesh<import("three").Geometry | import("three").BufferGeometry, import("three").Material | import("three").Material[]>;
+    getOuterPlane(): import("three").Mesh<import("three").Geometry | import("three").BufferGeometry, import("three").Material | import("three").Material[]>;
     updateSize(innerSize: number): void;
     private _updatePlane;
 }

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

@@ -1,5 +1,5 @@
 import { Base64Image } from '../common-interfaces';
-import { Box3, PerspectiveCamera, Scene, Texture, Vector3 } from 'three';
+import { Pixotron } from '../../../typings/pixotron';
 declare const DEFAULT_RENDER_OPTIONS: {
     /**
      * if true we use the current camera perspective
@@ -12,21 +12,14 @@ export interface PrepareImageOptions {
     showDimensions?: boolean;
 }
 export interface CameraTarget {
-    center: Vector3;
-    bounds: Vector3;
+    center: THREE.Vector3;
+    bounds: THREE.Vector3;
     diagonal: number;
 }
-export default class ImageRenderer {
-    private _roomleRenderer;
-    private _getRoomleRenderer;
-    setEnvMap(scene: Scene, envMap: Texture): void;
-    switchToPlannerSettings(): void;
-    switchToConfiguratorSettings(): void;
-    static getCameraTargetForBBox(bbox: Box3, spacing?: number): CameraTarget;
-    preparePerspectiveImage(scene: Scene, uiScene: Scene, camera: PerspectiveCamera, cameraTarget: CameraTarget, options?: PrepareImageOptions, objectRotation?: number): 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 declare const getImageRenderer: () => THREE.WebGLRenderer;
+export declare const getCameraTargetForBBox: (bbox: THREE.Box3, spacing?: number) => CameraTarget;
+export declare const preparePerspectiveImage: (scene: THREE.Scene, uiScene: THREE.Scene, camera: THREE.PerspectiveCamera, cameraTarget: CameraTarget, options?: PrepareImageOptions, objectRotation?: number) => Promise<Base64Image>;
+export declare const renderPerspectiveImage: (scene: THREE.Scene, camera: THREE.PerspectiveCamera, cameraTarget: CameraTarget, pixotron: Pixotron, sceneRenderer: THREE.WebGLRenderer, size?: number) => Promise<Base64Image>;
+export declare const placeCameraForPerspectiveImage: (camera: THREE.PerspectiveCamera, cameraTarget: CameraTarget, angleX: number, angleY: number) => void;
+export declare const prepareTopImage: (scene: THREE.Scene, uiScene: THREE.Scene, cameraTarget: CameraTarget, options?: PrepareImageOptions) => Promise<Base64Image>;
 export {};

package/lib/definitions/common-core/src/webgl/mesh-generator.d.ts

@@ -1,46 +1,46 @@
 import RapiAccess from '../../../common-core/src/rapi-access';
+import EnvironmentLoader from '../../../common-core/src/services/environment-loader';
 import DataSyncer from '../../../common-core/src/services/data-syncer';
 import SinglePromiseFactory from '../utils/single-promise-factory';
 import { RapiMaterial } from '../../../typings/rapi-types';
 import CacheHolder from '../services/cache-holder';
 import { Context } from '../di/context';
 import { PromiseQueue } from '../utils/promise-queue';
-import { BufferGeometry, Material, 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 _environmentLoader: EnvironmentLoader;
     protected _dataSyncer: DataSyncer;
     protected _singlePromiseFactory: SinglePromiseFactory;
     protected _cacheHolder: CacheHolder;
     private _plannerMeshGenerator;
-    protected _materialLoaded: (material: Material) => void;
+    protected _materialLoaded: (material: THREE.Material) => void;
     protected _maxAnisotropy: number;
     protected _maxTextures: number;
-    protected _textureLoader: TextureLoader;
-    protected _previewMaterial: MeshStandardMaterial;
-    protected _configuratorPreviewMaterial: MeshStandardMaterial;
+    protected _textureLoader: import("three").TextureLoader;
+    protected _previewMaterial: THREE.MeshStandardMaterial;
+    protected _configuratorPreviewMaterial: import("three").MeshStandardMaterial;
     constructor(creator: string);
-    getGeometry(meshId: string): BufferGeometry;
-    protected _generateGeometry(meshId: string, vertices: Int32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): BufferGeometry;
-    changeMaterialOfMesh(mesh: Mesh, material: Material, materialAttributes?: Record<string, string>): void;
+    getGeometry(meshId: string): THREE.BufferGeometry;
+    protected _generateGeometry(meshId: string, vertices: Int32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): THREE.BufferGeometry;
+    changeMaterialOfMesh(mesh: THREE.Mesh, material: THREE.Material, materialAttributes?: Record<string, string>): void;
     private _updateMaterialProperties;
     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>;
+    protected _loadTextures(rapiMaterial: RapiMaterial, material: THREE.MeshPhysicalMaterial, width?: number, height?: number): Promise<void>;
+    protected _loadMaterial(materialId: string, width?: number, height?: number): Promise<THREE.Material>;
+    protected _assignMaterial(mesh: THREE.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>;
+    protected _assignRGB(mesh: THREE.Mesh, rgbValue: number): Promise<void>;
+    protected _assignItem(mesh: THREE.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> | Mesh<BufferGeometry<import("three").NormalBufferAttributes>, MeshStandardMaterial>;
+    protected _createMesh(runtimeComponentId: number, geometryId: string, geometry: THREE.BufferGeometry): import("three").Mesh<import("three").BufferGeometry, import("three").Material>;
     protected _getComponentMeshId(runtimeComponentId: number, geometryId: string): string;
 }

package/lib/definitions/common-core/src/webgl/pixotron-util.d.ts

@@ -0,0 +1,39 @@
+import { Pixotron } from '../../../typings/pixotron';
+export default class PixotronUtil {
+    private _pixotron;
+    private _autoQualityAdapter;
+    private _manualQualityAdapter;
+    private _currentQualityAdapter;
+    private _highestQualitySetting;
+    private _highPixelRatioQualitySetting;
+    private _highQualitySetting;
+    private _midQualitySetting;
+    private _lowQualitySetting;
+    private _lowestQualitySetting;
+    private _sceneBoundingSphere;
+    private _currentQualitySetting;
+    constructor(pixotron: Pixotron);
+    getPixotronInstance(params?: any): Pixotron;
+    showGUI(): void;
+    updateBounds(bounds: THREE.Sphere): void;
+    private _getSaoRadius;
+    private _adjustSaoRadius;
+    private _adjustSaoBias;
+    private _getMinSaoRadius;
+    private _getMaxSaoRadius;
+    private _getMinSaoBias;
+    private _getMaxSaoBias;
+    updatePixelRatio(renderer: THREE.WebGLRenderer): void;
+    getHighPixelRatioQualitySetting(): any;
+    getLowestQualitySetting(): any;
+    private _initializeQualitySettings;
+    private _initializeQualityAdapters;
+    onAutoQualityChange(qualityChangeCallback: any): void;
+    onManualQualityChange(qualityChangeCallback: any): void;
+    getAutoAdapter(): any;
+    lockAdapter(): void;
+    unLockAdapter(): void;
+    enablePixotronAutoQuality(): void;
+    movingCameraStarts(): void;
+    movingCameraStops(): void;
+}

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

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

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

@@ -2,14 +2,13 @@ import EventDispatcher from '../../../configurator-core/src/utils/event-dispatch
 import RaycastHelper from '../../../configurator-core/src/utils/raycast-helper';
 import { Context } from '../di/context';
 import InputManager from '../input/input-manager';
-import { Camera, Scene } from 'three';
 export default abstract class SceneEventHandler<EventType> extends EventDispatcher<EventType> implements Context {
     _creator_: string;
     protected _inputManager: InputManager;
     protected _raycastHelper: RaycastHelper;
     protected _debug: boolean;
     protected _dragIn: boolean;
-    constructor(creator: string, scene: Scene, camera: Camera, inputManager: InputManager);
+    constructor(creator: string, scene: THREE.Scene, camera: THREE.Camera, inputManager: InputManager);
     protected abstract _interaction(): void;
     isDragIn(): boolean;
     setDragIn(dragIn: boolean, dragEvent?: DragEvent): void;

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

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

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

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

package/lib/definitions/configurator-core/__tests__/configurator-image-renderer.d.ts

@@ -0,0 +1 @@
+export {};