[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/tool MoveTool.java,1.36,1.37

[Nordholt <nor...@us...>]

Update of /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24141

Modified Files:
	MoveTool.java 
Log Message:
implemented first draft controlled move

Index: MoveTool.java
===================================================================
RCS file: /cvsroot/bprocessor/gl/src/net/sourceforge/bprocessor/gl/tool/MoveTool.java,v
retrieving revision 1.36
retrieving revision 1.37
diff -C2 -d -r1.36 -r1.37
*** MoveTool.java	15 Feb 2006 11:10:39 -0000	1.36
--- MoveTool.java	15 Feb 2006 11:26:35 -0000	1.37
***************
*** 50,53 ****
--- 50,56 ----
    public static final int THREE_CLICK = 2;
    
+   /** The controlled movement mode  */
+   public static final int CONTROLLED = 3;
+   
    /** The initial movepoint */
    private Vertex initial;
***************
*** 88,91 ****
--- 91,103 ----
    /** The Collection of entities being moved */
    private Collection moveEntities;
+   
+   /** Sliding edge of the to point */
+   private Edge toSlideEdge;
+   
+   /** Sliding edge of the from point */
+   private Edge fromSlideEdge;
+   
+   /** The edge being moved in a controlled way */
+   private Edge controlled;
  
    /**
***************
*** 99,102 ****
--- 111,116 ----
      restrictionVector = null;
      snapEntity = null;
+     toSlideEdge = null;
+     fromSlideEdge = null;
      numberOfClicks = 1;
      moveMode = AXIS_RESTRICTED;
***************
*** 104,108 ****
    
    /**
!    * Update selection
     *
     */
--- 118,122 ----
    
    /**
!    * Updat selection
     *
     */
***************
*** 141,144 ****
--- 155,165 ----
          moveEntities = selection;
          collect(selection, vertices);
+         if (moveMode == CONTROLLED) {
+           if (target instanceof Edge) {
+             controlled = (Edge)target;
+           } else {
+             log.warn("Controlled move only works with edges");
+           }
+         }
        } else {
          threeClickMove(e);
***************
*** 229,232 ****
--- 250,255 ----
      restrictionVector = null;
      dragPlane = null;
+     toSlideEdge = null;
+     fromSlideEdge = null;
      number = "";
    }
***************
*** 266,271 ****
--- 289,332 ----
        if (parentPos != null) {
          Vertex delta = parentPos.minus(from);
+         
          //Restricting movement to fit movement mode.
          delta = restrict(delta, e);
+         
+         if (moveMode == CONTROLLED) {
+           Vertex toDelta;
+           Vertex fromDelta;
+           
+           Vertex deltaUnit = delta.copy();
+           deltaUnit.scale(1 / deltaUnit.length());
+ 
+           Vertex toDir = toSlideEdge.getTo().minus(toSlideEdge.getFrom());
+           double toScale;
+           if (delta.getX() != 0) {
+             toScale =  delta.getX() / (toDir.dot(deltaUnit) * deltaUnit.getX());
+           } else if (delta.getY() != 0) {
+             toScale = delta.getY() / (toDir.dot(deltaUnit) * deltaUnit.getY());
+           } else {
+             toScale = delta.getZ() / (toDir.dot(deltaUnit) * deltaUnit.getZ());
+           } 
+           
+           Vertex fromDir = fromSlideEdge.getTo().minus(fromSlideEdge.getFrom());
+           double fromScale;
+           if (delta.getX() != 0) {
+             fromScale = delta.getX() / (fromDir.dot(deltaUnit) * deltaUnit.getX());
+           } else if (delta.getY() != 0) {
+             fromScale = delta.getY() / (fromDir.dot(deltaUnit) * deltaUnit.getY());
+           } else {
+             fromScale = delta.getZ() / (fromDir.dot(deltaUnit) * deltaUnit.getZ());
+           }
+ 
+           toDir.scale(toScale);
+           toDelta = toDir;
+           fromDir.scale(fromScale);
+           fromDelta = fromDir;
+ 
+ 
+           controlled.getTo().move(toDelta.getX(), toDelta.getY(), toDelta.getZ());
+           controlled.getFrom().move(fromDelta.getX(), fromDelta.getY(), fromDelta.getZ());
+         }        
              
          if (log.isDebugEnabled()) {
***************
*** 274,279 ****
          }      
        
!         delta = snapToInitial(delta);
!         move(vertices, delta);
          from.move(delta.getX(), delta.getY(), delta.getZ());
          glv.setLength(from.minus(initial).length());
--- 335,342 ----
          }      
        
!         //delta = snapToInitial(delta);
!         if (moveMode != CONTROLLED) {
!           move(vertices, delta);
!         }
          from.move(delta.getX(), delta.getY(), delta.getZ());
          glv.setLength(from.minus(initial).length());
***************
*** 331,334 ****
--- 394,402 ----
          }
        }
+     } else if (moveMode == CONTROLLED) {
+       Vertex restrictCopy = restrictionVector.copy();
+       restrictCopy.scale(1 / restrictCopy.length());
+       restrictCopy.scale(delta.dot(restrictCopy));
+       delta = restrictCopy;
      }
      return delta;
***************
*** 382,385 ****
--- 450,494 ----
          clearConstructors(moveConstructors);
        }
+     } else if (moveMode == CONTROLLED && controlled != null) {
+       if (toSlideEdge == null && fromSlideEdge == null) {
+         findTarget(e);
+         if (target instanceof Surface) {
+           Surface targetSurface = (Surface)target;
+           if (controlled.getSurfaces().contains(targetSurface)) {
+             glv.getView().makeTarget(target);
+             dragPlane = targetSurface.plane();
+             List edges = targetSurface.getEdges();
+             int index = edges.indexOf(controlled);
+             Edge leftEdge;
+             Edge rightEdge;
+             if (index == 0) {
+               leftEdge = (Edge)edges.get(edges.size() - 1);
+               rightEdge = (Edge)edges.get(index + 1);
+             } else if (index == (edges.size() - 1)) {
+               leftEdge = (Edge)edges.get(index - 1);
+               rightEdge = (Edge)edges.get(0);
+             } else {
+               leftEdge = (Edge)edges.get(index - 1);
+               rightEdge = (Edge)edges.get(index + 1);
+             }
+             Vertex to = controlled.getTo();
+             Vertex from = controlled.getFrom();
+             if (to.getEdges().contains(leftEdge) && 
+                 from.getEdges().contains(rightEdge)) {
+               toSlideEdge = leftEdge;
+               fromSlideEdge = rightEdge;
+             } else if (from.getEdges().contains(leftEdge) && 
+                        to.getEdges().contains(rightEdge)) {
+               fromSlideEdge = leftEdge;
+               toSlideEdge = rightEdge;              
+             }
+                         
+             Vertex edgeDirection = controlled.getTo().minus(controlled.getFrom());
+             Vertex surfaceNormal = targetSurface.normal();
+             restrictionVector = edgeDirection.cross(surfaceNormal);
+             restrictionVector.scale(1 / restrictionVector.length());
+           }
+         }
+       }
      }
    }
***************
*** 512,516 ****
        }
      }
-     Project.getInstance().changed(sel);
    }
  
--- 621,624 ----