@onerjs/core 8.44.9 → 8.45.2

package/Gizmos/boundingBoxGizmo.d.ts

@@ -144,6 +144,8 @@ export declare class BoundingBoxGizmo extends Gizmo implements IBoundingBoxGizmo
     private _tmpRotationMatrix;
     private _incrementalStartupValue;
     private _incrementalAnchorStartupValue;
+    private _isCenterScaleModeActive;
+    private _centerScaleKeyObserver;
     /**
      * If child meshes should be ignored when calculating the bounding box. This should be set to true to avoid perf hits with heavily nested meshes (Default: false)
      */

package/Gizmos/boundingBoxGizmo.js

@@ -12,6 +12,7 @@ import { PivotTools } from "../Misc/pivotTools.js";
 import { Color3 } from "../Maths/math.color.js";
 import { Epsilon } from "../Maths/math.constants.js";
 import { TransformNode } from "../Meshes/transformNode.js";
+import { KeyboardEventTypes } from "../Events/keyboardEvents.js";
 /**
  * Dragging operation in observable
  */
@@ -125,6 +126,8 @@ export class BoundingBoxGizmo extends Gizmo {
         this._tmpRotationMatrix = new Matrix();
         this._incrementalStartupValue = Vector3.Zero();
         this._incrementalAnchorStartupValue = Vector3.Zero();
+        this._isCenterScaleModeActive = false;
+        this._centerScaleKeyObserver = null;
         /**
          * If child meshes should be ignored when calculating the bounding box. This should be set to true to avoid perf hits with heavily nested meshes (Default: false)
          */
@@ -388,6 +391,9 @@ export class BoundingBoxGizmo extends Gizmo {
                     scaleBoxesDragBehavior.moveAttached = false;
                     let totalRelativeDragDistance = 0;
                     let previousScale = 0;
+                    const initialAnchorCenter = new Vector3();
+                    const initialBoxPosition = new Vector3();
+                    const initialMeshAbsolutePosition = new Vector3();
                     box.addBehavior(scaleBoxesDragBehavior);
                     scaleBoxesDragBehavior.onDragObservable.add((event) => {
                         this.onScaleBoxDragObservable.notifyObservers({ dragOperation: 1 /* DragOperation.Scaling */, dragAxis: new Vector3(i - 1, j - 1, k - 1) });
@@ -420,7 +426,12 @@ export class BoundingBoxGizmo extends Gizmo {
                             fullScale.multiplyInPlace(this._axisFactor);
                             fullScale.addInPlace(this._incrementalStartupValue);
                             this.updateBoundingBox();
-                            if (this.scalePivot) {
+                            if (this._isCenterScaleModeActive) {
+                                // Use the original bounding box center captured at drag start so the pivot
+                                // stays fixed when the modifier is toggled mid-drag
+                                this._anchorMesh.position.copyFrom(initialAnchorCenter);
+                            }
+                            else if (this.scalePivot) {
                                 this.attachedMesh.getWorldMatrix().getRotationMatrixToRef(this._tmpRotationMatrix);
                                 // Move anchor to desired pivot point (Bottom left corner + dimension/2)
                                 this._boundingDimensions.scaleToRef(0.5, this._tmpVector);
@@ -431,13 +442,20 @@ export class BoundingBoxGizmo extends Gizmo {
                                 this._anchorMesh.position.addInPlace(this._tmpVector);
                             }
                             else {
-                                // Scale from the position of the opposite corner
-                                box.absolutePosition.subtractToRef(this._anchorMesh.position, this._tmpVector);
-                                this._anchorMesh.position.subtractInPlace(this._tmpVector);
+                                // Scale from the original opposite corner (2*initialCenter - initialBoxPos)
+                                // so toggling modes mid-drag always references the same fixed point
+                                initialAnchorCenter.scaleToRef(2, this._tmpVector);
+                                this._tmpVector.subtractInPlace(initialBoxPosition);
+                                this._anchorMesh.position.copyFrom(this._tmpVector);
                                 if (this.attachedMesh.isUsingPivotMatrix()) {
                                     this._anchorMesh.position.subtractInPlace(this.attachedMesh.getPivotPoint());
                                 }
                             }
+                            // Reset mesh and anchor to drag-start state each frame so the pivot-scale
+                            // computation is non-iterative; mid-drag mode toggles won't cause jumps
+                            this.attachedMesh.setAbsolutePosition(initialMeshAbsolutePosition);
+                            this.attachedMesh.scaling.copyFrom(this._incrementalStartupValue);
+                            this._anchorMesh.scaling.copyFrom(this._incrementalAnchorStartupValue);
                             this._anchorMesh.addChild(this.attachedMesh);
                             if (this.incrementalSnap) {
                                 fullScale.x /= Math.abs(this._incrementalStartupValue.x) < Epsilon ? 1 : this._incrementalStartupValue.x;
@@ -446,14 +464,32 @@ export class BoundingBoxGizmo extends Gizmo {
                                 fullScale.x = Math.max(this._incrementalAnchorStartupValue.x * fullScale.x, this.scalingSnapDistance);
                                 fullScale.y = Math.max(this._incrementalAnchorStartupValue.y * fullScale.y, this.scalingSnapDistance);
                                 fullScale.z = Math.max(this._incrementalAnchorStartupValue.z * fullScale.z, this.scalingSnapDistance);
+                                if (this._isCenterScaleModeActive) {
+                                    fullScale.x = this._incrementalAnchorStartupValue.x + (fullScale.x - this._incrementalAnchorStartupValue.x) * 2;
+                                    fullScale.y = this._incrementalAnchorStartupValue.y + (fullScale.y - this._incrementalAnchorStartupValue.y) * 2;
+                                    fullScale.z = this._incrementalAnchorStartupValue.z + (fullScale.z - this._incrementalAnchorStartupValue.z) * 2;
+                                }
                                 this._anchorMesh.scaling.x += (fullScale.x - this._anchorMesh.scaling.x) * Math.abs(dragAxis.x);
                                 this._anchorMesh.scaling.y += (fullScale.y - this._anchorMesh.scaling.y) * Math.abs(dragAxis.y);
                                 this._anchorMesh.scaling.z += (fullScale.z - this._anchorMesh.scaling.z) * Math.abs(dragAxis.z);
                             }
                             else {
-                                this._anchorMesh.scaling.addInPlace(deltaScale);
-                                if (this._anchorMesh.scaling.x < 0 || this._anchorMesh.scaling.y < 0 || this._anchorMesh.scaling.z < 0) {
-                                    this._anchorMesh.scaling.subtractInPlace(deltaScale);
+                                // Compute absolute scale from total drag distance so modifier toggles mid-drag work retroactively
+                                const scaleMultiplier = this._isCenterScaleModeActive ? 2 : 1;
+                                const totalScale = totalRelativeDragDistance * this._scaleDragSpeed * scaleMultiplier;
+                                const newAnchorScale = this._incrementalAnchorStartupValue.clone();
+                                if (zeroAxisCount === 2) {
+                                    newAnchorScale.x += totalScale * Math.abs(dragAxis.x) * this._axisFactor.x;
+                                    newAnchorScale.y += totalScale * Math.abs(dragAxis.y) * this._axisFactor.y;
+                                    newAnchorScale.z += totalScale * Math.abs(dragAxis.z) * this._axisFactor.z;
+                                }
+                                else {
+                                    newAnchorScale.x += totalScale * this._axisFactor.x;
+                                    newAnchorScale.y += totalScale * this._axisFactor.y;
+                                    newAnchorScale.z += totalScale * this._axisFactor.z;
+                                }
+                                if (newAnchorScale.x > 0 && newAnchorScale.y > 0 && newAnchorScale.z > 0) {
+                                    this._anchorMesh.scaling.copyFrom(newAnchorScale);
                                 }
                             }
                             this._anchorMesh.removeChild(this.attachedMesh);
@@ -471,6 +507,9 @@ export class BoundingBoxGizmo extends Gizmo {
                         previousScale = 0;
                         this._incrementalStartupValue.copyFrom(this.attachedMesh.scaling);
                         this._incrementalAnchorStartupValue.copyFrom(this._anchorMesh.scaling);
+                        initialAnchorCenter.copyFrom(this._anchorMesh.position);
+                        initialBoxPosition.copyFrom(box.absolutePosition);
+                        initialMeshAbsolutePosition.copyFrom(this.attachedMesh.getAbsolutePosition());
                     });
                     scaleBoxesDragBehavior.onDragEndObservable.add((event) => {
                         this.onScaleBoxDragEndObservable.notifyObservers({ dragOperation: 1 /* DragOperation.Scaling */, dragAxis: new Vector3(i - 1, j - 1, k - 1) });
@@ -485,6 +524,15 @@ export class BoundingBoxGizmo extends Gizmo {
             }
         }
         this._rootMesh.addChild(this._scaleBoxesParent);
+        // Keyboard observer for center-scale mode (Ctrl on Windows, Opt/Alt on Mac)
+        this._centerScaleKeyObserver = gizmoLayer.originalScene.onKeyboardObservable.add(({ type, event }) => {
+            if (type === KeyboardEventTypes.KEYDOWN && (event.ctrlKey || event.altKey)) {
+                this._isCenterScaleModeActive = true;
+            }
+            else if (type === KeyboardEventTypes.KEYUP && !event.ctrlKey && !event.altKey) {
+                this._isCenterScaleModeActive = false;
+            }
+        });
         // Hover color change
         const pointerIds = [];
         this._pointerObserver = gizmoLayer.utilityLayerScene.onPointerObservable.add((pointerInfo) => {
@@ -781,6 +829,7 @@ export class BoundingBoxGizmo extends Gizmo {
     dispose() {
         this.gizmoLayer.utilityLayerScene.onPointerObservable.remove(this._pointerObserver);
         this.gizmoLayer.originalScene.onBeforeRenderObservable.remove(this._renderObserver);
+        this.gizmoLayer.originalScene.onKeyboardObservable.remove(this._centerScaleKeyObserver);
         this._lineBoundingBox.dispose();
         this._rotateAnchorsParent.dispose();
         this._scaleBoxesParent.dispose();