// Transform.java

public class Transform {
   public Transform ()
   {  working = new Matrix ();  inverse = new Matrix ();  current = false;
      depth = 0;  initialize (1);
   }

   public Transform (int i)
   {  working = new Matrix ();  inverse = new Matrix ();  current = false;
      depth = 0;  initialize (i);
   }

   final void concatenate ()
   {  matrix.multiply (working, inverse);  matrix.load (inverse);  dirty ();  }

   public final int depth ()  {return depth;}

   final void dirty ()  {current = false;}

   public final void identity ()  {matrix.identity ();  dirty ();}

   public final void initialize (int i)
   {  stack = new Matrix[i];
      for (int j = 0; j < i; j++)  stack[j] = new Matrix ();
      matrix = stack[0];
   }

   public final Matrix inverse ()  {update ();  return inverse;}

   public final void invert ()
   {  matrix.inverse (working);  inverse.load(matrix);  matrix.load(working);  }

   public final Matrix matrix ()  {return matrix;}

   public final void multiply (Matrix matrix1)
   {  matrix.multiply (matrix1, working);  matrix.load (working);  dirty ();  }

   public final void orthographic (float f, float f1, float f2, float f3,
                                   float f4, float f5)
   {  working.orthographic (f, f1, f2, f3, f4, f5);  concatenate ();  }

   public final void pop ()
   {  depth--;  stack[depth].load (matrix);  matrix = stack[depth];  }

   public final void projection (float f, float f1, float f2, float f3,
                                 float f4, float f5)
   {  working.projection (f, f1, f2, f3, f4, f5);  concatenate ();  }

   public final void push ()
   {  depth++;  stack[depth].load (matrix);  matrix = stack[depth];  }

   public final void rotate (float f, Vector vector)
   {  working.rotate (f, vector);  concatenate ();  }

   public final void rotateX (float f)  {working.rotateX (f);  concatenate ();}
   public final void rotateY (float f)  {working.rotateY (f);  concatenate ();}
   public final void rotateZ (float f)  {working.rotateZ (f);  concatenate ();}
   public final void scale (float f)    {working.scale (f);    concatenate ();}

   public final void scale (float f, float f1, float f2)
   {  working.scale (f, f1, f2);  concatenate ();  }

   public final int size ()  {return stack.length;}

   public final void transform (Vector vector, Vector vector1)
   {  matrix.transform (vector, vector1);  }

   public final void translate (float f, float f1, float f2)
   {  working.translate (f, f1, f2);  concatenate ();  }

   public final void transpose ()
   {  matrix.transpose (working);  matrix.load (working);  dirty ();  }

   final void update ()
   {  if (!current) {matrix.inverse (inverse);  current = true;}  }

   public final void zero ()  {matrix.zero ();  dirty ();}

   Matrix  matrix, working, inverse, stack [];
   int     depth;
   boolean current;
}