ciao gernot,
  im sorry but youll have to excuse my stupidity.. i dont really
understand how to this mixing of coordinate systems is happeneing..  i
ahve an class entity that is a branchgraph that has a position and
direction in the absolute world.  derived from that class is a viewport
class which adds a viewplatform etc.. it is like a camera... these are
seperate branchgraphs in the virtual universe, not children of each
other...  i have an entity (sphere) sitting down the neg z axis alittle
and i set the viewport up the z axis alittle..  in my entity code is
where i try to update an entity's transform acording to the entity's
position and direction..  but if i try to set some rotation i get
nothing.. the euler method doesnt really work cause it assumes the
vector3d used for direction contains angles in radians, which it
doesnt.. it is just a direction/orientation vector... i want to be able
to make an entity (hence the viewport) point in any direction.. this way
the camera can look around.. thats what im trying to do now.. im sure
this isnt a difficult problem but im really dubm or blind or something
cause ive been stuck on this awhile... ive included my entity and
viewport code.. the _updateTransform method in entity is i think the
source of all my problems.. if i dont set a rotation then things are
ok.. but which way does it default to?  looking down the positive z
axis?  i know this is alot so if you dont have the time no prob.. thanks
for you help anyway... gracia tanta, wayne


[EMAIL PROTECTED] wrote:
>
> Hi Wayne,
> this sounds like you're doing your transformations in the local coordinate
> system of the object. If you want to let move things in another coordinate
> system, you first have to perform a coord. transformation. for example
> tranform your object into the CS of your viewpoint, apply navigation
> transforms to it and transform it
> back.
> You can read more about that in chapter 8 (8.5.1) of Java3D API
> Specification.
>
> Gernot
> [EMAIL PROTECTED]
>
>                     "wayne c
>                     deprince jr."        To:     [EMAIL PROTECTED]
>                     <wcd2@lehigh.        cc:
>                     edu>                 Subject:     Re: [JAVA3D] help setting 
>direction
>
>                     10.12.99
>                     16:12
>                     Please
>                     respond to
>                     wcd2
>
> gracia gernot... i tried the attached code and things seem pretty good..
> however, when i translate the object in in the +/- x direction it moves
> diagonaly.. when i move it right it moves up and right, and left moves
> it down and left?  i dont know what a euler angle is, but maybe i was
> unclear.. i dont have the angles of rotation yet.. i need to get them..
> i only have a directino vector.  is this what setEuler does?  sorry for
> the clueless ness.. ciao, wayne
>
>   /**
>    * Updates the Tranform3D in the TransformGroup according to the
>    * position, direction, normal.  The transform is updated in place.
>    * !NOT IMPLEMENTED!
>    *
>    * @param t the Transform3D to update.
>    * @param p The new position.
>    * @param d The new direction.
>    * @param n The new normal.
>    */
>   private void _updateTransform(Transform3D t, Point3d p, Vector3d d,
>                                 Vector3d n)
>     {
>
>       // find the point we are looking at.
>       //Point3d center = new Point3d();
>       //center.sub(p, d);
>
>       //t.lookAt(p, center, new Vector3d(0.0, 0.0, 0.0));
>       //return;
>
>       // First apply the position changes.
>
>       // Now set the direction which this should be pointing.
>       // We will do the rotations here.
>       // Normalize the direction first.
>       //d.normalize();
>       t.setTranslation(new Vector3d((Tuple3d)p));
>       Transform3D rot = new Transform3D();
>       rot.setEuler(new Vector3d(d));
>       Matrix3d rot_matrix = new Matrix3d();
>       rot.get(rot_matrix);
>       t.setRotation(rot_matrix);
>
>       return;
> }
>
> [EMAIL PROTECTED] wrote:
> >
> > hi Wayne,
> >
> > to put an orientation given by a vector to a transform3D, just use
> setEuler
> > () from Transform3D.
> > euler angles describe  angles between a vector an the axis of a
> coordinate
> > system (if i guess right...)
> >
> > Gernot
> > [EMAIL PROTECTED](See attached file: wcd2.vcf)
/*
 * wayne c. deprince jr.
 * 10.28.1999.22.16
 *
 */


package enjine;


import java.lang.Math.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import java.io.*;

import com.sun.j3d.loaders.*;


/**
 * The camera, viewport, etc., into the world simluted by Enjine.
 *
 * @author wayne c. deprince jr.
 * @see Enjine, Entity, View
 */
