@colijnit/homedecorator 255.1.1

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

@@ -0,0 +1,84 @@
+import { BaseItem } from './base-item';
+import { CustomMesh, CustomObject3D } from './custom-objects';
+import { Euler, Mesh, Object3D, Vector3 } from 'three';
+import type { Metadata } from './metadata';
+import { AdjustableElementInterface } from '../../../core/interface/adjustable-element.interface';
+import { Texture } from '../../../core/model/texture';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { ChildParams } from '../../../core/interface/child-params.interface';
+/**
+ * An Item is an abstract entity for all things placed in the scene,
+ * e.g. at walls or on the floor.
+ */
+export declare class Item extends BaseItem {
+    rawMetadata: Metadata;
+    set allwaysConfigureMode(value: boolean);
+    get allwaysConfigureMode(): boolean;
+    set configuring(value: boolean);
+    get configuring(): boolean;
+    get shouldMoveChild(): boolean;
+    obsolete: boolean;
+    childParams: ChildParams;
+    highLightDisabled: boolean;
+    wantsRotation: Euler;
+    configuringChangeHandler: Function;
+    mouseOverHandler: Function;
+    mouseOffHandler: Function;
+    selectedHandler: Function;
+    unselectedHandler: Function;
+    protected visibleClone: Object3D;
+    protected centerPivot: boolean;
+    protected ignoreInvisible: boolean;
+    protected updatePivotOnCreate: boolean;
+    private _elementConfiguration;
+    private _allwaysConfigureMode;
+    private _configuring;
+    private _selectedObject;
+    private _elementSelectedHandler;
+    private _elementUnselectedHandler;
+    private _childElementPositionChangedHandler;
+    private _dragConnectorHandler;
+    private _childElementPlaceHandler;
+    private _outlineService;
+    constructor(rawMetadata: Metadata, object: any, texture?: Texture, handlers?: any);
+    /**
+     * Clean clone without own properties
+     * @param recursive
+     */
+    clone(recursive?: boolean): this;
+    dispose(): void;
+    private _fakeHandler;
+    private _getIdentifierFromSelection;
+    connectorFromElement(selection: Selection): AdjustableElementInterface;
+    updateElementConnector(selection: Selection, connector: string, connectedNodeId: number): void;
+    clearChildren(): void;
+    addChild(child: Object3D | Mesh): void;
+    moveChildToPosition(pos: Vector3): void;
+    dragConnector(connector: CustomMesh | Mesh, pos: Vector3): void;
+    cloneVisible(): Object3D;
+    updatePivot(force?: boolean): void;
+    getVisibleMeshesParents(): (Item | CustomMesh)[];
+    getObjectsByUserDataProp(userDataObjectProp: string, prop: string, value: any): CustomObject3D[];
+    getOverallPosition(newBasePosition?: Vector3): Vector3;
+    getComposedPositions(newBasePosition?: Vector3): Vector3[];
+    getComposedRotations(newBaseRotation?: Euler): Euler[];
+    endDrag(): void;
+    initObject(itemType: any, id: string, identifier: string, modelUrl: any): void;
+    getHalfSize(): Vector3;
+    /** on is a bool */
+    protected updateHighlight(): void;
+    /** */
+    mouseOver(mesh: Mesh): void;
+    /** */
+    mouseOff(): void;
+    /** */
+    setSelected(mesh?: Mesh, mousePosition?: Vector3): void;
+    /** */
+    setUnselected(): void;
+    clicked(): void;
+    deselectObject(): void;
+    resize(height: number, width: number, depth: number): void;
+    resized(): void;
+    protected recalcPivot(): void;
+    resetBoundingboxes(): void;
+}

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

