@colijnit/homedecorator 255.1.1

package/app/plugins/core3d/service/item-group.service.d.ts

@@ -0,0 +1,33 @@
+import { OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Vector3 } from 'three';
+import { Item } from '../items/item';
+import { ItemGroup } from '../items/item-group';
+import { MessageBusService } from '../../../core/service/message-bus.service';
+import { ItemService } from './item.service';
+import * as i0 from "@angular/core";
+export declare class ItemGroupService implements OnDestroy {
+    private _messageBusService;
+    private _itemService;
+    objectAdded: Subject<Item | ItemGroup>;
+    grouped: Subject<ItemGroup>;
+    ungrouped: Subject<void>;
+    private _objectsToGroup;
+    private _selectedGroup;
+    private _subs;
+    set selectedGroup(value: ItemGroup);
+    constructor(_messageBusService: MessageBusService, _itemService: ItemService);
+    ngOnDestroy(): void;
+    removeGroup(group: ItemGroup): void;
+    addIfNotExist(object: Item): void;
+    addOrRemoveIfExist(object: Item): void;
+    resetObjectsToGroup(): void;
+    reattachToItemGroup(item: Item, itemGroup: ItemGroup, originalPosition: Vector3): void;
+    private _groupObjects;
+    private _unGroupObjects;
+    private _showMenu;
+    private _shouldBeWallItemGroup;
+    private _cancelGroupObjects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemGroupService>;
+}

package/app/plugins/core3d/service/item.service.d.ts

@@ -0,0 +1,37 @@
+import { OnDestroy } from '@angular/core';
+import * as THREE from 'three';
+import { Vector3 } from 'three';
+import { Subject } from 'rxjs';
+import { Item } from '../items/item';
+import { SceneService } from './scene.service';
+import { MessageBusService } from '../../../core/service/message-bus.service';
+import { ThreedModel } from '../model/threed-model';
+import { Furniture } from '../items/furniture';
+import * as i0 from "@angular/core";
+export declare class ItemService implements OnDestroy {
+    private _sceneService;
+    private _messageService;
+    items: Item[];
+    copyItem: Subject<Item>;
+    deleteItem: Subject<Item>;
+    removeAllItems: Subject<void>;
+    constructor(_sceneService: SceneService, _messageService: MessageBusService);
+    ngOnDestroy(): void;
+    addItem(obj: any, addToScene?: boolean): void;
+    removeItem(obj: any, addedToGroup?: boolean, emitMessage?: boolean): void;
+    getObjectPlanes(): any[];
+    getWallItems(): Item[];
+    getFurniture(): Furniture[];
+    getNonFurniture(): Item[];
+    getConfigurables(): Item[];
+    getIOneFurniture(): Item[];
+    getCameraItem(): Item;
+    getWalkthroughCamera(): Item;
+    removeFloorItems(): void;
+    removeAll(): void;
+    addJsonItem(modelData: ThreedModel, point: THREE.Vector3): Item;
+    addFloorGroupItem(modelData: ThreedModel, point: Vector3): Promise<Item>;
+    glassMaterialCheck(item: Item): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemService>;
+}

package/app/plugins/core3d/service/light-presets.service.d.ts

@@ -0,0 +1,46 @@
+import { OnDestroy } from '@angular/core';
+import { Light } from 'three';
+import { BehaviorSubject } from 'rxjs';
+import { LightPreset } from '../../../core/model/light-preset';
+import { LightsService } from './lights.service';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import { HomedecoratorAppService } from '../../../core/service/homedecorator-app.service';
+import { ViewModeService } from '../../../core/service/view-mode.service';
+import { SceneService } from './scene.service';
+import { HomedecoratorDictionaryService } from '../../../core/service/homedecorator-dictionary.service';
+import { DialogService } from '../../../shared/dialog/service/dialog.service';
+import { ScreenSizeAnalysisService } from '../../../shared/screen-size-analysis/screen-size-analysis.service';
+import * as i0 from "@angular/core";
+export declare class LightPresetsService implements OnDestroy {
+    private _lightsService;
+    private _settingsService;
+    private _appService;
+    private _viewModeService;
+    private _sceneService;
+    private _dictionaryService;
+    private _dialogService;
+    private _screenSizeAnalysis;
+    set activeLightPreset(value: LightPreset);
+    get activeLightPreset(): LightPreset;
+    loadedLightPresets: LightPreset[];
+    presetLoaded: BehaviorSubject<boolean>;
+    private _activeLightPreset;
+    private _lightsMap;
+    constructor(_lightsService: LightsService, _settingsService: HomedecoratorSettingsService, _appService: HomedecoratorAppService, _viewModeService: ViewModeService, _sceneService: SceneService, _dictionaryService: HomedecoratorDictionaryService, _dialogService: DialogService, _screenSizeAnalysis: ScreenSizeAnalysisService);
+    init(): void;
+    ngOnDestroy(): void;
+    deleteCurrentPreset(): Promise<void>;
+    createNewLightPreset(): void;
+    loadLightPreset(lightPreset: LightPreset): Promise<void>;
+    savePreset(preset?: LightPreset): void;
+    saveActivePreset(): void;
+    saveOrDeletePreset(preset: LightPreset, deleteFromIndex?: boolean): Promise<void>;
+    removeLightByIndex(index: number): void;
+    upsertLight(index: number, light: Light): void;
+    private _checkDirtyPreset;
+    private _createLightFromProperties;
+    private _setObjectProperties;
+    private _prepareForSave;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LightPresetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LightPresetsService>;
+}

