@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/service/item-group.service.js

@@ -0,0 +1,117 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { WallItem, WallItemGroup } from '../items/wall-objects';
+import { ItemGroup } from '../items/item-group';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { CustomWallFloorItem } from '../items/custom-wall-floor-item';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/service/message-bus.service";
+import * as i2 from "./item.service";
+export class ItemGroupService {
+    constructor(_messageBusService, _itemService) {
+        this._messageBusService = _messageBusService;
+        this._itemService = _itemService;
+        this.objectAdded = new Subject();
+        this.grouped = new Subject();
+        this.ungrouped = new Subject();
+        this._objectsToGroup = [];
+        this._subs = [];
+        this._subs.push(this._messageBusService.subscribe(MessageType.GroupObjects, () => this._groupObjects()), this._messageBusService.subscribe(MessageType.UngroupObjects, () => this._unGroupObjects()), this._messageBusService.subscribe(MessageType.CancelGroupObject, () => this._cancelGroupObjects()));
+    }
+    set selectedGroup(value) {
+        this._selectedGroup = value;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    removeGroup(group) {
+        group.items.forEach((i) => {
+            this._itemService.removeItem(i);
+        });
+        this._itemService.removeItem(group);
+    }
+    addIfNotExist(object) {
+        const index = this._objectsToGroup.indexOf(object, 0);
+        const isObjectAlreadySelected = index > -1;
+        if (!isObjectAlreadySelected) {
+            this._objectsToGroup.push(object);
+            this.objectAdded.next(object);
+        }
+        this._showMenu();
+    }
+    addOrRemoveIfExist(object) {
+        const index = this._objectsToGroup.indexOf(object, 0);
+        const isObjectAlreadySelected = index > -1;
+        if (isObjectAlreadySelected) {
+            this._objectsToGroup.splice(index, 1);
+            const objectToSelect = this._objectsToGroup[this._objectsToGroup.length - 1];
+            if (objectToSelect) {
+                this.objectAdded.next(objectToSelect);
+            }
+        }
+        else {
+            this._objectsToGroup.push(object);
+            this.objectAdded.next(object);
+        }
+        this._showMenu();
+    }
+    resetObjectsToGroup() {
+        this._objectsToGroup = [];
+    }
+    reattachToItemGroup(item, itemGroup, originalPosition) {
+        item.position.copy(originalPosition);
+        this._itemService.removeItem(item, true);
+        itemGroup.addItem(item);
+        itemGroup.createBoundaryBox();
+    }
+    _groupObjects() {
+        const itemGroup = this._shouldBeWallItemGroup() ? new WallItemGroup() : new ItemGroup();
+        this._objectsToGroup.forEach(o => {
+            itemGroup.addItem(o);
+            this._itemService.removeItem(o, true);
+        });
+        itemGroup.createBoundaryBox();
+        itemGroup.centerPivot();
+        if (itemGroup instanceof WallItemGroup) {
+            itemGroup.handleGroupCreation();
+        }
+        this._itemService.addItem(itemGroup);
+        this.resetObjectsToGroup();
+        this._selectedGroup = itemGroup;
+        this.grouped.next(itemGroup);
+    }
+    _unGroupObjects() {
+        const groupRotation = this._selectedGroup.rotation.clone();
+        this._selectedGroup.items.forEach(o => {
+            const objectRotation = o.rotation.clone();
+            o.applyMatrix4(this._selectedGroup.matrixWorld);
+            o.rotation.set(groupRotation.x + objectRotation.x, groupRotation.y + objectRotation.y, groupRotation.z + objectRotation.z);
+            this._selectedGroup.removeItem(o);
+            this._itemService.addItem(o);
+            o.mouseOff();
+        });
+        this._itemService.removeItem(this._selectedGroup);
+        this.resetObjectsToGroup();
+        this.ungrouped.next();
+    }
+    _showMenu() {
+        const showGroupMenu = this._objectsToGroup.length > 1;
+        this._messageBusService.emit(MessageType.GroupModeChanged, { showGroupMenu: showGroupMenu });
+    }
+    _shouldBeWallItemGroup() {
+        return (this._objectsToGroup[0] instanceof WallItem && !(this._objectsToGroup[0] instanceof CustomWallFloorItem)) ||
+            this._objectsToGroup[0] instanceof CustomWallFloorItem && this._objectsToGroup[0].onWall;
+    }
+    _cancelGroupObjects() {
+        this._objectsToGroup = [];
+    }
+}
+ItemGroupService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemGroupService, deps: [{ token: i1.MessageBusService }, { token: i2.ItemService }], target: i0.ɵɵFactoryTarget.Injectable });
+ItemGroupService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemGroupService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemGroupService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBusService }, { type: i2.ItemService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item-group.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/item-group.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {Subject, Subscription} from 'rxjs';\r\nimport {Vector3} from 'three';\r\nimport {WallItem, WallItemGroup} from '../items/wall-objects';\r\nimport {Item} from '../items/item';\r\nimport {ItemGroup} from '../items/item-group';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {ItemService} from './item.service';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {CustomWallFloorItem} from '../items/custom-wall-floor-item';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ItemGroupService implements OnDestroy {\r\n  public objectAdded: Subject<Item | ItemGroup> = new Subject();\r\n  public grouped: Subject<ItemGroup> = new Subject();\r\n  public ungrouped: Subject<void> = new Subject();\r\n\r\n  private _objectsToGroup: Item[] = [];\r\n  private _selectedGroup: ItemGroup;\r\n  private _subs: Subscription[] = [];\r\n\r\n  public set selectedGroup(value: ItemGroup) {\r\n    this._selectedGroup = value;\r\n  }\r\n\r\n  constructor(\r\n    private _messageBusService: MessageBusService,\r\n    private _itemService: ItemService) {\r\n    this._subs.push(\r\n      this._messageBusService.subscribe(MessageType.GroupObjects, () => this._groupObjects()),\r\n      this._messageBusService.subscribe(MessageType.UngroupObjects, () => this._unGroupObjects()),\r\n      this._messageBusService.subscribe(MessageType.CancelGroupObject, () => this._cancelGroupObjects()),\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public removeGroup(group: ItemGroup): void {\r\n    group.items.forEach((i: Item) => {\r\n      this._itemService.removeItem(i);\r\n    });\r\n    this._itemService.removeItem(group);\r\n  }\r\n\r\n  public addIfNotExist(object: Item): void {\r\n    const index = this._objectsToGroup.indexOf(object, 0);\r\n    const isObjectAlreadySelected = index > -1;\r\n    if (!isObjectAlreadySelected) {\r\n      this._objectsToGroup.push(object);\r\n      this.objectAdded.next(object);\r\n    }\r\n    this._showMenu();\r\n  }\r\n\r\n  public addOrRemoveIfExist(object: Item): void {\r\n    const index = this._objectsToGroup.indexOf(object, 0);\r\n    const isObjectAlreadySelected = index > -1;\r\n    if (isObjectAlreadySelected) {\r\n      this._objectsToGroup.splice(index, 1);\r\n      const objectToSelect = this._objectsToGroup[this._objectsToGroup.length - 1];\r\n      if (objectToSelect) {\r\n        this.objectAdded.next(objectToSelect);\r\n      }\r\n    } else {\r\n      this._objectsToGroup.push(object);\r\n      this.objectAdded.next(object);\r\n    }\r\n    this._showMenu();\r\n  }\r\n\r\n  public resetObjectsToGroup(): void {\r\n    this._objectsToGroup = [];\r\n  }\r\n\r\n  public reattachToItemGroup(item: Item, itemGroup: ItemGroup, originalPosition: Vector3) {\r\n    item.position.copy(originalPosition);\r\n    this._itemService.removeItem(item, true);\r\n    itemGroup.addItem(item);\r\n    itemGroup.createBoundaryBox();\r\n  }\r\n\r\n  private _groupObjects(): void {\r\n    const itemGroup = this._shouldBeWallItemGroup() ? new WallItemGroup() : new ItemGroup();\r\n    this._objectsToGroup.forEach(o => {\r\n      itemGroup.addItem(o);\r\n      this._itemService.removeItem(o, true);\r\n    });\r\n    itemGroup.createBoundaryBox();\r\n    itemGroup.centerPivot();\r\n    if (itemGroup instanceof WallItemGroup) {\r\n      itemGroup.handleGroupCreation();\r\n    }\r\n    this._itemService.addItem(itemGroup);\r\n    this.resetObjectsToGroup();\r\n    this._selectedGroup = itemGroup;\r\n    this.grouped.next(itemGroup);\r\n  }\r\n\r\n  private _unGroupObjects(): void {\r\n    const groupRotation = this._selectedGroup.rotation.clone();\r\n    this._selectedGroup.items.forEach(o => {\r\n      const objectRotation = o.rotation.clone();\r\n      o.applyMatrix4(this._selectedGroup.matrixWorld);\r\n      o.rotation.set(groupRotation.x + objectRotation.x, groupRotation.y + objectRotation.y, groupRotation.z + objectRotation.z);\r\n      this._selectedGroup.removeItem(o);\r\n      this._itemService.addItem(o);\r\n      o.mouseOff();\r\n    });\r\n    this._itemService.removeItem(this._selectedGroup);\r\n    this.resetObjectsToGroup();\r\n    this.ungrouped.next();\r\n  }\r\n\r\n  private _showMenu(): void {\r\n    const showGroupMenu = this._objectsToGroup.length > 1;\r\n    this._messageBusService.emit(MessageType.GroupModeChanged, {showGroupMenu: showGroupMenu});\r\n  }\r\n\r\n  private _shouldBeWallItemGroup(): boolean {\r\n    return (this._objectsToGroup[0] instanceof WallItem && !(this._objectsToGroup[0] instanceof CustomWallFloorItem)) ||\r\n      this._objectsToGroup[0] instanceof CustomWallFloorItem && (this._objectsToGroup[0] as CustomWallFloorItem).onWall;\r\n  }\r\n\r\n  private _cancelGroupObjects(): void {\r\n    this._objectsToGroup = [];\r\n  }\r\n}\r\n"]}

package/esm2015/app/plugins/core3d/service/item.service.js

@@ -0,0 +1,205 @@
+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 { Injectable } from '@angular/core';
+import * as THREE from 'three';
+import { Euler, Mesh } from 'three';
+import { Subject } from 'rxjs';
+import { Factory, isFloorType, isFurnitureType, isWallType } from '../items/factory';
+import { Item } from '../items/item';
+import { Utils } from '../core/utils';
+import { MessageType } from '../../../core/enum/message-type.enum';
+import { ItemType } from '../items/item-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./scene.service";
+import * as i2 from "../../../core/service/message-bus.service";
+export class ItemService {
+    constructor(_sceneService, _messageService) {
+        this._sceneService = _sceneService;
+        this._messageService = _messageService;
+        this.items = [];
+        this.copyItem = new Subject();
+        this.deleteItem = new Subject();
+        this.removeAllItems = new Subject();
+        window.onbeforeunload = () => this.ngOnDestroy();
+    }
+    ngOnDestroy() {
+        this.removeAll();
+    }
+    // todo: fix the any
+    addItem(obj, addToScene = true) {
+        this.items.push(obj);
+        if (addToScene) {
+            this._sceneService.addObject(obj);
+        }
+    }
+    // todo: fix the any
+    removeItem(obj, addedToGroup = false, emitMessage = true) {
+        if (typeof obj === 'string') {
+            obj = this._sceneService.scene.getObjectByName(obj);
+        }
+        if (obj) {
+            Utils.removeValue(this.items, obj);
+            this._sceneService.removeObject(obj, true, !addedToGroup);
+            if (emitMessage) {
+                this._messageService.emit(MessageType.ItemRemoved, { item: obj, addedToGroup: addedToGroup });
+            }
+        }
+    }
+    getObjectPlanes() {
+        return this.items.reduce((meshes, item) => meshes.concat(item.getVisibleMeshes ? item.getVisibleMeshes() : []), []);
+    }
+    getWallItems() {
+        const items = this.items.filter((item) => item instanceof Item);
+        return items.filter((item) => {
+            const itemType = item.metadata && item.metadata.itemType;
+            return isWallType(itemType);
+        });
+    }
+    getFurniture() {
+        const furniture = this.items
+            .filter(item => !item.metadata || isFurnitureType(item.metadata.itemType))
+            .map(item => item);
+        return furniture;
+    }
+    getNonFurniture() {
+        return this.items.filter(item => item.metadata && !isFurnitureType(item.metadata.itemType));
+    }
+    getConfigurables() {
+        return this.items.filter(i => i.configurable);
+    }
+    getIOneFurniture() {
+        return this.items.filter(i => i.metadata && i.metadata.ione);
+    }
+    getCameraItem() {
+        return this.items.filter((mesh) => mesh.name === 'Camera')[0]; // TODO: identify camera by other means?
+    }
+    getWalkthroughCamera() {
+        return this.items.filter((item) => item.name === 'Walkthrough Camera')[0];
+    }
+    removeFloorItems() {
+        this.items.reduce((keep, item) => {
+            if (isFurnitureType(item.userData.itemType) && !Utils.isCamera(item)) {
+                this.removeItem(item);
+                return keep;
+            }
+            else {
+                return keep.concat(item);
+            }
+        }, []);
+    }
+    removeAll() {
+        const allItems = this.items.slice();
+        allItems.forEach(i => {
+            this.removeItem(i);
+        });
+        this.removeAllItems.next();
+    }
+    addJsonItem(modelData, point) {
+        const metadata = {
+            itemName: modelData.name,
+            itemDescription: modelData.description,
+            resizable: modelData.resizable,
+            modelUrl: modelData.url,
+            itemType: modelData.type,
+            opening: modelData.opening,
+            isCustom: modelData.isCustom,
+            position: point.clone(),
+            rotation: modelData.rotation ? modelData.rotation : new Euler(0, 0, 0),
+            scale: modelData.scale,
+            texture: modelData.texture,
+            doorColor: modelData.doorColor,
+            frameColor: modelData.frameColor,
+            windowColor: modelData.windowColor,
+            doorpost: modelData.doorpost,
+            locked: modelData.locked,
+            canElevate: modelData.canElevate,
+            elevation: modelData.elevation,
+            elevationFixed: modelData.elevationFixed,
+            elevationAdjustable: modelData.elevationAdjustable,
+            scalable: modelData.scalable,
+            scalePercentage: modelData.scalePercentage,
+            usePivot: (modelData.type === ItemType.InWall && modelData.isCustom) ? false : true,
+            centerPivot: isFloorType(modelData.type),
+            onWall: modelData.onWall,
+            isGlass: modelData.isGlass
+        };
+        const itemConstructor = Factory.getClass(modelData.type);
+        const oldObject = modelData.object.constructor.name === 'Object' && modelData.object.hasOwnProperty('geometry');
+        const object = oldObject ? new Mesh(modelData.object.geometry, modelData.object.materials) : modelData.object;
+        const item = new itemConstructor(metadata, object, modelData.texture);
+        item.additionalTexture = modelData.additionalTexture;
+        item.fixed = modelData.fixed || false;
+        if (metadata.opening) {
+            item.opening = Object.assign({}, metadata.opening);
+        }
+        item.userData.itemType = metadata.itemType;
+        this.addItem(item);
+        return item;
+    }
+    addFloorGroupItem(modelData, point) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadata = {
+                itemName: modelData.name,
+                itemDescription: modelData.description,
+                resizable: modelData.resizable,
+                modelUrl: modelData.url,
+                itemType: modelData.type,
+                opening: modelData.opening,
+                isCustom: modelData.isCustom,
+                texture: modelData.texture,
+                position: point.clone(),
+                rotation: modelData.rotation ? modelData.rotation : new Euler(0, 0, 0),
+                scale: modelData.scale,
+                doorColor: modelData.doorColor,
+                frameColor: modelData.frameColor,
+                windowColor: modelData.windowColor,
+                locked: modelData.locked,
+                canElevate: modelData.canElevate,
+                elevation: modelData.elevation,
+                elevationFixed: modelData.elevationFixed,
+                elevationAdjustable: modelData.elevationAdjustable,
+                scalable: modelData.scalable,
+                centerPivot: true,
+                onWall: modelData.onWall
+            };
+            const itemConstructor = Factory.getClass(modelData.type);
+            const item = yield new itemConstructor(metadata, modelData.object);
+            this.addItem(item);
+            return item;
+        });
+    }
+    glassMaterialCheck(item) {
+        if (item) {
+            item.traverse((child) => {
+                if (child instanceof Mesh && child.material) {
+                    child.castShadow = true;
+                    const materials = !Array.isArray(child.material) ? [child.material] : child.material;
+                    materials.forEach(material => {
+                        if (material.name && (material.name === 'Fixed_Glass' || material.name === 'Default_Glass')) {
+                            child.castShadow = false;
+                            material.transparent = true;
+                            material.format = THREE.RGBAFormat;
+                            material.needsUpdate = true;
+                        }
+                    });
+                }
+            });
+        }
+    }
+}
+ItemService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemService, deps: [{ token: i1.SceneService }, { token: i2.MessageBusService }], target: i0.ɵɵFactoryTarget.Injectable });
+ItemService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }, { type: i2.MessageBusService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item.service.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/service/item.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport * as THREE from 'three';\r\nimport {Euler, Mesh, Vector3} from 'three';\r\nimport {Subject} from 'rxjs';\r\nimport {Factory, isFloorType, isFurnitureType, isWallType} from '../items/factory';\r\nimport type {Metadata} from '../items/metadata';\r\nimport {Item} from '../items/item';\r\nimport {SceneService} from './scene.service';\r\nimport {MessageBusService} from '../../../core/service/message-bus.service';\r\nimport {Utils} from '../core/utils';\r\nimport {MessageType} from '../../../core/enum/message-type.enum';\r\nimport {ThreedModel} from '../model/threed-model';\r\nimport {Furniture} from '../items/furniture';\r\nimport {ItemType} from '../items/item-type';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ItemService implements OnDestroy {\r\n\r\n  public items: Item[] = [];\r\n\r\n  public copyItem: Subject<Item> = new Subject<Item>();\r\n  public deleteItem: Subject<Item> = new Subject<Item>();\r\n  public removeAllItems: Subject<void> = new Subject<void>();\r\n\r\n  constructor(\r\n    private _sceneService: SceneService,\r\n    private _messageService: MessageBusService\r\n  ) {\r\n    window.onbeforeunload = () => this.ngOnDestroy();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.removeAll();\r\n  }\r\n\r\n  // todo: fix the any\r\n  public addItem(obj: any, addToScene: boolean = true): void {\r\n    this.items.push(obj);\r\n    if (addToScene) {\r\n      this._sceneService.addObject(obj);\r\n    }\r\n  }\r\n\r\n  // todo: fix the any\r\n  public removeItem(obj: any, addedToGroup: boolean = false, emitMessage: boolean = true): void {\r\n    if (typeof obj === 'string') {\r\n      obj = this._sceneService.scene.getObjectByName(obj) as Item;\r\n    }\r\n    if (obj) {\r\n      Utils.removeValue(this.items, obj);\r\n      this._sceneService.removeObject(obj, true, !addedToGroup);\r\n      if (emitMessage) {\r\n        this._messageService.emit(MessageType.ItemRemoved, {item: obj, addedToGroup: addedToGroup});\r\n      }\r\n    }\r\n  }\r\n\r\n  public getObjectPlanes() {\r\n    return this.items.reduce((meshes, item: Item) =>\r\n        meshes.concat(item.getVisibleMeshes ? item.getVisibleMeshes() : [])\r\n      , []);\r\n  }\r\n\r\n  public getWallItems(): Item[] {\r\n    const items: Item[] = this.items.filter((item: Item) => item instanceof Item);\r\n    return items.filter((item: Item) => {\r\n      const itemType = item.metadata && item.metadata.itemType;\r\n      return isWallType(itemType);\r\n    });\r\n  }\r\n\r\n  public getFurniture(): Furniture[] {\r\n    const furniture = this.items\r\n      .filter(item => !item.metadata || isFurnitureType(item.metadata.itemType))\r\n      .map(item => item as Furniture);\r\n    return furniture;\r\n  }\r\n\r\n  public getNonFurniture(): Item[] {\r\n    return this.items.filter(item => item.metadata && !isFurnitureType(item.metadata.itemType));\r\n  }\r\n\r\n  public getConfigurables(): Item[] {\r\n    return this.items.filter(i => i.configurable);\r\n  }\r\n\r\n  public getIOneFurniture(): Item[] {\r\n    return this.items.filter(i => i.metadata && i.metadata.ione);\r\n  }\r\n\r\n  public getCameraItem(): Item {\r\n    return this.items.filter((mesh: any) => mesh.name === 'Camera')[0]; // TODO: identify camera by other means?\r\n  }\r\n\r\n  public getWalkthroughCamera(): Item {\r\n    return this.items.filter((item) => item.name === 'Walkthrough Camera')[0];\r\n  }\r\n\r\n  public removeFloorItems(): void {\r\n    this.items.reduce((keep: Item[], item: Item) => {\r\n      if (isFurnitureType(item.userData.itemType) && !Utils.isCamera(item)) {\r\n        this.removeItem(item);\r\n        return keep;\r\n      } else {\r\n        return keep.concat(item);\r\n      }\r\n    }, []);\r\n  }\r\n\r\n  public removeAll(): void {\r\n    const allItems: Item[] = this.items.slice();\r\n    allItems.forEach(i => {\r\n      this.removeItem(i);\r\n    });\r\n    this.removeAllItems.next();\r\n  }\r\n\r\n  public addJsonItem(modelData: ThreedModel, point: THREE.Vector3): Item {\r\n    const metadata: Metadata = {\r\n      itemName: modelData.name,\r\n      itemDescription: modelData.description,\r\n      resizable: modelData.resizable,\r\n      modelUrl: modelData.url,\r\n      itemType: modelData.type,\r\n      opening: modelData.opening,\r\n      isCustom: modelData.isCustom,\r\n      position: point.clone(),\r\n      rotation: modelData.rotation ? modelData.rotation : new Euler(0, 0, 0),\r\n      scale: modelData.scale,\r\n      texture: modelData.texture,\r\n      doorColor: modelData.doorColor,\r\n      frameColor: modelData.frameColor,\r\n      windowColor: modelData.windowColor,\r\n      doorpost: modelData.doorpost,\r\n      locked: modelData.locked,\r\n      canElevate: modelData.canElevate,\r\n      elevation: modelData.elevation,\r\n      elevationFixed: modelData.elevationFixed,\r\n      elevationAdjustable: modelData.elevationAdjustable,\r\n      scalable: modelData.scalable,\r\n      scalePercentage: modelData.scalePercentage,\r\n      usePivot: (modelData.type === ItemType.InWall && modelData.isCustom) ? false : true,\r\n      centerPivot: isFloorType(modelData.type),\r\n      onWall: modelData.onWall,\r\n      isGlass: modelData.isGlass\r\n    };\r\n\r\n    const itemConstructor = Factory.getClass(modelData.type);\r\n    const oldObject: boolean = modelData.object.constructor.name === 'Object' && modelData.object.hasOwnProperty('geometry');\r\n    const object = oldObject ? new Mesh(modelData.object.geometry, modelData.object.materials) : modelData.object;\r\n    const item = new itemConstructor(\r\n      metadata,\r\n      object,\r\n      modelData.texture\r\n    );\r\n    item.additionalTexture = modelData.additionalTexture;\r\n    item.fixed = modelData.fixed || false;\r\n    if (metadata.opening) {\r\n      item.opening = Object.assign({}, metadata.opening);\r\n    }\r\n    item.userData.itemType = metadata.itemType;\r\n    this.addItem(item);\r\n    return item;\r\n  }\r\n\r\n  public async addFloorGroupItem(modelData: ThreedModel, point: Vector3): Promise<Item> {\r\n    const metadata: Metadata = {\r\n      itemName: modelData.name,\r\n      itemDescription: modelData.description,\r\n      resizable: modelData.resizable,\r\n      modelUrl: modelData.url,\r\n      itemType: modelData.type,\r\n      opening: modelData.opening,\r\n      isCustom: modelData.isCustom,\r\n      texture: modelData.texture,\r\n      position: point.clone(),\r\n      rotation: modelData.rotation ? modelData.rotation : new Euler(0, 0, 0),\r\n      scale: modelData.scale,\r\n      doorColor: modelData.doorColor,\r\n      frameColor: modelData.frameColor,\r\n      windowColor: modelData.windowColor,\r\n      locked: modelData.locked,\r\n      canElevate: modelData.canElevate,\r\n      elevation: modelData.elevation,\r\n      elevationFixed: modelData.elevationFixed,\r\n      elevationAdjustable: modelData.elevationAdjustable,\r\n      scalable: modelData.scalable,\r\n      centerPivot: true,\r\n      onWall: modelData.onWall\r\n    };\r\n    const itemConstructor = Factory.getClass(modelData.type);\r\n\r\n    const item = await new itemConstructor(metadata, modelData.object);\r\n    this.addItem(item);\r\n    return item;\r\n  }\r\n\r\n  public glassMaterialCheck(item: Item) {\r\n    if (item) {\r\n      item.traverse((child) => {\r\n        if (child instanceof Mesh && child.material) {\r\n          child.castShadow = true;\r\n          const materials: any = !Array.isArray(child.material) ? [child.material] : child.material;\r\n          materials.forEach(material => {\r\n            if (material.name && (material.name === 'Fixed_Glass' || material.name === 'Default_Glass')) {\r\n              child.castShadow = false;\r\n              material.transparent = true;\r\n              material.format = THREE.RGBAFormat;\r\n              material.needsUpdate = true;\r\n            }\r\n          });\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n}\r\n"]}