@colijnit/homedecorator 255.1.1

package/app/plugins/core3d/hud/on-wall-measurements.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import { Measurements } from './measurements';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import { HalfEdge, WallItem } from '../items/wall-objects';
+import { RoomService } from '../../room-planner/components/floorplanner/service/room.service';
+import { ItemService } from '../service/item.service';
+export declare class OnWallMeasurements extends Measurements {
+    closestEdge: HalfEdge;
+    private _roomService;
+    private _itemService;
+    constructor(roomService: RoomService, itemService: ItemService, item: WallItem, font: Font);
+    makeMeasurements(): THREE.Object3D[];
+    private edgeMeasurements;
+    private getZPos;
+    protected hasChanged(): boolean;
+    private makeSideMeasurements;
+    private getClosestWallEdge;
+}

package/app/plugins/core3d/hud/opening-symbol.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import { InWallItem } from '../items/wall-objects';
+export declare class OpeningSymbol {
+    private openingSymbol;
+    constructor(item: InWallItem);
+    get objects(): THREE.Object3D[];
+    update(item: InWallItem): void;
+    setVisibility(visible: boolean): void;
+    private makeOpeningDirectionSymbol;
+    private makeSingleOpeningDirectionSymbol;
+}

package/app/plugins/core3d/hud/rotation-helper.d.ts

@@ -0,0 +1,44 @@
+import { Mesh, Object3D, Quaternion } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import { SceneUpdate } from '../interface/scene-update.interface';
+export declare class RotationHelper {
+    private _item;
+    private _hudFont;
+    private _arrow;
+    private _angleArc;
+    private _boundingBox;
+    private _angleScale;
+    private _snapperArea;
+    private _angleUnit;
+    set angleUnit(value: string);
+    get objects(): (Object3D | Mesh)[];
+    private get rotatingObjects();
+    get rotationSnappers(): Object3D[];
+    get rotationSnapperArea(): Object3D;
+    set floorOffsetHeight(number: any);
+    static CanRotateX(value: number): boolean;
+    static CanRotateY(value: number): boolean;
+    static CanRotateZ(value: number): boolean;
+    static Default180(value: number): boolean;
+    constructor(_item: any, _hudFont: Font);
+    setTextsDirection(quaternion: Quaternion): void;
+    update(item: any): SceneUpdate;
+    setColor(newColor: string): void;
+    getItem(): any;
+    private _itemSize;
+    private _itemDirectionVector;
+    private _makeLine;
+    private _makeCone;
+    private _makeSphere;
+    private _makeBoundingBox;
+    private _makeArrow;
+    private _makeScaleCircle;
+    private _makeAngleArc;
+    private _makeSnapperArea;
+    private _rotateDirection;
+    private _rotatedBoundingBoxPoint;
+    private _makeAngleScale;
+    private _makeAngleScaleLabels;
+    private _makeAngleScaleLines;
+    private _makeRotationScale;
+}

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

@@ -0,0 +1,3 @@
+import { Mesh } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+export declare function makeTextMesh(text: string, font: Font, color?: any, size?: number, beveled?: boolean, depthTest?: boolean, label?: string): Mesh;

package/app/plugins/core3d/interface/dragged-data.interface.d.ts

@@ -0,0 +1,10 @@
+import { ItemType } from '../items/item-type';
+import { HdecoPlacement } from '@colijnit/configuratorapi/build/enum/hdeco-placement.enum';
+export interface DraggedData {
+    name: string;
+    type: ItemType;
+    iOne?: boolean;
+    constructFn?: Function;
+    overrides?: any;
+    placementType?: HdecoPlacement;
+}

package/app/plugins/core3d/interface/edge-visibility-changes.d.ts

@@ -0,0 +1,5 @@
+import { HalfEdge } from '../items/wall-objects';
+export interface EdgeVisibilityChanges {
+    edge: HalfEdge;
+    visibility: boolean;
+}

package/app/plugins/core3d/interface/model.interface.d.ts

@@ -0,0 +1,42 @@
+import { Texture } from '../../../core/model/texture';
+import { OpeningInterface } from './opening.interface';
+import { EulerOrder } from 'three';
+export interface ModelInterface {
+    name: string;
+    description?: string;
+    thumbnailUrl: string;
+    url: string;
+    type: string;
+    modelType: string;
+    isCustom?: boolean;
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        _x: number;
+        _y: number;
+        _z: number;
+        _order: EulerOrder;
+    };
+    resizable: boolean;
+    mtlUrl: string;
+    preload: boolean;
+    texture: Texture;
+    width: number;
+    height: number;
+    opening: OpeningInterface;
+    fixed: boolean;
+    category: string;
+    show: boolean;
+    additionalTexture?: Texture;
+    canElevate?: boolean;
+    doorpost?: boolean;
+    elevation?: number;
+    elevationFixed?: boolean;
+    elevationAdjustable?: boolean;
+    scalable?: boolean;
+    onWall?: boolean;
+    isGlass?: boolean;
+}

