snapping refactoring + scale!

jme3-scenecomposer/src/com/jme3/gde/scenecomposer/SceneComposerToolController.java

@@ -5,6 +5,8 @@
 package com.jme3.gde.scenecomposer;
 
 import com.jme3.asset.AssetManager;
+import com.jme3.collision.CollisionResult;
+import com.jme3.collision.CollisionResults;
 import com.jme3.gde.core.scene.SceneApplication;
 import com.jme3.gde.core.scene.controller.SceneToolController;
 import com.jme3.gde.core.sceneexplorer.nodes.AbstractSceneExplorerNode;
@@ -12,7 +14,10 @@ import com.jme3.gde.core.sceneexplorer.nodes.JmeNode;
 import com.jme3.gde.scenecomposer.gizmo.GizmoFactory;
 import com.jme3.gde.scenecomposer.tools.shortcuts.ShortcutManager;
 import com.jme3.input.event.KeyInputEvent;
+import com.jme3.math.Quaternion;
+import com.jme3.math.Ray;
 import com.jme3.math.Vector2f;
+import com.jme3.math.Vector3f;
 import com.jme3.renderer.Camera;
 import com.jme3.renderer.RenderManager;
 import com.jme3.renderer.ViewPort;
@@ -384,5 +389,48 @@ public class SceneComposerToolController extends SceneToolController {
     public JmeNode getRootNode() {
         return rootNode;
     }
+    
+    
+    public void updateSelectedTranslation(Vector3f translation) {
+        if (isSnapToScene()) {
+            translation = snapToScene(translation);
+        }
+        if (isSnapToGrid()) {
+            translation.set(
+                    (int) translation.x,
+                    (int) translation.y,
+                    (int) translation.z);
+        }
+        selected.setLocalTranslation(translation);
+    }
+    
+    public void updateSelectedRotation(Quaternion rotation) {
+        selected.setLocalRotation(rotation);
+    }
+    
+    public void updateSelectedScale(Vector3f scale) {
+        if (isSnapToGrid()) {
+            scale.set(
+                    (int) Math.max(scale.x, 1),
+                    (int) Math.max(scale.y, 1),
+                    (int) Math.max(scale.z, 1));
+        }
+        selected.setLocalScale(scale);
+    }
+
+    private Vector3f snapToScene(final Vector3f position) {
+        final Ray ray = new Ray(position, Vector3f.UNIT_Y.negate());
+        final CollisionResults collisionResults = new CollisionResults();
+        final Node root = getRootNode().getLookup()
+                .lookup(Node.class);
+        root.collideWith(ray, collisionResults);
+        for (CollisionResult r : collisionResults) {
+            if (r.getGeometry() != selected) {
+                position.y = r.getContactPoint().y;
+                break;
+            }
+        }
+        return position;
+    }
 
 }

jme3-scenecomposer/src/com/jme3/gde/scenecomposer/tools/MoveTool.java

@@ -14,6 +14,7 @@ import com.jme3.gde.core.sceneexplorer.nodes.JmeSpatial;
 import com.jme3.gde.core.undoredo.AbstractUndoableSceneEdit;
 import com.jme3.gde.scenecomposer.SceneComposerToolController;
 import com.jme3.gde.scenecomposer.SceneEditTool;
+import com.jme3.math.Quaternion;
 import com.jme3.math.Ray;
 import com.jme3.math.Vector2f;
 import com.jme3.math.Vector3f;
@@ -144,18 +145,8 @@ public class MoveTool extends SceneEditTool {
             } else {
                 position = startPosition.add(diff);
             }
-
-            if (toolController.isSnapToScene()) {
-                position = snapToScene(position);
-            }
-            if (toolController.isSnapToGrid()) {
-                position.set(
-                        (int) position.x,
-                        (int) position.y,
-                        (int) position.z);
-            }
             lastPosition = position;
-            toolController.getSelectedSpatial().setLocalTranslation(position);
+            toolController.updateSelectedTranslation(position);
             updateToolsTransformation();
         }
     }
@@ -178,21 +169,6 @@ public class MoveTool extends SceneEditTool {
         }
     }
 