package/app/plugins/core3d/service/lights.service.d.ts

@@ -0,0 +1,38 @@
+import { OnDestroy } from '@angular/core';
+import { Light } from 'three';
+import { Subject } from 'rxjs';
+import { SceneService } from './scene.service';
+import { ConfigurationService } from '../../../core/service/configuration.service';
+import { FloorplanService } from '../../room-planner/components/floorplanner/service/floorplan.service';
+import { ItemService } from './item.service';
+import * as i0 from "@angular/core";
+export declare class LightsService implements OnDestroy {
+    private _sceneService;
+    private _configurationService;
+    private _floorplanService;
+    private _itemService;
+    lights: Light[];
+    onLightAdded: Subject<{
+        light: Light;
+        index: number;
+    }>;
+    private _subs;
+    constructor(_sceneService: SceneService, _configurationService: ConfigurationService, _floorplanService: FloorplanService, _itemService: ItemService);
+    ngOnDestroy(): void;
+    init(): void;
+    createLight<T extends Light>(modelClass: any): void;
+    addLight(light: Light): void;
+    removeLightByIndex(idx: number, updateLightArray?: boolean): void;
+    removeAllLights(): void;
+    replaceLight(idx: number, light: Light): void;
+    initiateLightPreset(): void;
+    updateAllOffsets(): void;
+    updateOffsets(light: Light): void;
+    private _showHideInteriorLights;
+    private _updateInteriorLights;
+    private _removeLight;
+    private _addLight;
+    private _updateShadowCamera;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LightsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LightsService>;
+}

package/app/plugins/core3d/service/message-board.service.d.ts

@@ -0,0 +1,18 @@
+import { Mesh, Scene } from 'three';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import { FontService } from './font.service';
+import * as i0 from "@angular/core";
+export declare class MessageBoardService {
+    private _settingsService;
+    private _fontService;
+    scene: Scene;
+    board: Mesh;
+    messages: Mesh[];
+    private _font;
+    constructor(_settingsService: HomedecoratorSettingsService, _fontService: FontService);
+    init(scene: Scene): Promise<void>;
+    addMessage(message: string): void;
+    private _createMessageBoard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageBoardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageBoardService>;
+}

package/app/plugins/core3d/service/models.service.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from 'three';
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { CustomButton } from '../../../core/model/custom-button';
+import { JsonUtilsService } from '../../../core/service/json-utils.service';
+import { ThreedModel } from '../model/threed-model';
+import { UtilsService } from '../../../core/service/utils.service';
+import { HomedecoratorAppService } from '../../../core/service/homedecorator-app.service';
+import { ConfigurationService } from '../../../core/service/configuration.service';
+import * as i0 from "@angular/core";
+export interface ThreeGeoMat {
+    geometry: THREE.BufferGeometry;
+    materials: THREE.Material[];
+}
+export declare class ModelsService implements OnDestroy {
+    private _utilsService;
+    private _jsonUtilsService;
+    private _appService;
+    private _configurationService;
+    customButtons: CustomButton[];
+    models: ThreedModel[];
+    modelsLoaded: BehaviorSubject<boolean>;
+    private _modelsLoadedSub;
+    constructor(_utilsService: UtilsService, _jsonUtilsService: JsonUtilsService, _appService: HomedecoratorAppService, _configurationService: ConfigurationService);
+    ngOnDestroy(): void;
+    private _load;
+    private getModel;
+    hasModel(name: string): boolean;
+    get(name: string, overrides?: any): Promise<ThreedModel>;
+    getFurnitures(): ThreedModel[];
+    getItemsFromCategory(category: string): Promise<ThreedModel[]>;
+    getInWalls(): ThreedModel[];
+    addCustomButton(button: CustomButton): void;
+    private _getInWallItemThickness;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModelsService>;
+}

