[Bprocessor-commit] gl/src/net/sourceforge/bprocessor/gl/tool ExtrusionTool.java,NONE,1.1 MoveTool.java,NONE,1.1

[rimestad <rim...@us...>]

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

Added Files:
	ExtrusionTool.java MoveTool.java 
Log Message:
initial import

--- NEW FILE: MoveTool.java ---
//---------------------------------------------------------------------------------
// $Id: MoveTool.java,v 1.1 2005/08/05 10:50:16 rimestad Exp $
//
// Copyright (c) 2005      The BProcessor Team (http://bprocessor.sourceforge.net) 
// Released under the Lesser GNU Public License v2.1
//---------------------------------------------------------------------------------
package net.sourceforge.bprocessor.gl.tool;

import net.sourceforge.bprocessor.gl.GLView;
import net.sourceforge.bprocessor.gl.view.View;

import net.sourceforge.bprocessor.model.Vertex;

import java.awt.event.MouseEvent;

import java.util.List;

import org.apache.log4j.Logger;
/**
 * The move tool
 */
public class MoveTool extends SelectTool {
  /** The logger */
  private static Logger log = Logger.getLogger(MoveTool.class);

  /**
   * The Constructor
   * @param glv The 3D canvas
   */
  public MoveTool(GLView glv) {
    super(glv);
  }

  /** 
   * Invoked when the mouse is held pressed and moved
   * @param e The MouseEvent object 
   */
  protected void dragged(MouseEvent e) {  
    if (e.getButton() == MouseEvent.BUTTON1) {
      if (selectedVertex != null) {
        int x = e.getX();
        int y = e.getY();
        View view = glv.getView();
        double[] coords = view.toCanvasCoords(new double[]{x, y});
        coords = snapToGrid(coords);
        updateVertex(selectedVertex, coords);
      } else if (selectedSurface != null) {
        View view = glv.getView();
        int x = e.getX();
        int y = e.getY();
        double[] coordsa = view.toCanvasCoords(new double[]{x, y});
        double[] coordsb = view.toCanvasCoords(new double[]{pressPos[0], pressPos[1]});
        double[] delta = new double[] {coordsa[0] - coordsb[0],
                                       coordsa[1] - coordsb[1],
                                       coordsa[2] - coordsb[2]};
        
        List l = Util.traverse(selectedSurface);
        for (int i = 0; i < l.size(); i++) {
          Vertex v = (Vertex)l.get(i);
          coordsa = new double[] {v.getX() + delta[0], 
                                  v.getY() + delta[1], 
                                  v.getZ() + delta[2]};
          updateVertex(v, coordsa);
        }
      } else if (selectedEdge != null) {
        View view = glv.getView();
        int x = e.getX();
        int y = e.getY();
        double[] coordsa = view.toCanvasCoords(new double[]{x, y});
        double[] coordsb = view.toCanvasCoords(new double[]{pressPos[0], pressPos[1]});
        double[] delta = new double[] {coordsa[0] - coordsb[0],
                                       coordsa[1] - coordsb[1],
                                       coordsa[2] - coordsb[2]};
        Vertex to = selectedEdge.getTo();
        Vertex from = selectedEdge.getFrom();

        coordsa = new double[] {to.getX() + delta[0], 
                                to.getY() + delta[1], 
                                to.getZ() + delta[2]};
        updateVertex(to, coordsa);
        coordsa = new double[] {from.getX() + delta[0], 
                                from.getY() + delta[1], 
                                from.getZ() + delta[2]};
        updateVertex(from, coordsa);
      }
      pressPos[0] = e.getX();
      pressPos[1] = e.getY();
    }
  }
}

--- NEW FILE: ExtrusionTool.java ---
//---------------------------------------------------------------------------------
// $Id: ExtrusionTool.java,v 1.1 2005/08/05 10:50:16 rimestad Exp $
//
// Copyright (c) 2005      The BProcessor Team (http://bprocessor.sourceforge.net) 
// Released under the Lesser GNU Public License v2.1
//---------------------------------------------------------------------------------
package net.sourceforge.bprocessor.gl.tool;

import net.sourceforge.bprocessor.gl.GLView;

import net.sourceforge.bprocessor.kernel.notification.Notification;
import net.sourceforge.bprocessor.kernel.notification.Notifier;

import net.sourceforge.bprocessor.model.Edge;
import net.sourceforge.bprocessor.model.Surface;
import net.sourceforge.bprocessor.model.Vertex;

import java.awt.event.MouseEvent;

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.Set;

import org.apache.log4j.Logger;
/**
 * The extrusion tool
 */
public class ExtrusionTool extends SelectTool {
  /** The logger */
  private static Logger log = Logger.getLogger(ExtrusionTool.class);

  /** the new surface to drag */
  private static Surface dragSurface = null;
  
  /**
   * The Constructor
   * @param glv The 3D canvas
   */
  public ExtrusionTool(GLView glv) {
    super(glv);
  }