package/app/plugins/core3d/interface/opening.interface.d.ts

@@ -0,0 +1,6 @@
+export interface OpeningInterface {
+    show: boolean;
+    double: boolean;
+    invertDirection: boolean;
+    invertSide: boolean;
+}

package/app/plugins/core3d/interface/scene-option-button.interface.d.ts

@@ -0,0 +1,17 @@
+import { SafeHtml } from '@angular/platform-browser';
+export declare class SceneOptionButtonInterface {
+    id: number;
+    elementId: string;
+    label?: string;
+    class?: string;
+    tooltip?: string;
+    image?: string | SafeHtml;
+    order?: number;
+    toggle?: boolean;
+    tooltipActive?: string;
+    active?: boolean;
+    object?: any;
+    click?: Function;
+    show?: boolean;
+    children?: SceneOptionButtonInterface[];
+}

package/app/plugins/core3d/interface/scene-update.interface.d.ts

@@ -0,0 +1,5 @@
+import { Mesh, Object3D } from 'three';
+export interface SceneUpdate {
+    removals?: (Mesh | Object3D)[];
+    additions?: (Mesh | Object3D)[];
+}

package/app/plugins/core3d/items/base-item.d.ts

@@ -0,0 +1,97 @@
+import { Euler, Mesh, Object3D, Vector2, Vector3 } from 'three';
+import { Skin } from '../model/skin';
+import { Texture } from '../../../core/model/texture';
+import { Metadata } from './metadata';
+export declare abstract class BaseItem extends Object3D {
+    rawMetadata: Metadata;
+    object: Object3D | Mesh;
+    name: string;
+    description?: string;
+    canElevate: boolean;
+    stackable: boolean;
+    canMove: boolean;
+    locked: boolean;
+    itemGroup: any;
+    obstructFloorMoves: boolean;
+    allowRotate: boolean;
+    fixed: boolean;
+    skin: Skin;
+    additionalTexture: Texture;
+    frameTitle: string;
+    customMeshTitle: string;
+    canChangeCustomMeshColor: boolean;
+    isCustom: boolean;
+    scalable: boolean;
+    scalePercentage: number;
+    halfSize: Vector3;
+    set elevation(value: number);
+    get elevation(): number;
+    set elevationFixed(value: boolean);
+    get elevationFixed(): boolean;
+    elevationAdjustable: boolean;
+    canDelete: boolean;
+    canCopy: boolean;
+    canRotateX: boolean;
+    canRotateY: boolean;
+    canRotateZ: boolean;
+    default180: boolean;
+    configurable: boolean;
+    tempObject: boolean;
+    set metadata(value: Metadata);
+    get metadata(): Metadata;
+    protected positionSet: boolean;
+    protected hover: boolean;
+    protected selected: boolean;
+    protected highlighted: boolean;
+    protected emissiveColor: number;
+    protected resizable: boolean;
+    protected bBoxCorners: Vector2[];
+    protected usePivot: boolean;
+    private _elevation;
+    private _elevationFixed;
+    private _metadata;
+    constructor(rawMetadata: Metadata, object: Object3D | Mesh, texture?: Texture);
+    dispose(): void;
+    canBeRemoved(): boolean;
+    getVisibleMeshes(): (Mesh)[];
+    /** */
+    removeSelf(): void;
+    /** */
+    setFixed(fixed: boolean): void;
+    /** Subclass can define to take action after a resize. */
+    protected abstract resized(): void;
+    /** */
+    getHeight(): number;
+    /** */
+    getWidth(): number;
+    /** */
+    getDepth(): number;
+    setScale(x: number, y: number, z: number): void;
+    /** */
+    setElevation(elevation: number): void;
+    getHalfSize(): Vector3;
+    localAnchor(vec3: Vector3): Vector3;
+    /** */
+    removed(): void;
+    getBBoxCorners(): Vector2[];
+    /**
+     * returns the 2d corners of the bounding polygon
+     *
+     * offset is Vector3 (used for getting corners of object at a new position)
+     *
+     * TODO: handle rotated objects better!
+     */
+    computeBBoxCorners(position?: Vector3, rotation?: Euler): Vector2[];
+    /**
+     * Gets overridden in descendant classes
+     * @param color
+     */
+    updateFrameColor(color: number): void;
+    getRoot(): this;
+    calculateHalfSize(): void;
+    updateHalfsize(): void;
+    getFloorY(): number;
+    heightUpdated(amount?: number): void;
+    scaleGeometry(x: any, y: any, z: any): void;
+    protected setYPositionBasedOnElevation(): void;
+}

