@colijnit/homedecorator 255.1.1

package/app/plugins/core3d/core/dimensioning.d.ts

@@ -0,0 +1,19 @@
+export declare class Dimensioning {
+    /** Converts cm to dimensioning string.
+     * @param cm Centi meter value to be converted.
+     * @param dimUnit
+     * @param distanceStep
+     * @returns String representation.
+     */
+    static cmToMeasure(cm: number, dimUnit: string, distanceStep: number): string;
+    static mToMeasure(m: number, dimUnit: string, distanceStep: number): string;
+    static cmToUnit(cm: number, distanceStep: number): number;
+    static unitToCm(unit: number, distanceStep: number): number;
+    /** Converts scm to area string.
+     * @param scm Square centimeter value to be converted.
+     * @param dimSquUnit
+     * @returns String representation.
+     */
+    static scmToMeasure(scm: number, dimSquUnit: string): string;
+    static smToMeasure(sm: number, dimSquUnit: string): string;
+}

package/app/plugins/core3d/core/utils.d.ts

@@ -0,0 +1,147 @@
+import { BufferAttribute, BufferGeometry, Euler, Group, Material, Matrix4, Mesh, MeshBasicMaterial, Object3D, Vector2, Vector3 } from 'three';
+declare type Polygon = Vector2[];
+interface WorldProp {
+    matrix: Matrix4;
+    position: Vector3;
+    rotation: Euler;
+}
+/** Collection of utility functions. */
+export declare class Utils {
+    static axisY: Vector3;
+    static materialProps: string[];
+    /** Determines the distance of a point from a line.
+     * @param x Point's x coordinate.
+     * @param y Point's y coordinate.
+     * @param x1 Line-Point 1's x coordinate.
+     * @param y1 Line-Point 1's y coordinate.
+     * @param x2 Line-Point 2's x coordinate.
+     * @param y2 Line-Point 2's y coordinate.
+     * @returns The distance.
+     */
+    static pointDistanceFromLine(x: number, y: number, x1: number, y1: number, x2: number, y2: number): number;
+    /** Gets the projection of a point onto a line.
+     * @param x Point's x coordinate.
+     * @param y Point's y coordinate.
+     * @param x1 Line-Point 1's x coordinate.
+     * @param y1 Line-Point 1's y coordinate.
+     * @param x2 Line-Point 2's x coordinate.
+     * @param y2 Line-Point 2's y coordinate.
+     * @returns The point.
+     */
+    static closestPointOnLine(x: number, y: number, x1: number, y1: number, x2: number, y2: number): {
+        x: number;
+        y: number;
+    };
+    /** Gets the distance of two points.
+     * @param x1 X part of first point.
+     * @param y1 Y part of first point.
+     * @param x2 X part of second point.
+     * @param y2 Y part of second point.
+     * @returns The distance.
+     */
+    static distance(x1: number, y1: number, x2: number, y2: number): number;
+    /**  Gets the angle between 0,0 -> x1,y1 and 0,0 -> x2,y2 (-pi to pi)
+     * @returns The angle.
+     */
+    static angle(x1: number, y1: number, x2: number, y2: number): number;
+    /** shifts angle to be 0 to 2pi */
+    static angle2pi(x1: number, y1: number, x2: number, y2: number): number;
+    static lineToXAxisAngle(x1: number, y1: number, x2: number, y2: number): number;
+    /** Gets end point of line through two points of a certain length
+     */
+    static ProlongStraightLine(startX: number, startY: number, endX: number, endY: number, length: number): {
+        x: number;
+        y: number;
+    };
+    /** Checks if Polygon is clockwise.
+     * @param polygon Is array of points with x,y attributes
+     * @returns True if clockwise.
+     * based on http://stackoverflow.com/questions/1165647
+     */
+    static isClockwise(polygon: Polygon): boolean;
+    /** Creates a Guid.
+     * @returns A new Guid.
+     */
+    static guid(): string;
+    /** both arguments are Polygon (arrays with x,y attributes) */
+    static polygonPolygonIntersect(first: Polygon, second: Polygon): boolean;
+    /** Polygon is an array of points with x,y attributes */
+    static linePolygonIntersect(x1: number, y1: number, x2: number, y2: number, polygon: Polygon): boolean;
+    /** */
+    static lineLineIntersect(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): boolean;
+    static linesIntersection(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): number[];
+    /**
+     @param polygon Is an array of points with x,y attributes
+      @param startX X start coord for raycast
+      @param startY Y start coord for raycast
+    */
+    static pointInPolygon(x: number, y: number, polygon: Polygon, startX?: number, startY?: number): boolean;
+    /** Checks if all corners of inside polygon are inside the outside polygon */
+    static polygonInsidePolygon(inside: Polygon, outside: Polygon, startX?: number, startY?: number): boolean;
+    /** Checks if any corners of inside polygon are inside the second outside polygon */
+    static polygonOutsidePolygon(inside: Polygon, outside: Polygon, startX?: number, startY?: number): boolean;
+    static cloneMaterial(material: Material | Material[]): Material | Material[];
+    static cloneObject3D(source: Object3D): Object3D;
+    static cloneGroup(source: Group, meshMaterial?: MeshBasicMaterial): Group;
+    static forEach(array: any, action: any): void;
+    static forEachIndexed(array: any, action: any): void;
+    static map(array: any, func: any): any[];
+    /** Remove elements in array if func(element) returns true */
+    static removeIf(array: any, func: any): any[];
+    /** Shift the items in an array by shift (positive integer) */
+    static cycle(arr: any, shift: any): any;
+    /** Returns in the unique elemnts in arr */
+    static unique(arr: any, hashFunc: any): any[];
+    /** Remove value from array, if it is present */
+    static removeValue(array: any, value: any): void;
+    /** Checks if value is in array */
+    static hasValue: (array: any, value: any) => boolean;
+    /** Subtracts the elements in subArray from array */
+    static subtract(array: any, subArray: any): any[];
+    /** based on https://stackoverflow.com/questions/16285134/calculating-polygon-area#answer-33670691 */
+    static polygonArea(vertices: Polygon): number;
+    static polygonCenter(vertices: Polygon): {
+        x: number;
+        y: number;
+    };
+    static getTranslatedLine(start: Vector2, end: Vector2, angle: number, distance: number): {
+        start: Vector2;
+        end: Vector2;
+    };
+    static pointOnAngleAxis(distance: number, angle: number, dx: number, dy: number): {
+        x: number;
+        y: number;
+    };
+    static selectPointInsidePolygon(origCorner: {
+        x: number;
+        y: number;
+    }, delta: {
+        x: number;
+        y: number;
+    }, origCorners: Polygon): {
+        x: number;
+        y: number;
+    };
+    static setPlaneVisibility(plane: Mesh, isVisible: boolean): void;
+    static snapAngle(angle: number, snap?: number): number;
+    static moveAtAxis(position: Vector3, rotation: Euler, axis: 'x' | 'y' | 'z', axisValue: number): Vector3;
+    private static DisposeNode;
+    static DisposeMaterial(material: Material | Material[]): void;
+    static DisposeObject(object: Object3D | Mesh): void;
+    static polygonUnion(p1: Polygon, p2: Polygon): Polygon;
+    static polygonsUnion(polygons: Polygon[]): Polygon[];
+    private static oneToRest;
+    static uniqFn<T>(v: T, i: number, a: T[]): boolean;
+    static sampleSize<T>(input: T[], targetCount?: number): T[];
+    static toString(v: Vector3 | Euler): string;
+    static geometryMeshToWorldVertices(mesh: Mesh, sampleSize?: number): Vector3[];
+    static bufferGeometryMeshToWorldVertices(mesh: Mesh, sampleSize?: number): Vector3[];
+    static worldProps(mesh: Mesh): WorldProp[];
+    static isCamera(object: {
+        name: string;
+    }): boolean;
+    static GetVector3ArrayFromBufferAttribute(bufferAttribute: BufferAttribute): Vector3[];
+    static ApplyBufferAttributeMatrixTransform(bufferAttribute: BufferAttribute, transform: Matrix4): void;
+    static GetFaceNormalFromBufferGeometry(bufferGeometry: BufferGeometry, faceIndex: number, vertexIndex: number): Vector3;
+}
+export {};

