@roomle/web-sdk 2.60.0-alpha.2 → 2.60.0-alpha.3

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

@@ -1,8 +1,9 @@
 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;
@@ -12,53 +13,55 @@ 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: 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 getScreenXY: (obj: Vector3, camera: Camera, clientWidth: number, clientHeight: number) => Vector3;
+export declare const kernelBoxToThreeBox: (kernelCube: KernelCube, margin?: Vector3) => Box3;
 export declare const kernelDimensioningToThree: (dimensions: Dimensioning) => Dimensioning;
-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: {
+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: {
     opacity: number;
     transparent: boolean;
 }) => void;
-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 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 getMaterialId: (material: any, type?: KernelEnum) => string;
-export declare const vectorIsEqual: (vector1: THREE.Vector3, vector2: THREE.Vector3, tolerance?: number) => boolean;
-export declare const getYRotationOfObject: (object: THREE.Object3D) => number;
+export declare const vectorIsEqual: (vector1: Vector3, vector2: Vector3, tolerance?: number) => boolean;
+export declare const getYRotationOfObject: (object: Object3D) => number;
 /**
  * compares x and z and ignores y
  * @param box1
  * @param box2
  */
-export declare const compareBox3Size: (box1: THREE.Box3, box2: THREE.Box3) => number;
+export declare const compareBox3Size: (box1: Box3, box2: Box3) => number;
 export declare const isUVIdentityMatrix: (uvTransform: Float32Array) => boolean;
-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[];
+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;

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

@@ -8,6 +8,7 @@ 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 {
@@ -88,8 +89,8 @@ export default class ConfiguratorViewModel implements ConfiguratorKernelCallback
     planObjectUpdated(planObject: PlanObject): void;
     sceneCleared(): void;
     setListener(listener: ConfiguratorViewModelCallbackI): void;
-    getBoundingBox(): THREE.Box3;
-    getBoundingBoxWithPreviews(): THREE.Box3;
+    getBoundingBox(): Box3;
+    getBoundingBoxWithPreviews(): Box3;
     hasPreviews(): boolean;
     clearRootComponent(): void;
     debugSceneGraph(id?: number): void;
@@ -102,10 +103,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>): THREE.Mesh;
-    protected _setMaterial(mesh: THREE.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>): Mesh;
+    protected _setMaterial(mesh: Mesh, material: any, _type?: KernelEnum): void;
     constructComponents(planObjectId: number): void;
-    requestSubPartConstruction(partId: number): Promise<THREE.Mesh>;
+    requestSubPartConstruction(partId: number): Promise<Mesh>;
     protected getMeshGenerator(): MeshGenerator;
     setRequestRenderCallback(requestRenderCallback: () => void): void;
 }

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

@@ -1,9 +1,10 @@
 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: THREE.Object3D;
-    protected _boundingBox: THREE.Mesh;
+    protected _container: Object3D;
+    protected _boundingBox: Mesh;
     private _object;
     private _selectionMesh;
     protected _isSelected: boolean;