package/app/plugins/core3d/items/custom-cylinder-floor-item.d.ts

@@ -0,0 +1,12 @@
+import { Mesh, Object3D } from 'three';
+import { FloorItem } from './floor-item';
+import { Metadata } from './metadata';
+import { Texture } from '../../../core/model/texture';
+export declare class CustomCylinderFloorItem extends FloorItem {
+    get customMesh(): Mesh;
+    get radius(): number;
+    get height(): number;
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture?: Texture);
+    cloneItem(): CustomCylinderFloorItem;
+    resize(radius?: number, height?: number): void;
+}

package/app/plugins/core3d/items/custom-cylinder-wall-item.d.ts

@@ -0,0 +1,13 @@
+import { Mesh, Object3D } from 'three';
+import { WallItem } from './wall-objects';
+import { Metadata } from './metadata';
+import { Texture } from '../../../core/model/texture';
+export declare class CustomCylinderWallItem extends WallItem {
+    get customMesh(): Mesh;
+    get radius(): number;
+    get height(): number;
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture?: Texture);
+    resized(): void;
+    cloneItem(): CustomCylinderWallItem;
+    resize(radius?: number, height?: number): void;
+}

package/app/plugins/core3d/items/custom-floor-item.d.ts

@@ -0,0 +1,9 @@
+import { FloorItem } from './floor-item';
+import type { Metadata } from './metadata';
+/**
+ * Class explicitly used for configurable ione furniture
+ */
+export declare class CustomFloorItem extends FloorItem {
+    rawMetadata: Metadata;
+    constructor(rawMetadata: Metadata, object: any, handlers?: any);
+}

package/app/plugins/core3d/items/custom-objects.d.ts

@@ -0,0 +1,55 @@
+import { Euler, Mesh, Vector2, Vector3 } from 'three';
+import * as THREE from 'three';
+import { ChildParams } from '../../../core/interface/child-params.interface';
+export declare class CustomMesh extends Mesh {
+    private _boundingBox;
+    private _halfSize;
+    private _bBoxCorners;
+    private _bBoxCornersBasePosition;
+    connected: boolean;
+    connectedTo: string;
+    static create(original: Mesh): CustomMesh;
+    constructor(geometry: any, material: any, options?: any, original?: Mesh);
+    cloneVisible(): Mesh;
+    /**
+     * Clean clone without own properties
+     * @param recursive
+     */
+    clone(recursive?: boolean): this;
+    getYMin(): number;
+    getHalfSize(): Vector3;
+    getOverallPosition(newBasePosition: Vector3): Vector3;
+    getComposedPositions(newBasePosition: Vector3): Vector3[];
+    getComposedRotations(newBaseRotation?: Euler): Euler[];
+    localAnchor(newBasePosition?: Vector3): Vector3;
+    resetBoundingBox(): void;
+    getBBoxCorners(): Vector2[];
+    moveBBoxCorners(newPosition: Vector3): Vector2[];
+    rotateBBoxCorners(newRotation: Euler): Vector2[];
+    rescaled(): void;
+    dispose(): void;
+    private _getRootMeshPosition;
+    private _initializeDimensions;
+    private _boundingBoxToCorners;
+    private _getBoundingBox;
+    private _cleanupBoundingBox;
+    private _createBoundingBox;
+    private _findRoot;
+    getRoot(): any;
+}
+export declare class CustomObject3D extends THREE.Object3D {
+    connected: boolean;
+    connectedTo: string;
+    private _halfSize;
+    constructor(object3D: THREE.Object3D, childParams: ChildParams);
+    cloneVisible(): THREE.Object3D;
+    /**
+     * Clean clone without own properties
+     * @param recursive
+     */
+    clone(recursive?: boolean): this;
+    getYMin(): number;
+    getOverallPosition(newBasePosition?: THREE.Vector3): THREE.Vector3;
+    getComposedPositions(newBasePosition?: THREE.Vector3): THREE.Vector3[];
+    getComposedRotations(newBaseRotation?: THREE.Euler): THREE.Euler[];
+}

package/app/plugins/core3d/items/custom-shape-floor-item.d.ts