public class ViewPort extends Entity
{


  /**
   * The scenegraph View for this ViewPort.
   */
  private View _view;


  /**
   * The ViewPlatform associated with this View.
   */
  private ViewPlatform _platform;


  /**
   * Detailed constructor which allows setting of all Entity properties
   * (position, velocity, etc.) as well as the View.  Sets the elements
   * of this class to the arguments.  No validity
   * checking is preformed.  The values passed are copied into this
   * object rather than keeping a reference.  Also, the loader and
   * reader are used to load a BranchGroup
   * and add it as a child to this Entity's TransformGroup.
   *
   * @param view The View to use.
   * @param pos The position of the center of this entity.
   * @param dir The direction.
   * @param vel The velocity of this object.
   * @param accel The acceleration of the object.
   * @param norm The normal of this object.
   * @param max_speed The max_speed of the object.
   * @param mass The mass of this object.
   * @param loader The Java3D Loader to load up the info.  We assume the loader
   * will be configured to load the desired parts from the reader.
   * @param reader The Reader from which the Loader will load the info from.
   */
  public ViewPort(View view, Point3d pos, Vector3f dir, Vector3d vel,
                  Vector3f norm, Vector3d accel, float max_speed,
                  float mass, Loader loader, Reader reader)
    {

      super(pos, dir, vel, norm, accel, max_speed, mass, loader, reader);

      // Setup our view.
      _initializeView(view);
    }


  /**
   * Detailed constructor which sets the View of this ViewPort as well
   * as loading info from a reader.
   *
   * @param view The View to use for this ViewPort.
   * @param loader The Java3D loader.
   * @param reader The reader to load from.
   */
  public ViewPort(View view, Loader loader, Reader reader)
    {

      super(loader, reader);

      // Setup our view.
      _initializeView(view);
    }


  /**
   * Detailed constructor to load a View for this ViewPort.
   *
   * @param view The View for this ViewPort.
   */
  public ViewPort(View view)
    {
      this(view, null, null);
    }


  /**
   * Default constructor.  Creates a default View
   * for this ViewPort.
   *
   */
  public ViewPort()
    {
      this(new View(), null, null);
    }


  /**
   * Initialize our View and attach it to the internal ViewPlatform.
   * Then add the ViewPlatform as a child of our TransformGroup.
   *
   * @param view The View to init and attach.
   */
  private void _initializeView(View view)
    {

      /* Create a PhysicalBody and PhysicalEnviroment and
       * and attach them to the View.
       */
      _view = view;
      _view.setPhysicalBody(new PhysicalBody());
      _view.setPhysicalEnvironment(new PhysicalEnvironment());

      /* Create a ViewPlatform for this ViewPort and add it
       * as a child of this Entity's TransformGroup.  We don't
       * add this ViewPlatform using Entity.addChild() because
       * this is really a hidden child since ViewPort is an
       * Entity anyway.  We want the ViewPlatform to be an
       * atomic part of a ViewPort.
       */
      _platform = new ViewPlatform();

      (this.getTransformGroup()).addChild(_platform);
      _view.attachViewPlatform(_platform);
    }


  /**
   * The View for this ViewPort.
   *
   * @return A reference to the View used by this ViewPort.
   */
  public View getView()
    {
      return(_view);
    }


  /**
   * The ViewPlatform for this ViewPort.
   *
   * @return A reference to the ViewPlatform  used by this ViewPort.
   */
  public ViewPlatform getViewPlatform()
    {
      return(_platform);
    }

}
/*
 * wayne c. deprince jr.
 * 10.28.1999.22.16
 *
 */


package enjine;


import java.lang.Math.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import java.util.*;
import java.io.*;

import com.sun.j3d.loaders.*;


/**
 * The base class for all objects being simulated in Enjine.  This object
 * is represented in the java3D scene graph as a BranchGroup with a
 * TransformGroup as its only child.  Each Entity has its
 * own TransformGroup which is what positions, rotates, etc. all its
 * children.  All setting of position, direction, etc., affect this
 * TransformGroup.  Any children added
 * to this Entity are added as children of the TransformGroup, not the
 * BranchGroup
 *
 * @author wayne c. deprince jr.
 * @see Enjine
 */
public class Entity extends BranchGroup
{

  /**
   * The default position.
   */
  private static final Point3d _DEFAULT_POSITION =
  new Point3d(0.0, 0.0, 0.0);

