idx3d_Vector.java

// | -----------------------------------------------------------------
// | idx3d III is (c)1999/2000 by Peter Walser
// | -----------------------------------------------------------------
// | idx3d is a 3d engine written in 100% pure Java (1.1 compatible)
// | and provides a fast and flexible API for software 3d rendering
// | on the Java platform.
// |
// | Feel free to use the idx3d API / classes / source code for
// | non-commercial purposes (of course on your own risk).
// | If you intend to use idx3d for commercial purposes, please
// | contact me with an e-mail [proxima@active.ch].
// |
// | Thanx & greetinx go to:
// | * Wilfred L. Guerin,   for testing, bug report, and tons 
// |      of brilliant suggestions
// | * Sandy McArthur,  for reverse loops
// | * Dr. Douglas Lyons, for mentioning idx3d1 in his book
// | * Hugo Elias,    for maintaining his great page
// | * the comp.graphics.algorithms people, 
// |      for scientific concerns
// | * Tobias Hill,   for inspiration and awakening my
// |      interest in java gfx coding
// | * Kai Krause,    for inspiration and hope
// | * Incarom & Parisienne,  for keeping me awake during the 
// |      long coding nights
// | * Doris Langhard,  for being the sweetest girl on earth
// | * Etnica, Infinity Project, X-Dream and "Space Night"@BR3
// |      for great sound while coding
// | and all coderz & scenerz out there (keep up the good work, ppl :)
// |
// | Peter Walser
// | proxima@active.ch
// | http://www2.active.ch/~proxima
// | "On the eigth day, God started debugging"
// | -----------------------------------------------------------------

public class idx3d_Vector
// defines a 3d vector
{
  // F I E L D S
  
    public float x=0;      //Cartesian (default)
    public float y=0;      //Cartesian (default)
    public float z=0;      //Cartesian (default),Cylindric
    public float r=0;      //Cylindric
    public float theta=0;  //Cylindric


  // C O N S T R U C T O R S

    public idx3d_Vector ()
    {
    }

    public idx3d_Vector (float xpos, float ypos, float zpos)
    {
      x=xpos;
      y=ypos;
      z=zpos;
    }

  // P U B L I C   M E T H O D S

    public idx3d_Vector normalize()
    // Normalizes the vector
    {
      float dist=length();
      if (dist==0) return this;
      float invdist=1/dist;
      x*=invdist;
      y*=invdist;
      z*=invdist;
      return this;
    }
    
    public idx3d_Vector reverse()
    // Reverses the vector
    { 
      x=-x;
      y=-y;
      z=-z;
      return this;
    }
    
    public float length()
    // Lenght of this vector
    { 
      return (float)Math.sqrt(x*x+y*y+z*z);
    }

    public idx3d_Vector transform(idx3d_Matrix m)
    // Modifies the vector by matrix m 
    {
      float newx = x*m.m00 + y*m.m01 + z*m.m02+ m.m03;
      float newy = x*m.m10 + y*m.m11 + z*m.m12+ m.m13;
      float newz = x*m.m20 + y*m.m21 + z*m.m22+ m.m23;
      return new idx3d_Vector(newx,newy,newz);
    }

    public void buildCylindric()
    // Builds the cylindric coordinates out of the given cartesian coordinates
    {
      r=(float)Math.sqrt(x*x+y*y);
      theta=(float)Math.atan2(x,y);
    }

    public void buildCartesian()
    // Builds the cartesian coordinates out of the given cylindric coordinates
    {
      x=r*idx3d_Math.cos(theta);
      y=r*idx3d_Math.sin(theta);
    }

    public static idx3d_Vector getNormal(idx3d_Vector a, idx3d_Vector b)
    // returns the normal vector of the plane defined by the two vectors
    {
      return vectorProduct(a,b).normalize();
    }
    
    public static idx3d_Vector getNormal(idx3d_Vector a, idx3d_Vector b, idx3d_Vector c)
    // returns the normal vector of the plane defined by the two vectors
    {
      return vectorProduct(a,b,c).normalize();
    }
    
    public static idx3d_Vector vectorProduct(idx3d_Vector a, idx3d_Vector b)
    // returns a x b
    {
      return new idx3d_Vector(a.y*b.z-b.y*a.z,a.z*b.x-b.z*a.x,a.x*b.y-b.x*a.y);
    }
    
    public static idx3d_Vector vectorProduct(idx3d_Vector a, idx3d_Vector b, idx3d_Vector c)
    // returns (b-a) x (c-a)
    {
      return vectorProduct(sub(b,a),sub(c,a));
    }

    public static float angle(idx3d_Vector a, idx3d_Vector b)
    // returns the angle between 2 vectors
    {
      a.normalize();
      b.normalize();
      return (a.x*b.x+a.y*b.y+a.z*b.z);
    }
    
    public static idx3d_Vector add(idx3d_Vector a, idx3d_Vector b)
    // adds 2 vectors
    {
      return new idx3d_Vector(a.x+b.x,a.y+b.y,a.z+b.z);
    }
    
    public static idx3d_Vector sub(idx3d_Vector a, idx3d_Vector b)
    // substracts 2 vectors
    {
      return new idx3d_Vector(a.x-b.x,a.y-b.y,a.z-b.z);
    }
    
    public static idx3d_Vector scale(float f, idx3d_Vector a)
    // substracts 2 vectors
    {
      return new idx3d_Vector(f*a.x,f*a.y,f*a.z);
    }
    
    public static float len(idx3d_Vector a)
    // length of vector
    {
      return (float)Math.sqrt(a.x*a.x+a.y*a.y+a.z*a.z);
    }
    
    public static idx3d_Vector random(float fact)
    // returns a random vector
    {
      return new idx3d_Vector(fact*idx3d_Math.random(),fact*idx3d_Math.random(),fact*idx3d_Math.random());
    }
    
    public String toString()
    {
      return new String ("<vector x="+x+" y="+y+" z="+z+">\r\n");
    }

    public idx3d_Vector getClone()
    {
      return new idx3d_Vector(x,y,z);
    }

}