-    private Vector3f snapToScene(final Vector3f position) {
-        final Ray ray = new Ray(position, Vector3f.UNIT_Y.negate());
-        final CollisionResults collisionResults = new CollisionResults();
-        final Node root = toolController.getRootNode().getLookup()
-                .lookup(Node.class);
-        root.collideWith(ray, collisionResults);
-        for (CollisionResult r : collisionResults) {
-            if (r.getGeometry() != toolController.getSelectedSpatial()) {
-                position.y = r.getContactPoint().y;
-                break;
-            }
-        }
-        return position;
-    }
-
     protected class MoveUndo extends AbstractUndoableSceneEdit {
 
         private Spatial spatial;

jme3-scenecomposer/src/com/jme3/gde/scenecomposer/tools/RotateTool.java

@@ -1,163 +1,162 @@
-/*
- * To change this template, choose Tools | Templates
- * and open the template in the editor.
- */
-package com.jme3.gde.scenecomposer.tools;
-
-import com.jme3.asset.AssetManager;
-import com.jme3.gde.core.sceneexplorer.nodes.JmeNode;
-import com.jme3.gde.core.sceneexplorer.nodes.JmeSpatial;
-import com.jme3.gde.core.undoredo.AbstractUndoableSceneEdit;
-import com.jme3.gde.scenecomposer.SceneComposerToolController;
-import com.jme3.gde.scenecomposer.SceneEditTool;
-import com.jme3.math.Quaternion;
-import com.jme3.math.Vector2f;
-import com.jme3.math.Vector3f;
-import com.jme3.scene.Node;
-import com.jme3.scene.Spatial;
-import org.openide.loaders.DataObject;
-import org.openide.util.Lookup;
-
-/**
- *
- * @author kbender
- */
-public class RotateTool extends SceneEditTool {
-
-    private Vector3f pickedMarker;
-    private Quaternion startRotate;
-    private Quaternion startWorldRotate;
-    private Quaternion lastRotate;
-    private boolean wasDragging = false;
-    private PickManager pickManager;
-
-    public RotateTool() {
-        axisPickType = SceneEditTool.AxisMarkerPickType.planeOnly;
-        setOverrideCameraControl(true);
-    }
-
-    @Override
-    public void activate(AssetManager manager, Node toolNode, Node onTopToolNode, Spatial selectedSpatial, SceneComposerToolController toolController) {
-        super.activate(manager, toolNode, onTopToolNode, selectedSpatial, toolController);
-        pickManager = Lookup.getDefault().lookup(PickManager.class);
-        displayCircles();
-    }
-
-    @Override
-    public void actionPrimary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject dataObject) {
-        if (!pressed) {
-            setDefaultAxisMarkerColors();
-            pickedMarker = null; // mouse released, reset selection
-            if (wasDragging) {
-                actionPerformed(new RotateUndo(toolController.getSelectedSpatial(), startRotate, lastRotate));
-                wasDragging = false;
-            }
-            pickManager.reset();
-        } else {
-            if (toolController.getSelectedSpatial() == null) {
-                return;
-            }
-
-            if (pickedMarker == null) {
-                pickedMarker = pickAxisMarker(camera, screenCoord, axisPickType);
-                if (pickedMarker == null) {
-                    return;
-                }
-
-                if (pickedMarker.equals(QUAD_XY)) {
-                    pickManager.initiatePick(toolController.getSelectedSpatial(), PickManager.PLANE_XY, getTransformType(), camera, screenCoord);
-                } else if (pickedMarker.equals(QUAD_XZ)) {
-                    pickManager.initiatePick(toolController.getSelectedSpatial(), PickManager.PLANE_XZ, getTransformType(), camera, screenCoord);
-                } else if (pickedMarker.equals(QUAD_YZ)) {
-                    pickManager.initiatePick(toolController.getSelectedSpatial(), PickManager.PLANE_YZ, getTransformType(), camera, screenCoord);
-                }
-                startRotate = toolController.getSelectedSpatial().getLocalRotation().clone();
-                startWorldRotate = toolController.getSelectedSpatial().getWorldRotation().clone();
-                wasDragging = true;
-            }
-        }
-    }
-
-    @Override
-    public void actionSecondary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject dataObject) {
-        if (pressed) {
-            cancel();
-        }
-    }
-
-    @Override
-    public void mouseMoved(Vector2f screenCoord, JmeNode rootNode, DataObject currentDataObject) {
-        if (pickedMarker == null) {
-            highlightAxisMarker(camera, screenCoord, axisPickType);
-        } else {
-            pickedMarker = null;
-            pickManager.reset();
-        }
-    }
-
-    @Override
-    public void draggedPrimary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject currentDataObject) {
-        if (!pressed) {
-            setDefaultAxisMarkerColors();
-            pickedMarker = null; // mouse released, reset selection
-
-            if (wasDragging) {
-                actionPerformed(new RotateUndo(toolController.getSelectedSpatial(), startRotate, lastRotate));
-                wasDragging = false;
-            }
-            pickManager.reset();
-        } else if (wasDragging) {
-            if (!pickManager.updatePick(camera, screenCoord)) {
-                return;
-            }
-
-            if (pickedMarker.equals(QUAD_XY) || pickedMarker.equals(QUAD_XZ) || pickedMarker.equals(QUAD_YZ)) {
-                Quaternion rotation = startRotate.mult(pickManager.getRotation(startWorldRotate.inverse()));
-                toolController.getSelectedSpatial().setLocalRotation(rotation);
-                lastRotate = rotation;
-            }
-            updateToolsTransformation();
-        }
-    }
-
-    @Override
-    public void draggedSecondary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject currentDataObject) {
-        if (pressed) {
-            cancel();
-        }
-    }
-
-    private void cancel() {
-        if (wasDragging) {
-            wasDragging = false;
-            toolController.getSelectedSpatial().setLocalRotation(startRotate);
-            setDefaultAxisMarkerColors();
-            pickedMarker = null; // mouse released, reset selection
-            pickManager.reset();
-        }
-    }
-
-    private class RotateUndo extends AbstractUndoableSceneEdit {
-
-        private Spatial spatial;
-        private Quaternion before, after;
-
-        RotateUndo(Spatial spatial, Quaternion before, Quaternion after) {
-            this.spatial = spatial;
-            this.before = before;
-            this.after = after;
-        }
-
-        @Override
-        public void sceneUndo() {
-            spatial.setLocalRotation(before);
-            toolController.selectedSpatialTransformed();
-        }
-
-        @Override
-        public void sceneRedo() {
-            spatial.setLocalRotation(after);
-            toolController.selectedSpatialTransformed();
-        }
-    }
-}
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.jme3.gde.scenecomposer.tools;
+
+import com.jme3.asset.AssetManager;
+import com.jme3.gde.core.sceneexplorer.nodes.JmeNode;
+import com.jme3.gde.core.undoredo.AbstractUndoableSceneEdit;
+import com.jme3.gde.scenecomposer.SceneComposerToolController;
+import com.jme3.gde.scenecomposer.SceneEditTool;
+import com.jme3.math.Quaternion;
+import com.jme3.math.Vector2f;
+import com.jme3.math.Vector3f;
+import com.jme3.scene.Node;
+import com.jme3.scene.Spatial;
+import org.openide.loaders.DataObject;
+import org.openide.util.Lookup;
+
+/**
+ *
+ * @author kbender
+ */
+public class RotateTool extends SceneEditTool {
+
+    private Vector3f pickedMarker;
+    private Quaternion startRotate;
+    private Quaternion startWorldRotate;
+    private Quaternion lastRotate;
+    private boolean wasDragging = false;
+    private PickManager pickManager;
+
+    public RotateTool() {
+        axisPickType = SceneEditTool.AxisMarkerPickType.planeOnly;
+        setOverrideCameraControl(true);
+    }
+
+    @Override
+    public void activate(AssetManager manager, Node toolNode, Node onTopToolNode, Spatial selectedSpatial, SceneComposerToolController toolController) {
+        super.activate(manager, toolNode, onTopToolNode, selectedSpatial, toolController);
+        pickManager = Lookup.getDefault().lookup(PickManager.class);
+        displayCircles();
+    }
+
+    @Override
+    public void actionPrimary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject dataObject) {
+        if (!pressed) {
+            setDefaultAxisMarkerColors();
+            pickedMarker = null; // mouse released, reset selection
+            if (wasDragging) {
+                actionPerformed(new RotateUndo(toolController.getSelectedSpatial(), startRotate, lastRotate));
+                wasDragging = false;
+            }
+            pickManager.reset();
+        } else {
+            if (toolController.getSelectedSpatial() == null) {
+                return;
+            }
+
+            if (pickedMarker == null) {
+                pickedMarker = pickAxisMarker(camera, screenCoord, axisPickType);
+                if (pickedMarker == null) {
+                    return;
+                }
+
+                if (pickedMarker.equals(QUAD_XY)) {
+                    pickManager.initiatePick(toolController.getSelectedSpatial(), PickManager.PLANE_XY, getTransformType(), camera, screenCoord);
+                } else if (pickedMarker.equals(QUAD_XZ)) {
+                    pickManager.initiatePick(toolController.getSelectedSpatial(), PickManager.PLANE_XZ, getTransformType(), camera, screenCoord);
+                } else if (pickedMarker.equals(QUAD_YZ)) {
+                    pickManager.initiatePick(toolController.getSelectedSpatial(), PickManager.PLANE_YZ, getTransformType(), camera, screenCoord);
+                }
+                startRotate = toolController.getSelectedSpatial().getLocalRotation().clone();
+                startWorldRotate = toolController.getSelectedSpatial().getWorldRotation().clone();
+                wasDragging = true;
+            }
+        }
+    }
+
+    @Override
+    public void actionSecondary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject dataObject) {
+        if (pressed) {
+            cancel();
+        }
+    }
+
+    @Override
+    public void mouseMoved(Vector2f screenCoord, JmeNode rootNode, DataObject currentDataObject) {
+        if (pickedMarker == null) {
+            highlightAxisMarker(camera, screenCoord, axisPickType);
+        } else {
+            pickedMarker = null;
+            pickManager.reset();
+        }
+    }
+
+    @Override
+    public void draggedPrimary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject currentDataObject) {
+        if (!pressed) {
+            setDefaultAxisMarkerColors();
+            pickedMarker = null; // mouse released, reset selection
+
+            if (wasDragging) {
+                actionPerformed(new RotateUndo(toolController.getSelectedSpatial(), startRotate, lastRotate));
+                wasDragging = false;
+            }
+            pickManager.reset();
+        } else if (wasDragging) {
+            if (!pickManager.updatePick(camera, screenCoord)) {
+                return;
+            }
+
+            if (pickedMarker.equals(QUAD_XY) || pickedMarker.equals(QUAD_XZ) || pickedMarker.equals(QUAD_YZ)) {
+                Quaternion rotation = startRotate.mult(pickManager.getRotation(startWorldRotate.inverse()));
+                toolController.updateSelectedRotation(rotation);
+                lastRotate = rotation;
+            }
+            updateToolsTransformation();
+        }
+    }
+
+    @Override
+    public void draggedSecondary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject currentDataObject) {
+        if (pressed) {
+            cancel();
+        }
+    }
+
+    private void cancel() {
+        if (wasDragging) {
+            wasDragging = false;
+            toolController.getSelectedSpatial().setLocalRotation(startRotate);
+            setDefaultAxisMarkerColors();
+            pickedMarker = null; // mouse released, reset selection
+            pickManager.reset();
+        }
+    }
+
+    private class RotateUndo extends AbstractUndoableSceneEdit {
+
+        private Spatial spatial;
+        private Quaternion before, after;
+
+        RotateUndo(Spatial spatial, Quaternion before, Quaternion after) {
+            this.spatial = spatial;
+            this.before = before;
+            this.after = after;
+        }
+
+        @Override
+        public void sceneUndo() {
+            spatial.setLocalRotation(before);
+            toolController.selectedSpatialTransformed();
+        }
+
+        @Override
+        public void sceneRedo() {
+            spatial.setLocalRotation(after);
+            toolController.selectedSpatialTransformed();
+        }
+    }
+}