package/app/plugins/core3d/service/outline.service.d.ts

@@ -0,0 +1,40 @@
+import { OnDestroy } from '@angular/core';
+import { PerspectiveCamera, Scene, WebGLRenderer } from 'three';
+import { HomedecoratorAppEventService } from '../../../core/service/homedecorator-app-event.service';
+import { Furniture } from '../items/furniture';
+import { CustomObject3D } from '../items/custom-objects';
+import * as i0 from "@angular/core";
+export declare class OutlineService implements OnDestroy {
+    private _appEventService;
+    private _outlinePass;
+    private _texturePass;
+    private _fxaaPass;
+    private _composer;
+    private _enabled;
+    private _hideOutlineTimer;
+    private _hideOutlineTimeout;
+    private _animationDuration;
+    private _outlinePassAsError;
+    private _useMSAA;
+    private _renderTarget;
+    private _initializing;
+    private _scene;
+    private _renderer;
+    private _camera;
+    private _subs;
+    needsRender: boolean;
+    constructor(_appEventService: HomedecoratorAppEventService);
+    ngOnDestroy(): void;
+    init(renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera, width: number, height: number): void;
+    setSize(width: number, height: number): void;
+    render(): void;
+    forceRenderCanvas(): void;
+    showErrorOutline(item: Furniture): void;
+    showOutline(item: Furniture | CustomObject3D): Promise<void>;
+    hideOutline(): Promise<void>;
+    private _animatedOutlineStrength;
+    private _setErrorGlowSettings;
+    private _setSelectionGlowSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OutlineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OutlineService>;
+}

package/app/plugins/core3d/service/rotation.service.d.ts

@@ -0,0 +1,57 @@
+import { OnDestroy } from '@angular/core';
+import { Vector3 } from 'three';
+import { Subject } from 'rxjs';
+import { FloorItem } from '../items/floor-item';
+import { Item } from '../items/item';
+import { OutlineService } from './outline.service';
+import { CollisionManagerService } from '../collision-manager/collision-manager.service';
+import { ItemService } from './item.service';
+import { ConfigurationService } from '../../../core/service/configuration.service';
+import { HomedecoratorAppService } from '../../../core/service/homedecorator-app.service';
+import { SceneService } from './scene.service';
+import { ErrorGlowService } from './error-glow.service';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import * as i0 from "@angular/core";
+export declare class RotationService implements OnDestroy {
+    private _outlineService;
+    private _collisionManagerService;
+    private _itemService;
+    private _configService;
+    private _appService;
+    private _sceneService;
+    private _errorGlowService;
+    private _settingsService;
+    objectRotated: Subject<void>;
+    sliderValue: number;
+    private _subs;
+    private _mouseXOnMouseDown;
+    private _targetRotationOnMouseDownX;
+    private _targetRotationX;
+    private _mouseX;
+    private _itemToRotate;
+    private _renderInterval;
+    private _renderTimeout;
+    private _timeToRender;
+    private _moveFactor;
+    constructor(_outlineService: OutlineService, _collisionManagerService: CollisionManagerService, _itemService: ItemService, _configService: ConfigurationService, _appService: HomedecoratorAppService, _sceneService: SceneService, _errorGlowService: ErrorGlowService, _settingsService: HomedecoratorSettingsService);
+    ngOnDestroy(): void;
+    rotate(item: FloorItem, from: Vector3, to: Vector3, ccw?: boolean): Vector3;
+    enableRotationFor(item: Item): void;
+    private _handleMouseDown;
+    private _handleMouseMove;
+    private _handleSliderChange;
+    private _handleMouseUp;
+    private _handleMouseOut;
+    private _handleTouchStart;
+    private _handleTouchMove;
+    private _handleTouchEnd;
+    private _handleTouchCancel;
+    private _removeMouseEvents;
+    private _removeTouchEvents;
+    private _renderForAmountOfTime;
+    private _doRender;
+    private _removeListeners;
+    private _addListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RotationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RotationService>;
+}

package/app/plugins/core3d/service/scene-event.service.d.ts