@@ -0,0 +1,74 @@
+import { Skin } from '../model/skin';
+import { Texture } from '../../../core/model/texture';
+import * as THREE from 'three';
+import { Euler, Vector3 } from 'three';
+import { DecoNode } from '@colijnit/configuratorapi/build/model/deco-node';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { AdjustableElementInterface } from '../../../core/interface/adjustable-element.interface';
+import { ExternalSettingsInterface } from '../../../core/interface/external-settings.interface';
+/** Meta data for items. */
+export interface Metadata {
+    itemName?: string;
+    itemDescription?: string;
+    itemType?: number;
+    /**
+     * InstanceId
+     */
+    itemId?: string;
+    originalItemId?: string;
+    /**
+     * Sku
+     */
+    itemIdentifier?: string;
+    goodId?: string;
+    goodType?: string;
+    isCustom?: boolean;
+    locked?: boolean;
+    configurable?: boolean;
+    ione?: boolean;
+    position?: Vector3;
+    rotation?: number | Euler;
+    scale?: Vector3;
+    centerPivot?: boolean;
+    ignoreInvisible?: boolean;
+    updatePivotOnCreate?: boolean;
+    elementConfiguration?: AdjustableElementInterface[];
+    obsolete?: boolean;
+    externalSettings?: ExternalSettingsInterface;
+    thirdPartyModel?: boolean;
+    usePivot?: boolean;
+    decos?: DecoNode[];
+    selections?: Selection[];
+    canElevate?: boolean;
+    onWall?: boolean;
+    modelUrl?: string;
+    scalable?: boolean;
+    scalePercentage?: number;
+    resizable?: boolean;
+    elevation?: number;
+    elevationFixed?: boolean;
+    elevationAdjustable?: boolean;
+    schema?: string;
+    assetPath?: string;
+    texture?: Texture;
+    skin?: Skin;
+    frameColor?: number;
+    doorColor?: number;
+    windowColor?: THREE.Color;
+    doorpost?: boolean;
+    isGlass?: boolean;
+    itemGroup?: any;
+    canRotateX?: boolean;
+    canRotateY?: boolean;
+    canRotateZ?: boolean;
+    default180?: boolean;
+    objectUUID?: string;
+    conversionGTMSend?: boolean;
+    conversionSubmittedPrice?: string;
+    opening?: {
+        show: boolean;
+        double: boolean;
+        invertDirection: boolean;
+        invertSide: boolean;
+    };
+}

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

@@ -0,0 +1,8 @@
+import { Mesh, Object3D } from 'three';
+import { Metadata } from './metadata';
+import { FloorItem } from './floor-item';
+import { Texture } from '../../../core/model/texture';
+/** */
+export declare abstract class OnFloorItem extends FloorItem {
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture: Texture);
+}

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

@@ -0,0 +1,5 @@
+export interface Pin {
+    activate(): void;
+    deactivate(): void;
+    readonly isActive: boolean;
+}

package/app/plugins/core3d/items/three-mesh.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+/**
+ * Extended class to be able to clone meshes with userData that can contain objects with circular dependencies
+ * userData property is emptied and thus not being cloned
+ */
+export declare class ThreeMesh extends THREE.Mesh {
+    clone(recursive?: boolean): this;
+}

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

@@ -0,0 +1,8 @@
+import { Mesh, Object3D } from 'three';
+import { Metadata } from './metadata';
+import { WallItem } from './wall-objects';
+import { Texture } from '../../../core/model/texture';
+/** */
+export declare abstract class WallFloorItem extends WallItem {
+    constructor(metadata: Metadata, object: Mesh | Object3D, texture: Texture);
+}

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