  /** 
   * Invoked when the mouse is held pressed and moved
   * @param e The MouseEvent object 
   */
  protected void dragged(MouseEvent e) {
    if (e.getButton() == MouseEvent.BUTTON1) {
      if (selectedSurface != null) {
        if (!selectedSurface.equals(dragSurface)) {
          if (isExtrudeable(selectedSurface)) {
            dragSurface = selectedSurface;
          } else {
            dragSurface = null;
            createExtension();
          }
        } 
        if (dragSurface != null) {
          Vertex normal = dragSurface.normal();
          if (normal != null) {
            double[] second = glv.getView().toCanvasCoords(new double[] {e.getX(), e.getY()});
            normal.scale(1 / normal.length());
            Vertex proj = dragSurface.projection(second);

            List l = Util.traverse(dragSurface);
            for (int count = 0; l != null && count < l.size(); count++) {
              Vertex v = (Vertex)l.get(count);
              updateVertex(v, new double[] {v.getX() + proj.getX(), 
                                            v.getY() + proj.getY(), 
                                            v.getZ() + proj.getZ()});
            }
          }
        }
      }
    }
  }

  /**
   * Checks if a surface is extrudeable
   * @param s Surface
   * @return true if the surface is extrudeable otherwise false
   */
  private boolean isExtrudeable(Surface s) {
    if (s == null) {
      return false;
    }
    Vertex normal = s.normal();
    List l = Util.traverse(s);
    for (int i = 0; i < l.size(); i++) {
      Vertex v = (Vertex)l.get(i);
      Set edges = v.getEdges();
      if (edges.size() >= 3) {
        Iterator it = edges.iterator();
        while (it.hasNext()) {
          Edge e = (Edge)it.next();
          if (!s.contains(e)) {
            Vertex v1 = e.otherVertex(v);
            Vertex v2 = v1.minus(v);
            Vertex cross = v2.cross(normal);
            if (Math.abs(cross.length()) > 0.0001) {
              return false;
            }
          }
        }
      } else {
        return false;
      }
    }
    return true;
  }
  
  /**
   * Invoked when a mouse button has been pressed on a component.
   * @param e The MouseEvent object
   */
  protected void pressed(MouseEvent e) {
    super.pressed(e);
  }
  
  /**
   * Invoked when a mouse button has been released on a component.
   * @param e The MouseEvent
   */
  protected void released(MouseEvent e) {
    super.released(e);
  }

  /**
   * Do alle the initial extrusion stuff
   */
  private void createExtension() {
    Edge previousEdge = null;
    Vertex previousVertex = null;
    Edge first = null;
    List newEdges = new ArrayList();
    List edges = selectedSurface.getEdges();
    List top = new ArrayList(edges.size());
    Iterator i = edges.iterator();
    Edge current = null;
    if (i.hasNext()) {
      current = (Edge)i.next();
      Edge lastEdge = current;   
      for (int times = 0; times < edges.size(); times++) {
        if (previousEdge == null) {
          Vertex newTo = createVertex(new double[] {current.getFrom().getX(),
                                                    current.getFrom().getY(),
                                                    current.getFrom().getZ()});
          Vertex newFrom = createVertex(new double[] {current.getTo().getX(),
                                                      current.getTo().getY(),
                                                      current.getTo().getZ()});
          Edge newE = createEdge(newFrom, newTo);
          Edge ntofrom = createEdge(newTo, current.getFrom());
          Edge tonfrom = createEdge(current.getTo(), newFrom);
          newEdges.add(current);
          newEdges.add(tonfrom);
          newEdges.add(newE);
          newEdges.add(ntofrom);
          first = ntofrom;
          top.add(newE);
          previousEdge = tonfrom;
          previousVertex = newFrom;
        } else {
          if (times == edges.size() - 1 && 
              ((first.getTo()).equals(current.getTo()) || 
               (first.getTo()).equals(current.getFrom()))) {
            Edge newE = createEdge(first.getFrom(), previousEdge.getTo());
            newEdges.add(current);
            newEdges.add(first);
            newEdges.add(newE);
            newEdges.add(previousEdge);
            top.add(newE);
          } else {
            Vertex c = current.otherVertex(previousEdge.otherVertex(previousVertex));
            Vertex newFrom = createVertex(new double[] {c.getX(),
                                                        c.getY(),
                                                        c.getZ()});
            Edge newE = createEdge(newFrom, previousVertex);
            Edge tonfrom = createEdge(c, newFrom);
            newEdges.add(current);
            newEdges.add(tonfrom);
            newEdges.add(newE);
            newEdges.add(previousEdge);
            top.add(newE);
            previousEdge = tonfrom;
            previousVertex = newFrom;
          }
        }
        createSurface(newEdges);
        newEdges = new ArrayList();
        
        //get the next edge to work on
        Set nexts = (previousEdge.otherVertex(previousVertex)).getEdges();
        i = nexts.iterator();
        boolean found = false;
        while (i.hasNext() && !found) {
          Edge temp = (Edge)i.next();
          if (selectedSurface.getEdges().contains(temp) && !temp.equals(current)) {
            current = temp;
            found = true;
          }
        }
      }
    }
    dragSurface = createSurface(top);
    Notification n = new Notification(Notification.SURFACE_SELECTED, dragSurface.getId());
    Notifier.getInstance().sendNotification(n);
  }
}