|
|
@@ -6,77 +6,794 @@ package com.jme3.gde.scenecomposer.tools;
|
|
|
|
|
|
import com.jme3.gde.core.sceneexplorer.SceneExplorerTopComponent;
|
|
|
import com.jme3.gde.core.sceneexplorer.nodes.JmeNode;
|
|
|
+import com.jme3.gde.core.sceneexplorer.nodes.JmeSpatial;
|
|
|
import com.jme3.gde.core.sceneviewer.SceneViewerTopComponent;
|
|
|
+import com.jme3.gde.core.undoredo.AbstractUndoableSceneEdit;
|
|
|
import com.jme3.gde.scenecomposer.SceneEditTool;
|
|
|
+import com.jme3.input.KeyInput;
|
|
|
+import com.jme3.input.event.KeyInputEvent;
|
|
|
+import com.jme3.math.FastMath;
|
|
|
+import com.jme3.math.Matrix3f;
|
|
|
+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 com.jme3.terrain.Terrain;
|
|
|
+import java.util.logging.Level;
|
|
|
+import java.util.logging.Logger;
|
|
|
import org.openide.loaders.DataObject;
|
|
|
|
|
|
/**
|
|
|
- *
|
|
|
+ * This duplicates the Blender manipulate tool.
|
|
|
+ * It supports quick access to Grab, Rotate, and Scale operations
|
|
|
+ * by typing one of the following keys: 'g', 'r', or 's'
|
|
|
+ * Those keys can be followed by an axis key to specify what axis
|
|
|
+ * to perform the transformation: x, y, z
|
|
|
+ * Then, after the operation and axis are selected, you can type in a
|
|
|
+ * number and then hit 'enter' to complete the transformation.
|
|
|
+ *
|
|
|
+ * Ctrl+Shift+D will duplicate an object
|
|
|
+ * X will delete an object
|
|
|
+ *
|
|
|
+ * ITEMS TO FINISH:
|
|
|
+ * 1) fixed scale and rotation values by holding Ctrl and dragging mouse
|
|
|
+ * BUGS:
|
|
|
+ * 1) window always needs focus from primary click when it should focus from secondary and middle mouse
|
|
|
+ * 2) ESC will not reset currentState (ESC get hijacked)
|
|
|
+ * 3) rotation towards screen is busted (wrong axis)
|
|
|
+ *
|
|
|
* @author Brent Owens
|
|
|
*/
|
|
|
public class SelectTool extends SceneEditTool {
|
|
|
|
|
|
protected Spatial selected;
|
|
|
- private boolean wasDragging = false;
|
|
|
+
|
|
|
+ private enum State {translate, rotate, scale};
|
|
|
+ private State currentState = null;
|
|
|
+
|
|
|
+ private enum Axis {x, y, z};
|
|
|
+ private Axis currentAxis = null;
|
|
|
+
|
|
|
+ private StringBuilder numberBuilder = new StringBuilder(); // gets appended with numbers
|
|
|
+
|
|
|
+ private Quaternion startRot;
|
|
|
+ private Vector3f startTrans;
|
|
|
+ private Vector3f startScale;
|
|
|
+
|
|
|
+ private boolean wasDraggingL = false;
|
|
|
+ private boolean wasDraggingR = false;
|
|
|
+ private boolean wasDownR = false;
|
|
|
+ private boolean ctrlDown = false;
|
|
|
+ private boolean shiftDown = false;
|
|
|
+ private boolean altDown = false;
|
|
|
+
|
|
|
+ private MoveUndo moving;
|
|
|
+ private ScaleUndo scaling;
|
|
|
+ private RotateUndo rotating;
|
|
|
+ private Vector2f startMouseCoord; // for scaling and rotation
|
|
|
+ private Vector2f startSelectedCoord; // for scaling and rotation
|
|
|
+ private float lastRotAngle; // used for rotation
|
|
|
|
|
|
+ /**
|
|
|
+ * This is stateful:
|
|
|
+ * First it checks for a command (rotate, translate, delete, etc..)
|
|
|
+ * Then it checks for an axis (x,y,z)
|
|
|
+ * Then it checks for a number (user typed a number
|
|
|
+ * Then, finally, it checks if Enter was hit.
|
|
|
+ *
|
|
|
+ * If either of the commands was actioned, the preceeding states/axis/amount
|
|
|
+ * will be reset. For example if the user types: G Y 2 R
|
|
|
+ * Then it will:
|
|
|
+ * 1) Set state as 'Translate' for the G (grab)
|
|
|
+ * 2) Set the axis as 'Y'; it will translate along the Y axis
|
|
|
+ * 3) Distance will be 2, when the 2 key is hit
|
|
|
+ * 4) Distance, Axis, and state are then reset because a new state was set: Rotate
|
|
|
+ * it won't actually translate because 'Enter' was not hit and 'R' reset the state.
|
|
|
+ *
|
|
|
+ */
|
|
|
+ @Override
|
|
|
+ public void keyPressed(KeyInputEvent kie) {
|
|
|
+
|
|
|
+ checkModificatorKeys(kie); // alt,shift,ctrl
|
|
|
+
|
|
|
+ if (selected == null)
|
|
|
+ return; // only do anything if a spatial is selected
|
|
|
+
|
|
|
+ // key released
|
|
|
+ if (kie.isReleased()) {
|
|
|
+ boolean commandUsed = checkCommandKey(kie);
|
|
|
+ boolean stateChange = checkStateKey(kie);
|
|
|
+ boolean axisChange = checkAxisKey(kie);
|
|
|
+ boolean numberChange = checkNumberKey(kie);
|
|
|
+ boolean enterHit = checkEnterHit(kie);
|
|
|
+ boolean escHit = checkEscHit(kie);
|
|
|
+
|
|
|
+ if (commandUsed)
|
|
|
+ return; // commands take priority
|
|
|
+
|
|
|
+ if (stateChange) {
|
|
|
+ currentAxis = null;
|
|
|
+ numberBuilder = new StringBuilder();
|
|
|
+ recordInitialState(selected);
|
|
|
+ }
|
|
|
+ else if (axisChange) {}
|
|
|
+ else if (numberChange) {}
|
|
|
+ else if (enterHit) {
|
|
|
+ if (currentState != null && numberBuilder.length() > 0) {
|
|
|
+ applyKeyedChangeState(selected);
|
|
|
+ clearState(false);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ // -----------------------
|
|
|
+ // reset conditions below:
|
|
|
+
|
|
|
+ if (escHit) {
|
|
|
+ if (moving != null)
|
|
|
+ moving.sceneUndo();
|
|
|
+
|
|
|
+ moving = null;
|
|
|
+ clearState();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!stateChange && !axisChange && !numberChange && !enterHit && !escHit) {
|
|
|
+ // nothing valid was hit, reset the state
|
|
|
+ //clearState(); // this will be
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Abort any manipulations
|
|
|
+ */
|
|
|
+ private void clearState() {
|
|
|
+ clearState(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ private void clearState(boolean resetSelected) {
|
|
|
+ if (resetSelected && selected != null) {
|
|
|
+ // reset the transforms
|
|
|
+ if (startRot != null)
|
|
|
+ selected.setLocalRotation(startRot);
|
|
|
+ if (startTrans != null)
|
|
|
+ selected.setLocalTranslation(startTrans);
|
|
|
+ if (startScale != null)
|
|
|
+ selected.setLocalScale(startScale);
|
|
|
+ }
|
|
|
+ currentState = null;
|
|
|
+ currentAxis = null;
|
|
|
+ numberBuilder = new StringBuilder();
|
|
|
+ startRot = null;
|
|
|
+ startTrans = null;
|
|
|
+ startScale = null;
|
|
|
+ startMouseCoord = null;
|
|
|
+ startSelectedCoord = null;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ private void recordInitialState(Spatial selected) {
|
|
|
+ startRot = selected.getLocalRotation().clone();
|
|
|
+ startTrans = selected.getLocalTranslation().clone();
|
|
|
+ startScale = selected.getLocalScale().clone();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Applies the changes entered by a number, not by mouse.
|
|
|
+ * Translate: adds the value to the current local translation
|
|
|
+ * Rotate: rotates by X degrees
|
|
|
+ * Scale: scale the current scale by X amount
|
|
|
+ */
|
|
|
+ private void applyKeyedChangeState(Spatial selected) {
|
|
|
+ Float value = null;
|
|
|
+ try {
|
|
|
+ value = new Float(numberBuilder.toString());
|
|
|
+ } catch (NumberFormatException e){
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (currentState == State.translate) {
|
|
|
+ float x = 0, y= 0, z = 0;
|
|
|
+ if (currentAxis == Axis.x)
|
|
|
+ x = value;
|
|
|
+ else if (currentAxis == Axis.y)
|
|
|
+ y = value;
|
|
|
+ else if (currentAxis == Axis.z)
|
|
|
+ z = value;
|
|
|
+ Vector3f before = selected.getLocalTranslation().clone();
|
|
|
+ Vector3f after = selected.getLocalTranslation().addLocal(x, y, z);
|
|
|
+ selected.setLocalTranslation(after);
|
|
|
+ actionPerformed(new MoveUndo(selected, before, after));
|
|
|
+ } else if (currentState == State.scale) {
|
|
|
+ float x = 1, y= 1, z = 1;
|
|
|
+ if (currentAxis == Axis.x)
|
|
|
+ x = value;
|
|
|
+ else if (currentAxis == Axis.y)
|
|
|
+ y = value;
|
|
|
+ else if (currentAxis == Axis.z)
|
|
|
+ z = value;
|
|
|
+ else if (currentAxis == null) {
|
|
|
+ x = value;
|
|
|
+ y = value;
|
|
|
+ z = value;
|
|
|
+ }
|
|
|
+ Vector3f before = selected.getLocalScale().clone();
|
|
|
+ Vector3f after = selected.getLocalScale().multLocal(x, y, z);
|
|
|
+ selected.setLocalScale(after);
|
|
|
+ actionPerformed(new ScaleUndo(selected, before, after));
|
|
|
+ } else if (currentState == State.rotate) {
|
|
|
+ float x = 0, y= 0, z = 0;
|
|
|
+ if (currentAxis == Axis.x)
|
|
|
+ x = 1;
|
|
|
+ else if (currentAxis == Axis.y)
|
|
|
+ y = 1;
|
|
|
+ else if (currentAxis == Axis.z)
|
|
|
+ z = 1;
|
|
|
+ Vector3f axis = new Vector3f(x,y,z);
|
|
|
+ Quaternion initialRot = selected.getLocalRotation().clone();
|
|
|
+ Quaternion rot = new Quaternion();
|
|
|
+ rot = rot.fromAngleAxis(value*FastMath.DEG_TO_RAD, axis);
|
|
|
+ selected.setLocalRotation(selected.getLocalRotation().mult(rot));
|
|
|
+ RotateUndo undo = new RotateUndo(selected, initialRot, rot);
|
|
|
+ actionPerformed(undo);
|
|
|
+ toolController.updateSelection(null);// force a re-draw of the bbox shape
|
|
|
+ toolController.updateSelection(selected);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void checkModificatorKeys(KeyInputEvent kie) {
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_LCONTROL || kie.getKeyCode() == KeyInput.KEY_RCONTROL)
|
|
|
+ ctrlDown = kie.isPressed();
|
|
|
+
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_LSHIFT || kie.getKeyCode() == KeyInput.KEY_RSHIFT)
|
|
|
+ shiftDown = kie.isPressed();
|
|
|
+
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_LMENU || kie.getKeyCode() == KeyInput.KEY_RMENU)
|
|
|
+ altDown = kie.isPressed();
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean checkCommandKey(KeyInputEvent kie) {
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_D) {
|
|
|
+ if (ctrlDown && shiftDown) {
|
|
|
+ duplicateSelected();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // X will only delete if the user isn't already transforming
|
|
|
+ if (currentState == null && kie.getKeyCode() == KeyInput.KEY_X) {
|
|
|
+ if (!ctrlDown && !shiftDown) {
|
|
|
+ deleteSelected();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean checkStateKey(KeyInputEvent kie) {
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_G) {
|
|
|
+ currentState = State.translate;
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_R) {
|
|
|
+ currentState = State.rotate;
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_S) {
|
|
|
+ currentState = State.scale;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean checkAxisKey(KeyInputEvent kie) {
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_X) {
|
|
|
+ currentAxis = Axis.x;
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_Y) {
|
|
|
+ currentAxis = Axis.y;
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_Z) {
|
|
|
+ currentAxis = Axis.z;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean checkNumberKey(KeyInputEvent kie) {
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_MINUS) {
|
|
|
+ if (numberBuilder.length() > 0) {
|
|
|
+ if (numberBuilder.charAt(0) == '-') {
|
|
|
+ numberBuilder.replace(0, 1, "");
|
|
|
+ } else {
|
|
|
+ numberBuilder.insert(0, '-');
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ numberBuilder.append('-');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_0) {
|
|
|
+ numberBuilder.append('0');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_1) {
|
|
|
+ numberBuilder.append('1');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_2) {
|
|
|
+ numberBuilder.append('2');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_3) {
|
|
|
+ numberBuilder.append('3');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_4) {
|
|
|
+ numberBuilder.append('4');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_5) {
|
|
|
+ numberBuilder.append('5');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_6) {
|
|
|
+ numberBuilder.append('6');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_7) {
|
|
|
+ numberBuilder.append('7');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_8) {
|
|
|
+ numberBuilder.append('8');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_9) {
|
|
|
+ numberBuilder.append('9');
|
|
|
+ return true;
|
|
|
+ } else if (kie.getKeyCode() == KeyInput.KEY_PERIOD) {
|
|
|
+ if (numberBuilder.indexOf(".") == -1){ // if it doesn't exist yet
|
|
|
+ if (numberBuilder.length() == 0 ||
|
|
|
+ (numberBuilder.length() == 1 && numberBuilder.charAt(0) == '-'))
|
|
|
+ numberBuilder.append("0.");
|
|
|
+ else
|
|
|
+ numberBuilder.append(".");
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean checkEnterHit(KeyInputEvent kie) {
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_RETURN) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean checkEscHit(KeyInputEvent kie) {
|
|
|
+ if (kie.getKeyCode() == KeyInput.KEY_ESCAPE) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
@Override
|
|
|
public void actionPrimary(Vector2f screenCoord, boolean pressed, final JmeNode rootNode, DataObject dataObject) {
|
|
|
- if (!pressed && !wasDragging) {
|
|
|
- // mouse released and wasn't dragging, select a new spatial
|
|
|
- final Spatial result = pickWorldSpatial(getCamera(), screenCoord, rootNode);
|
|
|
-
|
|
|
- java.awt.EventQueue.invokeLater(new Runnable() {
|
|
|
-
|
|
|
- public void run() {
|
|
|
+ if (!pressed) {
|
|
|
+ // left mouse released
|
|
|
+ if (!wasDraggingL) {
|
|
|
+ // left mouse pressed
|
|
|
+ if (currentState != null) {
|
|
|
+ // finish manipulating the spatial
|
|
|
+ if (moving != null) {
|
|
|
+ moving.after = selected.getLocalTranslation().clone();
|
|
|
+ actionPerformed(moving);
|
|
|
+ moving = null;
|
|
|
+ clearState(false);
|
|
|
+ } else if (scaling != null) {
|
|
|
+ scaling.after = selected.getLocalScale().clone();
|
|
|
+ actionPerformed(scaling);
|
|
|
+ scaling = null;
|
|
|
+ clearState(false);
|
|
|
+ } else if (rotating != null) {
|
|
|
+ rotating.after = selected.getLocalRotation().clone();
|
|
|
+ actionPerformed(rotating);
|
|
|
+ rotating = null;
|
|
|
+ clearState(false);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // mouse released and wasn't dragging, place cursor
|
|
|
+ final Vector3f result = pickWorldLocation(getCamera(), screenCoord, rootNode);
|
|
|
if (result != null) {
|
|
|
-// System.out.println(rootNode.getChild(result).getName());
|
|
|
- SceneViewerTopComponent.findInstance().setActivatedNodes(new org.openide.nodes.Node[]{rootNode.getChild(result)});
|
|
|
- SceneExplorerTopComponent.findInstance().setSelectedNode(rootNode.getChild(result));
|
|
|
-
|
|
|
- } else {
|
|
|
- SceneViewerTopComponent.findInstance().setActivatedNodes(new org.openide.nodes.Node[]{rootNode});
|
|
|
- SceneExplorerTopComponent.findInstance().setSelectedNode(rootNode);
|
|
|
+ if (toolController.isSnapToGrid())
|
|
|
+ result.set(Math.round(result.x), result.y, Math.round(result.z));
|
|
|
+ toolController.doSetCursorLocation(result);
|
|
|
}
|
|
|
}
|
|
|
- });
|
|
|
-
|
|
|
- if (result != null) {
|
|
|
- updateToolsTransformation();
|
|
|
}
|
|
|
- }
|
|
|
-
|
|
|
- if (!pressed) {
|
|
|
- wasDragging = false;
|
|
|
+ wasDraggingL = false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void actionSecondary(final Vector2f screenCoord, boolean pressed, final JmeNode rootNode, DataObject dataObject) {
|
|
|
- if (!pressed && !wasDragging) {
|
|
|
- final Vector3f result = pickWorldLocation(getCamera(), screenCoord, rootNode);
|
|
|
- if (result != null) {
|
|
|
- toolController.doSetCursorLocation(result);
|
|
|
+ if (pressed) {
|
|
|
+ // mouse down
|
|
|
+
|
|
|
+ if (!wasDraggingR && !wasDownR) { // wasn't dragging and was not down already
|
|
|
+ // pick on the spot
|
|
|
+ Spatial s = pickWorldSpatial(camera, screenCoord, rootNode);
|
|
|
+ if (!toolController.selectTerrain() && isTerrain(s) ) {
|
|
|
+ // only select non-terrain
|
|
|
+ selected = null;
|
|
|
+ return;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // climb up and find the Model Node (parent) and select that, don't select the geom
|
|
|
+ Spatial linkNodeParent = findModelNodeParent(s);
|
|
|
+ if (linkNodeParent != null)
|
|
|
+ s = linkNodeParent;
|
|
|
+ else
|
|
|
+ return;
|
|
|
+ final Spatial selec = s;
|
|
|
+ selected = selec;
|
|
|
+ java.awt.EventQueue.invokeLater(new Runnable() {
|
|
|
+ @Override
|
|
|
+ public void run() {
|
|
|
+ if (selec != null) {
|
|
|
+ SceneViewerTopComponent.findInstance().setActivatedNodes(new org.openide.nodes.Node[]{rootNode.getChild(selec)});
|
|
|
+ SceneExplorerTopComponent.findInstance().setSelectedNode(rootNode.getChild(selec));
|
|
|
+ } else {
|
|
|
+ SceneViewerTopComponent.findInstance().setActivatedNodes(new org.openide.nodes.Node[]{rootNode});
|
|
|
+ SceneExplorerTopComponent.findInstance().setSelectedNode(rootNode);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ toolController.updateSelection(selected);
|
|
|
}
|
|
|
- }
|
|
|
- if (!pressed) {
|
|
|
- wasDragging = false;
|
|
|
+ wasDownR = true;
|
|
|
+ } else {
|
|
|
+ // mouse up, stop everything
|
|
|
+ wasDownR = false;
|
|
|
+ wasDraggingR = false;
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Climb up the spatial until we find the first node parent.
|
|
|
+ * TODO: use userData to determine the actual model's parent.
|
|
|
+ */
|
|
|
+ private Spatial findModelNodeParent(Spatial child) {
|
|
|
+ if (child instanceof Node)
|
|
|
+ return child;
|
|
|
+
|
|
|
+ if (child.getParent() != null)
|
|
|
+ return findModelNodeParent(child.getParent());
|
|
|
+
|
|
|
+ return null;
|
|
|
+ }
|
|
|
|
|
|
@Override
|
|
|
- public void mouseMoved(Vector2f screenCoord) {
|
|
|
+ public void mouseMoved(Vector2f screenCoord, JmeNode rootNode, DataObject currentDataObject, JmeSpatial selectedSpatial) {
|
|
|
+ if (currentState != null) {
|
|
|
+ //if (currentAxis != null) {
|
|
|
+ // manipulate from specific axis
|
|
|
+ handleMouseManipulate(screenCoord, currentState, currentAxis, rootNode, currentDataObject, selectedSpatial);
|
|
|
+ //} else {
|
|
|
+ // manipulate from screen coordinates
|
|
|
+ //}
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void draggedPrimary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject currentDataObject) {
|
|
|
- wasDragging = pressed;
|
|
|
+ wasDraggingL = pressed;
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void draggedSecondary(Vector2f screenCoord, boolean pressed, JmeNode rootNode, DataObject currentDataObject) {
|
|
|
- wasDragging = pressed;
|
|
|
+ wasDraggingR = pressed;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Manipulate the spatial
|
|
|
+ */
|
|
|
+ private void handleMouseManipulate( Vector2f screenCoord,
|
|
|
+ State state,
|
|
|
+ Axis axis,
|
|
|
+ JmeNode rootNode,
|
|
|
+ DataObject currentDataObject,
|
|
|
+ JmeSpatial selectedSpatial)
|
|
|
+ {
|
|
|
+ if (state == State.translate) {
|
|
|
+ doMouseTranslate(axis, screenCoord, rootNode, selectedSpatial);
|
|
|
+ }
|
|
|
+ else if (state == State.scale) {
|
|
|
+ doMouseScale(axis, screenCoord, rootNode, selectedSpatial);
|
|
|
+ }
|
|
|
+ else if (state == State.rotate) {
|
|
|
+ doMouseRotate(axis, screenCoord, rootNode, selectedSpatial);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ private void doMouseTranslate(Axis axis, Vector2f screenCoord, JmeNode rootNode, JmeSpatial selectedSpatial) {
|
|
|
+ // free form translation
|
|
|
+ if (axis == null) {
|
|
|
+ if (toolController.isSnapToScene()) {
|
|
|
+ if (moving == null)
|
|
|
+ moving = new MoveUndo(selected, selected.getLocalTranslation().clone(), null);
|
|
|
+ Vector3f loc = pickWorldLocation(camera, screenCoord, rootNode, selectedSpatial);
|
|
|
+ if (loc != null) {
|
|
|
+ //Node sel = selectedSpatial.getLookup().lookup(Node.class);
|
|
|
+ if (toolController.isSnapToGrid()) {
|
|
|
+ selected.setLocalTranslation(loc.set(Math.round(loc.x), loc.y, Math.round(loc.z)));
|
|
|
+ } else {
|
|
|
+ selected.setLocalTranslation(loc);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ //TODO drag alone a camera-oriented axis
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ //snap to specific axis, ignoring snapToScene
|
|
|
+ if (moving == null)
|
|
|
+ moving = new MoveUndo(selected, selected.getLocalTranslation().clone(), null);
|
|
|
+ Vector3f loc = pickWorldLocation(camera, screenCoord, rootNode, selectedSpatial);
|
|
|
+ if (loc != null) {
|
|
|
+ if (toolController.isSnapToGrid())
|
|
|
+ loc.set(Math.round(loc.x), Math.round(loc.y), Math.round(loc.z)); // round the values
|
|
|
+
|
|
|
+ //Node sel = selectedSpatial.getLookup().lookup(Node.class);
|
|
|
+ Vector3f prev = selected.getLocalTranslation().clone();
|
|
|
+ Vector3f newLoc = new Vector3f(prev);
|
|
|
+ if (axis == Axis.x)
|
|
|
+ newLoc.x = loc.x;
|
|
|
+ else if (axis == Axis.y)
|
|
|
+ newLoc.y = loc.y;
|
|
|
+ if (axis == Axis.z)
|
|
|
+ newLoc.z = loc.z;
|
|
|
+
|
|
|
+ selected.setLocalTranslation(newLoc);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void doMouseScale(Axis axis, Vector2f screenCoord, JmeNode rootNode, JmeSpatial selectedSpatial) {
|
|
|
+ // scale based on the original mouse position and original model-to-screen position
|
|
|
+ // and compare that to the distance from the new mouse position and the original distance
|
|
|
+ if (startMouseCoord == null)
|
|
|
+ startMouseCoord = screenCoord.clone();
|
|
|
+ if (startSelectedCoord == null) {
|
|
|
+ Vector3f screen = getCamera().getScreenCoordinates(selected.getWorldTranslation());
|
|
|
+ startSelectedCoord = new Vector2f(screen.x, screen.y);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (scaling == null)
|
|
|
+ scaling = new ScaleUndo(selected, selected.getLocalScale().clone(), null);
|
|
|
+
|
|
|
+ float origDist = startMouseCoord.distanceSquared(startSelectedCoord);
|
|
|
+ float newDist = screenCoord.distanceSquared(startSelectedCoord);
|
|
|
+ if (origDist == 0)
|
|
|
+ origDist = 1;
|
|
|
+ float ratio = newDist/origDist;
|
|
|
+ Vector3f prev = selected.getLocalScale();
|
|
|
+ if (axis == Axis.x)
|
|
|
+ selected.setLocalScale(ratio, prev.y, prev.z);
|
|
|
+ else if (axis == Axis.y)
|
|
|
+ selected.setLocalScale(prev.x, ratio, prev.z);
|
|
|
+ else if (axis == Axis.z)
|
|
|
+ selected.setLocalScale(prev.x, prev.y, ratio);
|
|
|
+ else
|
|
|
+ selected.setLocalScale(ratio, ratio, ratio);
|
|
|
+ }
|
|
|
+
|
|
|
+ private void doMouseRotate(Axis axis, Vector2f screenCoord, JmeNode rootNode, JmeSpatial selectedSpatial) {
|
|
|
+ if (startMouseCoord == null)
|
|
|
+ startMouseCoord = screenCoord.clone();
|
|
|
+ if (startSelectedCoord == null) {
|
|
|
+ Vector3f screen = getCamera().getScreenCoordinates(selected.getWorldTranslation());
|
|
|
+ startSelectedCoord = new Vector2f(screen.x, screen.y);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (rotating == null)
|
|
|
+ rotating = new RotateUndo(selected, selected.getLocalRotation().clone(), null);
|
|
|
+
|
|
|
+ Vector2f origRot = startMouseCoord.subtract(startSelectedCoord);
|
|
|
+ Vector2f newRot = screenCoord.subtract(startSelectedCoord);
|
|
|
+ float newRotAngle = origRot.angleBetween(newRot);
|
|
|
+ float temp = newRotAngle;
|
|
|
+
|
|
|
+ if (lastRotAngle != 0)
|
|
|
+ newRotAngle -= lastRotAngle;
|
|
|
+
|
|
|
+ lastRotAngle = temp;
|
|
|
+
|
|
|
+ Quaternion rotate = new Quaternion();
|
|
|
+ if (axis == Axis.x) {
|
|
|
+ rotate = rotate.fromAngleAxis(newRotAngle, Vector3f.UNIT_X);
|
|
|
+ } else if (axis == Axis.y) {
|
|
|
+ rotate = rotate.fromAngleAxis(newRotAngle, Vector3f.UNIT_Y);
|
|
|
+ } else if (axis == Axis.z) {
|
|
|
+ rotate = rotate.fromAngleAxis(newRotAngle, Vector3f.UNIT_Z);
|
|
|
+ } else {
|
|
|
+ Vector3f screen = getCamera().getScreenCoordinates(selected.getWorldTranslation());
|
|
|
+ rotate = rotate.fromAngleAxis(newRotAngle, screen.normalize());
|
|
|
+ }
|
|
|
+ selected.setLocalRotation(selected.getLocalRotation().mult(rotate));
|
|
|
+
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ private void duplicateSelected() {
|
|
|
+ if (selected == null)
|
|
|
+ return;
|
|
|
+ Spatial clone = selected.clone();
|
|
|
+ clone.move(1, 0, 1);
|
|
|
+
|
|
|
+ selected.getParent().attachChild(clone);
|
|
|
+ actionPerformed(new DuplicateUndo(clone, selected.getParent()));
|
|
|
+ selected = clone;
|
|
|
+ final Spatial cloned = clone;
|
|
|
+ final JmeNode rootNode = toolController.getRootNode();
|
|
|
+ refreshSelected(rootNode, selected.getParent());
|
|
|
+
|
|
|
+ java.awt.EventQueue.invokeLater(new Runnable() {
|
|
|
+ @Override
|
|
|
+ public void run() {
|
|
|
+ if (cloned != null) {
|
|
|
+ SceneViewerTopComponent.findInstance().setActivatedNodes(new org.openide.nodes.Node[]{rootNode.getChild(cloned)});
|
|
|
+ SceneExplorerTopComponent.findInstance().setSelectedNode(rootNode.getChild(cloned));
|
|
|
+ } else {
|
|
|
+ SceneViewerTopComponent.findInstance().setActivatedNodes(new org.openide.nodes.Node[]{rootNode});
|
|
|
+ SceneExplorerTopComponent.findInstance().setSelectedNode(rootNode);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ // set to automatically 'grab'/'translate' the new cloned model
|
|
|
+ toolController.updateSelection(selected);
|
|
|
+ currentState = State.translate;
|
|
|
+ currentAxis = null;
|
|
|
+ }
|
|
|
+
|
|
|
+ private void deleteSelected() {
|
|
|
+ if (selected == null)
|
|
|
+ return;
|
|
|
+ Node parent = selected.getParent();
|
|
|
+ selected.removeFromParent();
|
|
|
+ actionPerformed(new DeleteUndo(selected, parent));
|
|
|
+
|
|
|
+ selected = null;
|
|
|
+ toolController.updateSelection(selected);
|
|
|
+
|
|
|
+ final JmeNode rootNode = toolController.getRootNode();
|
|
|
+ refreshSelected(rootNode, parent);
|
|
|
+ }
|
|
|
+
|
|
|
+ private void refreshSelected(final JmeNode jmeRootNode, final Node parent) {
|
|
|
+ java.awt.EventQueue.invokeLater(new Runnable() {
|
|
|
+ @Override
|
|
|
+ public void run() {
|
|
|
+ jmeRootNode.getChild(parent).refresh(false);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ private class MoveUndo extends AbstractUndoableSceneEdit {
|
|
|
+
|
|
|
+ private Spatial spatial;
|
|
|
+ private Vector3f before,after;
|
|
|
+
|
|
|
+ MoveUndo(Spatial spatial, Vector3f before, Vector3f after) {
|
|
|
+ this.spatial = spatial;
|
|
|
+ this.before = before;
|
|
|
+ this.after = after;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneUndo() {
|
|
|
+ spatial.setLocalTranslation(before);
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneRedo() {
|
|
|
+ spatial.setLocalTranslation(after);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private class ScaleUndo extends AbstractUndoableSceneEdit {
|
|
|
+
|
|
|
+ private Spatial spatial;
|
|
|
+ private Vector3f before,after;
|
|
|
+
|
|
|
+ ScaleUndo(Spatial spatial, Vector3f before, Vector3f after) {
|
|
|
+ this.spatial = spatial;
|
|
|
+ this.before = before;
|
|
|
+ this.after = after;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneUndo() {
|
|
|
+ spatial.setLocalScale(before);
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneRedo() {
|
|
|
+ spatial.setLocalScale(after);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ 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);
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneRedo() {
|
|
|
+ spatial.setLocalRotation(after);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private class DeleteUndo extends AbstractUndoableSceneEdit {
|
|
|
+
|
|
|
+ private Spatial spatial;
|
|
|
+ private Node parent;
|
|
|
+
|
|
|
+ DeleteUndo(Spatial spatial, Node parent) {
|
|
|
+ this.spatial = spatial;
|
|
|
+ this.parent = parent;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneUndo() {
|
|
|
+ parent.attachChild(spatial);
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneRedo() {
|
|
|
+ spatial.removeFromParent();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private class DuplicateUndo extends AbstractUndoableSceneEdit {
|
|
|
+
|
|
|
+ private Spatial spatial;
|
|
|
+ private Node parent;
|
|
|
+
|
|
|
+ DuplicateUndo(Spatial spatial, Node parent) {
|
|
|
+ this.spatial = spatial;
|
|
|
+ this.parent = parent;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneUndo() {
|
|
|
+ spatial.removeFromParent();
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void sceneRedo() {
|
|
|
+ parent.attachChild(spatial);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Check if the selected item is a Terrain
|
|
|
+ * It will climb up the parent tree to see if
|
|
|
+ * a parent is terrain too.
|
|
|
+ * Recursive call.
|
|
|
+ */
|
|
|
+ protected boolean isTerrain(Spatial s) {
|
|
|
+ if (s instanceof Terrain)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ if (s.getParent() != null) {
|
|
|
+ return isTerrain(s.getParent());
|
|
|
+ }
|
|
|
+ return false;
|
|
|
}
|
|
|
+
|
|
|
}
|
bre..ns