@@ -11,25 +12,25 @@ export default class PlanElementViewModel extends KernelViewModel {
     private _objectWaiter;
     protected _topView: boolean;
     constructor(planObject: PlanObject);
-    getSize(): THREE.Vector3;
+    getSize(): Vector3;
     update(): void;
     protected _updateBoundingBox(): void;
-    getPosition(): THREE.Vector3;
+    getPosition(): Vector3;
     getRotation(): number;
-    getBounds(): THREE.Box3;
-    getBoundingBox(): THREE.Mesh;
+    getBounds(): Box3;
+    getBoundingBox(): Mesh;
     getPlanElement(): PlanObject;
-    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;
+    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;
     getId(): number;
     clear(): void;
     remove(): void;
     hidePreviewBox(): void;
-    protected _generateBoundingBox(): THREE.Mesh;
+    protected _generateBoundingBox(): Mesh;
     select(): void;
     deselect(): void;
     hoverOn(): void;

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

@@ -1,5 +1,6 @@
 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;
@@ -9,6 +10,6 @@ export default class PlanObjectViewModel extends PlanElementViewModel {
     protected failInit(error: Error): Promise<void>;
     isInitDone(): Promise<void>;
     getPlanObject(): PlanObject;
-    getSize(): THREE.Vector3;
+    getSize(): 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 _encoding;
+    private _colorSpace;
     private _type;
     private _format;
     private _cubeTexture;

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

@@ -1,3 +1,4 @@
+import { Mesh, Object3D } from 'three';
 export default class BakedShadowPlane {
     private _innerPlaneMesh;
     private _outerPlaneMesh;
@@ -5,9 +6,9 @@ export default class BakedShadowPlane {
     private _innerSize;
     private _outerSize;
     constructor(size: number);
-    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[]>;
+    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[]>;
     updateSize(innerSize: number): void;
     private _updatePlane;
 }

package/lib/definitions/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/lib/definitions/common-core/src/webgl/image-renderer.d.ts

@@ -1,5 +1,5 @@
 import { Base64Image } from '../common-interfaces';
-import { Pixotron } from '../../../typings/pixotron';
+import { Box3, PerspectiveCamera, Scene, Texture, Vector3 } from 'three';
 declare const DEFAULT_RENDER_OPTIONS: {
     /**
      * if true we use the current camera perspective
@@ -12,14 +12,21 @@ export interface PrepareImageOptions {
     showDimensions?: boolean;
 }
 export interface CameraTarget {
-    center: THREE.Vector3;
-    bounds: THREE.Vector3;
+    center: Vector3;
+    bounds: Vector3;
     diagonal: number;
 }
-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 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 {};

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: THREE.Material) => void;
+    protected _materialLoaded: (material: Material) => void;
     protected _maxAnisotropy: number;
     protected _maxTextures: number;
-    protected _textureLoader: import("three").TextureLoader;
-    protected _previewMaterial: THREE.MeshStandardMaterial;
-    protected _configuratorPreviewMaterial: import("three").MeshStandardMaterial;
+    protected _textureLoader: TextureLoader;
+    protected _previewMaterial: MeshStandardMaterial;
+    protected _configuratorPreviewMaterial: MeshStandardMaterial;
     constructor(creator: string);
-    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;
+    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;
     private _updateMaterialProperties;
     protected _createMaterial(materialId: string, resolve: () => void, reject: (error: Error) => void, width?: number, height?: number): void;
     private _loadBenchmarkTextures;
-    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>;
+    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: THREE.Mesh, rgbValue: number): Promise<void>;
-    protected _assignItem(mesh: THREE.Mesh, catalogItemId: string): Promise<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: THREE.BufferGeometry): import("three").Mesh<import("three").BufferGeometry, import("three").Material>;
+    protected _createMesh(runtimeComponentId: number, geometryId: string, geometry: BufferGeometry): Mesh<BufferGeometry<import("three").NormalBufferAttributes>, Material> | Mesh<BufferGeometry<import("three").NormalBufferAttributes>, MeshStandardMaterial>;
     protected _getComponentMeshId(runtimeComponentId: number, geometryId: string): string;
 }

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

@@ -0,0 +1,59 @@
+import { SceneVolume } from './render-utility';
+import { Camera, Group, Layers, Mesh, Scene, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+export interface BakedGroundContactShadowParameters {
+    [key: string]: any;
+    enabled: boolean;
+    cameraHelper: boolean;
+    alwaysUpdate: boolean;
+    fadeIn: boolean;
+    blurMin: number;
+    blurMax: number;
+    fadeoutFalloff: number;
+    fadeoutBias: number;
+    opacity: number;
+    planeSize: number;
+    cameraFar: number;
+    hardLayers: Layers | null;
+    softLayers: Layers | null;
+    polygonOffset: number;
+    excludeGroundObjects: boolean;
+}
+export declare class BakedGroundContactShadow {
+    static addTestMesh: boolean;
+    private testMesh?;
+    shadowMapSize: number;
+    parameters: BakedGroundContactShadowParameters;
+    private renderer;
+    needsUpdate: boolean;
+    noNeedOfUpdateCount: number;
+    blurScale: number;
+    private groundGroup;
+    private groundShadowFar;
+    private shadowGroundPlane;
+    private groundContactCamera;
+    private renderTargetBlur;
+    private blurPass;
+    readonly renderTarget: WebGLRenderTarget;
+    private depthMaterial;
+    private renderOverrideVisibility;
+    constructor(renderer: WebGLRenderer, groundGroup: Group, parameters: any);
+    private getDefaultParameters;
+    dispose(): void;
+    updateParameters(parameters: any): void;
+    applyParameters(): void;
+    updateBounds(sceneBounds: SceneVolume, groundLevel?: number, groundContactShadowScale?: number): void;
+    updatePlaneAndShadowCamera(): void;
+    setGroundVisibility(visible: boolean, _camera?: Camera): void;
+    render(scene: Scene): void;
+    private renderGroundContact;
+    private renderBlur;
+    private renderReduceBandingBlur;
+    private renderBlurPass;
+}
+export declare class ShadowGroundPlane extends Mesh {
+    static alphaMap: boolean;
+    constructor(shadowMap: Texture | null, parameters?: any);
+    setShadowMap(shadowMap: Texture | null): void;
+    updateMaterial(parameters: any): void;
+    updateVisibility(visible: boolean): void;
+}

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

@@ -0,0 +1,108 @@
+import { DenoisePass } from './render-utility';
+import { Camera, Scene, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { SSAOPass } from 'realism-effects/src/ssao/SSAOPass.js';
+import { HBAOPass } from 'realism-effects/src/hbao/HBAOPass.js';
+import { PoissionDenoisePass } from 'realism-effects/src/poissionDenoise/PoissionDenoisePass.js';
+export declare enum NormalVectorSourceType {
+    INPUT_RGB_NORMAL = 0,
+    FLOAT_BUFFER_NORMAL = 1,
+    CONSTANT_Z = 2
+}
+export declare enum DepthValueSourceType {
+    SEPARATE_BUFFER = 0,
+    NORMAL_VECTOR_ALPHA = 1
+}
+export interface PoisonDenoiseParameters {
+    [key: string]: any;
+    iterations: number;
+    radius: number;
+    rings: number;
+    lumaPhi: number;
+    depthPhi: number;
+    normalPhi: number;
+    samples: number;
+}
+export interface SSAOEffectParameters {
+    [key: string]: any;
+    resolutionScale: number;
+    spp: number;
+    distance: number;
+    distancePower: number;
+    power: number;
+    bias: number;
+    thickness: number;
+}
+export interface HBAOEffectParameters {
+    [key: string]: any;
+    resolutionScale: number;
+    spp: number;
+    distance: number;
+    distancePower: number;
+    power: number;
+    bias: number;
+    thickness: number;
+}
+export declare const defaultSSAOEffectParameters: SSAOEffectParameters;
+export declare const defaultHBAOEffectParameters: HBAOEffectParameters;
+export declare const defaultPoisonDenoiseParameters: PoisonDenoiseParameters;
+export declare class SSAOEffect {
+    needsUpdate: boolean;
+    parameters: SSAOEffectParameters;
+    private width;
+    private height;
+    private loaded;
+    private normalVectorSourceType;
+    private depthValueSourceType;
+    private modulateRedChannel;
+    depthTexture: Texture | null;
+    normalTexture: Texture | null;
+    ssaoPass?: SSAOPass;
+    get texture(): Texture;
+    constructor(width: number, height: number, parameters?: any);
+    private getPass;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: any): void;
+    render(renderer: WebGLRenderer, camera: Camera, scene: Scene, renderTarget?: WebGLRenderTarget): void;
+}
+export declare class HBAOEffect {
+    needsUpdate: boolean;
+    parameters: HBAOEffectParameters;
+    private width;
+    private height;
+    private loaded;
+    private normalVectorSourceType;
+    private depthValueSourceType;
+    private modulateRedChannel;
+    depthTexture: Texture | null;
+    normalTexture: Texture | null;
+    hbaoPass?: HBAOPass;
+    get texture(): Texture;
+    constructor(width: number, height: number, parameters?: any);
+    private getPass;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: any): void;
+    render(renderer: WebGLRenderer, camera: Camera, scene: Scene, renderTarget?: WebGLRenderTarget): void;
+}
+export declare class PoissonDenoiseEffect implements DenoisePass {
+    needsUpdate: boolean;
+    parameters: PoisonDenoiseParameters;
+    private width;
+    private height;
+    private normalVectorSourceType;
+    private depthValueSourceType;
+    private rgInputTexture;
+    _inputTexture: Texture | null;
+    depthTexture: Texture | null;
+    normalTexture: Texture | null;
+    denoisePass?: PoissionDenoisePass;
+    get texture(): Texture | null;
+    set inputTexture(texture: Texture | null);
+    constructor(width: number, height: number, parameters?: any);
+    private getPass;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: any): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
+}

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

@@ -0,0 +1,43 @@
+import { NormalAndDepthRenderMaterial } from './shader-utility';
+import { Camera, MeshNormalMaterial, Scene, ShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+export interface GBufferTextures {
+    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
+    get gBufferTexture(): Texture;
+    get depthBufferTexture(): Texture;
+    get textureWithDepthValue(): Texture;
+}
+export interface GBufferParameters {
+    [key: string]: any;
+    depthNormalScale: number;
+}
+export declare class GBufferRenderTargets implements GBufferTextures {
+    parameters: GBufferParameters;
+    readonly floatGBufferRgbNormalAlphaDepth: boolean;
+    copyToSeparateDepthBuffer: boolean;
+    private targetMinificationTextureFilter;
+    private targetMagnificationTextureFilter;
+    private width;
+    private height;
+    private samples;
+    private _normalRenderMaterial?;
+    private _depthNormalRenderTarget?;
+    private _separateDeptRenderTarget?;
+    private renderPass;
+    private renderOverrideVisibility;
+    private copyMaterial?;
+    private shared;
+    needsUpdate: boolean;
+    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
+    get gBufferTexture(): Texture;
+    get depthBufferTexture(): Texture;
+    get textureWithDepthValue(): Texture;
+    get normalRenderMaterial(): MeshNormalMaterial | NormalAndDepthRenderMaterial;
+    get depthNormalRenderTarget(): WebGLRenderTarget;
+    get separateDeptRenderTarget(): WebGLRenderTarget;
+    constructor(parameters?: any);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera): void;
+    protected getCopyMaterial(parameters?: any): ShaderMaterial;
+    private copyDepthToSeparateDepthTexture;
+}

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

@@ -0,0 +1,72 @@
+import { Camera, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+export interface GroundReflectionParameters {
+    [key: string]: any;
+    enabled: boolean;
+    intensity: number;
+    fadeOut: number;
+    brightness: number;
+    blurHorizontal: number;
+    blurVertical: number;
+    blurAscent: number;
+    groundLevel: number;
+    renderTargetDownScale: number;
+}
+export declare class GroundReflectionPass {
+    private width;
+    private height;
+    parameters: GroundReflectionParameters;
+    private _shadowRenderTarget?;
+    private _reflectionRenderTarget?;
+    private _intensityRenderTarget?;
+    private _blurRenderTarget?;
+    private renderPass;
+    private blurPass;
+    private renderOverrideVisibility;
+    private groundShadowMaterial;
+    private reflectionIntensityMaterial;
+    private _copyMaterial;
+    get shadowRenderTarget(): WebGLRenderTarget;
+    get reflectionRenderTarget(): WebGLRenderTarget;
+    get intensityRenderTarget(): WebGLRenderTarget;
+    get blurRenderTarget(): WebGLRenderTarget;
+    constructor(width: number, height: number, parameters: any);
+    private newRenderTarget;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    updateParameters(parameters: any): void;
+    private updateCopyMaterial;
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera): void;
+    private renderGroundShadow;
+    private renderGroundReflection;
+    private renderGroundReflectionIntensity;
+    blurReflection(renderer: WebGLRenderer, camera: Camera, renderTargets: WebGLRenderTarget[]): void;
+    private createGroundReflectionCamera;
+}
+export declare class GroundReflectionIntensityMaterial extends ShaderMaterial {
+    private static shader;
+    constructor(parameters?: any);
+    update(parameters?: any): GroundReflectionIntensityMaterial;
+}
+export declare class GroundShadowMaterial extends ShaderMaterial {
+    private static shader;
+    constructor(parameters?: any);
+    update(parameters?: any): GroundReflectionIntensityMaterial;
+}
+export declare const BlurGroundReflectionShadowShader: {
+    uniforms: {
+        tDiffuse: {
+            value: Texture;
+        };
+        rangeMin: {
+            value: Vector2;
+        };
+        rangeMax: {
+            value: Vector2;
+        };
+        shadowScale: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};