@shopware-ag/dive 1.7.0 → 1.9.0

package/README.md

@@ -8,7 +8,7 @@
         <img alt="dive: npm" src="https://img.shields.io/npm/v/%40shopware-ag%2Fdive">
     </a>
     <a href="#badge">
-        <img alt="dive: licenst" src="https://img.shields.io/npm/l/%40shopware-ag%2Fdive">
+        <img alt="dive: license" src="https://img.shields.io/npm/l/%40shopware-ag%2Fdive">
     </a>
     <a href="#badge">
         <img alt="dive: types" src="https://img.shields.io/npm/types/%40shopware-ag%2Fdive">

package/build/dive.cjs

@@ -460,7 +460,12 @@ var init_PerspectiveCamera = __esm({
     };
     _DIVEPerspectiveCamera = class _DIVEPerspectiveCamera extends import_three4.PerspectiveCamera {
       constructor(settings = DIVEPerspectiveCameraDefaultSettings) {
-        super(settings.fov, 1, settings.near, settings.far);
+        super(
+          settings.fov || DIVEPerspectiveCameraDefaultSettings.fov,
+          1,
+          settings.near || DIVEPerspectiveCameraDefaultSettings.near,
+          settings.far || DIVEPerspectiveCameraDefaultSettings.far
+        );
         this.onSetCameraLayer = () => {
         };
         this.layers.mask = _DIVEPerspectiveCamera.EDITOR_VIEW_LAYER_MASK;
@@ -546,14 +551,16 @@ var DIVERendererDefaultSettings = {
   stencil: false,
   shadowMapEnabled: true,
   shadowMapType: import_three.PCFSoftShadowMap,
-  toneMapping: import_three.NoToneMapping
+  toneMapping: import_three.NoToneMapping,
+  canvas: void 0
 };
 var DIVERenderer = class extends import_three.WebGLRenderer {
   constructor(rendererSettings = DIVERendererDefaultSettings) {
     super({
-      antialias: rendererSettings.antialias,
-      alpha: rendererSettings.alpha,
-      preserveDrawingBuffer: true
+      antialias: rendererSettings.antialias || DIVERendererDefaultSettings.antialias,
+      alpha: rendererSettings.alpha || DIVERendererDefaultSettings.alpha,
+      preserveDrawingBuffer: true,
+      canvas: rendererSettings.canvas
     });
     // basic functionality members
     this.paused = false;
@@ -563,9 +570,9 @@ var DIVERenderer = class extends import_three.WebGLRenderer {
     this.preRenderCallbacks = /* @__PURE__ */ new Map();
     this.postRenderCallbacks = /* @__PURE__ */ new Map();
     this.setPixelRatio(window.devicePixelRatio);
-    this.shadowMap.enabled = rendererSettings.shadowMapEnabled;
-    this.shadowMap.type = rendererSettings.shadowMapType;
-    this.toneMapping = rendererSettings.toneMapping;
+    this.shadowMap.enabled = rendererSettings.shadowMapEnabled || DIVERendererDefaultSettings.shadowMapEnabled;
+    this.shadowMap.type = rendererSettings.shadowMapType || DIVERendererDefaultSettings.shadowMapType;
+    this.toneMapping = rendererSettings.toneMapping || DIVERendererDefaultSettings.toneMapping;
     this.debug.checkShaderErrors = false;
   }
   // Stops renderings and disposes the renderer.
@@ -664,10 +671,10 @@ var DIVERenderer = class extends import_three.WebGLRenderer {
 };
 
 // src/scene/Scene.ts
-var import_three13 = require("three");
+var import_three15 = require("three");
 
 // src/scene/root/Root.ts
-var import_three12 = require("three");
+var import_three14 = require("three");
 
 // src/scene/root/lightroot/LightRoot.ts
 var import_three7 = require("three");
@@ -1403,12 +1410,265 @@ var DIVEModelRoot = class extends import_three9.Object3D {
   }
 };
 
-// src/primitive/floor/Floor.ts
+// src/scene/root/primitiveroot/PrimitiveRoot.ts
+var import_three11 = require("three");
+
+// src/primitive/Primitive.ts
 var import_three10 = require("three");
 init_VisibilityLayerMask();
-var DIVEFloor = class extends import_three10.Mesh {
+var DIVEPrimitive = class extends import_three10.Object3D {
+  constructor() {
+    super();
+    this.isSelectable = true;
+    this.isMoveable = true;
+    this.gizmo = null;
+    this.layers.mask = PRODUCT_LAYER_MASK;
+    this._mesh = new import_three10.Mesh();
+    this._mesh.layers.mask = PRODUCT_LAYER_MASK;
+    this._mesh.castShadow = true;
+    this._mesh.receiveShadow = true;
+    this.add(this._mesh);
+    this._boundingBox = new import_three10.Box3();
+  }
+  SetGeometry(geometry) {
+    this.clear();
+    this._mesh.geometry = this.assembleGeometry(geometry);
+    this._boundingBox.setFromObject(this._mesh);
+  }
+  SetPosition(position) {
+    this.position.set(position.x, position.y, position.z);
+  }
+  SetRotation(rotation) {
+    this.rotation.setFromVector3(new import_three10.Vector3(rotation.x, rotation.y, rotation.z));
+  }
+  SetScale(scale) {
+    this.scale.set(scale.x, scale.y, scale.z);
+  }
+  SetVisibility(visible) {
+    this.traverse((child) => {
+      child.visible = visible;
+    });
+  }
+  SetMaterial(material) {
+    const primitiveMaterial = this._mesh.material;
+    primitiveMaterial.color = new import_three10.Color(material.color);
+    if (material.roughnessMap) {
+      primitiveMaterial.roughnessMap = material.roughnessMap;
+      primitiveMaterial.roughness = 1;
+    } else {
+      primitiveMaterial.roughness = material.roughness;
+    }
+    if (material.metalnessMap) {
+      primitiveMaterial.metalnessMap = material.metalnessMap;
+      primitiveMaterial.metalness = 0;
+    } else {
+      primitiveMaterial.metalness = material.metalness;
+    }
+  }
+  SetToWorldOrigin() {
+    var _a;
+    this.position.set(0, 0, 0);
+    (_a = DIVECommunication.get(this.userData.id)) == null ? void 0 : _a.PerformAction("UPDATE_OBJECT", { id: this.userData.id, position: this.position, rotation: this.rotation, scale: this.scale });
+  }
+  PlaceOnFloor() {
+    var _a;
+    this.position.y = -this._boundingBox.min.y * this.scale.y;
+    (_a = DIVECommunication.get(this.userData.id)) == null ? void 0 : _a.PerformAction("UPDATE_OBJECT", { id: this.userData.id, position: this.position, rotation: this.rotation, scale: this.scale });
+  }
+  DropIt() {
+    var _a;
+    if (!this.parent) {
+      console.warn("DIVEModel: DropIt() called on a model that is not in the scene.", this);
+      return;
+    }
+    const bottomY = this._boundingBox.min.y * this.scale.y;
+    const bbBottomCenter = this.localToWorld(this._boundingBox.getCenter(new import_three10.Vector3()).multiply(this.scale));
+    bbBottomCenter.y = bottomY + this.position.y;
+    const raycaster = new import_three10.Raycaster(bbBottomCenter, new import_three10.Vector3(0, -1, 0));
+    raycaster.layers.mask = PRODUCT_LAYER_MASK;
+    const intersections = raycaster.intersectObjects(findSceneRecursive(this).Root.children, true);
+    if (intersections.length > 0) {
+      const mesh = intersections[0].object;
+      mesh.geometry.computeBoundingBox();
+      const meshBB = mesh.geometry.boundingBox;
+      const worldPos = mesh.localToWorld(meshBB.max.clone());
+      const oldPos = this.position.clone();
+      const newPos = this.position.clone().setY(worldPos.y).sub(new import_three10.Vector3(0, bottomY, 0));
+      this.position.copy(newPos);
+      if (this.position.y === oldPos.y) return;
+      (_a = DIVECommunication.get(this.userData.id)) == null ? void 0 : _a.PerformAction("UPDATE_OBJECT", { id: this.userData.id, position: this.position, rotation: this.rotation, scale: this.scale });
+    }
+  }
+  onMove() {
+    var _a;
+    (_a = DIVECommunication.get(this.userData.id)) == null ? void 0 : _a.PerformAction("UPDATE_OBJECT", { id: this.userData.id, position: this.position, rotation: this.rotation, scale: this.scale });
+  }
+  onSelect() {
+    var _a;
+    (_a = DIVECommunication.get(this.userData.id)) == null ? void 0 : _a.PerformAction("SELECT_OBJECT", { id: this.userData.id });
+  }
+  onDeselect() {
+    var _a;
+    (_a = DIVECommunication.get(this.userData.id)) == null ? void 0 : _a.PerformAction("DESELECT_OBJECT", { id: this.userData.id });
+  }
+  assembleGeometry(geometry) {
+    switch (geometry.name) {
+      case "cylinder":
+        return this.createCylinderGeometry(geometry);
+      case "sphere":
+        return this.createSphereGeometry(geometry);
+      case "pyramid":
+        return this.createPyramidGeometry(geometry);
+      case "box":
+        return this.createBoxGeometry(geometry);
+      case "cone":
+        return this.createConeGeometry(geometry);
+      case "wall":
+        return this.createWallGeometry(geometry);
+      case "plane":
+        return this.createPlaneGeometry(geometry);
+      default:
+        return new import_three10.BufferGeometry();
+    }
+  }
+  createCylinderGeometry(geometry) {
+    return new import_three10.CylinderGeometry(geometry.width * 2, geometry.width * 2, geometry.height, 64);
+  }
+  createSphereGeometry(geometry) {
+    return new import_three10.SphereGeometry(geometry.width * 2, 64);
+  }
+  createPyramidGeometry(geometry) {
+    const geo = new import_three10.BufferGeometry();
+    const { width, height, depth } = geometry;
+    geo.setAttribute("position", new import_three10.Float32BufferAttribute([
+      width / 2,
+      0,
+      depth / 2,
+      // right back
+      width / 2,
+      0,
+      -depth / 2,
+      // right front
+      -width / 2,
+      0,
+      -depth / 2,
+      // left front
+      -width / 2,
+      0,
+      depth / 2,
+      // left back
+      0,
+      height,
+      0
+      // top
+    ], 3));
+    geo.setIndex(new import_three10.Uint32BufferAttribute([
+      1,
+      0,
+      4,
+      2,
+      1,
+      4,
+      3,
+      2,
+      4,
+      3,
+      0,
+      4,
+      0,
+      1,
+      2,
+      0,
+      2,
+      3
+    ], 1));
+    return geo;
+  }
+  createBoxGeometry(geometry) {
+    return new import_three10.BoxGeometry(geometry.width, geometry.height, geometry.depth);
+  }
+  createConeGeometry(geometry) {
+    return new import_three10.CylinderGeometry(0, geometry.width * 2, geometry.height, 64);
+  }
+  createWallGeometry(geometry) {
+    return new import_three10.BoxGeometry(geometry.width, geometry.height, geometry.depth, 16);
+  }
+  createPlaneGeometry(geometry) {
+    return new import_three10.BoxGeometry(geometry.width, geometry.height, geometry.depth);
+  }
+};
+
+// src/scene/root/primitiveroot/PrimitiveRoot.ts
+var DIVEPrimitiveRoot = class extends import_three11.Object3D {
   constructor() {
-    super(new import_three10.PlaneGeometry(1e4, 1e4), new import_three10.MeshStandardMaterial({ color: new import_three10.Color(150 / 255, 150 / 255, 150 / 255) }));
+    super();
+    this.name = "PrimitiveRoot";
+  }
+  GetPrimitive(object) {
+    if (object.id === void 0) {
+      console.warn("PrimitiveRoot.GetPrimitive: object.id is undefined");
+      return void 0;
+    }
+    return this.children.find((object3D) => object3D.userData.id === object.id);
+  }
+  UpdatePrimitive(object) {
+    if (object.id === void 0) {
+      console.warn("PrimitiveRoot.UpdatePrimitive: object.id is undefined");
+      return;
+    }
+    let sceneObject = this.children.find((object3D) => object3D.userData.id === object.id);
+    if (!sceneObject && object.geometry !== void 0) {
+      const primitive = new DIVEPrimitive();
+      primitive.SetGeometry(object.geometry);
+      sceneObject = primitive;
+      sceneObject.userData.id = object.id;
+      this.add(sceneObject);
+    }
+    if (object.position !== void 0) sceneObject.SetPosition(object.position);
+    if (object.rotation !== void 0) sceneObject.SetRotation(object.rotation);
+    if (object.scale !== void 0) sceneObject.SetScale(object.scale);
+    if (object.visible !== void 0) sceneObject.SetVisibility(object.visible);
+    if (object.material !== void 0) sceneObject.SetMaterial(object.material);
+  }
+  DeletePrimitive(object) {
+    if (object.id === void 0) {
+      console.warn(`PrimitiveRoot.DeletePrimitive: object.id is undefined`);
+      return;
+    }
+    const sceneObject = this.children.find((object3D) => object3D.userData.id === object.id);
+    if (!sceneObject) {
+      console.warn(`PrimitiveRoot.DeletePrimitive: Primitive with id ${object.id} not found`);
+      return;
+    }
+    const findScene = (object2) => {
+      if (object2.parent !== null) {
+        return findScene(object2.parent);
+      }
+      ;
+      return object2;
+    };
+    const scene = findScene(sceneObject);
+    scene.children.find((object2) => {
+      if ("isTransformControls" in object2) {
+        object2.detach();
+      }
+    });
+    this.remove(sceneObject);
+  }
+  PlaceOnFloor(object) {
+    if (object.id === void 0) console.warn("PrimitiveRoot.PlaceOnFloor: object.id is undefined");
+    const sceneObject = this.children.find((object3D) => object3D.userData.id === object.id);
+    if (!sceneObject) return;
+    sceneObject.PlaceOnFloor();
+  }
+};
+
+// src/primitive/floor/Floor.ts
+var import_three12 = require("three");
+init_VisibilityLayerMask();
+var DIVEFloor = class extends import_three12.Mesh {
+  constructor() {
+    super(new import_three12.PlaneGeometry(1e4, 1e4), new import_three12.MeshStandardMaterial({ color: new import_three12.Color(150 / 255, 150 / 255, 150 / 255) }));
     this.isFloor = true;
     this.name = "Floor";
     this.layers.mask = PRODUCT_LAYER_MASK;
@@ -1419,7 +1679,7 @@ var DIVEFloor = class extends import_three10.Mesh {
     this.visible = visible;
   }
   SetColor(color) {
-    this.material.color = new import_three10.Color(color);
+    this.material.color = new import_three12.Color(color);
   }
 };
 
@@ -1429,12 +1689,12 @@ var GRID_SIDE_LINE_COLOR = "#dddddd";
 
 // src/grid/Grid.ts
 init_VisibilityLayerMask();
-var import_three11 = require("three");
-var DIVEGrid = class extends import_three11.Object3D {
+var import_three13 = require("three");
+var DIVEGrid = class extends import_three13.Object3D {
   constructor() {
     super();
     this.name = "Grid";
-    const grid = new import_three11.GridHelper(100, 100, GRID_CENTER_LINE_COLOR, GRID_SIDE_LINE_COLOR);
+    const grid = new import_three13.GridHelper(100, 100, GRID_CENTER_LINE_COLOR, GRID_SIDE_LINE_COLOR);
     grid.material.depthTest = false;
     grid.layers.mask = HELPER_LAYER_MASK;
     this.add(grid);
@@ -1445,7 +1705,7 @@ var DIVEGrid = class extends import_three11.Object3D {
 };
 
 // src/scene/root/Root.ts
-var DIVERoot = class extends import_three12.Object3D {
+var DIVERoot = class extends import_three14.Object3D {
   get Floor() {
     return this.floor;
   }
@@ -1459,18 +1719,25 @@ var DIVERoot = class extends import_three12.Object3D {
     this.add(this.lightRoot);
     this.modelRoot = new DIVEModelRoot();
     this.add(this.modelRoot);
+    this.primitiveRoot = new DIVEPrimitiveRoot();
+    this.add(this.primitiveRoot);
     this.floor = new DIVEFloor();
     this.add(this.floor);
     this.grid = new DIVEGrid();
     this.add(this.grid);
   }
   ComputeSceneBB() {
-    const bb = new import_three12.Box3();
+    const bb = new import_three14.Box3();
     this.modelRoot.traverse((object) => {
       if ("isObject3D" in object) {
         bb.expandByObject(object);
       }
     });
+    this.primitiveRoot.traverse((object) => {
+      if ("isObject3D" in object) {
+        bb.expandByObject(object);
+      }
+    });
     return bb;
   }
   GetSceneObject(object) {
@@ -1484,6 +1751,9 @@ var DIVERoot = class extends import_three12.Object3D {
       case "model": {
         return this.modelRoot.GetModel(object);
       }
+      case "primitive": {
+        return this.primitiveRoot.GetPrimitive(object);
+      }
     }
   }
   AddSceneObject(object) {
@@ -1499,6 +1769,10 @@ var DIVERoot = class extends import_three12.Object3D {
         this.modelRoot.UpdateModel(object);
         break;
       }
+      case "primitive": {
+        this.primitiveRoot.UpdatePrimitive(object);
+        break;
+      }
     }
   }
   UpdateSceneObject(object) {
@@ -1514,6 +1788,10 @@ var DIVERoot = class extends import_three12.Object3D {
         this.modelRoot.UpdateModel(object);
         break;
       }
+      case "primitive": {
+        this.primitiveRoot.UpdatePrimitive(object);
+        break;
+      }
     }
   }
   DeleteSceneObject(object) {
@@ -1529,26 +1807,43 @@ var DIVERoot = class extends import_three12.Object3D {
         this.modelRoot.DeleteModel(object);
         break;
       }
+      case "primitive": {
+        this.primitiveRoot.DeletePrimitive(object);
+        break;
+      }
     }
   }
   PlaceOnFloor(object) {
-    this.modelRoot.PlaceOnFloor(object);
+    switch (object.entityType) {
+      case "pov":
+      case "light": {
+        break;
+      }
+      case "model": {
+        this.modelRoot.PlaceOnFloor(object);
+        break;
+      }
+      case "primitive": {
+        this.primitiveRoot.PlaceOnFloor(object);
+        break;
+      }
+    }
   }
 };
 
 // src/scene/Scene.ts
-var DIVEScene = class extends import_three13.Scene {
+var DIVEScene = class extends import_three15.Scene {
   get Root() {
     return this.root;
   }
   constructor() {
     super();
-    this.background = new import_three13.Color(16777215);
+    this.background = new import_three15.Color(16777215);
     this.root = new DIVERoot();
     this.add(this.root);
   }
   SetBackground(color) {
-    this.background = new import_three13.Color(color);
+    this.background = new import_three15.Color(color);
   }
   ComputeSceneBB() {
     return this.Root.ComputeSceneBB();
@@ -1574,14 +1869,14 @@ var DIVEScene = class extends import_three13.Scene {
 init_PerspectiveCamera();
 
 // src/controls/OrbitControls.ts
-var import_Addons3 = require("three/examples/jsm/Addons.js");
-var import_three14 = require("three");
+var import_OrbitControls = require("three/examples/jsm/controls/OrbitControls");
+var import_three16 = require("three");
 var import_tween = require("@tweenjs/tween.js");
 var DIVEOrbitControlsDefaultSettings = {
   enableDamping: true,
   dampingFactor: 0.04
 };
-var _DIVEOrbitControls = class _DIVEOrbitControls extends import_Addons3.OrbitControls {
+var _DIVEOrbitControls = class _DIVEOrbitControls extends import_OrbitControls.OrbitControls {
   constructor(camera, renderer, animationSystem, settings = DIVEOrbitControlsDefaultSettings) {
     super(camera, renderer.domElement);
     this.last = null;
@@ -1606,16 +1901,19 @@ var _DIVEOrbitControls = class _DIVEOrbitControls extends import_Addons3.OrbitCo
     this._removePreRenderCallback = () => {
       renderer.RemovePreRenderCallback(id);
     };
-    this.enableDamping = settings.enableDamping;
-    this.dampingFactor = settings.dampingFactor;
+    this.enableDamping = settings.enableDamping || DIVEOrbitControlsDefaultSettings.enableDamping;
+    this.dampingFactor = settings.dampingFactor || DIVEOrbitControlsDefaultSettings.dampingFactor;
+    this.object.position.set(0, 2, 2);
+    this.target.copy({ x: 0, y: 0.5, z: 0 });
+    this.update();
   }
   Dispose() {
     this._removePreRenderCallback();
     this.dispose();
   }
   ComputeEncompassingView(bb) {
-    const center = bb.getCenter(new import_three14.Vector3());
-    const size = bb.getSize(new import_three14.Vector3());
+    const center = bb.getCenter(new import_three16.Vector3());
+    const size = bb.getSize(new import_three16.Vector3());
     const distance = Math.max(size.x, size.y, size.z) * 1.25;
     const direction = this.object.position.clone().normalize();
     return {
@@ -1626,7 +1924,7 @@ var _DIVEOrbitControls = class _DIVEOrbitControls extends import_Addons3.OrbitCo
   ZoomIn(by) {
     const zoomBy = by || _DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
     const { minDistance, maxDistance } = this;
-    this.minDistance = this.maxDistance = import_three14.MathUtils.clamp(this.getDistance() - zoomBy, minDistance + zoomBy, maxDistance - zoomBy);
+    this.minDistance = this.maxDistance = import_three16.MathUtils.clamp(this.getDistance() - zoomBy, minDistance + zoomBy, maxDistance - zoomBy);
     this.update();
     this.minDistance = minDistance;
     this.maxDistance = maxDistance;
@@ -1634,7 +1932,7 @@ var _DIVEOrbitControls = class _DIVEOrbitControls extends import_Addons3.OrbitCo
   ZoomOut(by) {
     const zoomBy = by || _DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
     const { minDistance, maxDistance } = this;
-    this.minDistance = this.maxDistance = import_three14.MathUtils.clamp(this.getDistance() + zoomBy, minDistance + zoomBy, maxDistance - zoomBy);
+    this.minDistance = this.maxDistance = import_three16.MathUtils.clamp(this.getDistance() + zoomBy, minDistance + zoomBy, maxDistance - zoomBy);
     this.update();
     this.minDistance = minDistance;
     this.maxDistance = maxDistance;
@@ -1782,7 +2080,7 @@ var DIVEAnimationSystem = class {
 };
 
 // src/axiscamera/AxisCamera.ts
-var import_three15 = require("three");
+var import_three17 = require("three");
 var import_three_spritetext = __toESM(require("three-spritetext"), 1);
 init_VisibilityLayerMask();
 
@@ -1795,18 +2093,18 @@ var AxesColorGreen = AxesColorGreenLetter;
 var AxesColorBlue = AxesColorBlueLetter;
 
 // src/axiscamera/AxisCamera.ts
-var DIVEAxisCamera = class extends import_three15.OrthographicCamera {
+var DIVEAxisCamera = class extends import_three17.OrthographicCamera {
   constructor(renderer, scene, controls) {
     super(-1, 1, 1, -1, 0.1, 100);
     this.layers.mask = COORDINATE_LAYER_MASK;
-    this.axesHelper = new import_three15.AxesHelper(0.5);
+    this.axesHelper = new import_three17.AxesHelper(0.5);
     this.axesHelper.layers.mask = COORDINATE_LAYER_MASK;
     this.axesHelper.material.depthTest = false;
     this.axesHelper.position.set(0, 0, -1);
     this.axesHelper.setColors(
-      new import_three15.Color(AxesColorRed),
-      new import_three15.Color(AxesColorGreen),
-      new import_three15.Color(AxesColorBlue)
+      new import_three17.Color(AxesColorRed),
+      new import_three17.Color(AxesColorGreen),
+      new import_three17.Color(AxesColorBlue)
     );
     const x = new import_three_spritetext.default("X", 0.2, AxesColorRedLetter);
     const y = new import_three_spritetext.default("Y", 0.2, AxesColorGreenLetter);
@@ -1824,7 +2122,7 @@ var DIVEAxisCamera = class extends import_three15.OrthographicCamera {
     this._renderer = renderer;
     this._scene = scene;
     this._scene.add(this);
-    const restoreViewport = new import_three15.Vector4();
+    const restoreViewport = new import_three17.Vector4();
     this._renderCallbackId = renderer.AddPostRenderCallback(() => {
       const restoreBackground = scene.background;
       scene.background = null;
@@ -1843,7 +2141,7 @@ var DIVEAxisCamera = class extends import_three15.OrthographicCamera {
     this._scene.remove(this);
   }
   SetFromCameraMatrix(matrix) {
-    this.axesHelper.rotation.setFromRotationMatrix(new import_three15.Matrix4().extractRotation(matrix).invert());
+    this.axesHelper.rotation.setFromRotationMatrix(new import_three17.Matrix4().extractRotation(matrix).invert());
   }
 };
 
@@ -2132,14 +2430,14 @@ var DIVE = class _DIVE {
     const settingsDelta = getObjectDelta(this._settings, settings);
     if (settingsDelta.renderer) this.renderer = new DIVERenderer(this._settings.renderer);
     if (settingsDelta.perspectiveCamera) {
-      this.perspectiveCamera.fov = settingsDelta.perspectiveCamera.fov;
-      this.perspectiveCamera.near = settingsDelta.perspectiveCamera.near;
-      this.perspectiveCamera.far = settingsDelta.perspectiveCamera.far;
+      if (settingsDelta.perspectiveCamera.fov !== void 0) this.perspectiveCamera.fov = settingsDelta.perspectiveCamera.fov;
+      if (settingsDelta.perspectiveCamera.near !== void 0) this.perspectiveCamera.near = settingsDelta.perspectiveCamera.near;
+      if (settingsDelta.perspectiveCamera.far !== void 0) this.perspectiveCamera.far = settingsDelta.perspectiveCamera.far;
       this.perspectiveCamera.OnResize(this.renderer.domElement.width, this.renderer.domElement.height);
     }
     if (settingsDelta.orbitControls) {
-      this.orbitControls.enableDamping = settingsDelta.orbitControls.enableDamping;
-      this.orbitControls.dampingFactor = settingsDelta.orbitControls.dampingFactor;
+      if (settingsDelta.orbitControls.enableDamping !== void 0) this.orbitControls.enableDamping = settingsDelta.orbitControls.enableDamping;
+      if (settingsDelta.orbitControls.dampingFactor !== void 0) this.orbitControls.dampingFactor = settingsDelta.orbitControls.dampingFactor;
     }
     if (settingsDelta.autoResize !== this._settings.autoResize) {
       if (settingsDelta.autoResize) {
@@ -2182,6 +2480,7 @@ var DIVE = class _DIVE {
         console.log(this.scene);
       }
     };
+    console.log("DIVE initialized");
   }
   Dispose() {
     var _a;