@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/hud/rotation-helper.js

@@ -0,0 +1,263 @@
+import { BoxGeometry, CircleGeometry, CylinderGeometry, EdgesGeometry, Line, LineBasicMaterial, LineSegments, Mesh, MeshBasicMaterial, Object3D, RingGeometry, SphereGeometry, Vector3 } from 'three';
+import * as Geometry from '../model/geometry';
+const directionArrowHeight = 0.05;
+const itemDistance = 0.2;
+const defaultColor = '#ffffff';
+const rotationArcColor = '#ff0000';
+const smallTickLength = 0.05;
+const bigTickLength = 0.1;
+const angleLabelSize = 0.06;
+const axisY = new Vector3(0, 1, 0);
+let floorOffsetHeight = 0.004;
+export class RotationHelper {
+    constructor(_item, _hudFont) {
+        this._item = _item;
+        this._hudFont = _hudFont;
+        this._arrow = this._makeArrow(_item);
+        this._angleArc = this._makeAngleArc(_item);
+        this._boundingBox = this._makeBoundingBox(_item);
+        // this._angleScale = this._makeAngleScale(_item);
+        this._angleScale = this._makeRotationScale(_item);
+        this._snapperArea = this._makeSnapperArea(_item);
+    }
+    set angleUnit(value) {
+        this._angleUnit = value;
+    }
+    get objects() {
+        return [this._arrow, this._angleArc, this._boundingBox, this._angleScale, this._snapperArea];
+    }
+    get rotatingObjects() {
+        return [this._arrow, this._boundingBox];
+    }
+    get rotationSnappers() {
+        return [this._arrow, this._angleArc, this._angleScale];
+    }
+    get rotationSnapperArea() {
+        return this._snapperArea;
+    }
+    set floorOffsetHeight(number) {
+        floorOffsetHeight = number;
+    }
+    static CanRotateX(value) {
+        return (value & 2) === 2;
+    }
+    static CanRotateY(value) {
+        return (value & 4) === 4;
+    }
+    static CanRotateZ(value) {
+        return (value & 8) === 8;
+    }
+    static Default180(value) {
+        return (value & 1) === 1;
+    }
+    setTextsDirection(quaternion) {
+        // this._angleScale.children
+        //   .filter((mesh: Mesh) => mesh.geometry instanceof TextGeometry)
+        //   .forEach(mesh => mesh.quaternion.copy(quaternion));
+    }
+    update(item) {
+        // position changes, move everything
+        if (!item.position.equals(this._arrow.position)) {
+            this.objects.forEach(object => {
+                object.position.x = item.position.x;
+                object.position.z = item.position.z;
+                if (object === this._boundingBox) {
+                    object.position.y = item.getHeight() / 2 + item.elevation + floorOffsetHeight;
+                }
+            });
+        }
+        // rotation changes, rotate objects and re-create angleArc
+        if (item.rotation.y !== this._arrow.rotation.y) {
+            this.rotatingObjects.forEach(object => object.rotation.y = item.rotation.y);
+            const removeRef = this._angleArc;
+            this._angleArc = this._makeAngleArc(item);
+            return { removals: [removeRef], additions: [this._angleArc] };
+        }
+        else {
+            return {};
+        }
+    }
+    setColor(newColor) {
+        this._arrow.children.concat(this._angleScale.children).forEach((mesh) => {
+            mesh.material.color.set(newColor);
+            // (mesh.material as MeshBasicMaterial).opacity = 1;
+            mesh.material.needsUpdate = true;
+        });
+        this._boundingBox.material.color.set(newColor);
+        this._boundingBox.material.needsUpdate = true;
+    }
+    getItem() {
+        return this._item;
+    }
+    _itemSize(item) {
+        return Math.max(item.halfSize.x, item.halfSize.z) + 0.014 + itemDistance;
+    }
+    _itemDirectionVector(item) {
+        const vec = new Vector3(0, 0, this._itemSize(item));
+        return vec;
+    }
+    _makeLine(item) {
+        const geometry = Geometry.line(new Vector3(0, 0, 0), this._itemDirectionVector(item));
+        const line = new LineSegments(geometry, new LineBasicMaterial({ color: defaultColor, linewidth: 0.03 }));
+        line.position.set(0, directionArrowHeight, 0);
+        return line;
+    }
+    _makeCone(item) {
+        const coneGeo = new CylinderGeometry(directionArrowHeight, 0, 0.1);
+        const coneMat = new MeshBasicMaterial({ color: defaultColor });
+        const cone = new Mesh(coneGeo, coneMat);
+        cone.name = 'hud-cone';
+        cone.position.set(0, directionArrowHeight, this._itemSize(item));
+        cone.rotation.x = -Math.PI / 2.0;
+        return cone;
+    }
+    _makeSphere(item) {
+        const geometry = new SphereGeometry(0.04, 16, 16);
+        const material = new MeshBasicMaterial({ color: defaultColor });
+        const sphere = new Mesh(geometry, material);
+        sphere.name = 'hud-sphere';
+        sphere.position.set(0, directionArrowHeight, 0);
+        return sphere;
+    }
+    _makeBoundingBox(item) {
+        const geometry = new BoxGeometry(item.getWidth(), item.getHeight(), item.getDepth());
+        const edges = new EdgesGeometry(geometry, 1);
+        const frame = new LineSegments(edges, new LineBasicMaterial({ color: defaultColor }));
+        const y = item.getHeight() / 2 + item.elevation + floorOffsetHeight;
+        frame.position.set(item.position.x, y, item.position.z);
+        frame.rotation.y = item.rotation.y;
+        return frame;
+    }
+    _makeArrow(item) {
+        const object = new Object3D();
+        // direction arrow
+        const line = this._makeLine(item);
+        const cone = this._makeCone(item);
+        const sphere = this._makeSphere(item);
+        object.add(line);
+        object.add(cone);
+        object.add(sphere);
+        object.rotation.y = item.rotation.y;
+        object.position.x = item.position.x;
+        object.position.z = item.position.z;
+        object.position.y = floorOffsetHeight;
+        return object;
+    }
+    _makeScaleCircle(item) {
+        // const radius = this._itemSize(item);
+        // const points = Geometry.rotationPointsFromCircle(radius);
+        // const positions = [];
+        // points.forEach(p => positions.push(p.x, p.y, p.z));
+        // const geometry = new LineGeometry();
+        // geometry.setPositions(positions);
+        // geometry.rotateX(Math.PI / 2);
+        //
+        // const material = new LineMaterial({color: 0x00ff00 /*defaultColor*/, linewidth: 1});
+        // // Create the final object to add to the scene
+        // const line: Line2 = new Line2(geometry, material);
+        // return line;
+        const radius = this._itemSize(item);
+        const geometry = Geometry.rotationCircle(radius);
+        const material = new LineBasicMaterial({ color: defaultColor, linewidth: 5 });
+        // Create the final object to add to the scene
+        const line = new Line(geometry, material);
+        return line;
+    }
+    _makeAngleArc(item) {
+        const radius = this._itemSize(item) + directionArrowHeight;
+        const geometry = Geometry.rotationArc(radius, item.rotation.y);
+        const material = new LineBasicMaterial({
+            color: rotationArcColor
+        });
+        const object = new Line(geometry, material);
+        object.position.x = item.position.x;
+        object.position.z = item.position.z;
+        object.position.y = floorOffsetHeight;
+        return object;
+    }
+    _makeSnapperArea(item) {
+        const radius = this._itemSize(item) + directionArrowHeight;
+        const geometry = new CircleGeometry(radius, 32);
+        const material = new MeshBasicMaterial({ transparent: true, opacity: 0.0 });
+        const area = new Mesh(geometry, material);
+        area.position.x = item.position.x;
+        area.position.z = item.position.z;
+        area.position.y = floorOffsetHeight;
+        area.rotateX(-Math.PI / 2);
+        return area;
+    }
+    _rotateDirection(rotateY, direction) {
+        return direction.clone().applyAxisAngle(axisY, rotateY);
+    }
+    _rotatedBoundingBoxPoint(item, point) {
+        const rotatedPoint = this._rotateDirection(item.rotation.y, point);
+        return item.position.clone().add(rotatedPoint);
+    }
+    _makeAngleScale(item) {
+        const object = new Object3D();
+        if (this._hudFont) {
+            const labels = this._makeAngleScaleLabels(item, [0, Math.PI / 2, Math.PI, -Math.PI / 2]);
+            labels.forEach(label => object.add(label));
+        }
+        const lines = this._makeAngleScaleLines(item, [0, Math.PI / 2, Math.PI, -Math.PI / 2], [Math.PI / 6, 2 * Math.PI / 6, 4 * Math.PI / 6, 5 * Math.PI / 6, -Math.PI / 6, -2 * Math.PI / 6, -4 * Math.PI / 6, -5 * Math.PI / 6]);
+        lines.forEach(line => object.add(line));
+        const circle = this._makeScaleCircle(item);
+        circle.name = 'rotationCircle';
+        object.add(circle);
+        object.position.x = item.position.x;
+        object.position.z = item.position.z;
+        object.position.y = floorOffsetHeight;
+        return object;
+    }
+    _makeAngleScaleLabels(item, angles) {
+        return angles.map(angle => {
+            const geometry = Geometry.angleText(this._hudFont, angleLabelSize, angle, this._angleUnit);
+            const material = new MeshBasicMaterial({ color: defaultColor });
+            const mesh = new Mesh(geometry, material);
+            mesh.name = 'hud-angle-text';
+            const position = this._itemDirectionVector(item).applyAxisAngle(axisY, angle);
+            mesh.position.copy(position);
+            return mesh;
+        });
+    }
+    _makeAngleScaleLines(item, bigAngles, smallAngles) {
+        const createLineMesh = (start, end, length, angle) => {
+            const geometry = Geometry.line(start, end);
+            const material = new LineBasicMaterial({ color: defaultColor });
+            const mesh = new LineSegments(geometry, material);
+            const position = new Vector3(0, 0, this._itemSize(item) - length);
+            mesh.position.copy(position.applyAxisAngle(axisY, angle));
+            mesh.rotation.y = angle + Math.PI / 2;
+            return mesh;
+        };
+        const smallStartPos = new Vector3(-smallTickLength, 0, 0);
+        const bigStartPos = new Vector3(-bigTickLength, 0, 0);
+        const endPos = new Vector3(0, 0, 0);
+        const big = bigAngles.map(angle => createLineMesh(bigStartPos.clone(), endPos.clone(), bigTickLength, angle));
+        const small = smallAngles.map(angle => createLineMesh(smallStartPos.clone(), endPos.clone(), smallTickLength, angle));
+        return big.concat(small);
+    }
+    _makeRotationScale(item) {
+        const object = new Object3D();
+        const radius = this._itemSize(item);
+        const innerRadius = radius * 0.90;
+        // const geometry = new CircleGeometry(radius, 32);
+        const geometry = new RingGeometry(innerRadius, radius, 32);
+        const material = new MeshBasicMaterial({ color: 0xFFFFFF, transparent: true, opacity: 0.6 });
+        const circle = new Mesh(geometry, material);
+        const outlineInnerRadius = radius;
+        const outlineRadius = outlineInnerRadius * 1.01;
+        const geometryOutline = new RingGeometry(outlineInnerRadius, outlineRadius, 32);
+        const materialOutline = new MeshBasicMaterial({ color: 0x777777, transparent: true, opacity: 0.9 });
+        const circleOutline = new Mesh(geometryOutline, materialOutline);
+        circle.name = 'rotationCircle';
+        object.add(circle);
+        object.add(circleOutline);
+        object.rotation.x = -Math.PI / 2;
+        object.position.x = item.position.x;
+        object.position.z = item.position.z;
+        object.position.y = floorOffsetHeight;
+        return object;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rotation-helper.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/hud/rotation-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  BoxGeometry,\r\n  CircleGeometry,\r\n  CylinderGeometry,\r\n  EdgesGeometry,\r\n  Line,\r\n  LineBasicMaterial,\r\n  LineSegments,\r\n  Mesh,\r\n  MeshBasicMaterial,\r\n  Object3D,\r\n  Quaternion,\r\n  RingGeometry,\r\n  SphereGeometry,\r\n  Vector3\r\n} from 'three';\r\nimport * as Geometry from '../model/geometry';\r\nimport {Font} from 'three/examples/jsm/loaders/FontLoader';\r\nimport {SceneUpdate} from '../interface/scene-update.interface';\r\nimport type {Item} from '../items/item';\r\nimport type {ItemGroup} from '../items/item-group';\r\n\r\nconst directionArrowHeight = 0.05;\r\nconst itemDistance = 0.2;\r\nconst defaultColor = '#ffffff';\r\nconst rotationArcColor = '#ff0000';\r\nconst smallTickLength = 0.05;\r\nconst bigTickLength = 0.1;\r\nconst angleLabelSize = 0.06;\r\nconst axisY = new Vector3(0, 1, 0);\r\nlet floorOffsetHeight = 0.004;\r\n\r\nexport class RotationHelper {\r\n  private _arrow: Object3D;\r\n  private _angleArc: Line;\r\n  private _boundingBox: LineSegments;\r\n  private _angleScale: Object3D;\r\n  private _snapperArea: Object3D;\r\n  private _angleUnit: string;\r\n\r\n  set angleUnit(value: string) {\r\n    this._angleUnit = value;\r\n  }\r\n\r\n  public get objects(): (Object3D | Mesh)[] {\r\n    return [this._arrow, this._angleArc, this._boundingBox, this._angleScale, this._snapperArea];\r\n  }\r\n\r\n  private get rotatingObjects(): (Object3D | Mesh)[] {\r\n    return [this._arrow, this._boundingBox];\r\n  }\r\n\r\n  public get rotationSnappers(): Object3D[] {\r\n    return [this._arrow, this._angleArc, this._angleScale];\r\n  }\r\n\r\n  public get rotationSnapperArea(): Object3D {\r\n    return this._snapperArea;\r\n  }\r\n\r\n  public set floorOffsetHeight(number) {\r\n    floorOffsetHeight = number;\r\n  }\r\n\r\n  public static CanRotateX(value: number): boolean {\r\n    return (value & 2) === 2;\r\n  }\r\n\r\n  public static CanRotateY(value: number): boolean {\r\n    return (value & 4) === 4;\r\n  }\r\n\r\n  public static CanRotateZ(value: number): boolean {\r\n    return (value & 8) === 8;\r\n  }\r\n\r\n  public static Default180(value: number): boolean {\r\n    return (value & 1) === 1;\r\n  }\r\n\r\n  constructor(private _item, private _hudFont: Font) {\r\n    this._arrow = this._makeArrow(_item);\r\n    this._angleArc = this._makeAngleArc(_item);\r\n    this._boundingBox = this._makeBoundingBox(_item);\r\n    // this._angleScale = this._makeAngleScale(_item);\r\n    this._angleScale = this._makeRotationScale(_item);\r\n    this._snapperArea = this._makeSnapperArea(_item);\r\n  }\r\n\r\n  public setTextsDirection(quaternion: Quaternion) {\r\n    // this._angleScale.children\r\n    //   .filter((mesh: Mesh) => mesh.geometry instanceof TextGeometry)\r\n    //   .forEach(mesh => mesh.quaternion.copy(quaternion));\r\n  }\r\n\r\n  public update(item): SceneUpdate {\r\n    // position changes, move everything\r\n    if (!item.position.equals(this._arrow.position)) {\r\n      this.objects.forEach(object => {\r\n        object.position.x = item.position.x;\r\n        object.position.z = item.position.z;\r\n        if (object === this._boundingBox) {\r\n          object.position.y = item.getHeight() / 2 + item.elevation + floorOffsetHeight;\r\n        }\r\n      });\r\n    }\r\n    // rotation changes, rotate objects and re-create angleArc\r\n    if (item.rotation.y !== this._arrow.rotation.y) {\r\n      this.rotatingObjects.forEach(object => object.rotation.y = item.rotation.y);\r\n      const removeRef = this._angleArc;\r\n      this._angleArc = this._makeAngleArc(item);\r\n      return {removals: [removeRef], additions: [this._angleArc]};\r\n    } else {\r\n      return {};\r\n    }\r\n  }\r\n\r\n  public setColor(newColor: string) {\r\n    this._arrow.children.concat(this._angleScale.children).forEach((mesh: Mesh) => {\r\n      (mesh.material as MeshBasicMaterial).color.set(newColor);\r\n      // (mesh.material as MeshBasicMaterial).opacity = 1;\r\n      (mesh.material as MeshBasicMaterial).needsUpdate = true;\r\n    });\r\n    (this._boundingBox.material as LineBasicMaterial).color.set(newColor);\r\n    (this._boundingBox.material as LineBasicMaterial).needsUpdate = true;\r\n  }\r\n\r\n  public getItem(): any {\r\n    return this._item;\r\n  }\r\n\r\n  private _itemSize(item): number {\r\n    return Math.max(item.halfSize.x, item.halfSize.z) + 0.014 + itemDistance;\r\n  }\r\n\r\n  private _itemDirectionVector(item): Vector3 {\r\n    const vec = new Vector3(\r\n      0, 0, this._itemSize(item)\r\n    );\r\n    return vec;\r\n  }\r\n\r\n  private _makeLine(item): LineSegments {\r\n    const geometry = Geometry.line(\r\n      new Vector3(0, 0, 0),\r\n      this._itemDirectionVector(item)\r\n    );\r\n    const line = new LineSegments(\r\n      geometry,\r\n      new LineBasicMaterial({color: defaultColor, linewidth: 0.03})\r\n    );\r\n    line.position.set(0, directionArrowHeight, 0);\r\n    return line;\r\n  }\r\n\r\n  private _makeCone(item): Mesh {\r\n    const coneGeo = new CylinderGeometry(directionArrowHeight, 0, 0.1);\r\n    const coneMat = new MeshBasicMaterial({color: defaultColor});\r\n    const cone = new Mesh(coneGeo, coneMat);\r\n    cone.name = 'hud-cone';\r\n    cone.position.set(0, directionArrowHeight, this._itemSize(item));\r\n    cone.rotation.x = -Math.PI / 2.0;\r\n    return cone;\r\n  }\r\n\r\n  private _makeSphere(item): Mesh {\r\n    const geometry = new SphereGeometry(0.04, 16, 16);\r\n    const material = new MeshBasicMaterial({color: defaultColor});\r\n    const sphere = new Mesh(geometry, material);\r\n    sphere.name = 'hud-sphere';\r\n    sphere.position.set(0, directionArrowHeight, 0);\r\n    return sphere;\r\n  }\r\n\r\n  private _makeBoundingBox(item: Item | ItemGroup): LineSegments {\r\n    const geometry = new BoxGeometry(item.getWidth(), item.getHeight(), item.getDepth());\r\n    const edges = new EdgesGeometry(geometry, 1);\r\n    const frame = new LineSegments(edges, new LineBasicMaterial({color: defaultColor}));\r\n\r\n    const y = item.getHeight() / 2 + item.elevation + floorOffsetHeight;\r\n    frame.position.set(\r\n      item.position.x,\r\n      y,\r\n      item.position.z\r\n    );\r\n    frame.rotation.y = item.rotation.y;\r\n    return frame;\r\n  }\r\n\r\n  private _makeArrow(item): Object3D {\r\n    const object = new Object3D();\r\n\r\n    // direction arrow\r\n    const line = this._makeLine(item);\r\n    const cone = this._makeCone(item);\r\n    const sphere = this._makeSphere(item);\r\n    object.add(line);\r\n    object.add(cone);\r\n    object.add(sphere);\r\n\r\n    object.rotation.y = item.rotation.y;\r\n    object.position.x = item.position.x;\r\n    object.position.z = item.position.z;\r\n    object.position.y = floorOffsetHeight;\r\n\r\n    return object;\r\n  }\r\n\r\n  private _makeScaleCircle(item): Line {\r\n    // const radius = this._itemSize(item);\r\n    // const points = Geometry.rotationPointsFromCircle(radius);\r\n    // const positions = [];\r\n    // points.forEach(p => positions.push(p.x, p.y, p.z));\r\n    // const geometry = new LineGeometry();\r\n    // geometry.setPositions(positions);\r\n    // geometry.rotateX(Math.PI / 2);\r\n    //\r\n    // const material = new LineMaterial({color: 0x00ff00 /*defaultColor*/, linewidth: 1});\r\n    // // Create the final object to add to the scene\r\n    // const line: Line2 = new Line2(geometry, material);\r\n    // return line;\r\n    const radius = this._itemSize(item);\r\n    const geometry = Geometry.rotationCircle(radius);\r\n\r\n    const material = new LineBasicMaterial({color: defaultColor, linewidth: 5});\r\n    // Create the final object to add to the scene\r\n    const line: Line = new Line(geometry, material);\r\n    return line;\r\n  }\r\n\r\n  private _makeAngleArc(item): Line {\r\n    const radius = this._itemSize(item) + directionArrowHeight;\r\n    const geometry = Geometry.rotationArc(radius, item.rotation.y);\r\n    const material = new LineBasicMaterial({\r\n      color: rotationArcColor\r\n    });\r\n    const object = new Line(geometry, material);\r\n    object.position.x = item.position.x;\r\n    object.position.z = item.position.z;\r\n    object.position.y = floorOffsetHeight;\r\n    return object;\r\n  }\r\n\r\n  private _makeSnapperArea(item): Mesh {\r\n    const radius = this._itemSize(item) + directionArrowHeight;\r\n    const geometry = new CircleGeometry(radius, 32);\r\n    const material = new MeshBasicMaterial({transparent: true, opacity: 0.0});\r\n\r\n    const area = new Mesh(geometry, material);\r\n\r\n    area.position.x = item.position.x;\r\n    area.position.z = item.position.z;\r\n    area.position.y = floorOffsetHeight;\r\n\r\n    area.rotateX(-Math.PI / 2);\r\n\r\n    return area;\r\n  }\r\n\r\n  private _rotateDirection(rotateY: number, direction: Vector3): Vector3 {\r\n    return direction.clone().applyAxisAngle(axisY, rotateY);\r\n  }\r\n\r\n  private _rotatedBoundingBoxPoint(item, point: Vector3): Vector3 {\r\n    const rotatedPoint = this._rotateDirection(item.rotation.y, point);\r\n    return item.position.clone().add(rotatedPoint);\r\n  }\r\n\r\n  private _makeAngleScale(item): Object3D {\r\n    const object = new Object3D();\r\n    if (this._hudFont) {\r\n      const labels = this._makeAngleScaleLabels(item, [0, Math.PI / 2, Math.PI, -Math.PI / 2]);\r\n      labels.forEach(label => object.add(label));\r\n    }\r\n    const lines = this._makeAngleScaleLines(item,\r\n      [0, Math.PI / 2, Math.PI, -Math.PI / 2],\r\n      [Math.PI / 6, 2 * Math.PI / 6, 4 * Math.PI / 6, 5 * Math.PI / 6, -Math.PI / 6, -2 * Math.PI / 6, -4 * Math.PI / 6, -5 * Math.PI / 6]\r\n    );\r\n    lines.forEach(line => object.add(line));\r\n\r\n    const circle = this._makeScaleCircle(item);\r\n    circle.name = 'rotationCircle';\r\n    object.add(circle);\r\n\r\n    object.position.x = item.position.x;\r\n    object.position.z = item.position.z;\r\n    object.position.y = floorOffsetHeight;\r\n\r\n    return object;\r\n  }\r\n\r\n  private _makeAngleScaleLabels(item, angles: number[]): Mesh[] {\r\n    return angles.map(angle => {\r\n      const geometry = Geometry.angleText(this._hudFont, angleLabelSize, angle, this._angleUnit);\r\n      const material = new MeshBasicMaterial({color: defaultColor});\r\n      const mesh = new Mesh(geometry, material);\r\n      mesh.name = 'hud-angle-text';\r\n      const position = this._itemDirectionVector(item).applyAxisAngle(axisY, angle);\r\n      mesh.position.copy(position);\r\n      return mesh;\r\n    });\r\n  }\r\n\r\n  private _makeAngleScaleLines(item, bigAngles: number[], smallAngles: number[]): LineSegments[] {\r\n    const createLineMesh = (start: Vector3, end: Vector3, length: number, angle: number): LineSegments => {\r\n      const geometry = Geometry.line(start, end);\r\n      const material = new LineBasicMaterial({color: defaultColor});\r\n      const mesh = new LineSegments(geometry, material);\r\n      const position = new Vector3(0, 0, this._itemSize(item) - length);\r\n      mesh.position.copy(position.applyAxisAngle(axisY, angle));\r\n      mesh.rotation.y = angle + Math.PI / 2;\r\n      return mesh;\r\n    };\r\n    const smallStartPos = new Vector3(-smallTickLength, 0, 0);\r\n    const bigStartPos = new Vector3(-bigTickLength, 0, 0);\r\n    const endPos = new Vector3(0, 0, 0);\r\n    const big = bigAngles.map(angle => createLineMesh(\r\n      bigStartPos.clone(), endPos.clone(), bigTickLength, angle));\r\n    const small = smallAngles.map(angle => createLineMesh(\r\n      smallStartPos.clone(), endPos.clone(), smallTickLength, angle));\r\n    return big.concat(small);\r\n  }\r\n\r\n  private _makeRotationScale(item): Object3D {\r\n    const object = new Object3D();\r\n    const radius: number = this._itemSize(item);\r\n    const innerRadius: number = radius * 0.90;\r\n    // const geometry = new CircleGeometry(radius, 32);\r\n    const geometry: RingGeometry = new RingGeometry(innerRadius, radius, 32);\r\n    const material: MeshBasicMaterial = new MeshBasicMaterial({color: 0xFFFFFF, transparent: true, opacity: 0.6});\r\n    const circle: Mesh = new Mesh(geometry, material);\r\n\r\n    const outlineInnerRadius: number = radius;\r\n    const outlineRadius: number = outlineInnerRadius * 1.01;\r\n\r\n    const geometryOutline: RingGeometry = new RingGeometry(outlineInnerRadius, outlineRadius, 32);\r\n    const materialOutline: MeshBasicMaterial = new MeshBasicMaterial({color: 0x777777, transparent: true, opacity: 0.9});\r\n    const circleOutline: Mesh = new Mesh(geometryOutline, materialOutline);\r\n\r\n    circle.name = 'rotationCircle';\r\n    object.add(circle);\r\n    object.add(circleOutline);\r\n    object.rotation.x = -Math.PI / 2;\r\n    object.position.x = item.position.x;\r\n    object.position.z = item.position.z;\r\n    object.position.y = floorOffsetHeight;\r\n\r\n    return object;\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/hud/utils.js

@@ -0,0 +1,30 @@
+import * as THREE from 'three';
+import { TextGeometry } from 'three/examples/jsm/geometries/TextGeometry';
+const textHeight = 0.01;
+export function makeTextMesh(text, font, color = 0xFF00FF, size = 0.08, beveled = false, depthTest = true, label) {
+    if (label) {
+        label = label + ': ';
+    }
+    if (!label) {
+        label = '';
+    }
+    const textGeo = new TextGeometry(label + text, {
+        font: font,
+        size: size,
+        depth: textHeight,
+        curveSegments: 4,
+        bevelEnabled: beveled,
+        bevelThickness: 0.01,
+        bevelSize: 0.01
+    });
+    textGeo.computeBoundingBox();
+    textGeo.computeVertexNormals();
+    const materials = [
+        new THREE.MeshBasicMaterial({ color: color, depthTest: depthTest })
+    ];
+    if (beveled) {
+        materials.push(new THREE.MeshBasicMaterial({ color: 0xffffff, depthTest: depthTest }));
+    }
+    return new THREE.Mesh(textGeo, materials);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/plugins/core3d/interface/dragged-data.interface.js

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

package/esm2015/app/plugins/core3d/interface/edge-visibility-changes.js

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

package/esm2015/app/plugins/core3d/interface/model.interface.js

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

package/esm2015/app/plugins/core3d/interface/opening.interface.js

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

package/esm2015/app/plugins/core3d/interface/scene-option-button.interface.js

@@ -0,0 +1,6 @@
+export class SceneOptionButtonInterface {
+    constructor() {
+        this.active = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NlbmUtb3B0aW9uLWJ1dHRvbi5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2xpZW50L2FwcC9wbHVnaW5zL2NvcmUzZC9pbnRlcmZhY2Uvc2NlbmUtb3B0aW9uLWJ1dHRvbi5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLDBCQUEwQjtJQUF2QztRQVVTLFdBQU0sR0FBYSxLQUFLLENBQUM7SUFLbEMsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtTYWZlSHRtbH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XHJcblxyXG5leHBvcnQgY2xhc3MgU2NlbmVPcHRpb25CdXR0b25JbnRlcmZhY2Uge1xyXG4gIHB1YmxpYyBpZDogbnVtYmVyO1xyXG4gIHB1YmxpYyBlbGVtZW50SWQ6IHN0cmluZztcclxuICBwdWJsaWMgbGFiZWw/OiBzdHJpbmc7XHJcbiAgcHVibGljIGNsYXNzPzogc3RyaW5nO1xyXG4gIHB1YmxpYyB0b29sdGlwPzogc3RyaW5nO1xyXG4gIHB1YmxpYyBpbWFnZT86IHN0cmluZyB8IFNhZmVIdG1sO1xyXG4gIHB1YmxpYyBvcmRlcj86IG51bWJlcjtcclxuICBwdWJsaWMgdG9nZ2xlPzogYm9vbGVhbjtcclxuICBwdWJsaWMgdG9vbHRpcEFjdGl2ZT86IHN0cmluZztcclxuICBwdWJsaWMgYWN0aXZlPzogYm9vbGVhbiA9IGZhbHNlO1xyXG4gIHB1YmxpYyBvYmplY3Q/OiBhbnk7XHJcbiAgcHVibGljIGNsaWNrPzogRnVuY3Rpb247XHJcbiAgcHVibGljIHNob3c/OiBib29sZWFuO1xyXG4gIHB1YmxpYyBjaGlsZHJlbj86IFNjZW5lT3B0aW9uQnV0dG9uSW50ZXJmYWNlW107XHJcbn1cclxuIl19

package/esm2015/app/plugins/core3d/interface/scene-update.interface.js

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