@@ -0,0 +1,131 @@
+import { OnDestroy } from '@angular/core';
+import { Item } from '../items/item';
+import { Intersection, Mesh, Vector2, Vector3 } from 'three';
+import { HudService } from './hud.service';
+import { DragAndDropService } from './drag-and-drop.service';
+import { CameraService } from './camera.service';
+import { MessageBusService } from '../../../core/service/message-bus.service';
+import { SceneService } from './scene.service';
+import { RotationService } from './rotation.service';
+import { RoomService } from '../../room-planner/components/floorplanner/service/room.service';
+import { FloorService } from './floor.service';
+import { IntersectionService } from './intersection.service';
+import { ViewModeService } from '../../../core/service/view-mode.service';
+import { ItemGroupService } from './item-group.service';
+import { ItemService } from './item.service';
+import { HomedecoratorAppService } from '../../../core/service/homedecorator-app.service';
+import { ItemGroup } from '../items/item-group';
+import { HomedecoratorAppEventService } from '../../../core/service/homedecorator-app-event.service';
+import * as i0 from "@angular/core";
+export declare class SceneEventService implements OnDestroy {
+    private _hudService;
+    private _messageBusService;
+    private _sceneService;
+    private _dragAndDropService;
+    private _rotationService;
+    private _cameraService;
+    private _roomService;
+    private _floorService;
+    private _intersectionService;
+    private _viewModeService;
+    private _itemGroupService;
+    private _itemService;
+    private _appService;
+    private _eventService;
+    readonly intersectOffsetForWalls = 20;
+    readonly longTouchDuration = 600;
+    rotateNoDrag: boolean;
+    private _element;
+    private _controls;
+    private _camera;
+    private _mousePosition;
+    private _oldMousePosition;
+    private _rotationStartPoint;
+    private _intersectedObject;
+    private _intersectedMesh;
+    private _mouseoverObject;
+    private _selectedObject;
+    private _prevSelectedObject;
+    private _defaultCursorStyle;
+    private _explorePressed;
+    private _inDragOver;
+    private _mouseDown;
+    private _mouseMoved;
+    private _rotateMouseOver;
+    private _groupingMode;
+    private _state;
+    private _intersectedWall;
+    private _intersectedFloor;
+    private _subs;
+    private _cameraMoveSub;
+    private _debouncedSaveState;
+    private _touchStart;
+    private _touchEnd;
+    private _touchCancel;
+    private _touchMove;
+    constructor(_hudService: HudService, _messageBusService: MessageBusService, _sceneService: SceneService, _dragAndDropService: DragAndDropService, _rotationService: RotationService, _cameraService: CameraService, _roomService: RoomService, _floorService: FloorService, _intersectionService: IntersectionService, _viewModeService: ViewModeService, _itemGroupService: ItemGroupService, _itemService: ItemService, _appService: HomedecoratorAppService, _eventService: HomedecoratorAppEventService);
+    ngOnDestroy(): void;
+    init(element: HTMLElement): void;
+    setExploreMode(on?: boolean): void;
+    setSelectedObject(object: Item | ItemGroup, mesh?: Mesh): void;
+    startDragging(x: number, y: number, z?: number): void;
+    intersectingVec3(vec2: Vector2, intersection?: Intersection): Vector3;
+    private _isRotating;
+    private _keyDownEvent;
+    private _dragEnterEvent;
+    private _dragExitEvent;
+    private _dragOverEvent;
+    private _onDrop;
+    private _cancelDragDrop;
+    private _mouseUpEvent;
+    private _navigateExplore;
+    private _initPlaceOnTouchRequest;
+    private _touchEndEvent;
+    private _touchMoveEvent;
+    private _clearIntersectedObject;
+    private _toggleRotationHudIntersection;
+    private _updateIntersections;
+    private _itemIntersection;
+    private _getIntersections;
+    private _setMousePositionFromTouchEvent;
+    private _touchStartEvent;
+    private _leftMouseDownEvent;
+    private _overrideDefaultCursorStyle;
+    private _setGroupingMode;
+    private _getDraggedData;
+    private _clickPressed;
+    private _clickConnectorPressed;
+    private _clickDragged;
+    private _dragConnector;
+    private _checkWallsAndFloors;
+    private _wallIntersection;
+    private _wallIntersections;
+    private _edgeIntersections;
+    private _groundIntersections;
+    private _wallEdgeIntersected;
+    private _floorIntersection;
+    private _pointOnFloor;
+    private _isMouseEventAllowed;
+    private _mouseMoveEvent;
+    private _updateExplorePoint;
+    private _updateExploreIndicator;
+    private _acceptDrop;
+    private _releaseState;
+    private _addToItemGroup;
+    private _canGroupFloorItem;
+    private _canGroupWallItem;
+    private _canGroupItems;
+    private _switchState;
+    private _onEntry;
+    private _onExit;
+    private _setIntersectedObject;
+    private _mouseToVec3;
+    private _setSelectObject;
+    private _updateMouseover;
+    private _setObjectMouseOver;
+    private _setObjectMouseOff;
+    private _markSceneToUpdate;
+    private _setCursorStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneEventService>;
+}

