@colijnit/homedecorator 257.1.13 → 257.1.14

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

@@ -13,6 +13,7 @@ export declare abstract class BaseItem extends Object3D {
     locked: boolean;
     itemGroup: any;
     obstructFloorMoves: boolean;
+    positionValid: boolean;
     allowRotate: boolean;
     fixed: boolean;
     skin: Skin;

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

@@ -13,6 +13,7 @@ export declare class ItemGroup extends Group {
     wantsRotation: Euler;
     metadata: Metadata;
     boundaryBox: Box3;
+    positionValid: boolean;
     private _items;
     private _halfSize;
     private _boundaryBoxCenter;

package/app/plugins/core3d/service/error-glow.service.d.ts

@@ -1,8 +1,11 @@
-import { Euler, Object3D, Vector3 } from 'three';
+import { Euler, Group, Object3D, Vector3 } from 'three';
 import { SceneService } from './scene.service';
+import { Furniture } from '../items/furniture';
+import { Item } from '../items/item';
 import * as i0 from "@angular/core";
 export declare class ErrorGlowService {
     private _sceneService;
+    get errorGlow(): Object3D | Group;
     private _errorGlow;
     private _parent;
     constructor(_sceneService: SceneService);
@@ -10,7 +13,7 @@ export declare class ErrorGlowService {
     private static _cloneItem;
     private static _cloneGroup;
     private static _cloneObject3D;
-    showError(item: Object3D, position?: Vector3, rotation?: Euler, parent?: Object3D): void;
+    showError(item: Item | Furniture, position?: Vector3, rotation?: Euler, parent?: Object3D): void;
     hideError(): void;
     private _removeErrorGlowObject;
     static ɵfac: i0.ɵɵFactoryDeclaration<ErrorGlowService, never>;

package/app/plugins/core3d/service/rotation.service.d.ts

@@ -35,6 +35,7 @@ export declare class RotationService implements OnDestroy {
     private _moveFactor;
     constructor(_outlineService: OutlineService, _collisionManagerService: CollisionManagerService, _itemService: ItemService, _configService: ConfigurationService, _appService: HomedecoratorAppService, _sceneService: SceneService, _errorGlowService: ErrorGlowService, _settingsService: HomedecoratorSettingsService);
     ngOnDestroy(): void;
+    clearRotationError(item: FloorItem, from: Vector3, to: Vector3, ccw?: boolean): void;
     rotate(item: FloorItem, from: Vector3, to: Vector3, ccw?: boolean): Vector3;
     enableRotationFor(item: Item): void;
     private _handleMouseDown;

package/bundles/colijnit-homedecorator.umd.js

@@ -5754,6 +5754,7 @@
           _this.canMove = true;
           _this.locked = false;
           _this.obstructFloorMoves = true; // Does this object affect other floor items
+          _this.positionValid = true;
           _this.allowRotate = true; // Show rotate option in context menu
           _this.fixed = false;
           _this.canChangeCustomMeshColor = false;
@@ -6397,6 +6398,7 @@
           _this.locked = false;
           _this.obstructFloorMoves = true;
           _this.boundaryBox = new THREE.Box3();
+          _this.positionValid = true;
           _this._items = [];
           _this._halfSize = new THREE.Vector3();
           _this._boundaryBoxCenter = new THREE.Vector3();
@@ -19355,6 +19357,13 @@
       function ErrorGlowService(_sceneService) {
           this._sceneService = _sceneService;
       }
+      Object.defineProperty(ErrorGlowService.prototype, "errorGlow", {
+          get: function () {
+              return this._errorGlow;
+          },
+          enumerable: false,
+          configurable: true
+      });
       ErrorGlowService._createErrorGlow = function (item, color, opacity, ignoreDepth) {
           if (color === void 0) { color = defaultColor$2; }
           if (opacity === void 0) { opacity = defaultOpacity; }
@@ -19383,8 +19392,13 @@
           var newItem = this._cloneObject3D(source);
           if (meshMaterial) {
               newItem.traverse(function (child) {
-                  if (child instanceof THREE.Mesh) {
-                      child.material = meshMaterial;
+                  if (child.isMesh) {
+                      if (Array.isArray(child.material)) {
+                          child.material = child.material.map(function () { return meshMaterial; });
+                      }
+                      else {
+                          child.material = meshMaterial;
+                      }
                   }
               });
           }
@@ -19394,8 +19408,13 @@
           var newGroup = this._cloneObject3D(source);
           if (meshMaterial) {
               newGroup.traverse(function (child) {
-                  if (child instanceof THREE.Mesh) {
-                      child.material = meshMaterial;
+                  if (child.isMesh) {
+                      if (Array.isArray(child.material)) {
+                          child.material = child.material.map(function () { return meshMaterial; });
+                      }
+                      else {
+                          child.material = meshMaterial;
+                      }
                   }
               });
           }
@@ -19423,6 +19442,10 @@
                   var clone = _this._cloneObject3D(child);
                   clone.position.copy(child.position);
                   clone.rotation.copy(child.rotation);
+                  clone.scale.copy(child.scale);
+                  clone.name = child.name;
+                  clone.visible = child.visible;
+                  clone.userData = Object.assign({}, child.userData);
                   newObject.add(clone);
               }
           });
@@ -19431,6 +19454,7 @@
       ErrorGlowService.prototype.showError = function (item, position, rotation, parent) {
           var pos = position || item.position;
           var rot = rotation || item.rotation;
+          item.positionValid = false;
           if (this._errorGlow && this._errorGlow.userData.cloneID !== item.uuid) {
               this._removeErrorGlowObject();
           }
@@ -19551,6 +19575,20 @@
           this._subs.forEach(function (s) { return s.unsubscribe(); });
           this._removeListeners();
       };
+      RotationService.prototype.clearRotationError = function (item, from, to, ccw) {
+          if (ccw === void 0) { ccw = true; }
+          if (this._errorGlowService.errorGlow) {
+              var originalPosition = item.position;
+              var originalRotation = item.rotation;
+              var angle = Utils$1.angle(from.x - originalPosition.x, ccw ? from.z - originalPosition.z : Math.abs(from.z - originalPosition.z), to.x - originalPosition.x, ccw ? to.z - originalPosition.z : Math.abs(to.z - originalPosition.z)) + originalRotation.y;
+              var rotation = new THREE.Euler(originalRotation.x, angle, originalRotation.z);
+              var collisionInfo = this._collisionManagerService.validatePosition(null, rotation, item, this._itemService.getFurniture());
+              if (collisionInfo.valid) {
+                  this._errorGlowService.hideError();
+                  item.positionValid = true;
+              }
+          }
+      };
       RotationService.prototype.rotate = function (item, from, to, ccw) {
           if (ccw === void 0) { ccw = true; }
           if (!from || !to) {
@@ -19577,10 +19615,12 @@
           if (!collisionInfo.valid) {
               this._outlineService.showErrorOutline(item);
               if (collisionInfo.intersectsWall) {
-                  return from;
+                  this._errorGlowService.showError(item);
+                  // return from;
               }
           }
           else {
+              this._errorGlowService.hideError();
               this._outlineService.showOutline(item);
           }
           originalRotation.y = angle;
@@ -22035,7 +22075,8 @@
           this._placedPosition = position;
           this._placedIntersection = intersection;
           if (this.draggedData.type === ItemType.FloorDecoration && this._placedIntersection && this._placedIntersection.object) {
-              this._floorService.configureFloor((this._placedIntersection.object instanceof FloorPlaneItem ? this._placedIntersection.object : this._placedIntersection.object.parent));
+              this._floorService.configureFloor((this._placedIntersection.object instanceof FloorPlaneItem ?
+                  this._placedIntersection.object : this._placedIntersection.object.parent));
               this._replacePinWithFurniture(this._placedPosition);
           }
           else {
@@ -22058,7 +22099,7 @@
           this._placedPosition = null;
           this._placedIntersection = null;
           this.draggedStatus.clean();
-          this._errorGlowService.hideError();
+          // this._errorGlowService.hideError();
           this._snappingCollisionService.handleEndOfDragging();
           this._outlineService.hideOutline();
       };
@@ -22084,7 +22125,7 @@
           }
       };
       DragAndDropService.prototype.clickReleased = function () {
-          this._errorGlowService.hideError();
+          // this._errorGlowService.hideError();
           this._snappingCollisionService.handleEndOfDragging();
       };
       DragAndDropService.prototype._createPin = function (point, floorIntersect) {
@@ -22185,8 +22226,14 @@
           if (!item.elevationFixed) {
               item.elevation = 0;
           }
-          if (!collisionInfo.valid) {
-              positionMoveTo.y = item.getFloorY();
+          if (item.positionValid && !collisionInfo.valid) {
+              if (item.canElevate && !item.elevationFixed && collisionInfo.obstructingObjects && collisionInfo.obstructingObjects.length > 0) {
+                  positionMoveTo.y =
+                      collisionInfo.obstructingObjects[0].halfSize.y * 2 + (collisionInfo.obstructingObjects[0].elevation);
+              }
+              else {
+                  positionMoveTo.y = item.getFloorY();
+              }
               if (collisionInfo.intersectsWall /* && !(item instanceof CustomWallFloorItem)*/) {
                   positionMoveTo = this._slideAtFloor(item, positionMoveTo, item.rotation);
                   this._outlineService.showOutline(item);
@@ -22203,7 +22250,7 @@
                   item.elevation =
                       collisionInfo.obstructingObjects[0].halfSize.y * 2 + (collisionInfo.obstructingObjects[0].elevation);
               }
-              else if (this._settingsService.settings.options.usePlacementSnapping
+              else if (this._settingsService.settings.options.usePlacementSnapping && item.positionValid
               // && (item instanceof Item && (item.canSnapToWall || item.canSnapToObject))
               ) {
                   this._snappingCollisionService.handleSnapping(item, positionMoveTo);
@@ -22212,6 +22259,9 @@
                   positionMoveTo.y = item.getFloorY();
               }
               this._outlineService.showOutline(item);
+              if (!item.positionValid) {
+                  this._errorGlowService.showError(item);
+              }
               if (!this._snappingCollisionService.itemHasSnapped()) {
                   item.position.copy(positionMoveTo);
               }
@@ -23049,6 +23099,7 @@
                       this._dragAndDropService.clickDragged(intersection);
                       this._messageBusService.emit(MessageType.ClickDragged);
                       this._debouncedSaveState.next('item dragged');
+                      this._rotationService.clearRotationError(this._selectedObject, this._rotationStartPoint, intersection.point, !this.rotateNoDrag);
                   }
                   this._hudService.update();
               }