@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/hud/bounding-measurement-box/bounding-box-measurement.js

@@ -0,0 +1,99 @@
+import * as THREE from 'three';
+import { BoxMeasurement } from './box-measurement';
+import { makeTextMesh } from '../utils';
+import { MeasurementUtils, minSize, positioningFactors, xDirection, yDirection, zDirection } from './measurement-utils';
+export class BoundingBoxMeasurement {
+    constructor(_item, font, _dictionaryService) {
+        this._item = _item;
+        this._dictionaryService = _dictionaryService;
+        this.dimUnit = 'cm';
+        this.distanceStep = 1;
+        this._font = font;
+        this._height = _item.getHeight();
+        this._width = _item.getWidth();
+        this._depth = _item.getDepth();
+        this._measurements = this._createMeasurements();
+    }
+    _createMeasurements() {
+        const result = [];
+        const heightBox = this._createHeightMeasurement();
+        const widthBox = this._createWidthMeasurement();
+        const depthBox = this._createDepthMeasurement();
+        if (heightBox) {
+            result.push(heightBox);
+        }
+        if (widthBox) {
+            result.push(widthBox);
+        }
+        if (depthBox) {
+            result.push(depthBox);
+        }
+        return result;
+    }
+    _createHeightMeasurement() {
+        if (this._height < minSize) {
+            return;
+        }
+        const height = new BoxMeasurement();
+        const heightString = MeasurementUtils.makeText(this._height, this.dimUnit, this.distanceStep);
+        const text = this._dictionaryService.get('LABEL_HEIGHT');
+        height.textMesh = makeTextMesh(heightString, this._font, 0xFF00FF, 0.08, false, false, text);
+        height.positions = this._calculateHeightPositions();
+        return height;
+    }
+    _calculateHeightPositions() {
+        return positioningFactors.map(([j, k]) => {
+            return new THREE.Vector3()
+                .addScaledVector(xDirection, j / 2 * this._width)
+                .addScaledVector(zDirection, k / 2 * this._depth);
+        });
+    }
+    _createWidthMeasurement() {
+        if (this._width < minSize) {
+            return;
+        }
+        const width = new BoxMeasurement();
+        const widthString = MeasurementUtils.makeText(this._width, this.dimUnit, this.distanceStep);
+        const text = this._dictionaryService.get('LABEL_WIDTH');
+        width.textMesh = makeTextMesh(widthString, this._font, 0xFF00FF, 0.08, false, false, text);
+        width.positions = this._calculateWidthPositions();
+        return width;
+    }
+    _calculateWidthPositions() {
+        return positioningFactors.map(([j, k]) => {
+            return new THREE.Vector3()
+                .addScaledVector(yDirection, j / 2 * this._height)
+                .addScaledVector(zDirection, k / 2 * this._depth);
+        });
+    }
+    _createDepthMeasurement() {
+        if (this._depth < minSize) {
+            return;
+        }
+        const depth = new BoxMeasurement();
+        const depthString = MeasurementUtils.makeText(this._depth, this.dimUnit, this.distanceStep);
+        const text = this._dictionaryService.get('LABEL_DEPTH');
+        depth.textMesh = makeTextMesh(depthString, this._font, 0xFF00FF, 0.08, false, false, text);
+        depth.positions = this._calculateDepthPositions();
+        return depth;
+    }
+    _calculateDepthPositions() {
+        return positioningFactors.map(([j, k]) => {
+            return new THREE.Vector3()
+                .addScaledVector(yDirection, j / 2 * this._height)
+                .addScaledVector(xDirection, k / 2 * this._width);
+        });
+    }
+    getMeasurements() {
+        return this._measurements.map(value => value.textMesh);
+    }
+    updatePositions(camera) {
+        this._measurements.forEach((measurement) => measurement.updatePosition(this._item, camera));
+    }
+    setVisibility(visible) {
+        return this._measurements.forEach(value => {
+            value.setVisibility(visible);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bounding-box-measurement.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/core3d/hud/bounding-measurement-box/bounding-box-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAGjD,OAAO,EAAC,YAAY,EAAC,MAAM,UAAU,CAAC;AACtC,OAAO,EAAC,gBAAgB,EAAE,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAGtH,MAAM,OAAO,sBAAsB;IASjC,YACU,KAAuB,EAAE,IAAU,EACnC,kBAAkD;QADlD,UAAK,GAAL,KAAK,CAAkB;QACvB,uBAAkB,GAAlB,kBAAkB,CAAgC;QALrD,YAAO,GAAG,IAAI,CAAC;QACf,iBAAY,GAAG,CAAC,CAAC;QAMtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;QACjC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAE/B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAClD,CAAC;IAEO,mBAAmB;QACzB,MAAM,MAAM,GAAqB,EAAE,CAAC;QACpC,MAAM,SAAS,GAAmB,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAClE,MAAM,QAAQ,GAAmB,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAChE,MAAM,QAAQ,GAAmB,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAChE,IAAI,SAAS,EAAE;YACb,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SACxB;QACD,IAAI,QAAQ,EAAE;YACZ,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACvB;QACD,IAAI,QAAQ,EAAE;YACZ,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACvB;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,wBAAwB;QAC9B,IAAI,IAAI,CAAC,OAAO,GAAG,OAAO,EAAE;YAC1B,OAAO;SACR;QACD,MAAM,MAAM,GAAmB,IAAI,cAAc,EAAE,CAAC;QACpD,MAAM,YAAY,GAAG,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC9F,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QACzD,MAAM,CAAC,QAAQ,GAAG,YAAY,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAC7F,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACpD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,yBAAyB;QAC/B,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;YACvC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE;iBACvB,eAAe,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;iBAChD,eAAe,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,uBAAuB;QAC7B,IAAI,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE;YACzB,OAAO;SACR;QACD,MAAM,KAAK,GAAmB,IAAI,cAAc,EAAE,CAAC;QACnD,MAAM,WAAW,GAAG,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC5F,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACxD,KAAK,CAAC,QAAQ,GAAG,YAAY,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAC3F,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAClD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,wBAAwB;QAC9B,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;YACvC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE;iBACvB,eAAe,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;iBACjD,eAAe,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,uBAAuB;QAC7B,IAAI,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE;YACzB,OAAO;SACR;QACD,MAAM,KAAK,GAAmB,IAAI,cAAc,EAAE,CAAC;QACnD,MAAM,WAAW,GAAG,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAC5F,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACxD,KAAK,CAAC,QAAQ,GAAG,YAAY,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAC3F,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAClD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,wBAAwB;QAC9B,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;YACvC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE;iBACvB,eAAe,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;iBACjD,eAAe,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,eAAe;QACpB,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACzD,CAAC;IAEM,eAAe,CAAC,MAAoB;QACzC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,WAA2B,EAAE,EAAE,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9G,CAAC;IAEM,aAAa,CAAC,OAAgB;QACnC,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["import * as THREE from 'three';\r\n\r\nimport {Font} from 'three/examples/jsm/loaders/FontLoader';\r\nimport {Measurable} from './measurable';\r\nimport {BoxMeasurement} from './box-measurement';\r\nimport {Item} from '../../items/item';\r\nimport {ItemGroup} from '../../items/item-group';\r\nimport {makeTextMesh} from '../utils';\r\nimport {MeasurementUtils, minSize, positioningFactors, xDirection, yDirection, zDirection} from './measurement-utils';\r\nimport {HomedecoratorDictionaryService} from '../../../../core/service/homedecorator-dictionary.service';\r\n\r\nexport class BoundingBoxMeasurement implements Measurable {\r\n  private readonly _height: number;\r\n  private readonly _width: number;\r\n  private readonly _depth: number;\r\n  private readonly _font: Font;\r\n  private _measurements: BoxMeasurement[];\r\n  public dimUnit = 'cm';\r\n  public distanceStep = 1;\r\n\r\n  constructor(\r\n    private _item: Item | ItemGroup, font: Font,\r\n    private _dictionaryService: HomedecoratorDictionaryService\r\n  ) {\r\n    this._font = font;\r\n    this._height = _item.getHeight();\r\n    this._width = _item.getWidth();\r\n    this._depth = _item.getDepth();\r\n\r\n    this._measurements = this._createMeasurements();\r\n  }\r\n\r\n  private _createMeasurements(): BoxMeasurement[] {\r\n    const result: BoxMeasurement[] = [];\r\n    const heightBox: BoxMeasurement = this._createHeightMeasurement();\r\n    const widthBox: BoxMeasurement = this._createWidthMeasurement();\r\n    const depthBox: BoxMeasurement = this._createDepthMeasurement();\r\n    if (heightBox) {\r\n      result.push(heightBox);\r\n    }\r\n    if (widthBox) {\r\n      result.push(widthBox);\r\n    }\r\n    if (depthBox) {\r\n      result.push(depthBox);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  private _createHeightMeasurement(): BoxMeasurement {\r\n    if (this._height < minSize) {\r\n      return;\r\n    }\r\n    const height: BoxMeasurement = new BoxMeasurement();\r\n    const heightString = MeasurementUtils.makeText(this._height, this.dimUnit, this.distanceStep);\r\n    const text = this._dictionaryService.get('LABEL_HEIGHT');\r\n    height.textMesh = makeTextMesh(heightString, this._font, 0xFF00FF, 0.08, false, false, text);\r\n    height.positions = this._calculateHeightPositions();\r\n    return height;\r\n  }\r\n\r\n  private _calculateHeightPositions(): THREE.Vector3[] {\r\n    return positioningFactors.map(([j, k]) => {\r\n      return new THREE.Vector3()\r\n        .addScaledVector(xDirection, j / 2 * this._width)\r\n        .addScaledVector(zDirection, k / 2 * this._depth);\r\n    });\r\n  }\r\n\r\n  private _createWidthMeasurement() {\r\n    if (this._width < minSize) {\r\n      return;\r\n    }\r\n    const width: BoxMeasurement = new BoxMeasurement();\r\n    const widthString = MeasurementUtils.makeText(this._width, this.dimUnit, this.distanceStep);\r\n    const text = this._dictionaryService.get('LABEL_WIDTH');\r\n    width.textMesh = makeTextMesh(widthString, this._font, 0xFF00FF, 0.08, false, false, text);\r\n    width.positions = this._calculateWidthPositions();\r\n    return width;\r\n  }\r\n\r\n  private _calculateWidthPositions(): THREE.Vector3[] {\r\n    return positioningFactors.map(([j, k]) => {\r\n      return new THREE.Vector3()\r\n        .addScaledVector(yDirection, j / 2 * this._height)\r\n        .addScaledVector(zDirection, k / 2 * this._depth);\r\n    });\r\n  }\r\n\r\n  private _createDepthMeasurement() {\r\n    if (this._depth < minSize) {\r\n      return;\r\n    }\r\n    const depth: BoxMeasurement = new BoxMeasurement();\r\n    const depthString = MeasurementUtils.makeText(this._depth, this.dimUnit, this.distanceStep);\r\n    const text = this._dictionaryService.get('LABEL_DEPTH');\r\n    depth.textMesh = makeTextMesh(depthString, this._font, 0xFF00FF, 0.08, false, false, text);\r\n    depth.positions = this._calculateDepthPositions();\r\n    return depth;\r\n  }\r\n\r\n  private _calculateDepthPositions(): THREE.Vector3[] {\r\n    return positioningFactors.map(([j, k]) => {\r\n      return new THREE.Vector3()\r\n        .addScaledVector(yDirection, j / 2 * this._height)\r\n        .addScaledVector(xDirection, k / 2 * this._width);\r\n    });\r\n  }\r\n\r\n  public getMeasurements(): THREE.Mesh[] {\r\n    return this._measurements.map(value => value.textMesh);\r\n  }\r\n\r\n  public updatePositions(camera: THREE.Camera) {\r\n    this._measurements.forEach((measurement: BoxMeasurement) => measurement.updatePosition(this._item, camera));\r\n  }\r\n\r\n  public setVisibility(visible: boolean): void {\r\n    return this._measurements.forEach(value => {\r\n      value.setVisibility(visible);\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/hud/bounding-measurement-box/box-measurement.js

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+export class BoxMeasurement {
+    get textMesh() {
+        return this._textMesh;
+    }
+    set textMesh(value) {
+        this._textMesh = value;
+    }
+    get positions() {
+        return this._positions;
+    }
+    set positions(value) {
+        this._positions = value;
+    }
+    setVisibility(visible) {
+        this._textMesh.visible = visible;
+    }
+    /**
+     * For each of dimension find text position that is closest to the camera
+     * and changes text rotation to face the camera
+     */
+    updatePosition(item, camera) {
+        // make the text face the camera
+        this.textMesh.quaternion.copy(camera.quaternion);
+        // for each text find the position that is closest to the camera
+        this.textMesh.position.copy(this.positions
+            // since the item can be rotated, we need to take this rotation into account when calculating distance
+            .map(position => new THREE.Vector3().copy(position).applyQuaternion(item.quaternion).add(item.position))
+            // sort positions by the distance from the camera
+            .sort((a, b) => camera.position.distanceTo(a) - camera.position.distanceTo(b))
+        // take the first position from the array since after sorting it is the closest one
+        [0]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/hud/bounding-measurement-box/door-or-window-box-measurement.js

@@ -0,0 +1,95 @@
+import * as THREE from 'three';
+import { BoxMeasurement } from './box-measurement';
+import { MeasurementUtils, positioningFactors, xDirection, yDirection, zDirection } from './measurement-utils';
+import { makeTextMesh } from '../utils';
+const openingDirection = new THREE.Vector3(-1, 0, 1);
+const openingInverseDirection = new THREE.Vector3(1, 0, 1);
+const openingDoubleDirection = new THREE.Vector3(2, 0, 1);
+export class DoorOrWindowBoxMeasurement {
+    constructor(item, font, _dictionaryService) {
+        this.item = item;
+        this._dictionaryService = _dictionaryService;
+        this.dimUnit = 'cm';
+        this.distanceStep = 1;
+        this._font = font;
+        this._height = item.getHeight();
+        this._width = item.getWidth();
+        this._depth = item.getDepth() + 0.1; // Increased slightly to account for clipping issues
+        const totalWidth = item.getWidth();
+        this._openingDepth = this.item.opening && this.item.opening.double ? Math.ceil(totalWidth / 2) : totalWidth;
+        this._measurements = this.createMeasurements();
+    }
+    createMeasurements() {
+        const measurements = [];
+        measurements.push(this.createHeightMeasurement());
+        measurements.push(this.createWidthMeasurement());
+        if (this.item.opening && this.item.opening.show) {
+            measurements.push(this.createOpeningDepthMeasurement());
+        }
+        return measurements;
+    }
+    createHeightMeasurement() {
+        const height = new BoxMeasurement();
+        const heightString = MeasurementUtils.makeText(this._height, this.dimUnit, this.distanceStep);
+        const text = this._dictionaryService.get('LABEL_HEIGHT');
+        height.textMesh = makeTextMesh(heightString, this._font, text);
+        height.positions = this.calculateHeightPositions();
+        return height;
+    }
+    calculateHeightPositions() {
+        return positioningFactors.map(([j, k]) => {
+            return new THREE.Vector3()
+                .addScaledVector(xDirection, j / 2 * this._width)
+                .addScaledVector(zDirection, k / 2 * this._depth);
+        });
+    }
+    createWidthMeasurement() {
+        const width = new BoxMeasurement();
+        const widthString = MeasurementUtils.makeText(this._width, this.dimUnit, this.distanceStep);
+        const text = this._dictionaryService.get('LABEL_WIDTH');
+        width.textMesh = makeTextMesh(widthString, this._font, text);
+        width.positions = this.calculateWidthPositions();
+        return width;
+    }
+    calculateWidthPositions() {
+        return positioningFactors.map(([j, k]) => {
+            return new THREE.Vector3()
+                .addScaledVector(yDirection, j / 2 * this._height)
+                .addScaledVector(zDirection, k / 2 * this._depth);
+        });
+    }
+    createOpeningDepthMeasurement() {
+        const openingDepth = new BoxMeasurement();
+        const openingDepthString = MeasurementUtils.makeText(this._openingDepth, this.dimUnit, this.distanceStep);
+        const text = this._dictionaryService.get('LABEL_DEPTH');
+        openingDepth.textMesh = makeTextMesh(openingDepthString, this._font, text);
+        openingDepth.positions = this.calculateOpeningDepthPositions();
+        return openingDepth;
+    }
+    calculateOpeningDepthPositions() {
+        const openDir = new THREE.Vector3().copy(this.item.opening.double ? openingDoubleDirection : (this.item.opening.invertSide ? openingInverseDirection : openingDirection));
+        if (this.item.opening.invertDirection) {
+            openDir.multiply(new THREE.Vector3(1, 1, -1));
+        }
+        return [
+            new THREE.Vector3()
+                .addScaledVector(yDirection, -this._height / 2)
+                .addScaledVector(openDir, this._width / (this.item.opening.double ? 4 : 2))
+        ];
+    }
+    getMeasurements() {
+        return this._measurements.map(value => value.textMesh);
+    }
+    updatePositions(camera) {
+        this._measurements.forEach((measurement) => measurement.updatePosition(this.item, camera));
+    }
+    setVisibility(visible) {
+        return this._measurements.forEach(value => {
+            value.setVisibility(visible || this.isWallDoubleSided());
+        });
+    }
+    isWallDoubleSided() {
+        return this.item.currentWallEdge && this.item.currentWallEdge.wall.side === THREE.DoubleSide;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"door-or-window-box-measurement.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/core3d/hud/bounding-measurement-box/door-or-window-box-measurement.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\r\nimport {Font} from 'three/examples/jsm/loaders/FontLoader';\r\nimport {Measurable} from './measurable';\r\nimport {BoxMeasurement} from './box-measurement';\r\nimport {InWallItem} from '../../items/wall-objects';\r\nimport {HomedecoratorDictionaryService} from '../../../../core/service/homedecorator-dictionary.service';\r\nimport {MeasurementUtils, positioningFactors, xDirection, yDirection, zDirection} from './measurement-utils';\r\nimport {makeTextMesh} from '../utils';\r\n\r\n\r\nconst openingDirection = new THREE.Vector3(-1, 0, 1);\r\nconst openingInverseDirection = new THREE.Vector3(1, 0, 1);\r\nconst openingDoubleDirection = new THREE.Vector3(2, 0, 1);\r\n\r\nexport class DoorOrWindowBoxMeasurement implements Measurable {\r\n  private readonly _height: number;\r\n  private readonly _width: number;\r\n  private readonly _depth: number;\r\n  private readonly _openingDepth: number;\r\n  private readonly _font: Font;\r\n  private _measurements: BoxMeasurement[];\r\n  public dimUnit = 'cm';\r\n  public distanceStep = 1;\r\n\r\n  constructor(\r\n    private item: InWallItem, font: Font,\r\n    private _dictionaryService: HomedecoratorDictionaryService\r\n  ) {\r\n    this._font = font;\r\n    this._height = item.getHeight();\r\n    this._width = item.getWidth();\r\n    this._depth = item.getDepth() + 0.1; // Increased slightly to account for clipping issues\r\n    const totalWidth: number = item.getWidth();\r\n    this._openingDepth = this.item.opening && this.item.opening.double ? Math.ceil(totalWidth / 2) : totalWidth;\r\n\r\n    this._measurements = this.createMeasurements();\r\n  }\r\n\r\n  private createMeasurements(): BoxMeasurement[] {\r\n    const measurements: BoxMeasurement[] = [];\r\n    measurements.push(this.createHeightMeasurement());\r\n    measurements.push(this.createWidthMeasurement());\r\n\r\n    if (this.item.opening && this.item.opening.show) {\r\n      measurements.push(this.createOpeningDepthMeasurement());\r\n    }\r\n    return measurements;\r\n  }\r\n\r\n  private createHeightMeasurement(): BoxMeasurement {\r\n    const height: BoxMeasurement = new BoxMeasurement();\r\n    const heightString = MeasurementUtils.makeText(this._height, this.dimUnit, this.distanceStep);\r\n    const text = this._dictionaryService.get('LABEL_HEIGHT');\r\n    height.textMesh = makeTextMesh(heightString, this._font, text);\r\n    height.positions = this.calculateHeightPositions();\r\n    return height;\r\n  }\r\n\r\n  private calculateHeightPositions(): THREE.Vector3[] {\r\n    return positioningFactors.map(([j, k]) => {\r\n      return new THREE.Vector3()\r\n        .addScaledVector(xDirection, j / 2 * this._width)\r\n        .addScaledVector(zDirection, k / 2 * this._depth);\r\n    });\r\n  }\r\n\r\n  private createWidthMeasurement() {\r\n    const width: BoxMeasurement = new BoxMeasurement();\r\n    const widthString = MeasurementUtils.makeText(this._width, this.dimUnit, this.distanceStep);\r\n    const text = this._dictionaryService.get('LABEL_WIDTH');\r\n    width.textMesh = makeTextMesh(widthString, this._font, text);\r\n    width.positions = this.calculateWidthPositions();\r\n    return width;\r\n  }\r\n\r\n  private calculateWidthPositions(): THREE.Vector3[] {\r\n    return positioningFactors.map(([j, k]) => {\r\n      return new THREE.Vector3()\r\n        .addScaledVector(yDirection, j / 2 * this._height)\r\n        .addScaledVector(zDirection, k / 2 * this._depth);\r\n    });\r\n  }\r\n\r\n  private createOpeningDepthMeasurement() {\r\n    const openingDepth: BoxMeasurement = new BoxMeasurement();\r\n    const openingDepthString = MeasurementUtils.makeText(this._openingDepth, this.dimUnit, this.distanceStep);\r\n    const text = this._dictionaryService.get('LABEL_DEPTH');\r\n    openingDepth.textMesh = makeTextMesh(openingDepthString, this._font, text);\r\n    openingDepth.positions = this.calculateOpeningDepthPositions();\r\n    return openingDepth;\r\n  }\r\n\r\n  private calculateOpeningDepthPositions(): THREE.Vector3[] {\r\n    const openDir: THREE.Vector3 = new THREE.Vector3().copy(\r\n      this.item.opening.double ? openingDoubleDirection : (this.item.opening.invertSide ? openingInverseDirection : openingDirection));\r\n    if (this.item.opening.invertDirection) {\r\n      openDir.multiply(new THREE.Vector3(1, 1, -1));\r\n    }\r\n    return [\r\n      new THREE.Vector3()\r\n        .addScaledVector(yDirection, -this._height / 2)\r\n        .addScaledVector(openDir, this._width / (this.item.opening.double ? 4 : 2))\r\n    ];\r\n  }\r\n\r\n  getMeasurements(): THREE.Mesh[] {\r\n    return this._measurements.map(value => value.textMesh);\r\n  }\r\n\r\n  public updatePositions(camera: THREE.Camera) {\r\n    this._measurements.forEach((measurement: BoxMeasurement) => measurement.updatePosition(this.item, camera));\r\n  }\r\n\r\n  public setVisibility(visible: boolean): void {\r\n    return this._measurements.forEach(value => {\r\n      value.setVisibility(visible || this.isWallDoubleSided());\r\n    });\r\n  }\r\n\r\n  private isWallDoubleSided(): boolean {\r\n    return this.item.currentWallEdge && this.item.currentWallEdge.wall.side === THREE.DoubleSide;\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/hud/bounding-measurement-box/measurable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVhc3VyYWJsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jbGllbnQvYXBwL3BsdWdpbnMvY29yZTNkL2h1ZC9ib3VuZGluZy1tZWFzdXJlbWVudC1ib3gvbWVhc3VyYWJsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgVEhSRUUgZnJvbSAndGhyZWUnO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBNZWFzdXJhYmxlIHtcclxuICBkaW1Vbml0OiBzdHJpbmc7XHJcbiAgZGlzdGFuY2VTdGVwOiBudW1iZXI7XHJcbiAgZ2V0TWVhc3VyZW1lbnRzKCk6IFRIUkVFLk1lc2hbXTtcclxuICB1cGRhdGVQb3NpdGlvbnMoY2FtZXJhOiBUSFJFRS5DYW1lcmEpO1xyXG4gIHNldFZpc2liaWxpdHkodmlzaWJsZTogYm9vbGVhbik7XHJcbn1cclxuIl19

package/esm2015/app/plugins/core3d/hud/bounding-measurement-box/measurement-utils.js

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import { Dimensioning } from '../../core/dimensioning';
+export const minSize = 0.05;
+export const xDirection = new THREE.Vector3(1, 0, 0);
+export const yDirection = new THREE.Vector3(0, 1, 0);
+export const zDirection = new THREE.Vector3(0, 0, 1);
+export const positioningFactors = [
+    [-1, -1],
+    [-1, 1],
+    [1, -1],
+    [1, 1]
+];
+export class MeasurementUtils {
+    static makeText(value, dimUnit, distanceStep) {
+        let text;
+        if (value >= minSize) {
+            text = Dimensioning.mToMeasure(value, dimUnit, distanceStep);
+        }
+        return text;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/hud/custom-shape-name-label.js

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+import { makeTextMesh } from './utils';
+export class CustomShapeNameLabel {
+    constructor(item, font) {
+        this._shiftUp = 0.2;
+        this._label = makeTextMesh(item.name, font, 0x000000, 0.12, true, false);
+        this._label.geometry.translate(-item.getWidth() / 2, 0, 0);
+        this.update(item.position, item.getHeight());
+    }
+    get label() {
+        return this._label;
+    }
+    update(position, height) {
+        const labelPosition = this.calculateLabelPosition(position, height);
+        this.label.position.set(labelPosition.x, labelPosition.y, labelPosition.z);
+    }
+    faceToTheCameraPosition(camera) {
+        this.label.quaternion.copy(camera.quaternion);
+    }
+    faceToTheSouth(quaternion) {
+        this.label.quaternion.copy(quaternion);
+    }
+    setVisibility(visible) {
+        this.label.visible = visible;
+    }
+    calculateLabelPosition(position, height) {
+        const yPosition = position.y + (height / 2) + this._shiftUp;
+        return new THREE.Vector3(position.x, yPosition, position.z);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/hud/floor-indicator.js

@@ -0,0 +1,80 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as TWEEN from '@tweenjs/tween.js';
+import { IndicatorFactory } from './indicator-factory';
+export class FloorIndicator {
+    constructor(_sceneService) {
+        this._sceneService = _sceneService;
+    }
+    get objects() {
+        return [this.floorIndicator, this.confirmIndicator];
+    }
+    isSamePoint(point) {
+        return this.point && this.point.equals(point);
+    }
+    move(mouse, point, cameraDistance) {
+        const removals = this.floorIndicator ?
+            [this.floorIndicator] : [];
+        this.radius = Math.min(0.2, Math.abs(5 + 4000 / cameraDistance));
+        this.floorIndicator = IndicatorFactory.makeIndicator(point, this.radius);
+        this.point = point.clone();
+        return { removals, additions: [this.floorIndicator] };
+    }
+    stop() {
+        if (this.animation) {
+            this.animation.stop();
+        }
+    }
+    animateConfirm() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stop();
+            this.animation = yield this.createAnimation();
+            return this.animation;
+        });
+    }
+    createAnimation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.confirmIndicator = IndicatorFactory.makeTransparentRing(.8, this.radius * .9, this.radius);
+            this.confirmIndicator.position.copy(this.floorIndicator.position);
+            this._sceneService.addObject(this.confirmIndicator);
+            let activeTween;
+            try {
+                activeTween = yield this.animate(200, 1.4, false, TWEEN.Easing.Quadratic.In);
+                activeTween = yield this.animate(300, 1.2, true, TWEEN.Easing.Quadratic.Out);
+            }
+            catch (e) {
+                // in case the tween is stopped continue to remove the confirmIndicator
+            }
+            this.objects.forEach(o => this._sceneService.removeObject(o));
+            return activeTween;
+        });
+    }
+    animate(duration, targetScale, dim, easing) {
+        const scale = this.confirmIndicator.scale;
+        const target = scale.clone().multiplyScalar(targetScale);
+        const tween = new TWEEN.Tween(scale)
+            .to(target, duration)
+            .easing(easing)
+            .onUpdate(() => {
+            if (dim) {
+                this.confirmIndicator.material.opacity = 1 - scale.x / target.x;
+            }
+            this.confirmIndicator.scale.copy(scale);
+            this._sceneService.needsRender = true;
+        });
+        return new Promise((resolve, reject) => {
+            tween
+                .onComplete(resolve(tween))
+                .onStop(reject())
+                .start();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/hud/furniture-measurements.js

@@ -0,0 +1,44 @@
+import * as THREE from 'three';
+import { Measurements } from './measurements';
+const measurementsLevel = 50;
+export class FurnitureMeasurements extends Measurements {
+    constructor(roomService, itemService, item, font) {
+        super(item, font);
+        this._roomService = roomService;
+        this._itemService = itemService;
+    }
+    makeMeasurements() {
+        this.rotationY = this.item.rotation.y;
+        this.position = this.item.position.clone();
+        const object = new THREE.Object3D();
+        const intersectionPlanes = this._roomService.wallEdgePlanes().concat(this._itemService.getObjectPlanes().filter(this.nonItemPlane.bind(this, this.item)));
+        const directions = [
+            new THREE.Vector3(-1, 0, 0),
+            new THREE.Vector3(0, 0, -1),
+            new THREE.Vector3(1, 0, 0),
+            new THREE.Vector3(0, 0, 1), // top
+        ];
+        const meshPairs = directions.map((direction, index) => {
+            const vector = this.rotateDirection(this.item.rotation.y, direction);
+            const startPoint = direction.clone()
+                .multiply(this.item.getHalfSize());
+            const height = this.item.getHeight() > measurementsLevel ? measurementsLevel : 0;
+            const origin = this.rotatedBoundingBoxBottomPoint(this.item, startPoint).setY(height);
+            const intersection = this.raycastPlanes(intersectionPlanes, origin, vector);
+            if (intersection) {
+                return this.makeLabeledArrow(origin, vector, intersection.distance, { abs: intersection.distance / 2 }, index);
+            }
+        });
+        const meshes = Array.prototype.concat(...meshPairs).filter(mesh => mesh);
+        if (meshes.length) {
+            object.add(...meshes);
+        }
+        this.measurements = [object];
+        return this.measurements;
+    }
+    hasChanged() {
+        return this.rotationY !== this.item.rotation.y ||
+            !this.position.equals(this.item.position);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/hud/indicator-factory.js

@@ -0,0 +1,49 @@
+import * as THREE from 'three';
+import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+const indicatorColor = new THREE.Color('#F6F6F6');
+const ringOpacity = .8;
+const circleOpacity = .2;
+export class IndicatorFactory {
+    static makeIndicator(position, radius) {
+        const object = new THREE.Object3D();
+        object.position.copy(position);
+        const outerCircle = this.makeTransparentRing(ringOpacity, radius * .9, radius);
+        const innerCircle = this.makeTransparentCircle(circleOpacity, indicatorColor, radius * .9);
+        object.add(outerCircle);
+        object.add(innerCircle);
+        object.position.y = 0.01;
+        return object;
+    }
+    static makeIndicatorMesh(radius, ringColor) {
+        const outerCircle = this.makeTransparentRing(ringOpacity, radius * .9, radius, ringColor);
+        const innerCircle = this.makeTransparentCircle(circleOpacity, ringColor, radius * .8);
+        const indicatorGeometry = BufferGeometryUtils.mergeGeometries([
+            innerCircle.geometry, outerCircle.geometry
+        ]);
+        return new THREE.Mesh(indicatorGeometry, outerCircle.material);
+    }
+    static makeTransparentRing(opacity, innerRadius, outerRadius, color) {
+        const geometry = new THREE.RingGeometry(innerRadius, outerRadius, 32);
+        const material = new THREE.MeshBasicMaterial({
+            color: color ? color.convertSRGBToLinear() : indicatorColor.convertSRGBToLinear(),
+            opacity: ringOpacity,
+            transparent: true,
+            depthTest: false
+        });
+        const circle = new THREE.Mesh(geometry, material);
+        circle.name = 'hud-ring';
+        circle.rotation.x = -Math.PI / 2;
+        return circle;
+    }
+    static makeTransparentCircle(opacity, color, radius) {
+        const geometry = new THREE.CircleGeometry(radius, 32);
+        const material = new THREE.MeshBasicMaterial({
+            color: color.convertSRGBToLinear(), opacity: circleOpacity, transparent: true, depthTest: false
+        });
+        const circle = new THREE.Mesh(geometry, material);
+        circle.name = 'hud-circle';
+        circle.rotation.x = -Math.PI / 2;
+        return circle;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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