jme3-scenecomposer/src/com/jme3/gde/scenecomposer/tools/ScaleTool.java

@@ -6,7 +6,6 @@ package com.jme3.gde.scenecomposer.tools;
 
 import com.jme3.asset.AssetManager;
 import com.jme3.gde.core.sceneexplorer.nodes.JmeNode;
-import com.jme3.gde.core.sceneexplorer.nodes.JmeSpatial;
 import com.jme3.gde.core.undoredo.AbstractUndoableSceneEdit;
 import com.jme3.gde.scenecomposer.SceneComposerToolController;
 import com.jme3.gde.scenecomposer.SceneEditTool;
@@ -122,15 +121,15 @@ public class ScaleTool extends SceneEditTool {
                 diff += 1f;
                 Vector3f scale = startScale.mult(diff);
                 lastScale = scale;
-                toolController.getSelectedSpatial().setLocalScale(scale);
+                toolController.updateSelectedScale(scale);
             } else if (pickedMarker.equals(ARROW_X) || pickedMarker.equals(ARROW_Y) || pickedMarker.equals(ARROW_Z)) {
                 // Get the translation in the spatial Space
                 Quaternion worldToSpatial = toolController.getSelectedSpatial().getWorldRotation().inverse();
                 Vector3f diff = worldToSpatial.mult(pickManager.getTranslation(constraintAxis));
                 diff.multLocal(0.5f);
                 Vector3f scale = startScale.add(diff);
+                toolController.updateSelectedScale(scale);
                 lastScale = scale;
-                toolController.getSelectedSpatial().setLocalScale(scale);
             }
             updateToolsTransformation();
         }