@@ -0,0 +1,9 @@
+import { Mesh, Object3D } from 'three';
+import { FloorItem } from './floor-item';
+import { Metadata } from './metadata';
+import { Texture } from '../../../core/model/texture';
+export declare class CustomShapeFloorItem extends FloorItem {
+    get customMesh(): Mesh;
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture?: Texture);
+    cloneItem(): CustomShapeFloorItem;
+}

package/app/plugins/core3d/items/custom-shape-wall-item.d.ts

@@ -0,0 +1,10 @@
+import { Mesh, Object3D } from 'three';
+import { WallItem } from './wall-objects';
+import { Metadata } from './metadata';
+import { Texture } from '../../../core/model/texture';
+export declare class CustomShapeWallItem extends WallItem {
+    get customMesh(): Mesh;
+    constructor(metadata: Metadata, object: Mesh | Object3D, texture?: Texture);
+    cloneItem(): CustomShapeWallItem;
+    resize(height: number, width: number, depth: number): void;
+}

package/app/plugins/core3d/items/custom-wall-floor-item.d.ts

@@ -0,0 +1,19 @@
+import { WallItem, HalfEdge } from './wall-objects';
+import { Metadata } from './metadata';
+/**
+ * Class explicitly used for configurable ione furniture
+ */
+export declare class CustomWallFloorItem extends WallItem {
+    rawMetadata: Metadata;
+    onWall: boolean;
+    private _originalRotation;
+    private _origin;
+    constructor(rawMetadata: Metadata, object: any, handlers?: any);
+    heightUpdated(amount: number): void;
+    getFloorY(): number;
+    removeFromWall(): void;
+    placeOnEdge(edge: HalfEdge): void;
+    protected recalcPivot(): void;
+    moveFromWallToFloor(): void;
+    moveFromFloorToWall(): void;
+}

package/app/plugins/core3d/items/custom-wall-item.d.ts

@@ -0,0 +1,9 @@
+import { WallItem } from './wall-objects';
+import { Metadata } from './metadata';
+/**
+ * Class explicitly used for configurable ione furniture
+ */
+export declare class CustomWallItem extends WallItem {
+    rawMetadata: Metadata;
+    constructor(rawMetadata: Metadata, object: any, handlers?: any);
+}

package/app/plugins/core3d/items/factory.d.ts

@@ -0,0 +1,24 @@
+import { ItemType } from './item-type';
+import { HdecoPlacement } from '@colijnit/configuratorapi/build/enum/hdeco-placement.enum';
+export declare function isFloorDecoration(type: ItemType): boolean;
+export declare function isWallDecoration(type: ItemType): boolean;
+export declare function isWallType(type: ItemType): boolean;
+export declare function isFloorType(type: ItemType): boolean;
+export declare function isWallFloorType(type: ItemType): boolean;
+export declare function isOnFloorType(type: ItemType): boolean;
+export declare function isCustomFloorGroupType(type: ItemType): boolean;
+export declare function isFloorGroupType(type: ItemType): boolean;
+export declare function isCustomShapeType(type: ItemType): boolean;
+export declare function isCustomShapeWallType(type: ItemType): boolean;
+export declare function isCustomCylinderType(type: ItemType): boolean;
+export declare function isCustomCylinderWallType(type: ItemType): boolean;
+export declare function isFurnitureType(type: ItemType): boolean;
+export declare function isInWallType(type: ItemType): boolean;
+export declare function isItemGroupType(type: ItemType): boolean;
+export declare function isWallItemGroupType(type: ItemType): boolean;
+export declare function itemTypeFromPlacement(placement: HdecoPlacement): ItemType;
+/** Factory class to create items. */
+export declare class Factory {
+    /** Gets the class for the specified item. */
+    static getClass(itemType: ItemType): any;
+}

package/app/plugins/core3d/items/floor-item.d.ts

@@ -0,0 +1,13 @@
+import { Mesh, Object3D } from 'three';
+import type { Metadata } from './metadata';
+import { Item } from './item';
+import { Texture } from '../../../core/model/texture';
+/**
+ * A Floor Item is an entity to be placed related to a floor.
+ */
+export declare class FloorItem extends Item {
+    protected updatePivotOnCreate: boolean;
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture?: Texture, handlers?: any);
+    getFloorY(): number;
+    protected recalcPivot(): void;
+}

package/app/plugins/core3d/items/floor-pin.d.ts

@@ -0,0 +1,11 @@
+import { FloorItem } from './floor-item';
+import { Pin } from './pin';
+import { HalfEdge } from './wall-objects';
+export declare class FloorPin extends FloorItem implements Pin {
+    constructor();
+    deactivate(): void;
+    activate(): void;
+    get isActive(): boolean;
+    getFloorY(): number;
+    placeOnEdge(edge: HalfEdge): void;
+}

