www.pudn.com > j3dme-0.3.0.rar > Coordinate.java

/*
 * J3DME Fast 3D software rendering for small devices
 * Copyright (C) 2001 Onno Hommes
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package net.jscience.j3dme;

/**
 * This class provides the engine 3D coordinate transformations,
 * translations and scaling functions. All the calculations use
 * fixed point integers. A coordinate object is typically used
 * as a cache for coordinate transformations. Coordinates
 * can only be expressed as natural numbers (e.g. {1,4,7})
 */
public class Coordinate{

   /**
    * Cache values for rotation
    * sin and cosine values for pitch, yaw and roll
    */
   private int sp,cp,sy,cy,sr,cr;

   /**
    * The x component of the coordinate
    */
   public int x;

   /**
    * The y component of the coordinate
    */
   public int y;

   /**
    * The z or depth component of the coordinate
    */
   public int z;

   /**
    * The coordinate constructor.

    * The coordinate components will all be initialized to 0.
    *
    * @return a coordinate object {0,0,0}
    */
   public Coordinate(){
      x = 0;
      y = 0;
      z = 0;
      sp = 0;
      sy = 0;
      sr = 0;
      cp = 256;
      cy = 256;
      cr = 256;
   }

   /**
    * Another coordinate constructor.

    * The coordinate components will be initialized to the provided
    * x , y and z values.
    *
    * @param    xc The x component value
    * @param    yc The y component value
    * @param    zc The z component value
    * @return a coordinate object {xc,yc,zc}
    */
   public Coordinate(int xc, int yc,int zc){
      x = xc;
      y = yc;
      z = zc;
   }

   public void setRotation(int rotateX, int rotateY, int rotateZ){
        sp = Math.sin(rotateX);
        cp = Math.sin(64-rotateX);
        sy = Math.sin(rotateY);
        cy = Math.sin(64-rotateY);
        sr = Math.sin(rotateZ);
        cr = Math.sin(64-rotateZ);
   }

   /**
    * Apply rotation transformation to the Coordinate

    * Clockwise rotation around the x-axis, y-axis and z-axis.
    * The transformation angles must be specified in binary angles.
    * For example 128 is erqual to PI and 256 represents a full circle.
    *
    * @param    rotateX The angle around the x-axis.
    * @param    rotateY The angle around the y-axis.
    * @param    rotateZ The angle around the z-axis.
    */
   public void rotate(){

     // X-axis rotation (picth)
     int ry = y*cp-z*sp;
     int rz = y*sp+z*cp;

     // Y-axis rotation (rotateY)
     int rx = x*cy-(rz*sy>>8);
     rz = x*sy+(rz*cy>>8);

     // Z-axis rotation (rotateZ)
     if (sr != 0 && cr != 255){
        int nrx = rx>>8;
        rx = nrx*cr-(ry*sr>>8);
        ry = nrx*sr+(ry*cr>>8);
     }

     // Set the new coordinate values
     x=rx>>8;
     y=ry>>8;
     z=rz>>8;
   }

   /**
    * Apply a vector translation to the Coordinate

    * This function will translate a coordinate along the
    * provided translation vector.
    *
    * @param    translateX The x-component of the vector.
    * @param    translateY The y-component of the vector.
    * @param    translateX The z-component of the vector.
    */
   public void translate(int translateX, int translateY, int translateZ){
     x += translateX;
     y += translateY;
     z += translateZ;
   }

   /**
    * Scale the coordinate

    * This function will multiply a coordinate times the provided
    * scale factor. The scale factor must be provided as an 8-bit
    * fixed point integer.
    *
    * @param    scale_factor The fixed point multiply factor.
    */
   public void scale(int scale_factor){
     x = x * scale_factor >> 8;
     y = y * scale_factor >> 8;
     z = z * scale_factor >> 8;
   }

   /**
    * Return the approximate distance to the origin

    * This function will quickly approximate the distance to the
    * origin. Using the sqrt(x^2+y^2+z^2) takes to long,
    * therefor a simple max(x,y,z) function is used to determine the
    * approximate or perceived distance.
    *
    * @return The perceived distance from the origin.
    */
   public int getDistance(){

     // Determine perceived distance fast; sqrt(x^2+y^2+z^) is too slow
     return Math.max(Math.max((x < 0)?-x:x,(y<0)?-y:y),(z<0)?-z:z);
   }
}