  /**
   * The default direction.
   */
  private static final Vector3d _DEFAULT_DIRECTION =
  new Vector3d(0.0, 0.0, 0.0);

  /**
   * The default velocity.
   */
  private static final Vector3d _DEFAULT_VELOCITY =
  new Vector3d(0.0, 0.0, 0.0);


  /**
   * The default acceleration.
   */
  private static final Vector3d _DEFAULT_ACCELERATION =
  new Vector3d(0.0, 0.0, 0.0);


  /**
   * The default normal.
   */
  private static final Vector3d _DEFAULT_NORMAL =
  new Vector3d(0.0, 0.0, 0.0);


  /**
   * The default mass.
   */
  private static final float _DEFAULT_MASS = 1.0f;


  /**
   * The default max speed.
   */
  private static final float _DEFAULT_MAX_SPEED = 1.0f;


  /**
   * The TransformGroup that defines the position of this Entity in the
   * world.
   */
  private TransformGroup _transform_group;


  /**
   * The main Transform3D for this Entity's TransformGroup.
   */
  private Transform3D _transform;


  /**
   * The collection of children this Entity has.
   */
  private Collection _children;


  /**
   * The velocity of this entity.
   */
  private Vector3d _velocity;


  /**
   * The direction.
   */
  private Vector3d _direction;


  /**
   * The position.
   */
  private Point3d _position;


  /**
   * The acceleration.
   */
  private Vector3d _acceleration;


  /**
   * The maximum speed.
   */
  private float _max_speed;


  /**
   * The mass.
   */
  private float _mass;


  /**
   * The normal of this entity.
   */
  private Vector3d _normal;


  /**
   * Detailed constructor.  Sets the elements of this class to the
   * arguments.  No validity checking is preformed.  The values passed
   * are copied into this object rather than keeping a a reference.
   * Also, the loader and reader are used to load a BranchGroup
   * and add it as a child to this Entity's TransformGroup.
   *
   * @param pos The position of the center of this entity.
   * @param dir The direction.
   * @param vel The velocity of this object.
   * @param accel The acceleration of the object.
   * @param norm The normal of this object.
   * @param max_speed The max_speed of the object.
   * @param mass The mass of this object.
   * @param loader The Java3D Loader to load up the info.  We assume the
   * loader will be configured to load the desired parts from the reader.
   * @param reader The Reader from which the Loader will load the info
   * from.
   */
  public Entity(Point3d pos, Vector3d dir, Vector3d vel, Vector3d norm,
                Vector3d accel, float max_speed, float mass,
                Loader loader, Reader reader)
    {

      super();

      // Copy the values into our internal data members.
      _position = new Point3d(pos);
      _velocity = new Vector3d(vel);
      _direction = new Vector3d(dir);
      _mass = mass;
      _normal = new Vector3d(norm);
      _acceleration = new Vector3d(accel);
      _max_speed = max_speed;

      // Create the collection to hold the children of this Entity.
      _children = new HashSet();

      /* Now create the TransformGroup for this Entity and set
       * it's value according to our position, etc.
       */
      _transform = new Transform3D();
      _transform_group = new TransformGroup(_transform);

      /* Let's allow this TransformGroup's transform to be read and written,
       * as well as allowing children to be added and removed.
       */
      //_transform_group.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
      _transform_group.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
      _transform_group.setCapability(Group.ALLOW_CHILDREN_EXTEND);
      _transform_group.setCapability(Group.ALLOW_CHILDREN_READ); //?
      _transform_group.setCapability(Group.ALLOW_CHILDREN_WRITE); //?

      // Now set this TransformGroup to update our position, etc.
      _updateTransformGroup();

      // Now let's load any info using the Loader and Reader.
      if ((loader != null) && (reader != null))
        {

          Scene s = null;

          // Try to load the info.
          try
            {

              s = loader.load(reader);

            } catch (FileNotFoundException e)
              {

                System.err.println("loading of " + reader.toString() +
                                   " failed");
                System.err.println(e.toString());
              }

          /* If we got the scene info, add it as a child to
           * our transform group.
           */
          if (s != null)
            {
              _transform_group.addChild(s.getSceneGroup());
            }
        }

      // First let's set some caps for our BranchGroup.
      //this.setCapability(Group.ALLOW_CHILDREN_EXTEND);
      this.setCapability(Group.ALLOW_CHILDREN_READ);  //?
      this.setCapability(Group.ALLOW_CHILDREN_WRITE);  //?
      this.setCapability(BranchGroup.ALLOW_DETACH);  //?

      // Now let's add this TransformGroup to our BranchGroup.
      this.addChild(_transform_group);

      // Now let's compile ourselves?
      this.compile();
    }