package/app/plugins/core3d/service/scene-options.service.d.ts

@@ -0,0 +1,11 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { SceneOptionButtonInterface } from '../interface/scene-option-button.interface';
+import * as i0 from "@angular/core";
+export declare class SceneOptionsService {
+    sceneOptionButtonAdded: BehaviorSubject<SceneOptionButtonInterface>;
+    sceneOptionButtonUpdated: Subject<SceneOptionButtonInterface>;
+    addSceneOptionButton(button: SceneOptionButtonInterface): void;
+    updateSceneOptionButton(button: SceneOptionButtonInterface): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneOptionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneOptionsService>;
+}

package/app/plugins/core3d/service/scene.service.d.ts

@@ -0,0 +1,74 @@
+import { OnDestroy } from '@angular/core';
+import { Object3D, Scene, Vector2, Vector3, WebGLRenderer } from 'three';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { CameraService } from './camera.service';
+import { ConfigurationService } from '../../../core/service/configuration.service';
+import { XrService } from './xr.service';
+import { VrService } from './vr.service';
+import { ArService } from './ar.service';
+import { MessageBusService } from '../../../core/service/message-bus.service';
+import { ViewModeService } from '../../../core/service/view-mode.service';
+import { OutlineService } from './outline.service';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import { WebGLPathTracer } from 'three-gpu-pathtracer';
+import * as i0 from "@angular/core";
+export declare class SceneService implements OnDestroy {
+    private _cameraService;
+    private _configurationService;
+    private _xrService;
+    private _vrService;
+    private _arService;
+    private _messageBusService;
+    private _viewModeService;
+    private _outlineService;
+    private _settingsService;
+    set needsRender(value: boolean);
+    get needsRender(): boolean;
+    scene: Scene;
+    renderer: WebGLRenderer;
+    pathTracer: WebGLPathTracer;
+    onBeforeRender: Subject<{
+        renderer: WebGLRenderer;
+        scene: Scene;
+    }>;
+    onAfterRender: Subject<{
+        renderer: WebGLRenderer;
+        scene: Scene;
+    }>;
+    sceneInitialized: BehaviorSubject<boolean>;
+    renderingThroughPostProcessingPipeline: boolean;
+    webGL2Available: boolean;
+    domElement: HTMLElement;
+    private _needsRender;
+    private _arMode;
+    private _subs;
+    private _maxRenderSamples;
+    private _numberOfSamplesRendered;
+    constructor(_cameraService: CameraService, _configurationService: ConfigurationService, _xrService: XrService, _vrService: VrService, _arService: ArService, _messageBusService: MessageBusService, _viewModeService: ViewModeService, _outlineService: OutlineService, _settingsService: HomedecoratorSettingsService);
+    ngOnDestroy(): void;
+    getScene(): Scene;
+    set arMode(value: boolean);
+    get arMode(): boolean;
+    init(element: HTMLElement): void;
+    addObject(obj: Object3D, forceRender?: boolean): void;
+    removeObject(obj: Object3D, forceRender?: boolean, cleanUp?: boolean): void;
+    updatePathTracer(): void;
+    positionInSceneToScreen(pos: Vector3): Vector2;
+    rendererPropsChange(): void;
+    private _initScene;
+    private _initCamera;
+    private _initOutline;
+    private _initPathTracer;
+    private _initRenderer;
+    private _resizeRendererToDisplaySize;
+    private _updateWindowSize;
+    private _checkCanvasResize;
+    private _render;
+    private _animate;
+    private _pauseAnimation;
+    private _is3DMode;
+    private _setSceneBackground;
+    getSceneCanvasImage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneService>;
+}

package/app/plugins/core3d/service/vr.service.d.ts