package/app/plugins/core3d/items/floor-plane-item.d.ts

@@ -0,0 +1,30 @@
+import { BufferGeometry, Color, Material, Mesh, Object3D } from 'three';
+import { Metadata } from './metadata';
+import { Item } from './item';
+import { Texture } from '../../../core/model/texture';
+/**
+ * A Floor plane item is the actual plane used for floors
+ */
+export declare class FloorPlaneItem extends Item {
+    canMove: boolean;
+    fixed: boolean;
+    floorColor: Color;
+    floorTexture: Texture;
+    protected updatePivotOnCreate: boolean;
+    private _originalFloorMaterial;
+    private _originalGeometry;
+    private _originalUvs;
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture?: Texture, handlers?: any);
+    set floorMaterial(mat: Material);
+    getTexture(): Texture;
+    getColor(): Color;
+    canBeRemoved(): boolean;
+    removed(): void;
+    updateUvs(): void;
+    updateGeometry(geo: BufferGeometry): void;
+    resetUvs(): void;
+    resetGeometry(): void;
+    getMaterial(): Material | Material[];
+    private _getGeometry;
+    private _setGeometry;
+}

package/app/plugins/core3d/items/furniture.d.ts

@@ -0,0 +1,3 @@
+import { Item } from './item';
+import { ItemGroup } from './item-group';
+export declare type Furniture = Item | ItemGroup;

package/app/plugins/core3d/items/in-wall-floor-item.d.ts

@@ -0,0 +1,9 @@
+import { Mesh, Object3D } from 'three';
+import { Metadata } from './metadata';
+import { InWallItem } from './wall-objects';
+import { Texture } from '../../../core/model/texture';
+/** */
+export declare class InWallFloorItem extends InWallItem {
+    constructor(metadata: Metadata, object: Mesh | Object3D, texture?: Texture);
+    protected createClass(): InWallFloorItem;
+}

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

@@ -0,0 +1,51 @@
+import { Box3, Euler, Group, Mesh, Object3D, Vector2, Vector3 } from 'three';
+import { CustomMesh } from './custom-objects';
+import type { Metadata } from './metadata';
+import { Item } from './item';
+export declare class ItemGroup extends Group {
+    elevation: number;
+    elevationFixed: boolean;
+    elevationAdjustable: boolean;
+    canElevate: boolean;
+    allowRotate: boolean;
+    locked: boolean;
+    obstructFloorMoves: boolean;
+    wantsRotation: Euler;
+    metadata: Metadata;
+    boundaryBox: Box3;
+    private _items;
+    private _halfSize;
+    private _boundaryBoxCenter;
+    private _boundaryBoxColor;
+    private _emissiveColor;
+    private _selected;
+    private _hover;
+    private _highlighted;
+    get items(): Item[];
+    set items(value: Item[]);
+    get halfSize(): Vector3;
+    set halfSize(value: Vector3);
+    get boundaryBoxCenter(): Vector3;
+    get boundaryBoxColor(): string;
+    getHalfSize(): Vector3;
+    getHeight(): number;
+    getWidth(): number;
+    getDepth(): number;
+    constructor();
+    addItem(item: Item): void;
+    removeItem(item: Item): void;
+    setSelected(mesh?: Mesh, mousePosition?: Vector3): void;
+    setUnselected(): void;
+    mouseOver(mesh?: Mesh): void;
+    mouseOff(): void;
+    removed(): void;
+    canBeRemoved(): boolean;
+    cloneVisible(): Object3D;
+    createBoundaryBox(): void;
+    centerPivot(): void;
+    getVisibleMeshes(): Mesh[];
+    getVisibleMeshesParents(): CustomMesh[];
+    computeBBoxCorners(position?: Vector3, rotation?: Euler): Vector2[];
+    getFloorY(): number;
+    private updateHighlight;
+}

package/app/plugins/core3d/items/item-type.d.ts

@@ -0,0 +1,21 @@
+export declare enum ItemType {
+    Floor = 1,
+    Wall = 2,
+    InWall = 3,
+    InWallFloor = 7,
+    OnFloor = 8,
+    WallFloor = 9,
+    CustomFloorGroup = 10,
+    CustomShape = 11,
+    FloorGroup = 12,
+    ItemGroup = 13,
+    CustomCylinder = 14,
+    CustomCylinderWall = 15,
+    CustomShapeWall = 16,
+    CustomWall = 20,
+    CustomWallFloor = 21,
+    WallItemGroup = 22,
+    WallDecoration = 23,
+    WindowDecoration = 24,
+    FloorDecoration = 25
+}