  /**
   * Detailed constructor.  Sets the elements of this class to the
   * arguments.  No validity checking is preformed.  The values passed
   * are copied into this object rather than keeping a a reference.
   *
   * @param pos The position of the center of this entity.
   * @param dir The direction.
   * @param vel The velocity of this object.
   * @param accel The acceleration of the object.
   * @param norm The normal of this object.
   * @param max_speed The max_speed of the object.
   * @param mass The mass of this object.
   */
  public Entity(Point3d pos, Vector3d dir, Vector3d vel, Vector3d norm,
                Vector3d accel, float max_speed, float mass)
    {
      this(pos, dir, vel, norm, accel, max_speed, mass, null, null);
    }


  /**
   * Detailed constructor.  Creates a Entity with a BranchGroup loaded by
   * loader from reader as a child of this Entity's TransformGroup.
   *
   * @param loader The Java3D Loader to load up the info.  We assume the loader
   * will be configured to load the desired parts from the reader.
   * @param reader The Reader from which the Loader will load the info from.
   */
  public Entity(Loader loader, Reader reader)
    {
      this(_DEFAULT_POSITION, _DEFAULT_DIRECTION,
           _DEFAULT_VELOCITY, _DEFAULT_NORMAL,
           _DEFAULT_ACCELERATION, _DEFAULT_MAX_SPEED, _DEFAULT_MASS,
           loader, reader);
    }


  /**
   * Default constructor. Initializes all the elements to 0 and null.
   */
  public Entity()
    {
      this(_DEFAULT_POSITION, _DEFAULT_DIRECTION,
           _DEFAULT_VELOCITY, _DEFAULT_NORMAL,
           _DEFAULT_ACCELERATION, _DEFAULT_MAX_SPEED, _DEFAULT_MASS,
           null, null);
    }


  /**
   * Finalizer.
   */
  protected void finalize()
    {

    }


  /**
   * Updates the Tranform3D in the TransformGroup according to the
   * position, direction, normal.  The transform is updated in place.
   * !NOT IMPLEMENTED!
   *
   * @param t the Transform3D to update.
   * @param p The new position.
   * @param d The new direction.
   * @param n The new normal.
   */
  private void _updateTransform(Transform3D t, Point3d p, Vector3d d,
                                Vector3d n)
    {

      // 3dica method!@!@#!@#!#!@#

      Matrix3d orient = new Matrix3d();

      Vector3d y = new Vector3d((-d.y * d.x),
                                (1.0 - (d.y * d.y)),
                                (-d.y * d.z));

      y.normalize();
      d.normalize();

      Vector3d x = new Vector3d();
      x.cross(y, d);
      x.normalize();

      //orient.setRow(0, x);
      //orient.setRow(1, y);
      orient.setRow(2, d);

      Vector3d translation = new Vector3d((Tuple3d)p);

      t.set(orient, translation, 1.0);

      return;




      // try again!!@#!@!@#!@#!@#?!?!
      /*
      double roll = d.z, pitch = d.x, yaw = d.y;

      Matrix3d x_rot = new Matrix3d();
      Matrix3d y_rot = new Matrix3d();
      Matrix3d z_rot = new Matrix3d();
      Matrix3d orient = new Matrix3d();

      z_rot.rotZ(roll);
      y_rot.rotY(yaw);
      x_rot.rotX(pitch);

      orient.setIdentity();

      orient.mul(z_rot);
      orient.mul(y_rot);
      orient.mul(x_rot);

      Vector3d translation = new Vector3d((Tuple3d)p);

      t.set(orient, translation, 1.0);

      return;
      */




      // try lookat?!
      /*
      Point3d center = new Point3d();
      center.add(p, d);

      t.lookAt(p, center, new Vector3d(0.0, 1.0, 0.0));
      return;
      */



      // try DOF method from computer graphics book!>!?!
      /*
      Vector3d translation = new Vector3d((Tuple3d)p);
      t.setTranslation(translation);

      Vector3d x = new Vector3d(1.0, 0.0, 0.0);
      Vector3d y = new Vector3d(0.0, 1.0, 0.0);
      Vector3d z = new Vector3d(0.0, 0.0, 1.0);

      // Normalize the direction first.
      //d.normalize();

      Matrix3d rot = new Matrix3d();
      //rot.setIdentity();
      Vector3d v = new Vector3d();
      v.cross(y, d);
      v.normalize();
      rot.setColumn(0, v);

      v.cross(y, d);
      v.cross(d, v);
      v.normalize();
      rot.setColumn(1, v);

      rot.setColumn(2, d);

      t.setRotation(rot);
      return;
      */




      // try euler method?!!?!?
      //d.normalize();
      /*
      Vector3d translation = new Vector3d((Tuple3d)p);
      //translation.negate();
      t.setTranslation(translation);

      Transform3D rot = new Transform3D();
      rot.setEuler(new Vector3d(d));
      Matrix3d rot_matrix = new Matrix3d();
      rot.get(rot_matrix);
      t.setRotation(rot_matrix);

      //translation.negate();
      //t.setTranslation(translation);
      return;
      */




      // what method is this!?!!?
      /*
      Vector3f x = new Vector3f(1.0f, 0.0f, 0.0f);
      Vector3f y = new Vector3f(0.0f, 1.0f, 0.0f);
      Vector3f z = new Vector3f(0.0f, 0.0f, 1.0f);

      Matrix3d rot = new Matrix3d();
      rot.setIdentity();

      t.get(rot);

      System.err.println("dir = " + d);

      Matrix3d x_rot = new Matrix3d();
      Vector3f temp = new Vector3f();
      x_rot.setIdentity();
      //x_rot.rotX();
      //System.err.println("x angle = " + z.angle(temp));

      Matrix3d y_rot = new Matrix3d();
      y_rot.setIdentity();
      //y_rot.rotY();
      //System.err.println("y angle = " + x.angle(temp));

      Matrix3d z_rot = new Matrix3d();
      z_rot.setIdentity();
      //y_rot.rotZ();
      //System.err.println("z angle = " + y.angle(temp));

      rot.mul(x_rot);
      rot.mul(y_rot);
      rot.mul(z_rot);

      // Now set the rotation of this transform.
      t.setRotation(rot);
      */
    }