@@ -0,0 +1,44 @@
+import { Scene, WebGLRenderer } from 'three';
+import { ViewModeService } from '../../../core/service/view-mode.service';
+import * as i0 from "@angular/core";
+export declare class VrService {
+    private _viewModeService;
+    private _scene;
+    private _renderer;
+    private _camera;
+    private _tempMatrix;
+    private _currentClosestIntersection;
+    private _meshes;
+    private _raycaster;
+    private _reticle;
+    private _controller0;
+    private _controller1;
+    private _session;
+    private _user;
+    private _selectedObject;
+    constructor(_viewModeService: ViewModeService);
+    init(scene: Scene, renderer: WebGLRenderer): void;
+    render(): void;
+    endSession(): void;
+    private _initSession;
+    private _onSessionStarted;
+    private _onSessionEnded;
+    startVRSession(): void;
+    private _createControllers;
+    private _onSelectStart;
+    private _onSelectEnd;
+    private _getIntersections;
+    private _registerMeshes;
+    private _handleIntersections;
+    private _handleControllerIntersections;
+    private _getNearestIntersection;
+    private _handleFloorIntersection;
+    private _handleObjectIntersection;
+    private _handleNoIntersections;
+    private _updateControllerRay;
+    private _isObjectFloor;
+    private _getParentOfChild;
+    private _updateObjectSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VrService>;
+}

package/app/plugins/core3d/service/wall-measurements.service.d.ts

@@ -0,0 +1,23 @@
+import { OnDestroy } from '@angular/core';
+import { FloorplanService } from '../../room-planner/components/floorplanner/service/floorplan.service';
+import { ViewModeService } from '../../../core/service/view-mode.service';
+import { SceneService } from './scene.service';
+import { ConfigurationService } from '../../../core/service/configuration.service';
+import { FontService } from './font.service';
+import * as i0 from "@angular/core";
+export declare class WallMeasurementsService implements OnDestroy {
+    private _floorplanService;
+    private _viewModeService;
+    private _sceneService;
+    private _configurationService;
+    private _fontService;
+    private _measurements;
+    private _subs;
+    constructor(_floorplanService: FloorplanService, _viewModeService: ViewModeService, _sceneService: SceneService, _configurationService: ConfigurationService, _fontService: FontService);
+    ngOnDestroy(): void;
+    private _showMeasurements;
+    private _removeMeasurements;
+    private _makeMeasurements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WallMeasurementsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WallMeasurementsService>;
+}

package/app/plugins/core3d/service/xr.service.d.ts

@@ -0,0 +1,56 @@
+import { OnDestroy } from '@angular/core';
+import * as THREE from 'three';
+import { Camera, Scene, WebGLRenderer } from 'three';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { XrMode } from '../../../core/enum/xr-mode.enum';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import { DebugService } from '../../../core/service/debug.service';
+import { MessageBoardService } from './message-board.service';
+import * as i0 from "@angular/core";
+export declare class XrService implements OnDestroy {
+    private _settingsService;
+    private _debugService;
+    private _messageBoard;
+    gamepad: any;
+    axes: number[];
+    touchpadIsPressed: boolean;
+    triggerIsPressed: boolean;
+    angularVelocity: THREE.Vector3;
+    renderer: WebGLRenderer;
+    scene: Scene;
+    camera: Camera;
+    controller: any;
+    vrSupported: boolean;
+    arSupported: boolean;
+    sessionStarted: Subject<XrMode>;
+    sessionEnded: Subject<void>;
+    userSelectInAr: BehaviorSubject<boolean>;
+    refSpace: any;
+    viewerSpace: any;
+    session: any;
+    hitTestSource: any;
+    private _vrDisplay;
+    private _vrController;
+    private _subs;
+    private _cameraHeight;
+    private _mode;
+    constructor(_settingsService: HomedecoratorSettingsService, _debugService: DebugService, _messageBoard: MessageBoardService);
+    ngOnDestroy(): void;
+    init(renderer: WebGLRenderer, scene: Scene, camera: Camera): Promise<void>;
+    startAr(): void;
+    stopAr(): void;
+    startVr(): void;
+    stopVr(): void;
+    update(): void;
+    private _doBeforeRenderScene;
+    private _logMessage;
+    private _onSessionStarted;
+    private _onUserSelect;
+    private _onSessionEnded;
+    private _updateController;
+    private _findGamepad;
+    private _createController;
+    private _createMeshes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<XrService>;
+}

package/app/plugins/core3d/textures/DepthDataTexture.d.ts

@@ -0,0 +1,5 @@
+import { DataTexture } from 'three';
+export declare class DepthDataTexture extends DataTexture {
+    constructor();
+    updateDepth(depthData: any): void;
+}