package/app/plugins/core3d/core3d/components/scenecontrol/scene-control.component.d.ts

@@ -0,0 +1,49 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as THREE from 'three';
+import { SceneService } from '../../../service/scene.service';
+import { MessageBusService } from '../../../../../core/service/message-bus.service';
+import { ConfigurationService } from '../../../../../core/service/configuration.service';
+import { LightPresetsService } from '../../../service/light-presets.service';
+import * as i0 from "@angular/core";
+export declare class LightParams {
+    name: string;
+    color: any;
+    skyColor: any;
+    groundColor: any;
+    useAdditionalColors: boolean;
+    positioning: boolean;
+    showHelper: boolean;
+    helper: boolean;
+    addHelperFn: Function;
+    removeHelperFn: Function;
+    canCastShadow: boolean;
+}
+export declare class LightControl {
+    light: THREE.Light;
+    params: LightParams;
+}
+export declare class SceneControlComponent implements OnInit, OnDestroy {
+    private _sceneService;
+    private _messageBusService;
+    private _configurationService;
+    private _lightPresetService;
+    private gui;
+    private subs;
+    private lights;
+    constructor(_sceneService: SceneService, _messageBusService: MessageBusService, _configurationService: ConfigurationService, _lightPresetService: LightPresetsService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initGui;
+    private addRenderOptions;
+    private addLights;
+    private createLightControls;
+    private createLightFolder;
+    private createSpotlightHelper;
+    private createPointlightHelper;
+    private createDirectionalLightHelper;
+    private createHemisphereLightHelper;
+    private removeLightHelper;
+    private _updateScene;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SceneControlComponent, "rp-scene-control", never, {}, {}, never, never>;
+}

package/app/plugins/core3d/core3d/components/scenecontrol/scene-control.component.scss

@@ -0,0 +1,3 @@
+::ng-deep .dg.ac {
+  top: 65px;
+}

package/app/plugins/core3d/core3d/core3d.component.d.ts

@@ -0,0 +1,76 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { PluginInterface } from '../../plugin-interface';
+import { IconEnum } from '../../../core/enum/icon.enum';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { IconName } from '../../../core/enum/icon-name.enum';
+import { ViewModeService } from '../../../core/service/view-mode.service';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import { XrService } from '../service/xr.service';
+import { VrService } from '../service/vr.service';
+import { PresetsService } from '../../../core/service/presets.service';
+import { MessageBusService } from '../../../core/service/message-bus.service';
+import { ConfigurationService } from '../../../core/service/configuration.service';
+import { CameraService } from '../service/camera.service';
+import { FloorplanService } from '../../room-planner/components/floorplanner/service/floorplan.service';
+import { ItemService } from '../service/item.service';
+import { HomedecoratorIconCacheService } from '../../../core/service/homedecorator-icon-cache.service';
+import { ScreenSizeAnalysisService } from '../../../shared/screen-size-analysis/screen-size-analysis.service';
+import { WallMeasurementsService } from '../service/wall-measurements.service';
+import * as i0 from "@angular/core";
+export declare class Core3dComponent implements OnInit, OnDestroy, PluginInterface {
+    viewModeService: ViewModeService;
+    settingsService: HomedecoratorSettingsService;
+    xrService: XrService;
+    private _vrService;
+    private _presetService;
+    private _messageService;
+    private _configurationService;
+    private _cameraService;
+    private _floorplanService;
+    private _itemService;
+    private _dialog;
+    iconService: HomedecoratorIconCacheService;
+    private _screenSizeService;
+    private _wallMeasurementsService;
+    readonly icon: typeof IconEnum;
+    readonly viewModes: typeof ViewMode;
+    readonly iconName: typeof IconName;
+    toolbarIconTopView: TemplateRef<any>;
+    toolbarIconWalkThrough: TemplateRef<any>;
+    toolbarIconVR: TemplateRef<any>;
+    layerClass: string;
+    private _disableMouse;
+    handledocumentMouseUp(event: any): void;
+    handleDocumentMouseDown(event: any): void;
+    showCameraControls: boolean;
+    showSceneControls: boolean;
+    phoneSizeScreen: boolean;
+    showLightplan: boolean;
+    showCameraControlButtons: boolean;
+    show3DWaterMark: boolean;
+    private _subs;
+    constructor(viewModeService: ViewModeService, settingsService: HomedecoratorSettingsService, xrService: XrService, _vrService: VrService, _presetService: PresetsService, _messageService: MessageBusService, _configurationService: ConfigurationService, _cameraService: CameraService, _floorplanService: FloorplanService, _itemService: ItemService, _dialog: MatDialog, iconService: HomedecoratorIconCacheService, _screenSizeService: ScreenSizeAnalysisService, _wallMeasurementsService: WallMeasurementsService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    cameraCenter(e?: Event): void;
+    cameraZoomIn(e?: Event): void;
+    cameraZoomOut(e?: Event): void;
+    cameraPanLeft(e: Event): void;
+    cameraPanRight(e: Event): void;
+    cameraPanUp(e: Event): void;
+    cameraPanDown(e: Event): void;
+    hasRooms(): boolean;
+    setViewModeTopView(): void;
+    setViewModeVr(): void;
+    setViewModeWalkThrough(): void;
+    beforePresetLoad(data: any): Promise<void>;
+    private _afterRoomLoaded;
+    getObjects(): {
+        view: any;
+    };
+    copySceneInstance(saveAs: boolean): Promise<void>;
+    loadObjects(data: any): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Core3dComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Core3dComponent, "rp-core3d", never, {}, {}, never, never>;
+}

package/app/plugins/core3d/core3d/core3d.component.scss

@@ -0,0 +1,27 @@
+:host {
+  display: block;
+  &.disable-mouse #controls {
+    pointer-events: none;
+  }
+  .powered-by-wrapper {
+    pointer-events: none;
+    position: absolute;
+    bottom: 0;
+    left: 50%;
+    transform: translateX(-50%);
+    width: 30%;
+    height: 30px;
+    background: rgba(0, 0, 0, 0.1);
+    border-radius: 10px;
+    padding: 10px;
+    opacity: 0.4;
+    ::ng-deep co-icon {
+      width: 100%;
+      height: 100%;
+      svg {
+        height: 100%;
+        width: 100%;
+      }
+    }
+  }
+}

package/app/plugins/core3d/core3d.module.d.ts

@@ -0,0 +1,38 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./directive/scene.directive";
+import * as i2 from "./core3d/core3d.component";
+import * as i3 from "./core3d/components/scenecontrol/scene-control.component";
+import * as i4 from "./walkthrough-camera-controls/walkthrough-camera-controls.component";
+import * as i5 from "./components/lightplan/lightplan.component";
+import * as i6 from "./components/lightplan/edit-light/edit-light.component";
+import * as i7 from "./components/scene-options/scene-options.component";
+import * as i8 from "./components/lightplan/edit-lightplan/edit-lightplan.component";
+import * as i9 from "./components/ar-gui/ar-gui-root/ar-gui-root.component";
+import * as i10 from "./components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-buttons/ar-gui-buttons.component";
+import * as i11 from "./components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-configurator/ar-gui-configurator.component";
+import * as i12 from "./components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-context-menu/ar-gui-context-menu.component";
+import * as i13 from "./components/ar-gui/ar-gui-root/ar-gui-elements/ar-gui-notifications/ar-gui-notifications.component";
+import * as i14 from "../../core/core.module";
+import * as i15 from "@angular/common";
+import * as i16 from "@angular/forms";
+import * as i17 from "@angular/material/input";
+import * as i18 from "@angular/material/button";
+import * as i19 from "@angular/material/checkbox";
+import * as i20 from "@angular/material/tooltip";
+import * as i21 from "@angular/material/slider";
+import * as i22 from "@angular/material/select";
+import * as i23 from "../../development/development.module";
+import * as i24 from "@colijnit/corecomponents_v12";
+import * as i25 from "../../shared/toolbar-icon/toolbar-icon.module";
+import * as i26 from "../../shared/zoom-controls/zoom-controls.module";
+import * as i27 from "../render/render.module";
+import * as i28 from "@angular/material/icon";
+import * as i29 from "../lite-selector/lite-selector.module";
+import * as i30 from "@angular/material/progress-bar";
+import * as i31 from "../../shared/slider-input/slider-input.module";
+import * as i32 from "@angular/material/core";
+export declare class Core3dModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<Core3dModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<Core3dModule, [typeof i1.SceneDirective, typeof i2.Core3dComponent, typeof i3.SceneControlComponent, typeof i4.WalkthroughCameraControlsComponent, typeof i5.LightplanComponent, typeof i6.EditLightComponent, typeof i7.SceneOptionsComponent, typeof i8.EditLightplanComponent, typeof i9.ArGuiRootComponent, typeof i10.ArGuiButtonsComponent, typeof i11.ArGuiConfiguratorComponent, typeof i12.ArGuiContextMenuComponent, typeof i13.ArGuiNotificationsComponent], [typeof i14.CoreModule, typeof i15.CommonModule, typeof i16.FormsModule, typeof i17.MatInputModule, typeof i18.MatButtonModule, typeof i19.MatCheckboxModule, typeof i20.MatTooltipModule, typeof i21.MatSliderModule, typeof i22.MatSelectModule, typeof i23.DevelopmentModule, typeof i24.IconModule, typeof i25.ToolbarIconModule, typeof i26.ZoomControlsModule, typeof i27.RenderModule, typeof i28.MatIconModule, typeof i29.LiteSelectorModule, typeof i30.MatProgressBarModule, typeof i31.SliderInputModule, typeof i32.MatOptionModule, typeof i19.MatCheckboxModule], [typeof i2.Core3dComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<Core3dModule>;
+}

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

@@ -0,0 +1,26 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { SceneService } from '../service/scene.service';
+import { CameraService } from '../service/camera.service';
+import { LightsService } from '../service/lights.service';
+import { LightPresetsService } from '../service/light-presets.service';
+import { IntersectionService } from '../service/intersection.service';
+import { HudService } from '../service/hud.service';
+import { MessageBusService } from '../../../core/service/message-bus.service';
+import { SceneEventService } from '../service/scene-event.service';
+import * as i0 from "@angular/core";
+export declare class SceneDirective implements AfterViewInit, OnDestroy {
+    private _element;
+    private _sceneService;
+    private _cameraService;
+    private _lightService;
+    private _lightPresetsService;
+    private _intersectionService;
+    private hudService;
+    private messageBusService;
+    private sceneEventService;
+    constructor(_element: ElementRef, _sceneService: SceneService, _cameraService: CameraService, _lightService: LightsService, _lightPresetsService: LightPresetsService, _intersectionService: IntersectionService, hudService: HudService, messageBusService: MessageBusService, sceneEventService: SceneEventService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SceneDirective, "[scene]", never, {}, {}, never>;
+}

package/app/plugins/core3d/enum/ar-feature.enum.d.ts

@@ -0,0 +1,12 @@
+export declare enum ArFeature {
+    PlaneDetection = "PlaneDetection",
+    PlaneDetectionHitTest = "PlaneDetectionHitTest",
+    DefaultHitTest = "DefaultHitTest",
+    AnchoredHitTest = "AnchoredHitTest",
+    CPUDepthHitTest = "CPUDepthHitTest",
+    GPUDepthHitTest = "GPUDepthHitTest",
+    CPUDepthOcclusion = "CPUDepthOcclusion",
+    GPUDepthOcclusion = "GPUDepthOcclusion",
+    LightEstimation = "LightEstimation",
+    ReflectionCubeMap = "ReflectionCubeMap"
+}

package/app/plugins/core3d/enum/direction.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum Direction {
+    PositiveX = 0,
+    PositiveZ = 1,
+    PositiveY = 2,
+    NegativeX = 3,
+    NegativeZ = 4,
+    NegativeY = 5
+}

package/app/plugins/core3d/enum/result-type.enum.d.ts

@@ -0,0 +1,19 @@
+export declare enum ResultType {
+    Unknown = "Unknown",
+    BuildFromScratch = "BuildFromScratch",
+    NeedsUserInput = "NeedsUserInput",
+    NoAdjustables = "NoAdjustables",
+    NoSelections = "NoSelections",
+    NoDecoNodes = "NoDecoNodes",
+    GameobjectNameMismatchInSource = "GameobjectNameMismatchInSource",
+    ArticleNotFound = "ArticleNotFound",
+    No3DModel = "No3DModel",
+    ErrorSettingInstance = "ErrorSettingInstance",
+    Timeout = "Timeout",
+    ConfigurationNotFixed = "ConfigurationNotFixed",
+    ConfigurationPartiallyFixed = "ConfigurationPartiallyFixed",
+    Obsolete = "Obsolete",
+    Loaded = "Loaded",
+    ConfigurationFixed = "ConfigurationFixed",
+    ExternalSourceNotAvailable = "ExternalSourceNotAvailable"
+}

package/app/plugins/core3d/hud/bounding-measurement-box/bounding-box-measurement.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import { Measurable } from './measurable';
+import { Item } from '../../items/item';
+import { ItemGroup } from '../../items/item-group';
+import { HomedecoratorDictionaryService } from '../../../../core/service/homedecorator-dictionary.service';
+export declare class BoundingBoxMeasurement implements Measurable {
+    private _item;
+    private _dictionaryService;
+    private readonly _height;
+    private readonly _width;
+    private readonly _depth;
+    private readonly _font;
+    private _measurements;
+    dimUnit: string;
+    distanceStep: number;
+    constructor(_item: Item | ItemGroup, font: Font, _dictionaryService: HomedecoratorDictionaryService);
+    private _createMeasurements;
+    private _createHeightMeasurement;
+    private _calculateHeightPositions;
+    private _createWidthMeasurement;
+    private _calculateWidthPositions;
+    private _createDepthMeasurement;
+    private _calculateDepthPositions;
+    getMeasurements(): THREE.Mesh[];
+    updatePositions(camera: THREE.Camera): void;
+    setVisibility(visible: boolean): void;
+}

package/app/plugins/core3d/hud/bounding-measurement-box/box-measurement.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import { Item } from '../../items/item';
+import { ItemGroup } from '../../items/item-group';
+export declare class BoxMeasurement {
+    private _textMesh;
+    private _positions;
+    get textMesh(): THREE.Mesh;
+    set textMesh(value: THREE.Mesh);
+    get positions(): THREE.Vector3[];
+    set positions(value: THREE.Vector3[]);
+    setVisibility(visible: boolean): void;
+    /**
+     * For each of dimension find text position that is closest to the camera
+     * and changes text rotation to face the camera
+     */
+    updatePosition(item: Item | ItemGroup, camera: THREE.Camera): void;
+}

package/app/plugins/core3d/hud/bounding-measurement-box/door-or-window-box-measurement.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import { Measurable } from './measurable';
+import { InWallItem } from '../../items/wall-objects';
+import { HomedecoratorDictionaryService } from '../../../../core/service/homedecorator-dictionary.service';
+export declare class DoorOrWindowBoxMeasurement implements Measurable {
+    private item;
+    private _dictionaryService;
+    private readonly _height;
+    private readonly _width;
+    private readonly _depth;
+    private readonly _openingDepth;
+    private readonly _font;
+    private _measurements;
+    dimUnit: string;
+    distanceStep: number;
+    constructor(item: InWallItem, font: Font, _dictionaryService: HomedecoratorDictionaryService);
+    private createMeasurements;
+    private createHeightMeasurement;
+    private calculateHeightPositions;
+    private createWidthMeasurement;
+    private calculateWidthPositions;
+    private createOpeningDepthMeasurement;
+    private calculateOpeningDepthPositions;
+    getMeasurements(): THREE.Mesh[];
+    updatePositions(camera: THREE.Camera): void;
+    setVisibility(visible: boolean): void;
+    private isWallDoubleSided;
+}

package/app/plugins/core3d/hud/bounding-measurement-box/measurable.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+export interface Measurable {
+    dimUnit: string;
+    distanceStep: number;
+    getMeasurements(): THREE.Mesh[];
+    updatePositions(camera: THREE.Camera): any;
+    setVisibility(visible: boolean): any;
+}

package/app/plugins/core3d/hud/bounding-measurement-box/measurement-utils.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+export declare const minSize = 0.05;
+export declare const xDirection: THREE.Vector3;
+export declare const yDirection: THREE.Vector3;
+export declare const zDirection: THREE.Vector3;
+export declare const positioningFactors: number[][];
+export declare class MeasurementUtils {
+    static makeText(value: number, dimUnit: string, distanceStep: number): string;
+}

package/app/plugins/core3d/hud/custom-shape-name-label.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import type { Item } from '../items/item';
+import type { ItemGroup } from '../items/item-group';
+export declare class CustomShapeNameLabel {
+    private _label;
+    private _shiftUp;
+    get label(): THREE.Mesh;
+    constructor(item: Item | ItemGroup, font: Font);
+    update(position: THREE.Vector3, height: number): void;
+    faceToTheCameraPosition(camera: THREE.Camera): void;
+    faceToTheSouth(quaternion: THREE.Quaternion): void;
+    setVisibility(visible: boolean): void;
+    private calculateLabelPosition;
+}

package/app/plugins/core3d/hud/floor-indicator.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+import * as TWEEN from '@tweenjs/tween.js';
+import { SceneService } from '../service/scene.service';
+import { SceneUpdate } from '../interface/scene-update.interface';
+export declare class FloorIndicator {
+    private _sceneService;
+    private floorIndicator;
+    private confirmIndicator;
+    private point;
+    private radius;
+    private animation;
+    constructor(_sceneService: SceneService);
+    get objects(): (THREE.Mesh | THREE.Object3D)[];
+    isSamePoint(point: THREE.Vector3): boolean;
+    move(mouse: THREE.Vector2, point: THREE.Vector3, cameraDistance: number): SceneUpdate;
+    stop(): void;
+    animateConfirm(): Promise<TWEEN.Tween>;
+    private createAnimation;
+    private animate;
+}

package/app/plugins/core3d/hud/furniture-measurements.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import { Measurements } from './measurements';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import { RoomService } from '../../room-planner/components/floorplanner/service/room.service';
+import { ItemService } from '../service/item.service';
+export declare class FurnitureMeasurements extends Measurements {
+    private _roomService;
+    private _itemService;
+    constructor(roomService: RoomService, itemService: ItemService, item: any, font: Font);
+    makeMeasurements(): THREE.Object3D[];
+    protected hasChanged(): boolean;
+}

package/app/plugins/core3d/hud/indicator-factory.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three';
+export declare class IndicatorFactory {
+    static makeIndicator(position: THREE.Vector3, radius: number): THREE.Object3D;
+    static makeIndicatorMesh(radius: number, ringColor?: THREE.Color): THREE.Mesh;
+    static makeTransparentRing(opacity: number, innerRadius: number, outerRadius: any, color?: THREE.Color): THREE.Mesh;
+    static makeTransparentCircle(opacity: number, color: THREE.Color, radius: number): THREE.Mesh;
+}

package/app/plugins/core3d/hud/measurements.d.ts

@@ -0,0 +1,46 @@
+import * as THREE from 'three';
+import { Mesh } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import { SceneUpdate } from '../interface/scene-update.interface';
+export declare abstract class Measurements {
+    protected item: any;
+    private font;
+    protected rotationY: number;
+    protected position: THREE.Vector3;
+    protected measurements: THREE.Object3D[];
+    private _rayCaster;
+    private _dimUnit;
+    private _distanceStep;
+    private _labelMeshCache;
+    private _updateCounter;
+    set dimUnit(value: string);
+    set distanceStep(value: number);
+    constructor(item: any, font: Font);
+    get objects(): (THREE.Object3D | THREE.Mesh)[];
+    update(force?: boolean): SceneUpdate;
+    forceUpdate(): SceneUpdate;
+    setTextsDirection(quaternion: THREE.Quaternion): void;
+    private setMeasurementTextsDirection;
+    abstract makeMeasurements(): THREE.Object3D[];
+    protected abstract hasChanged(): boolean;
+    protected raycastPlanes(planes: Mesh[], origin: THREE.Vector3, direction: THREE.Vector3): {
+        distance: number;
+        point: THREE.Vector3;
+    };
+    protected isWallDoubleSided(): boolean;
+    protected get wallThickness(): number;
+    protected isWallEdgePlane(mesh: THREE.Mesh): boolean;
+    setVisibility(visible: boolean): void;
+    updateLabelCache(index: number, intersectionDistance: number): void;
+    protected makeLabeledArrow(origin: THREE.Vector3, rotatedDirection: THREE.Vector3, length: number, labelDistance: {
+        abs?: number;
+        rel?: {
+            direction: THREE.Vector3;
+            value: number;
+        };
+    }, index: number): (THREE.Mesh | THREE.ArrowHelper)[];
+    protected nonItemPlane(item: any, plane: any): boolean;
+    protected rotateDirection(rotateY: number, direction: THREE.Vector3): THREE.Vector3;
+    protected rotatedBoundingBoxBottomPoint(item: any, point: THREE.Vector3): THREE.Vector3;
+    protected rotatedBoundingBoxPoint(item: any, point: THREE.Vector3): THREE.Vector3;
+}