  /**
   * Updates the child TransformGroup of the BranchGroup with the new
   * Transform3D.  This method must be called if position, normal,
   * direction change and the Transform3D must be updated.
   */
  private void _updateTransformGroup()
    {

      // Update the Transform3D for this object with the new info.
      _updateTransform(_transform, _position, _direction, _normal);

      // Now update the TransformGroup with the new Transform3D values.
      _transform_group.setTransform(_transform);
    }


  /**
   * Returns the TransformGroup which positions, directs, etc. this Entity
   * and any children of this Entity.  When setPosition, setNormal, etc.,
   * are called they affect this TransformGroup.
   *
   * @return The TransformGroup that positions this Entity.
   */
  protected TransformGroup getTransformGroup()
    {
      return(_transform_group);
    }


  /**
   * Adds a child Entity under the TransformGroup of this Entity.  The child's
   * TransformGroup will transform its position relative to
   * its parents.  In java3D terms, the TransformGroup will be a child of this
   * Entity's TransformGroup, thus any setPosition, etc., made to the
   * child Entity will be relative to where the parent is.
   * Note each child can have one parent as per java3D.
   *
   * @param child The Entity to add as a child of this Entity.
   * @return false if child is already a child.
   */
  public boolean addChild(Entity child)
    {

      /* Get this child's TransformGroup and add it as a child to our
       * TransformGroup.
       */
      //_transform_group.addChild(child.getTransformGroup());

      /* Add this child's to our TransformGroup.
       */
      _transform_group.addChild(child);

      // Now add this Entity to our collection of children.
      //return(_children.add(child));
      return(true);
    }


  /**
   * Removes a child Entity from this Entity.
   *
   * @param child The Entity child to remove.
   * @return false if child is not a child of this Entity.
   */
  public boolean removeChild(Entity child)
    {

      /* Remove this child's from a child of this
       * Entity's TransformGroup.
       */

      // This is dumb, the Group class has no way of just removing a child
      // without an index!  So we have to find the child ourselvs.
      int limit = _transform_group.numChildren();
      //TransformGroup tg;

      for (int i = 0; i < limit; ++i)
        {

          //tg = (TransformGroup) _transform_group.getChild(i);

          //if (tg == child.getTransformGroup())
          if (_transform_group.getChild(i) == child)
            {

              /* Ok, we have the index of the child to remove, so remove
               * it from the TransformGroup.
               */
              _transform_group.removeChild(i);

              // Now remove it from our collection.
              //return(_children.remove(child));
              return(true);
            }
        }

      // We don't have this child.
      return(false);
    }