@@ -0,0 +1,512 @@
+import { BoxGeometry, Euler, Intersection, Matrix4, Mesh, Object3D, Quaternion, Vector2, Vector3 } from 'three';
+import * as THREE from 'three';
+import { Texture } from '../../../core/model/texture';
+import { Item } from './item';
+import { ThreeMesh } from './three-mesh';
+import { Metadata } from './metadata';
+import { CollisionInfo } from '../model/collision-info';
+import { ItemGroup } from './item-group';
+import { FloorPlaneItem } from './floor-plane-item';
+/**
+ * A Wall is the basic element to create Rooms.
+ *
+ * Walls consists of two half edges.
+ */
+export declare class Wall {
+    private start;
+    private end;
+    /** The unique id of each wall. */
+    private id;
+    /** Front is the plane from start to end. */
+    frontEdge: HalfEdge;
+    /** Back is the plane from end to start. */
+    backEdge: HalfEdge;
+    /** */
+    orphan: boolean;
+    /** Items attached to this wall */
+    items: Item[];
+    itemsChanged: boolean;
+    /** */
+    onItems: Item[];
+    /** The front-side texture. */
+    frontTexture: Texture;
+    /** The back-side texture. */
+    backTexture: Texture;
+    /** The front-side color. */
+    frontColor: number;
+    /** The back-side color. */
+    backColor: number;
+    thickness: any;
+    set height(value: number);
+    get height(): number;
+    amountWallMoved: Vector2;
+    private _height;
+    /**
+     * Constructs a new wall.
+     * @param start Start corner.
+     * @param end End corner.
+     */
+    constructor(start: Corner, end: Corner);
+    private getUuid;
+    showHideWall(show: boolean): void;
+    resetFrontBack(): void;
+    private move;
+    private relativeMove;
+    fireRedraw(): void;
+    getStart(): Corner;
+    getEnd(): Corner;
+    getStartX(): number;
+    getEndX(): number;
+    getStartY(): number;
+    getEndY(): number;
+    remove(): void;
+    setStart(corner: Corner): void;
+    setEnd(corner: Corner): void;
+    distanceFrom(x: number, y: number): number;
+    closestPointTo(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+    isToOrFrom(x: number, y: number): boolean;
+    /** Return the corner opposite of the one provided.
+     * @param corner The given corner.
+     * @returns The opposite corner.
+     */
+    private _oppositeCorner;
+    get length(): number;
+    get edgesLengths(): number[];
+    updateInWallItems(): void;
+    updateWallItems(): void;
+    getItems(): Item[];
+    getWallItems(): WallItem[];
+    get side(): 0 | 1 | 2;
+    addItem(item: Item): void;
+    removeItem(item: Item): void;
+    addOnItem(item: Item): void;
+    removeOnItem(item: Item): void;
+}
+/**
+ * Corners are used to define Walls.
+ */
+export declare class Corner {
+    x: number;
+    y: number;
+    id?: string;
+    /** Array of start walls. */
+    wallStarts: Wall[];
+    /** Array of end walls. */
+    wallEnds: Wall[];
+    /** Constructs a corner.
+     * @param x X coordinate.
+     * @param y Y coordinate.
+     * @param id An optional unique id. If not set, created internally.
+     */
+    constructor(x: number, y: number, id?: string);
+    absorbWallsFrom(corner: Corner): void;
+    /**
+     * @returns
+     * @deprecated
+     */
+    getX(): number;
+    /**
+     * @returns
+     * @deprecated
+     */
+    getY(): number;
+    /** Moves corner relatively to new position.
+     * @param dx The delta x.
+     * @param dy The delta y.
+     */
+    relativeMove(dx: number, dy: number): void;
+    /** Removes all walls. */
+    removeAll(): void;
+    /** Moves corner to new position.
+     * @param newX The new x position.
+     * @param newY The new y position.
+     */
+    move(newX: number, newY: number): void;
+    /** Gets the adjacent corners.
+     * @returns Array of corners.
+     */
+    adjacentCorners(): Corner[];
+    /** Checks if a wall is connected.
+     * @param wall A wall.
+     * @returns True in case of connection.
+     */
+    isWallConnected(wall: Wall): boolean;
+    /**
+     *
+     */
+    distanceFrom(x: number, y: number): number;
+    /** Gets the distance from a wall.
+     * @param wall A wall.
+     * @returns The distance.
+     */
+    distanceFromWall(wall: Wall): number;
+    /** Gets the distance from a corner.
+     * @param corner A corner.
+     * @returns The distance.
+     */
+    distanceFromCorner(corner: Corner): number;
+    /** Detaches a wall.
+     * @param wall A wall.
+     */
+    detachWall(wall: Wall): void;
+    /** Attaches a start wall.
+     * @param wall A wall.
+     */
+    attachStart(wall: Wall): void;
+    /** Attaches an end wall.
+     * @param wall A wall.
+     */
+    attachEnd(wall: Wall): void;
+    /** Get wall to corner.
+     * @param corner A corner.
+     * @return The associated wall or null.
+     */
+    wallTo(corner: Corner): Wall;
+    /** Get wall from corner.
+     * @param corner A corner.
+     * @return The associated wall or null.
+     */
+    wallFrom(corner: Corner): Wall;
+    /** Get wall to or from corner.
+     * @param corner A corner.
+     * @return The associated wall or null.
+     */
+    wallToOrFrom(corner: Corner): Wall;
+    get startWalls(): Wall[];
+    get endWalls(): Wall[];
+    /** Ensure we do not have duplicate walls (i.e. same start and end points) */
+    removeDuplicateWalls(): void;
+}
+/**
+ * Half Edges are created by Room.
+ *
+ * Once rooms have been identified, Half Edges are created for each interior wall.
+ *
+ * A wall can have two half edges if it is visible from both sides.
+ */
+export declare class HalfEdge {
+    private room;
+    wall: Wall;
+    front: boolean;
+    /** The successor edge in CCW ??? direction. */
+    next: HalfEdge;
+    /** The predecessor edge in CCW ??? direction. */
+    prev: HalfEdge;
+    /** */
+    offset: number;
+    /** When height of walls are modified, plane should be recreated */
+    set height(value: number);
+    get height(): number;
+    /** used for intersection testing... not convinced this belongs here */
+    plane: ThreeMesh;
+    /** transform from world coords to wall planes (z=0) */
+    interiorTransform: Matrix4;
+    /** transform from world coords to wall planes (z=0) */
+    invInteriorTransform: Matrix4;
+    /** transform from world coords to wall planes (z=0) */
+    private exteriorTransform;
+    /** transform from world coords to wall planes (z=0) */
+    private invExteriorTransform;
+    private _height;
+    /** */
+    edges: Edge[];
+    /**
+     * Constructs a half edge.
+     * @param room The associated room.
+     * @param wall The corresponding wall.
+     * @param front True if front side.
+     */
+    constructor(room: Room, wall: Wall, front: boolean);
+    showHideEdge(show: boolean): void;
+    updateVisibility(cameraPosition: Vector3): boolean;
+    updateVisiblity(visibility: boolean): void;
+    redraw(): Promise<void>;
+    /**
+     *
+     */
+    getTexture(): Texture;
+    getColor(): number;
+    /**
+     *
+     */
+    setTexture(texture: Texture): Promise<void>;
+    setColor(value: number): void;
+    /**
+     * this feels hacky, but need wall items
+     */
+    generatePlane(): void;
+    disposePlane(): void;
+    interiorDistance(): number;
+    private computeTransforms;
+    /** Gets the distance from specified point.
+     * @param x X coordinate of the point.
+     * @param y Y coordinate of the point.
+     * @returns The distance.
+     */
+    distanceTo(x: number, y: number): number;
+    getStart(): Corner;
+    getEnd(): Corner;
+    private getOppositeEdge;
+    interiorEnd(): Vector2;
+    interiorStart(): Vector2;
+    interiorCenter(): Vector2;
+    exteriorEnd(): Vector2;
+    exteriorStart(): Vector2;
+    /** Get the corners of the half edge.
+     * @returns An array of x,y pairs.
+     */
+    corners(): {
+        x: number;
+        y: number;
+    }[];
+    /**
+     * Gets CCW angle from v1 to v2
+     */
+    private halfAngleVector;
+    get invExteriorQuaternion(): Quaternion;
+}
+export declare class Edge {
+    private _halfEdge;
+    private _fillerColor;
+    private readonly _wall;
+    private readonly _front;
+    private _fillerMaterial;
+    private _wallMaterial;
+    private _planes;
+    private _last;
+    visible: any;
+    constructor(_halfEdge: HalfEdge);
+    showHideEdge(show: boolean): void;
+    private _planeList;
+    getPlanes(): Mesh[];
+    getTopSideFillers(): Mesh[];
+    init(): Promise<void>;
+    redraw(): Promise<void>;
+    updateVisibility(cameraPosition: Vector3): boolean;
+    updateObjectVisibility(): void;
+    setAllPlanesVisible(): void;
+    private _addMaterialMap;
+    private _isValid;
+    private _updateFillerMaterial;
+    private _updateWallMaterial;
+    private _equalLastVec2;
+    private _copyLast;
+    private _transformParam;
+    private _invTransformParam;
+    private _updateMainPlane;
+    private _updateBottomPlane;
+    private _updateTopPlane;
+    private _updateSidePlanes;
+    updatePlanes(): Promise<void>;
+    private _updateUvs;
+    private _createGeometry;
+    private _buildSideFiller;
+    private _buildFiller;
+    private _toVec2;
+    private _toVec3;
+}
+export declare class Room {
+    corners: Corner[];
+    interiorCorners: Corner[];
+    private edgePointer;
+    edgeHeights: any[];
+    floorPlane: FloorPlaneItem;
+    floorTexture: Texture;
+    floorColor: number;
+    ceilingPlane: Mesh;
+    constructor(corners: Corner[], defaultTexture?: Texture);
+    dispose(): void;
+    getInteriorCorners(): Vector2[];
+    getUuid(): string;
+    getTexture(): Texture;
+    getColor(): number;
+    useTexture(): void;
+    /**
+     * textureStretch always true, just an argument for consistency with walls
+     */
+    updateWallHeights(): void;
+    private setDefaultFloorTexture;
+    private _updateInteriorCorners;
+    private _setEdgePointer;
+    get area(): number;
+    get center(): {
+        x: number;
+        y: number;
+    };
+    private _polygonFromCorners;
+}
+/**
+ * A Wall Item is an entity to be placed related to a wall.
+ */
+export declare abstract class WallItem extends Item {
+    /** The currently applied wall */
+    currentWall: Wall;
+    /** The currently applied wall edge. */
+    currentWallEdge: HalfEdge;
+    /** Used for finding rotations */
+    private _refVec;
+    private _positionYTolerance;
+    /** */
+    private _wallOffsetScalar;
+    /** */
+    private _sizeX;
+    /** */
+    private _sizeY;
+    private _flipped;
+    protected texture: Texture;
+    /** */
+    protected addToWall: boolean;
+    /** */
+    protected boundToFloor: boolean;
+    /** */
+    protected frontVisible: boolean;
+    protected backVisible: boolean;
+    private _hasFrontEdge;
+    private _hasBackEdge;
+    private _onFrontSide;
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture?: Texture, handlers?: any);
+    /** */
+    removed(): void;
+    removeFromWall(): void;
+    /**
+     * Only hides item when entire wall is hidden
+     * This prevents items being set hidden for inner walls
+     * */
+    updateEdgeVisibility(edge: Edge): void;
+    /** */
+    updateSize(): void;
+    /** */
+    resized(): void;
+    /** */
+    placeOnEdge(edge: HalfEdge): void;
+    reposition(): void;
+    getFloorY(): number;
+    isValidPosition(position: THREE.Vector3, rotation?: THREE.Euler, options?: any): CollisionInfo;
+    /** */
+    moveToPosition(vec3: THREE.Vector3, intersection?: THREE.Intersection): void;
+    /** */
+    moveTo2dPosition(x: number, y: number, edge: HalfEdge): void;
+    /** */
+    getWallOffset(): number;
+    getStartX(): number;
+    getStartY(): number;
+    getEndX(): number;
+    getEndY(): number;
+    /**
+     @returns x axis size of item's bounding box
+     */
+    getSizeX(): number;
+    /**
+     @returns y axis size of item's bounding box
+     */
+    getSizeY(): number;
+    heightUpdated(amount?: number): void;
+    updateGeometry(width: number, height: number): void;
+    setTexture(texture: Texture): Promise<void>;
+    onWallMoved(wall: Wall): void;
+    updateMaterialVisibility(side?: number): void;
+    createTextureMaterial(options?: any): Promise<THREE.MeshPhongMaterial>;
+    getTexture(): Texture;
+    protected createMaterial(side?: number, isSame?: boolean): Promise<void>;
+    protected setYPositionBasedOnElevation(): void;
+    protected addMaterialMap(material: THREE.MeshPhongMaterial, texture: Texture, flip: boolean): Promise<void>;
+    protected getMaterialMapDimensions(): THREE.Vector2;
+    protected getMaterials(textureMaterialFront: THREE.Material, textureMaterialBack: THREE.Material): THREE.Material[];
+    protected getItemThickness(): number;
+    /** */
+    protected redrawWall(): void;
+    /** */
+    private _changeWallEdge;
+    private _boundToFloorY;
+    /** takes the move vec3, and makes sure object stays bounded on plane */
+    private _boundMove;
+    private _isWallSame;
+    private _getMaxY;
+    private _getMinT;
+    private _moveToYPosition;
+}
+export declare class InWallItem extends WallItem {
+    private readonly _frameWidth;
+    private readonly _frameDepth;
+    private readonly _defaultFrameColor;
+    private readonly _defaultDoorColor;
+    opening: {
+        show: boolean;
+        double: boolean;
+        invertDirection: boolean;
+        invertSide: boolean;
+    };
+    frameColor: number;
+    doorColor: number;
+    windowColor: THREE.Color;
+    isGlass: boolean;
+    protected topFrame: THREE.Mesh;
+    protected leftFrame: THREE.Mesh;
+    protected rightFrame: THREE.Mesh;
+    protected bottomFrame: THREE.Mesh;
+    protected customMesh: THREE.Mesh;
+    protected frameMaterial: THREE.MeshPhongMaterial;
+    protected doorMaterialFront: THREE.MeshPhongMaterial;
+    protected windowMaterial: THREE.MeshPhongMaterial;
+    private _isWindow;
+    private _doorpost;
+    get doorpost(): boolean;
+    constructor(metadata: Metadata, object: Object3D | Mesh, texture?: Texture);
+    dispose(): void;
+    placeOnEdge(edge: HalfEdge): void;
+    /** */
+    getWallOffset(): number;
+    distanceFrom2d(x: number, y: number): number;
+    onWallUpdated(wall: Wall): void;
+    updateFrameColor(color: number): void;
+    updateDoorColor(color: number): void;
+    updateGlassMaterial(): void;
+    updateGeometry(width: number, height: number): void;
+    adjustWallBox(geometry: BoxGeometry): void;
+    getVisibleMeshes(): THREE.Mesh[];
+    createTextureMaterial(options?: any): Promise<THREE.MeshPhongMaterial>;
+    createCustomMesh(width: number, height: number): void;
+    cloneItem(): InWallItem;
+    protected createMaterial(side?: 2, isSame?: boolean): Promise<void>;
+    protected createClass(): InWallItem;
+    protected cloneProperties(clone: InWallItem): void;
+    protected getMaterials(textureMaterialFront: THREE.Material, textureMaterialBack: THREE.Material): THREE.Material[];
+    protected getMaterialMapDimensions(): THREE.Vector2;
+    protected initiateItemObject(data: any): void;
+    private _setDefault;
+    private _createMaterials;
+    private _getHeightFrame;
+    private _createFrameSide;
+    private _getAdditionalTexture;
+    private _glassMaterialCheck;
+}
+export declare class WallItemGroup extends ItemGroup {
+    currentWallEdge: HalfEdge;
+    currentWall: Wall;
+    elevationAdjustable: boolean;
+    private _positionYTolerance;
+    private _originalRotation;
+    private _onFrontSide;
+    private _wallOffsetScalar;
+    private _sizeX;
+    private _sizeY;
+    private _refVec;
+    constructor();
+    protected redrawWall(): void;
+    isValidPosition(position: Vector3, rotation?: Euler, options?: any): CollisionInfo;
+    moveToPosition(vec3: Vector3, intersection?: Intersection): void;
+    createBoundaryBox(): void;
+    centerPivot(): void;
+    updateSize(): void;
+    onWallMoved(wall: Wall): void;
+    placeOnEdge(edge: HalfEdge): void;
+    handleGroupCreation(): void;
+    private _changeWallEdge;
+    updateEdgeVisibility(edge: Edge): void;
+    private _boundMove;
+    private _getMaxY;
+    private _getMinY;
+}