  /**
   * Gets the total number of Entity children this Entity has.
   *
   * @return The number of children this Entity has.
   */
  public int getNumberOfChildren()
    {
      //return(_children.size());
      return(_transform_group.numChildren());
    }


  /**
   * Returns the children of this Entity.
   *
   * @return The children of this Entity.
   */
  public Enumeration getChildren()
    {
      //return(_children.iterator());
      return(_transform_group.getAllChildren());
    }


  /**
   * Returns the position of the center of this object in the passed Point3d.
   *
   * @param pos The Point3d to return the value in.
   */
  public void getPosition(Point3d pos)
    {
      pos.set(_position);
    }


  /**
   * Sets the position of the center of this object.
   *
   * @param position The Point3d to set this objects position to.
   */
  public void setPosition(Point3d pos)
    {

      _position.set(pos);
      _updateTransformGroup();
    }


  /**
   * Returns the velocity of this object.
   *
   * @param v Returns the velocity of this object in this Vector3f.
   */
  public void getVelocity(Vector3d v)
    {
      v.set(_velocity);
    }


  /**
   * Sets the velocity of this object.
   *
   * @param v The Vector3f to set this objects velocity to.
   */
  public void setVelocity(Vector3d v)
    {

      _velocity.set(v);
      _updateTransformGroup();
    }


  /**
   * Returns the mass of this object.
   *
   * @return Returns the mass of this object.
   */
  public float getMass()
    {
      return(_mass);
    }


  /**
   * Sets the mass of this object.
   *
   * @param The value to set this objects mass to.
   */
  protected void setMass(float mass)
    {
      _mass = mass;
    }


  /**
   * Returns the acceleration of this object.
   *
   * @param a Returns the acceleration of this object in this Vector3f.
   */
  public void getAcceleration(Vector3d a)
    {
      a.set(_acceleration);
    }


  /**
   * Sets the acceleration of this object.
   *
   * @param a The value to set this objects acceleration to.
   */
  public void setAcceleration(Vector3d a)
    {
      _acceleration.set(a);
    }


  /**
   * Returns the max speed of this object.
   *
   * @return Returns the max speed of this object.
   */
  public float getMaxSpeed()
    {
      return(_max_speed);
    }


  /**
   * Sets the max speed of this object.
   *
   * @param The value to set this objects max speed to.
   */
  protected void setMaxSpeed(float max_speed)
    {
      _max_speed = max_speed;
    }


  /**
   * Returns the normal of this object.
   *
   * @param n Returns the normal of this object in this Vector3f.
   */
  public void getNormal(Vector3d n)
    {
      n.set(_normal);
    }


  /**
   * Sets the normal of this object.
   *
   * @param n The Vector3d to set this objects normal to.
   */
  public void setNormal(Vector3d n)
    {

      _normal.set(n);
      _updateTransformGroup();
    }



  /**
   * Returns the direction of this object.
   *
   * @param n Returns the direction of this object in this Vector3f.
   */
  public void getDirection(Vector3d d)
    {
      d.set(_direction);
    }


  /**
   * Sets the direction of this object.  This will affect
   * the normal as well.
   *
   * @param n The Vector3d to set this objects direction to.
   */
  public void setDirection(Vector3d d)
    {

      _direction.set(d);
      _updateTransformGroup();
    }


  /**
   * Returns this Entity's id.  This id is unique for all instances of Entity.
   *
   * @return The id of this Entity.
   */
  /*public int getId()
    {
    return(_id);
    }*/

}
begin:vcard
n:deprince jr.;wayne c.
tel;cell:215.630.5146
tel;home:610.997.0147
tel;work:610.758.4785
x-mozilla-html:TRUE
url:http://www.lehigh.edu/~wcd2
org:Lehigh University;Electrical Engineering and Computer Science
adr:;;328 Adams Street Apt. #204;Bethlehem;PA;18015;USA
version:2.1
email;internet:[EMAIL PROTECTED]
title:MS/Phd Student - T.A.
note;quoted-printable:Instant Messenger Name - mrgrimm55=0D=0A
end:vcard

Reply via email to