Commit: 330dbd18622934376d803455320607727de98fa6 - MikuMikuStudio (git)

Main repository of MikuMikuStudio

Commit MetaInfo

• Revision: 330dbd18622934376d803455320607727de98fa6 (tree)
• Time: 2003-09-05 06:17:51
• Author: mojomonkey <mojomonkey@75d0...>
• Commiter: mojomonkey

Log Message

New Milkshape loader changes.

git-svn-id: http://jmonkeyengine.googlecode.com/svn/trunk@78 75d07b2b-3a1a-0410-a2c5-0572b91ccdca

Change Summary

• modified: src/jme/geometry/model/Joint.java
• modified: src/jme/geometry/model/Keyframe.java
• modified: src/jme/geometry/model/Material.java
• modified: src/jme/geometry/model/Mesh.java
• add: src/jme/geometry/model/Model.java
• modified: src/jme/geometry/model/Triangle.java
• modified: src/jme/geometry/model/Vertex.java
• modified: src/jme/geometry/model/ms/MilkshapeModel.java
• modified: src/jme/math/Matrix.java
• modified: src/jme/math/Vector.java
• modified: src/jme/system/DisplaySystem.java
• modified: src/jme/texture/TextureManager.java
• modified: src/test/general/TestMain.java
• add: src/test/model/ms3dAscii/TestAsciiMilkshape.java
• delete: src/test/model/{ => ms3dAscii}/TestMilkshape.java

Incremental Difference

--- a/src/jme/geometry/model/Joint.java
+++ b/src/jme/geometry/model/Joint.java
@@ -29,26 +29,90 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
+
 package jme.geometry.model;
 
 import jme.math.Matrix;
 
+
+
 /**
- * <code>Joint</code> defines a joint for a model. 
- * 
- * @author Mark Powell
+ * A Joint stores everything about an animated bone (a joint that knows
+ * about its parent joint - the two endpoints make up a bone).
+ *
+ * @author naj
+ * @version 0.1
  */
 public class Joint {
+
+    /**
+     * The name of the joint in MS3D.
+     */
     public String name;
+
+    /**
+     * The name of the parent joint in MS3D.
+     */
     public String parentName;
-    public float[] rotation = new float[3];
-    public float[] translation = new float[3];
-    public byte flags;
-    public Matrix absolute, relative;
-    public int numRotationKeyframes, numTranslationKeyframes;
-    public Keyframe[] translationKeyframes;
-    public Keyframe[] rotationKeyframes;
-    public int currentTranslationKeyframe, currentRotationKeyframe;
-    public Matrix finalMatrix;
-    public int parent;
-}
+
+    /**
+     * The flags in MS3D.
+     */
+    public int flags;
+
+    /**
+     * The local translation of the joint in 3D space.
+     */
+    public float posx, posy, posz;
+
+    /**
+     * The local rotation of the joint in 3D space.
+     */
+    public float rotx, roty, rotz;
+
+    /**
+     * The number of position keyframes for the joint.
+     */
+    public int numberPosistionKeyframes;
+
+    /**
+     * The number of position keyframes for the joint.
+     */
+    public int numberRotationKeyframes;
+
+    /**
+     * The tranlation keyframes of the animation.
+     */
+    public Keyframe[] positionKeys;
+
+    /**
+     * The rotation keyframes of the animation.
+     */
+    public Keyframe[] rotationKeys;
+
+    /**
+     * The transformation of a joint from its parent.
+     */
+    public Matrix relativeMatrix = new Matrix();
+
+    /**
+     * The original transformation of the joint.
+     */
+    public Matrix absoluteMatrix = new Matrix();
+
+    /**
+     * The helper matrix for calculating the final matrix.
+     */
+    public Matrix relativeFinalMatrix = new Matrix();
+
+    /**
+     * The final result of all transformations in the skeleton.
+     */
+    public Matrix finalMatrix = new Matrix();
+
+    /**
+     * The parent joint index.
+     */
+    public int parentIndex;
+
+}
\ No newline at end of file

--- a/src/jme/geometry/model/Keyframe.java
+++ b/src/jme/geometry/model/Keyframe.java
@@ -29,15 +29,44 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
+
 package jme.geometry.model;
 
 /**
- * <code>Keyframe</code> represents a frame of animation for a model.
- * 
- * @author Mark Powell
+ * A Keyframe is a point in time which defines when a joint will reach a
+ * certain rotation or translation. To perform animation, you interpolate
+ * the translation or rotation over the time frame.
+ *
+ * @author naj
+ * @version 0.1
  */
 public class Keyframe {
-    public int jointIndex;
+
+    /**
+     * The time in milliseconds after the start of the animation for which
+     * that keyframe occurs.
+     */
     public float time;
-    public float parameter[] = new float[3];
-}
+
+    /**
+     * For a position keyframe (x,y,z) are the coordinates to translate.
+     * For a rotation keyframe (x,y,z) are angles, in radians, to rotate.
+     */
+    public float x, y, z;
+
+    /**
+     * Create a keyframe at a given time and vector.
+     * @param time the time in milliseconds after the start of the animation
+     * for which that keyframe occurs.
+     * @param x the x value of the translation or rotation for the keyframe.
+     * @param y the y value of the translation or rotation for the keyframe.
+     * @param z the z value of the translation or rotation for the keyframe.
+     */
+    public Keyframe(float time, float x, float y, float z) {
+        this.time = time;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+}
\ No newline at end of file

--- a/src/jme/geometry/model/Material.java
+++ b/src/jme/geometry/model/Material.java
@@ -29,45 +29,66 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
+
 package jme.geometry.model;
 
 /**
- * <code>Material</code> maintains all standard lighting coeffecients 
- * for OpenGL based lighting as well as texture information. 
- * @author Mark Powell
+ * A Material is a texture map in MS3D.  Currently, as of version 0.1 of
+ * najgl, only bitmap (*.bmp) textures are supported.
+ *
+ * @author naj
+ * @version 0.1
  */
-
 public class Material {
+
+    /**
+     * The filename of the bitmap.  Must be relative to the loaded model file.
+     */
     public String name;
+
+    /**
+     * The filename of the color map.  Must be relative to the loaded model file.
+     */
+    public String colorMap;
+
+    /**
+     * The filename of the alpah map.  Must be relative to the loaded model file.
+     */
+    public String alphaMap;
+
+    /**
+     * A pointer to the memory address of the texture in opengl memory.
+     */
+    public int glTextureAddress;
+
+    /**
+     * An array of (r,g,b,a) color values for natural light.
+     */
+    public float[] ambient;
+
+    /**
+     * An array of (r,g,b,a) color values for indirect light.
+     */
+    public float[] diffuse;
+
+    /**
+     * An array of (r,g,b,a) color values for direct light.
+     */
+    public float[] specular;
+
+    /**
+     * An array of (r,g,b,a) color values for projected light.
+     */
+    public float[] emissive;
+
+    /**
+     * The ammount of light to be reflected off of the texture.
+     */
+    public float shininess;
+
+    /**
+     * The ammount of light to pass through the texture.
+     */
     public float transparency;
-    public byte mode;
-    public String alphaFilename;
-	/**
-	 * defines the color and intensity of the ambient or natural light.
-	 */
-	public float[] ambient = new float[4];
-	/**
-	 * defines the color and intensity of the diffuse or indirect light.
-	 */
-	public float[] diffuse = new float[4];
-	/**
-	 * defines the color and intensity of the specular or direct light.
-	 */
-	public float[] specular = new float[4];
-	/**
-	 * defines the color and intensity of the emissive or projected light.
-	 */
-	public float[] emissive = new float[4];
-	/**
-	 * defines the amount of light is reflected by the material.
-	 */
-	public float shininess;
-	/**
-	 * defines the id of the texture as assigned by OpenGL.
-	 */
-	public int texture;
-	/**
-	 * defines the name of the image file used to generate the texture.
-	 */
-	public String textureFilename;
-}
+
+}
\ No newline at end of file

--- a/src/jme/geometry/model/Mesh.java
+++ b/src/jme/geometry/model/Mesh.java
@@ -29,29 +29,61 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
+
 package jme.geometry.model;
 
 /**
- * <code>Mesh</code> defines a group of triangles that are all related in some way.
- * Typically a mesh will share a <code>Material</code> and a collection of meshes
- * will define a model.
- * @author Mark Powell
+ * A Mesh is a group of related triangles in MS3D.
  *
- *Special thanks to Chman's <a href="http://chman-area.tuxfamily.org">site</a> for help.
+ * @author naj
+ * @version 0.1
  */
 public class Mesh {
-    public byte flags;
+
+    /**
+     * The name of the mesh in MS3D.
+     */
     public String name;
-	/**
-	 * the index into an array of materials. 
-	 */
-	public int materialIndex;
-	/**
-	 * the number of triangles that make up the mesh.
-	 */
-	public int numTriangles;
-	/**
-	 * indices into the array of triangles.
-	 */
-	public int[] triangleIndices;
-}
+
+    /**
+     * The flags in MS3D.
+     */
+    public int flags;
+
+    /**
+     * The index into the array of materials in the model.  -1 indicates that
+     * the mesh does not have a material assigned to it.
+     */
+    public int materialIndex;
+
+    /**
+     * The number of vertices in the mesh.
+     */
+    public int numberVertices;
+
+    /**
+     * The number of normal vectors in the mesh.
+     */
+    public int numberNormals;
+
+    /**
+     * The number of triangles in the mesh.
+     */
+    public int numberTriangles;
+
+    /**
+     * The vertices in the mesh.
+     */
+    public Vertex[] vertices;
+
+    /**
+     * The normals in the mesh.  Stores as an array of (x,y,z) arrays.
+     */
+    public float[][] normals;
+
+    /**
+     * The traingles in the mesh.
+     */
+    public Triangle[] triangles;
+
+}
\ No newline at end of file

--- /dev/null
+++ b/src/jme/geometry/model/Model.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2003, jMonkeyEngine - Mojo Monkey Coding
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this 
+ * list of conditions and the following disclaimer. 
+ * 
+ * Redistributions in binary form must reproduce the above copyright notice, 
+ * this list of conditions and the following disclaimer in the documentation 
+ * and/or other materials provided with the distribution. 
+ * 
+ * Neither the name of the Mojo Monkey Coding, jME, jMonkey Engine, nor the 
+ * names of its contributors may be used to endorse or promote products derived 
+ * from this software without specific prior written permission. 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+package jme.geometry.model;
+
+/**
+ * An interface for models.  Models should be able to load from a file and
+ * draw itself (animated if possible).
+ *
+ * @author naj
+ * @version 0.1
+ */
+public interface Model {
+
+    /**
+     * Loads a model from a file that contains the model information.
+     * @param filename file that contains the model information.
+     */
+    public void load(String filename);
+
+    /**
+     * Draw the model (to opengl).
+     */
+    public void render();
+
+}
\ No newline at end of file

--- a/src/jme/geometry/model/Triangle.java
+++ b/src/jme/geometry/model/Triangle.java
@@ -29,34 +29,79 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
+
 package jme.geometry.model;
 
 /**
- * <code>Triangle</code> defines all attributes of a triangle. This includes
- * the three points that define it's position, the normal of each point, and
- * the texture coordinates.
+ * A Triangle is a polygon in MD3D.  It holds indexes to the three vertices
+ * in the model, as well as indexes to its normals.
  *
- * @author Mark Powell
+ * @author naj
+ * @version 0.1
  */
 public class Triangle {
+
+    /**
+     * The flags in MS3D.
+     */
     public int flags;
-    public byte smoothingGroup;
-    public byte groupIndex;
-    
-    /**
-	 * the indices into the array of vertices/
-	 */
-	public int[] vertexIndices = new int[3];
-	/**
-	 * the normal for each point.
-	 */
-	public float[][] vertexNormals = new float[3][3];
-	/**
-	 * the s texture coordinate for each point.
-	 */
-	public float[] s = new float[3];
-	/**
-	 * the t texture coordinate for each point.
-	 */
-	public float[] t = new float[3];
-}
+
+    /**
+     * Vertex 1.
+     */
+    public int vertexIndex1;
+
+    /**
+     * Vertex 2.
+     */
+    public int vertexIndex2;
+
+    /**
+     * Vertex 3.
+     */
+    public int vertexIndex3;
+
+    /**
+     * Normal 1.
+     */
+    public int normalIndex1;
+
+    /**
+     * Normal 2.
+     */
+    public int normalIndex2;
+
+    /**
+     * Normal 3.
+     */
+    public int normalIndex3;
+
+    /**
+     * The MS3D smoothing group.
+     */
+    public int smoothingGroup;
+
+    /**
+     * Creates a triangle with the vertices and normals given.
+     *
+     * @param flags the MS3D flags.
+     * @param vertexIndex1 vertex 1.
+     * @param vertexIndex2 vertex 2.
+     * @param vertexIndex3 vertex 3.
+     * @param normalIndex1 normal 1.
+     * @param normalIndex2 normal 2.
+     * @param normalIndex3 normal 3.
+     * @param smoothingGroup the MS3D smoothing group.
+     */
+    public Triangle(int flags, int vertexIndex1, int vertexIndex2, int vertexIndex3, int normalIndex1, int normalIndex2, int normalIndex3, int smoothingGroup) {
+        this.flags = flags;
+        this.vertexIndex1 = vertexIndex1;
+        this.vertexIndex2 = vertexIndex2;
+        this.vertexIndex3 = vertexIndex3;
+        this.normalIndex1 = normalIndex1;
+        this.normalIndex2 = normalIndex2;
+        this.normalIndex3 = normalIndex3;
+        this.smoothingGroup = smoothingGroup;
+    }
+
+}
\ No newline at end of file

--- a/src/jme/geometry/model/Vertex.java
+++ b/src/jme/geometry/model/Vertex.java
@@ -29,51 +29,74 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
-package jme.geometry.model;
-
-import jme.math.Vector;
 
+package jme.geometry.model;
 
 /**
- * <code>Vertex</code> provides an extension to <code>Vector</code> to handle
- * texture coordinates as well as positions. 
- * 
- * @author Mark Powell
+ * A Vertex is a 3D point (x,y,z) along with a 2D texture map point (u,v).
+ * It also knows which bone (Joint) it is associated with for animations.
+ *
+ * @author naj
+ * @version 0.1
  */
-public class Vertex extends Vector {
-    public byte refCount;
+public class Vertex {
+
+    /**
+     * The flags in MS3D.
+     */
+    public int flags;
+
+    /**
+     * The x value of the 3D point.
+     */
+    public float x;
+
+    /**
+     * The y value of the 3D point.
+     */
+    public float y;
+
+    /**
+     * The z value of the 3D point.
+     */
+    public float z;
+
+    /**
+     * The x value of the 2D texture point.
+     */
+    public float u;
+
+    /**
+     * The y value of the 2D texture point.
+     */
+    public float v;
+
+    /**
+     * The index into the array of bones (Joint) in the model.
+     */
+    public int boneIndex;
     
-    public byte flags;
-	/**
-	 * the u coordinate of the texture.
-	 */
-	public float u;
-	/**
-	 * the v coordinate of the texture.
-	 */
-	public float v;
-	/**
-	 * the red component of the color.
-	 */
-	public float r;
-	/**
-	 * the green component of the color.
-	 */
-	public float g;
-	/**
-	 * the blue component of the color.
-	 */
-	public float b;
-	/**
-	 * the alpha value of the point.
-	 */
-	public float a;
-	/**
-	 * the bone this point is connected to.
-	 */
-	public byte boneId;
-	/**
-	 * the position of the point.
-	 */
-	public float[] point = new float[3];
-}
+    public Vertex() {}
+
+    /**
+     * Creates a Vertex with the given 3D point and texture coordinates, as
+     * well as a bone reference if used in animations.
+     * @param flags the flags in MS3D.
+     * @param x the x value of the 3D point.
+     * @param y the y value of the 3D point.
+     * @param z the z value of the 3D point.
+     * @param u the x value of the 2D texture point.
+     * @param v the y value of the 2D texture point.
+     * @param boneIndex the index into the array of bones (Joint) in the model.
+     */
+    public Vertex(int flags, float x, float y, float z, float u, float v, int boneIndex) {
+        this.flags = flags;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.u = u;
+        this.v = v;
+        this.boneIndex = boneIndex;
+    }
+
+}
\ No newline at end of file

--- a/src/jme/geometry/model/ms/MilkshapeModel.java
+++ b/src/jme/geometry/model/ms/MilkshapeModel.java
@@ -29,644 +29,594 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
+
 package jme.geometry.model.ms;
 
+import java.io.BufferedReader;
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
+import java.io.FileReader;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
-import java.nio.FloatBuffer;
-import java.util.logging.Level;
-
-import org.lwjgl.opengl.GL;
-import org.lwjgl.opengl.Window;
 
-import jme.exception.MonkeyGLException;
-import jme.geometry.*;
-import jme.geometry.bounding.BoundingBox;
-import jme.geometry.bounding.BoundingSphere;
 import jme.geometry.model.Joint;
 import jme.geometry.model.Keyframe;
 import jme.geometry.model.Material;
 import jme.geometry.model.Mesh;
+import jme.geometry.model.Model;
 import jme.geometry.model.Triangle;
 import jme.geometry.model.Vertex;
 import jme.math.Matrix;
+import jme.math.Quaternion;
 import jme.math.Vector;
+import jme.system.DisplaySystem;
 import jme.texture.TextureManager;
-import jme.utility.Conversion;
-import jme.utility.LoggingSystem;
+
+import org.lwjgl.opengl.GL;
 
 /**
- * 
- * <code>MilkshapeModel</code> defines a model created by the Milkshape 3D 
- * modeling package. The loader handles all aspects of the Milkshape model up
- * to version 3. Animation is not currently supported, but planned.
- * 
- * @author Mark Powell
- * @version $Id: MilkshapeModel.java,v 1.5 2003-09-03 16:20:52 mojomonkey Exp $
+ * A MilkshapeModel represents a Milkshape 3D model.  Currently, it can only
+ * load the exported ascii text version of an MD3D model.  In the future, the
+ * binary version may be supported, but there really is no need for it because
+ * it does not matter how long it takes to load the animation.  Loading should
+ * take place at game startup.  If speed becomes extremely important in the
+ * future, the binary loader may be an option, or serialized models is another
+ * option.  Unless someone contributes a binary loader or add the nehe lwjgl
+ * port of the binary loader that actually loads multiple texture correctly :)
+ *
+ * The model can also draw itself, fully textured, to OpenGL through lwjgl.
+ *
+ * Bone animation is also supported.
+ *
+ * SPECIAL THANKS:
+ * Animation method was ported by naj from a MSVC++ Model Viewer tutorial
+ * written by Mete Ciragan (creator of Milkshape).
+ *
+ * @author naj
+ * @version 0.1
  */
-public class MilkshapeModel implements Geometry {
-    //defines the bounding volumes of the model.
-    private BoundingSphere boundingSphere;
-    private BoundingBox boundingBox;
-
-    //animation attributes
-    private float animationFPS;
-    private float currentTime;
-    private int totalFrames;
-
-    //model data information
-    private String modelFile;
-    private ByteBuffer buffer;
-    private String id;
-    private String path;
-    private int version;
+public class MilkshapeModel implements Model {
 
     /**
-     * the color of the model. This color will be applied as a whole to the
-     * model and may be trumped by the material level.
-     */
-    private float red, blue, green, alpha;
-    /**
-     * the scale of the model, where 1.0 is the standard size of the model.
-     */
-    private Vector scale;
-    /**
-     * the number of meshes that makes up the model.
+     * Debugging variable to toggle animations.
      */
-    private int numMeshes = 0;
-    /**
-     * the number of materials that makes up the model.
-     */
-    private int numMaterials = 0;
-    /**
-     * the number of triangles that makes up the model.
-     */
-    private int numTriangles = 0;
+    private boolean animated;
+
     /**
-     * the number of vertices that makes up the model.
+     * The total number of frames in the animation.
      */
-    private int numVertices = 0;
+    private int totalFrames;
+
     /**
-     * the number of joints that make up the model.
+     * The current frame of the animation.
      */
-    private int numJoints = 0;
+    private float currentFrame;
+
     /**
-     * the total animation time.
+     * The number of meshes in the model.
      */
-    private float totalTime = 0;
+    private int numberMeshes;
+
     /**
-     * the array of meshes that build the model.
+     * The number of materials or textures in the model.
      */
-    private Mesh meshes[] = null;
+    private int numberMaterials;
+
     /**
-     * the array of materials that build the model.
+     * The number of joints or bones in the model.
      */
-    private Material materials[] = null;
+    private int numberJoints;
+
     /**
-     * the array of triangles that build the model.
+     * The meshes in the model.
      */
-    private Triangle triangles[] = null;
+    private Mesh[] meshes;
+
     /**
-     * the array of vertices that build the model.
+     * The materials in the model.
      */
-    private Vertex vertices[] = null;
+    private Material[] materials;
+
     /**
-     * the array of Joints that build the model.
+     * The joints in the model.
      */
-    private Joint joints[] = null;
+    private Joint[] joints;
 
     /**
-     * Constructor instantiates a new <code>MilkshapeModel</code> object. 
-     * @param modelFile the Milkshape file.
-     * @throws MonkeyGLException if the OpenGL context has not been created.
+     * The absolute path to the directory containing the model file.  Used
+     * to load the texture files.
      */
-    public MilkshapeModel(String modelFile) {
-        if (!Window.isCreated()) {
-            throw new MonkeyGLException(
-                "OpenGL context must be " + "created before MilkshapeModel.");
-        }
+    private String absoluteFilePath;
 
-        this.modelFile = modelFile;
+    
 
-        red = 1.0f;
-        blue = 1.0f;
-        green = 1.0f;
-        alpha = 1.0f;
-        scale = new Vector(1.0f, 1.0f, 1.0f);
+    public MilkshapeModel() {
+        this.animated = false;
+    }
 
-        initialize();
-        setBoundingVolumes();
+    public MilkshapeModel(boolean animated) {
+        this.animated = animated;
     }
 
     /**
-     * <code>initialize</code> reads the Milkshape model and sets the 
-     * structure for rendering.
+     * Draws the model to OpenGL via lwjgl.  Also advances the animation
+     * frames along if there are animations for the model.
      */
-    public void initialize() {
-        //read the byte data
-        byte data[] = null;
-        File file = new File(modelFile);
-        path =
-            file.getAbsolutePath().substring(
-                0,
-                file.getAbsolutePath().length() - file.getName().length());
-        int length = (int) file.length();
-        data = new byte[length];
-        FileInputStream fis;
-        try {
-            fis = new FileInputStream(file);
-            fis.read(data);
-            fis.close();
-        } catch (FileNotFoundException e) {
-            LoggingSystem.getLoggingSystem().getLogger().log(
-                Level.WARNING,
-                "Could not find model file " + modelFile);
-            return;
-        } catch (IOException e) {
-            LoggingSystem.getLoggingSystem().getLogger().log(
-                Level.WARNING,
-                "Could not read model file " + modelFile);
-            return;
+    public void render() {
+        
+        if (animated) {
+            advanceFrame();
         }
+        boolean isTextureEnabled = GL.glIsEnabled(GL.GL_TEXTURE_2D);
 
-        buffer = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
+        for (int meshIndex = 0; meshIndex < numberMeshes; meshIndex++) {
+            int materialIndex = meshes[meshIndex].materialIndex;
 
-        //read header information
-        //the ID is 10 bytes
-        byte idBuffer[] = new byte[10];
-        for (int i = 0; i < 10; i++) {
-            idBuffer[i] = buffer.get();
-        }
-        id = Conversion.byte2String(idBuffer);
-        version = buffer.getInt();
-
-        if (!id.equals("MS3D000000")) {
-            LoggingSystem.getLoggingSystem().getLogger().log(
-                Level.WARNING,
-                modelFile + " is not a valid Milkshape3D model file.");
-            return;
-        }
-
-        if (version < 3) {
-            LoggingSystem.getLoggingSystem().getLogger().log(
-                Level.WARNING,
-                "Bad " + modelFile + " version.");
-            return;
-        }
+            if (materialIndex >= 0) {
+                ByteBuffer buffer = ByteBuffer.allocateDirect(16).order(ByteOrder.nativeOrder());
 
-        //Read the vertices
-        numVertices = buffer.getShort();
-        vertices = new Vertex[numVertices];
-        for (int i = 0; i < numVertices; i++) {
-            vertices[i] = new Vertex();
-            vertices[i].flags = buffer.get();
-            vertices[i].point[0] = buffer.getFloat();
-            vertices[i].point[1] = buffer.getFloat();
-            vertices[i].point[2] = buffer.getFloat();
-            vertices[i].boneId = buffer.get();
-            vertices[i].refCount = buffer.get();
-        }
+                GL.glMaterial(GL.GL_FRONT, GL.GL_AMBIENT, buffer.asFloatBuffer().put(materials[materialIndex].ambient));
+                GL.glMaterial(GL.GL_FRONT, GL.GL_DIFFUSE, buffer.asFloatBuffer().put(materials[materialIndex].diffuse));
+                GL.glMaterial(GL.GL_FRONT, GL.GL_SPECULAR, buffer.asFloatBuffer().put(materials[materialIndex].specular));
+                GL.glMaterial(GL.GL_FRONT, GL.GL_EMISSION, buffer.asFloatBuffer().put(materials[materialIndex].emissive));
+                GL.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, materials[materialIndex].shininess);
 
-        //Read the Triangles
-        numTriangles = buffer.getShort();
-        triangles = new Triangle[numTriangles];
-        for (int i = 0; i < numTriangles; i++) {
-            triangles[i] = new Triangle();
-            triangles[i].flags = buffer.getShort();
-            for (int j = 0; j < 3; j++) {
-                triangles[i].vertexIndices[j] = buffer.getShort();
+                if (materials[materialIndex].glTextureAddress > 0) {
+                    GL.glBindTexture(GL.GL_TEXTURE_2D, materials[materialIndex].glTextureAddress);
+                    GL.glEnable(GL.GL_TEXTURE_2D);
+                } else {
+                    GL.glDisable(GL.GL_TEXTURE_2D);
+                }
+            } else {
+                GL.glDisable(GL.GL_TEXTURE_2D);
             }
 
-            for (int j = 0; j < 3; j++) {
-                triangles[i].vertexNormals[j][0] = buffer.getFloat();
-                triangles[i].vertexNormals[j][1] = buffer.getFloat();
-                triangles[i].vertexNormals[j][2] = buffer.getFloat();
-            }
+            int triangleCount = meshes[meshIndex].numberTriangles;
+            Vertex[] vertices = meshes[meshIndex].vertices;
 
-            for (int j = 0; j < 3; j++) {
-                triangles[i].s[j] = buffer.getFloat();
-            }
+            GL.glBegin(GL.GL_TRIANGLES);
+            for (int triangleIndex = 0; triangleIndex < triangleCount; triangleIndex++) {
+                Triangle triangle = (meshes[meshIndex].triangles)[triangleIndex];
+
+                Vertex vertex = vertices[triangle.vertexIndex1];
+                float[] normals = (meshes[meshIndex].normals)[triangle.normalIndex1];
+                if (!animated || vertex.boneIndex == -1) {
+                    GL.glNormal3f(normals[0], normals[1], normals[2]);
+                    GL.glTexCoord2f(vertex.u, vertex.v);
+                    GL.glVertex3f(vertex.x, vertex.y, vertex.z);
+                } else {
+                    Vector animationVector = new Vector(vertex.x, vertex.y, vertex.z).rotate(joints[vertex.boneIndex].finalMatrix);
+                    animationVector.x += joints[vertex.boneIndex].finalMatrix.matrix[0][3];
+                    animationVector.y += joints[vertex.boneIndex].finalMatrix.matrix[1][3];
+                    animationVector.z += joints[vertex.boneIndex].finalMatrix.matrix[2][3];
+                    GL.glNormal3f(normals[0], normals[1], normals[2]);
+                    GL.glTexCoord2f(vertex.u, vertex.v);
+                    GL.glVertex3f(animationVector.x, animationVector.y, animationVector.z);
+                }
 
-            for (int j = 0; j < 3; j++) {
-                triangles[i].t[j] = 1.0f - buffer.getFloat();
+                vertex = vertices[triangle.vertexIndex2];
+                normals = (meshes[meshIndex].normals)[triangle.normalIndex2];
+                if (!animated || vertex.boneIndex == -1) {
+                    GL.glNormal3f(normals[0], normals[1], normals[2]);
+                    GL.glTexCoord2f(vertex.u, vertex.v);
+                    GL.glVertex3f(vertex.x, vertex.y, vertex.z);
+                } else {
+                    Vector animationVector = new Vector(vertex.x, vertex.y, vertex.z).rotate(joints[vertex.boneIndex].finalMatrix);
+                    animationVector.x += joints[vertex.boneIndex].finalMatrix.matrix[0][3];
+                    animationVector.y += joints[vertex.boneIndex].finalMatrix.matrix[1][3];
+                    animationVector.z += joints[vertex.boneIndex].finalMatrix.matrix[2][3];
+                    GL.glNormal3f(normals[0], normals[1], normals[2]);
+                    GL.glTexCoord2f(vertex.u, vertex.v);
+                    GL.glVertex3f(animationVector.x, animationVector.y, animationVector.z);
+                }
+
+                vertex = vertices[triangle.vertexIndex3];
+                normals = (meshes[meshIndex].normals)[triangle.normalIndex3];
+                if (!animated || vertex.boneIndex == -1) {
+                    GL.glNormal3f(normals[0], normals[1], normals[2]);
+                    GL.glTexCoord2f(vertex.u, vertex.v);
+                    GL.glVertex3f(vertex.x, vertex.y, vertex.z);
+                } else {
+                    Vector animationVector = new Vector(vertex.x, vertex.y, vertex.z).rotate(joints[vertex.boneIndex].finalMatrix);
+                    animationVector.x += joints[vertex.boneIndex].finalMatrix.matrix[0][3];
+                    animationVector.y += joints[vertex.boneIndex].finalMatrix.matrix[1][3];
+                    animationVector.z += joints[vertex.boneIndex].finalMatrix.matrix[2][3];
+                    GL.glNormal3f(normals[0], normals[1], normals[2]);
+                    GL.glTexCoord2f(vertex.u, vertex.v);
+                    GL.glVertex3f(animationVector.x, animationVector.y, animationVector.z);
+                }
             }
+            GL.glEnd();
+        }
 
-            triangles[i].smoothingGroup = buffer.get();
-            triangles[i].groupIndex = buffer.get();
+        if (isTextureEnabled) {
+            GL.glEnable(GL.GL_TEXTURE_2D);
+        } else {
+            GL.glDisable(GL.GL_TEXTURE_2D);
         }
+        
+    }
 
-        //Read the meshes
-        numMeshes = buffer.getShort();
-        meshes = new Mesh[numMeshes];
-        for (int i = 0; i < numMeshes; i++) {
-            meshes[i] = new Mesh();
-            meshes[i].flags = buffer.get();
-            //get the name 32 bytes
-            byte nameBuffer[] = new byte[32];
-            for (int j = 0; j < 32; j++) {
-                nameBuffer[j] = buffer.get();
-            }
-            meshes[i].name = Conversion.byte2String(nameBuffer);
-            meshes[i].numTriangles = buffer.getShort();
-            meshes[i].triangleIndices = new int[meshes[i].numTriangles];
-            for (int j = 0; j < meshes[i].numTriangles; j++) {
-                meshes[i].triangleIndices[j] = buffer.getShort();
+    /**
+     * Loads an ascii text model exported from MS3D.
+     * @param filename the file to load.
+     */
+    public void load(String filename) {
+        try {
+            File file = new File(filename);
+            absoluteFilePath = file.getAbsolutePath();
+            absoluteFilePath = absoluteFilePath.substring(0, absoluteFilePath.lastIndexOf(File.separator) + 1);
+            BufferedReader reader = new BufferedReader(new FileReader(file));
+            String line;
+            while ( (line = getNextLine(reader)) != null) {
+                if (line.startsWith("Frames: ")) {
+                    totalFrames = Integer.parseInt(line.substring(8));
+                }
+                if (line.startsWith("Frame: ")) {
+                    currentFrame = Integer.parseInt(line.substring(7));
+                }
+                if (line.startsWith("Meshes: ")) {
+                    numberMeshes = Integer.parseInt(line.substring(8));
+                    meshes = new Mesh[numberMeshes];
+                    parseMeshes(reader);
+                }
+                if (line.startsWith("Materials: ")) {
+                    numberMaterials = Integer.parseInt(line.substring(11));
+                    materials = new Material[numberMaterials];
+                    parseMaterials(reader);
+                }
+                if (line.startsWith("Bones: ")) {
+                    numberJoints = Integer.parseInt(line.substring(7));
+                    joints = new Joint[numberJoints];
+                    parseJoints(reader);
+                }
             }
-            meshes[i].materialIndex = buffer.get();
-
+        } catch (Exception e) {
+            e.printStackTrace();
         }
 
-        //read materials
-        numMaterials = buffer.getShort();
-        materials = new Material[numMaterials];
-        for (int i = 0; i < numMaterials; i++) {
-            materials[i] = new Material();
+        reloadTextures();
+    }
 
-            //read the material name 32 bytes
-            byte nameBuffer[] = new byte[32];
-            for (int j = 0; j < 32; j++) {
-                nameBuffer[j] = buffer.get();
+    /**
+     * Simple parser to extract the mesh information from the text file.
+     */
+    private void parseMeshes(BufferedReader reader) throws Exception {
+        for (int i = 0; i < numberMeshes; i++) {
+            Mesh mesh = new Mesh();
+            String line = getNextLine(reader);
+            mesh.name = line.substring(1, line.lastIndexOf("\""));
+            mesh.flags = Integer.parseInt(line.substring(line.lastIndexOf("\"") + 2, line.lastIndexOf(" ")));
+            mesh.materialIndex = Integer.parseInt(line.substring(line.lastIndexOf(" ") + 1));
+
+            line = getNextLine(reader);
+            mesh.numberVertices = Integer.parseInt(line);
+            Vertex[] vertices = new Vertex[mesh.numberVertices];
+            for (int j = 0; j < mesh.numberVertices; j++) {
+                line = getNextLine(reader);
+                String[] values = line.split(" ");
+                vertices[j] = new Vertex(Integer.parseInt(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2]), Float.parseFloat(values[3]), Float.parseFloat(values[4]), Float.parseFloat(values[5]), Integer.parseInt(values[6]));
             }
-            materials[i].name = Conversion.byte2String(nameBuffer);
-
-            materials[i].ambient[0] = buffer.getFloat();
-            materials[i].ambient[1] = buffer.getFloat();
-            materials[i].ambient[2] = buffer.getFloat();
-            materials[i].ambient[3] = buffer.getFloat();
-
-            materials[i].diffuse[0] = buffer.getFloat();
-            materials[i].diffuse[1] = buffer.getFloat();
-            materials[i].diffuse[2] = buffer.getFloat();
-            materials[i].diffuse[3] = buffer.getFloat();
-
-            materials[i].specular[0] = buffer.getFloat();
-            materials[i].specular[1] = buffer.getFloat();
-            materials[i].specular[2] = buffer.getFloat();
-            materials[i].specular[3] = buffer.getFloat();
-
-            materials[i].emissive[0] = buffer.getFloat();
-            materials[i].emissive[1] = buffer.getFloat();
-            materials[i].emissive[2] = buffer.getFloat();
-            materials[i].emissive[3] = buffer.getFloat();
-
-            materials[i].shininess = buffer.getFloat();
-            materials[i].transparency = buffer.getFloat();
-            materials[i].mode = buffer.get();
-
-            //get texture
-            byte texBuffer[] = new byte[128];
-            for (int j = 0; j < 128; j++) {
-                texBuffer[j] = buffer.get();
+            mesh.vertices = vertices;
+
+            line = getNextLine(reader);
+            mesh.numberNormals = Integer.parseInt(line);
+            float[][] normals = new float[mesh.numberNormals][3];
+            for (int j = 0; j < mesh.numberNormals; j++) {
+                line = getNextLine(reader);
+                String[] values = line.split(" ");
+                normals[j] = new float[] {
+                    Float.parseFloat(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2])};
             }
-            materials[i].textureFilename = Conversion.byte2String(texBuffer);
-            byte alphaBuffer[] = new byte[128];
-            for (int j = 0; j < 128; j++) {
-                alphaBuffer[j] = buffer.get();
+            mesh.normals = normals;
+
+            line = getNextLine(reader);
+            mesh.numberTriangles = Integer.parseInt(line);
+            Triangle[] triangles = new Triangle[mesh.numberTriangles];
+            for (int j = 0; j < mesh.numberTriangles; j++) {
+                line = getNextLine(reader);
+                String[] values = line.split(" ");
+                triangles[j] = new Triangle(Integer.parseInt(values[0]), Integer.parseInt(values[1]), Integer.parseInt(values[2]), Integer.parseInt(values[3]), Integer.parseInt(values[4]), Integer.parseInt(values[5]), Integer.parseInt(values[6]), Integer.parseInt(values[7]));
             }
-            materials[i].alphaFilename = Conversion.byte2String(texBuffer);
+            mesh.triangles = triangles;
+            meshes[i] = mesh;
         }
-        loadTextures();
-
-        //Read key frames
-        animationFPS = buffer.getFloat();
-        currentTime = (buffer.getFloat() * 1000);
-        totalFrames = buffer.getInt();
-
-        numJoints = buffer.getShort();
-        joints = new Joint[numJoints];
-
-        for (int i = 0; i < numJoints; i++) {
-            joints[i] = new Joint();
-            joints[i].flags = buffer.get();
-            //get name 32 bytes
-            byte[] nameBuffer = new byte[32];
-            for (int j = 0; j < 32; j++) {
-                nameBuffer[j] = buffer.get();
-            }
+    }
+
+    /**
+     * Simple parser to extract the material information from the text file.
+     */
+    private void parseMaterials(BufferedReader reader) throws Exception {
+        for (int i = 0; i < numberMaterials; i++) {
+            String line = getNextLine(reader);
+            Material material = new Material();
+            material.name = line.substring(1, line.length() - 1);
+            line = getNextLine(reader);
+            String[] values = line.split(" ");
+            material.ambient = new float[] {
+                Float.parseFloat(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2]), Float.parseFloat(values[3])};
+            line = getNextLine(reader);
+            values = line.split(" ");
+            material.diffuse = new float[] {
+                Float.parseFloat(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2]), Float.parseFloat(values[3])};
+            line = getNextLine(reader);
+            values = line.split(" ");
+            material.specular = new float[] {
+                Float.parseFloat(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2]), Float.parseFloat(values[3])};
+            line = getNextLine(reader);
+            values = line.split(" ");
+            material.emissive = new float[] {
+                Float.parseFloat(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2]), Float.parseFloat(values[3])};
+            line = getNextLine(reader);
+            material.shininess = Float.parseFloat(line);
+            line = getNextLine(reader);
+            material.transparency = Float.parseFloat(line);
+            line = getNextLine(reader);
+            material.colorMap = line.substring(1, line.length() - 1);
+            line = getNextLine(reader);
+            material.alphaMap = line.substring(1, line.length() - 1);
+            materials[i] = material;
+        }
+    }
 
-            joints[i].name = Conversion.byte2String(nameBuffer);
-            //get parent name 32 bytes
-            byte[] parentBuffer = new byte[32];
-            for (int j = 0; j < 32; j++) {
-                parentBuffer[j] = buffer.get();
+    /**
+     * Simple parser to extract the joint information from the text file.
+     */
+    private void parseJoints(BufferedReader reader) throws Exception {
+        for (int i = 0; i < numberJoints; i++) {
+            String line = getNextLine(reader);
+            Joint joint = new Joint();
+            joint.name = line.substring(1, line.length() - 1);
+            line = getNextLine(reader);
+            joint.parentName = line.substring(1, line.length() - 1);
+            line = getNextLine(reader);
+            String[] values = line.split(" ");
+            joint.flags = Integer.parseInt(values[0]);
+            joint.posx = Float.parseFloat(values[1]);
+            joint.posy = Float.parseFloat(values[2]);
+            joint.posz = Float.parseFloat(values[3]);
+            joint.rotx = Float.parseFloat(values[4]);
+            joint.roty = Float.parseFloat(values[5]);
+            joint.rotz = Float.parseFloat(values[6]);
+            line = getNextLine(reader);
+            joint.numberPosistionKeyframes = Integer.parseInt(line);
+            Keyframe[] positionKeyframes = new Keyframe[joint.numberPosistionKeyframes];
+            for (int j = 0; j < joint.numberPosistionKeyframes; j++) {
+                line = getNextLine(reader);
+                values = line.split(" ");
+                positionKeyframes[j] = new Keyframe(Float.parseFloat(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2]), Float.parseFloat(values[3]));
             }
-            joints[i].parentName = Conversion.byte2String(parentBuffer);
+            joint.positionKeys = positionKeyframes;
+            line = getNextLine(reader);
+            joint.numberRotationKeyframes = Integer.parseInt(line);
+            Keyframe[] rotationKeyframes = new Keyframe[joint.numberRotationKeyframes];
+            for (int j = 0; j < joint.numberRotationKeyframes; j++) {
+                line = getNextLine(reader);
+                values = line.split(" ");
+                rotationKeyframes[j] = new Keyframe(Float.parseFloat(values[0]), Float.parseFloat(values[1]), Float.parseFloat(values[2]), Float.parseFloat(values[3]));
+            }
+            joint.rotationKeys = rotationKeyframes;
+            joints[i] = joint;
 
             int parentIndex = -1;
             if (joints[i].parentName.length() > 0) {
-                for (int j = 0; j < numJoints; j++) {
-                    if (joints[j]
-                        .name
-                        .equalsIgnoreCase(joints[i].parentName)) {
+                for (int j = 0; j < numberJoints; j++) {
+                    if (joints[j].name.equalsIgnoreCase(joints[i].parentName)) {
                         parentIndex = j;
                         break;
                     }
                 }
                 if (parentIndex == -1) {
-                    LoggingSystem.getLoggingSystem().getLogger().log(
-                        Level.WARNING,
-                        "Milkshape does not have a parent joint.");
-                    return;
+                    System.out.println("CRAP!");
+                    System.exit(1);
                 }
             }
-            joints[i].parent = parentIndex;
-            joints[i].rotation[0] = buffer.getFloat();
-            joints[i].rotation[1] = buffer.getFloat();
-            joints[i].rotation[2] = buffer.getFloat();
-
-            joints[i].translation[0] = buffer.getFloat();
-            joints[i].translation[1] = buffer.getFloat();
-            joints[i].translation[2] = buffer.getFloat();
-
-            joints[i].numRotationKeyframes = buffer.getShort();
-            joints[i].rotationKeyframes =
-                new Keyframe[joints[i].numRotationKeyframes];
-
-            joints[i].numTranslationKeyframes = buffer.getShort();
-            joints[i].translationKeyframes =
-                new Keyframe[joints[i].numTranslationKeyframes];
-
-            for (int j = 0; j < joints[i].numRotationKeyframes; j++) {
-                joints[i].rotationKeyframes[j] = new Keyframe();
-                joints[i].rotationKeyframes[j].time =
-                    (buffer.getFloat() * 1000);
-                joints[i].rotationKeyframes[j].parameter[0] = buffer.getFloat();
-                joints[i].rotationKeyframes[j].parameter[1] = buffer.getFloat();
-                joints[i].rotationKeyframes[j].parameter[2] = buffer.getFloat();
-            }
-
-            for (int j = 0; j < joints[i].numTranslationKeyframes; j++) {
-                joints[i].translationKeyframes[j] = new Keyframe();
-                joints[i].translationKeyframes[j].time =
-                    (buffer.getFloat() * 1000);
-                joints[i].translationKeyframes[j].parameter[0] =
-                    buffer.getFloat();
-                joints[i].translationKeyframes[j].parameter[1] =
-                    buffer.getFloat();
-                joints[i].translationKeyframes[j].parameter[2] =
-                    buffer.getFloat();
-            }
+            joints[i].parentIndex = parentIndex;
+        }
+        if (animated) {
+            setupJointAnimations();
         }
-
-        //setupJoints();
-        //restart();
     }
 
     /**
-     * <code>render</code> using the current mesh and material information to
-     * display the model to the screen.
+     * Calculate the initial absolute and relative matrices for the joints.
      */
-    public void render() {
-        Triangle currentTri;
-        int triangleIndex;
-        int index;
-        FloatBuffer temp =
-            ByteBuffer
-                .allocateDirect(16)
-                .order(ByteOrder.nativeOrder())
-                .asFloatBuffer();
-        GL.glColor4f(red, green, blue, alpha);
-        GL.glPushMatrix();
-        GL.glScalef(scale.x, scale.y, scale.z);
-
-        //go through each mesh and render them.
-        for (int i = 0; i < numMeshes; i++) {
-            int materialIndex = meshes[i].materialIndex;
-            //if the material is set, use it to set the texture and lighting.
-            if (materialIndex >= 0) {
-                temp.clear();
-                temp.put(materials[materialIndex].ambient);
-                temp.flip();
-                GL.glMaterial(GL.GL_FRONT, GL.GL_AMBIENT, temp);
-                
-                temp.clear();
-                temp.put(materials[materialIndex].diffuse);
-                temp.flip();
-                GL.glMaterial(GL.GL_FRONT, GL.GL_DIFFUSE, temp);
-                
-                temp.clear();
-                temp.put(materials[materialIndex].specular);
-                temp.flip();
-                GL.glMaterial(GL.GL_FRONT, GL.GL_SPECULAR, temp);
-                
-                temp.clear();
-                temp.put(materials[materialIndex].emissive);
-                temp.flip();
-                GL.glMaterial(GL.GL_FRONT, GL.GL_EMISSION, temp);
-                
-                GL.glMaterialf(
-                    GL.GL_FRONT,
-                    GL.GL_SHININESS,
-                    materials[materialIndex].shininess);
-
-                if (materials[materialIndex].texture > 0) {
-                    TextureManager.getTextureManager().bind(
-                        materials[materialIndex].texture);
-                    GL.glEnable(GL.GL_TEXTURE_2D);
-                } else
-                    GL.glDisable(GL.GL_TEXTURE_2D);
+    private void setupJointAnimations() {
+        for (int jointIndex = 0; jointIndex < numberJoints; jointIndex++) {
+            Joint joint = joints[jointIndex];
+            Vector rotationVector = new Vector();
+            rotationVector.x = joint.rotx * 180 / (float) Math.PI;
+            rotationVector.y = joint.roty * 180 / (float) Math.PI;
+            rotationVector.z = joint.rotz * 180 / (float) Math.PI;
+            joints[jointIndex].relativeMatrix.angleRotationDegrees(rotationVector);
+            joints[jointIndex].relativeMatrix.matrix[0][3] = joint.posx;
+            joints[jointIndex].relativeMatrix.matrix[1][3] = joint.posy;
+            joints[jointIndex].relativeMatrix.matrix[2][3] = joint.posz;
+            if (joint.parentIndex != -1) {
+                joints[jointIndex].absoluteMatrix = joints[joint.parentIndex].absoluteMatrix.multiply(joints[jointIndex].relativeMatrix);
+                joints[jointIndex].finalMatrix.copy(joints[jointIndex].absoluteMatrix);
             } else {
-                GL.glDisable(GL.GL_TEXTURE_2D);
+                joints[jointIndex].absoluteMatrix.copy(joints[jointIndex].relativeMatrix);
+                joints[jointIndex].finalMatrix.copy(joints[jointIndex].relativeMatrix);
             }
+        }
 
-            GL.glBegin(GL.GL_TRIANGLES);
-            int m = meshes[i].numTriangles;
-
-            //render all triangles defined for the current mesh.
-            for (int j = 0; j < m; j++) {
-                triangleIndex = meshes[i].triangleIndices[j];
-                currentTri = triangles[triangleIndex];
-
-                for (int k = 0; k < 3; k++) {
-                    index = currentTri.vertexIndices[k];
-
-                    GL.glNormal3f(
-                        currentTri.vertexNormals[k][0],
-                        currentTri.vertexNormals[k][1],
-                        currentTri.vertexNormals[k][2]);
-                    GL.glTexCoord2f(currentTri.s[k], currentTri.t[k]);
-                    GL.glVertex3f(
-                        vertices[index].point[0],
-                        vertices[index].point[1],
-                        vertices[index].point[2]);
+        for (int meshIndex = 0; meshIndex < numberMeshes; meshIndex++) {
+            Mesh pMesh = meshes[meshIndex];
+            for (int j = 0; j < pMesh.numberVertices; j++) {
+                Vertex vertex = pMesh.vertices[j];
+                if (vertex.boneIndex != -1) {
+                    vertex.x -= joints[vertex.boneIndex].absoluteMatrix.matrix[0][3];
+                    vertex.y -= joints[vertex.boneIndex].absoluteMatrix.matrix[1][3];
+                    vertex.z -= joints[vertex.boneIndex].absoluteMatrix.matrix[2][3];
+                    Vector inverseRotationVector = new Vector();
+                    inverseRotationVector = new Vector(vertex.x, vertex.y, vertex.z).inverseRotate(joints[vertex.boneIndex].absoluteMatrix);
+                    vertex.x = inverseRotationVector.x;
+                    vertex.y = inverseRotationVector.y;
+                    vertex.z = inverseRotationVector.z;
                 }
             }
-            GL.glEnd();
         }
-        GL.glPopMatrix();
-        GL.glDisable(GL.GL_TEXTURE_2D);
-    }
-
-    /**
-     * <code>setTexture</code> is not used for the model. Instead, the 
-     * material set up is responsible for defining the texture.
-     * @param filename not used.
-     */
-    public void setTexture(String filename) {
-        //do nothing as textures are defined within the Milkshape MilkshapeModel.
-    }
-
-    /**
-     * <code>setColor</code> will define the color of the model. This overall
-     * color may be overridden by the defined material information of the
-     * model.
-     * @param red the red component of the color.
-     * @param green the green component of the color.
-     * @param blue the blue component of the color.
-     * @param alpha the transparency of the color.
-     */
-    public void setColor(float red, float green, float blue, float alpha) {
-        this.red = red;
-        this.green = green;
-        this.blue = blue;
-        this.alpha = alpha;
     }
 
     /**
-     * <code>setScale</code> sets the overall size of the model. The scale is
-     * used to decrease or increase the size of the model, where 1.0 is the 
-     * normal size of the model.
-     * @param scale the multiplier of the model's size.
+     * Set the final matrix of all of the joints to be part way between the
+     * previous keyframe and the next keyframe, depending on how much time
+     * has passed since the last keyframe.
      */
-    public void setScale(Vector scale) {
-        this.scale = scale;
-    }
+    private void advanceFrame() {
+        /* FIXME: The current frame needs to be determined by what milkshape
+                  model defined, not a constant value as below... otherwise,
+                  animations are going to be out of synch on different fps
+                  systems and animations with different numbers of frames */
+        //currentFrame += ExampleModelLoader.dt;
+        currentFrame += 0.1f;
+        if (currentFrame > totalFrames) {
+            currentFrame = 0.0f;
+        }
 
-    /**
-     * <code>getBoundingSphere</code> returns the bounding sphere that 
-     * contains the model.
-     * @return the bounding sphere of the model.
-     */
-    public BoundingSphere getBoundingSphere() {
-        return boundingSphere;
-    }
+        for (int meshIndex = 0; meshIndex < numberJoints; meshIndex++) {
+            Joint joint = joints[meshIndex];
+            int positionKeyframeCount = joint.numberPosistionKeyframes;
+            int rotationKeyframeCount = joint.numberRotationKeyframes;
+            if (positionKeyframeCount == 0 && rotationKeyframeCount == 0) {
+                joints[meshIndex].finalMatrix.copy(joints[meshIndex].absoluteMatrix);
+            } else {
+                Vector positionVector = new Vector();
+                Quaternion rotationVector = new Quaternion();
+                Keyframe lastPositionKeyframe = null;
+                Keyframe currentPositionKeyframe = null;
+                for (int keyframeIndex = 0; keyframeIndex < positionKeyframeCount; keyframeIndex++) {
+                    Keyframe positionKeyframe = joint.positionKeys[keyframeIndex];
+                    if (positionKeyframe.time >= currentFrame) {
+                        currentPositionKeyframe = positionKeyframe;
+                        break;
+                    }
+                    lastPositionKeyframe = positionKeyframe;
+                }
+                if (lastPositionKeyframe != null && currentPositionKeyframe != null) {
+                    float d = currentPositionKeyframe.time - lastPositionKeyframe.time;
+                    float s = (currentFrame - lastPositionKeyframe.time) / d;
+                    positionVector.x = lastPositionKeyframe.x + (currentPositionKeyframe.x - lastPositionKeyframe.x) * s;
+                    positionVector.y = lastPositionKeyframe.y + (currentPositionKeyframe.y - lastPositionKeyframe.y) * s;
+                    positionVector.z = lastPositionKeyframe.z + (currentPositionKeyframe.z - lastPositionKeyframe.z) * s;
+                } else if (lastPositionKeyframe == null) {
+                    currentPositionKeyframe.x = positionVector.x;
+                    currentPositionKeyframe.y = positionVector.y;
+                    currentPositionKeyframe.z = positionVector.z;
+                } else if (currentPositionKeyframe == null) {
+                    lastPositionKeyframe.x = positionVector.x;
+                    lastPositionKeyframe.y = positionVector.y;
+                    lastPositionKeyframe.z = positionVector.z;
+                }
+                Matrix slerpedMatrix = new Matrix();
+                Keyframe lastRotationKeyframe = null;
+                Keyframe currentRotationKeyframe = null;
+                for (int keyframeIndex = 0; keyframeIndex < rotationKeyframeCount; keyframeIndex++) {
+                    Keyframe rotationKeyframe = joint.rotationKeys[keyframeIndex];
+                    if (rotationKeyframe.time >= currentFrame) {
+                        currentRotationKeyframe = rotationKeyframe;
+                        break;
+                    }
+                    lastRotationKeyframe = rotationKeyframe;
+                }
+                if (lastRotationKeyframe != null && currentRotationKeyframe != null) {
+                    float d = currentRotationKeyframe.time - lastRotationKeyframe.time;
+                    float s = (currentFrame - lastRotationKeyframe.time) / d;
+                    Quaternion slerpedQuaternion = new Quaternion();
+                    Quaternion lastRotationQuaternion = new Quaternion();
+                    Quaternion currentRotationQuaternion = new Quaternion();
+                    lastRotationQuaternion.fromAngles(new float[]{lastRotationKeyframe.x, lastRotationKeyframe.y, lastRotationKeyframe.z});
+                    currentRotationQuaternion.fromAngles(new float[] {currentRotationKeyframe.x, currentRotationKeyframe.y, currentRotationKeyframe.z});
+                    slerpedQuaternion = slerpedQuaternion.slerp(lastRotationQuaternion, currentRotationQuaternion, s);
+                    slerpedMatrix.set(slerpedQuaternion);
+                } else if (lastRotationKeyframe == null) {
+                    rotationVector.x = currentRotationKeyframe.x * 180 / (float) Math.PI;
+                    rotationVector.y = currentRotationKeyframe.y * 180 / (float) Math.PI;
+                    rotationVector.z = currentRotationKeyframe.z * 180 / (float) Math.PI;
+                    slerpedMatrix.angleRotationDegrees(new Vector(rotationVector.x, rotationVector.y, rotationVector.z));
+                } else if (currentRotationKeyframe == null) {
+                    rotationVector.x = lastRotationKeyframe.x * 180 / (float) Math.PI;
+                    rotationVector.y = lastRotationKeyframe.y * 180 / (float) Math.PI;
+                    rotationVector.z = lastRotationKeyframe.z * 180 / (float) Math.PI;
+                    slerpedMatrix.angleRotationDegrees(new Vector(rotationVector.x, rotationVector.y, rotationVector.z));
+                }
+                slerpedMatrix.matrix[0][3] = positionVector.x;
+                slerpedMatrix.matrix[1][3] = positionVector.y;
+                slerpedMatrix.matrix[2][3] = positionVector.z;
+                joints[meshIndex].relativeFinalMatrix = joints[meshIndex].relativeMatrix.multiply(slerpedMatrix);
+                if (joint.parentIndex == -1) {
+                    joints[meshIndex].finalMatrix.copy(joints[meshIndex].relativeFinalMatrix);
+                } else {
+                    joints[meshIndex].finalMatrix = joints[joint.parentIndex].finalMatrix.multiply(joints[meshIndex].relativeFinalMatrix);
+                }
+            }
+        }
 
-    /**
-     * <code>getBoundingBox</code> returns the bounding box that contains the
-     * model.
-     * @return the bounding box of the model.
-     */
-    public BoundingBox getBoundingBox() {
-        return boundingBox;
     }
 
     /**
-     * <code>setBoundingVolumes</code> intializes the bounding sphere and box
-     * of the model.
-     *
+     * Returns the next line from the text file being parsed.  Removes
+     * comments and trims the line of whitespace.
      */
-    private void setBoundingVolumes() {
-        float distanceSqr = 0;
-        float tempValue;
-        for (int i = 0; i < numVertices; i++) {
-            tempValue =
-                vertices[i].point[0] * vertices[i].point[0]
-                    + vertices[i].point[1] * vertices[i].point[1]
-                    + vertices[i].point[2] * vertices[i].point[2];
-            if (tempValue > distanceSqr) {
-                distanceSqr = tempValue;
+    private String getNextLine(BufferedReader reader) throws Exception {
+        String line = null;
+        while ( (line = reader.readLine()) != null) {
+            line = line.trim();
+            if (line.startsWith("//") || "".equals(line)) {
+                continue;
             }
+            break;
         }
-        distanceSqr *= scale.x;
-        float distance = (float) Math.sqrt(distanceSqr);
-        boundingSphere = new BoundingSphere(distance, null);
-        boundingBox =
-            new BoundingBox(
-                new Vector(),
-                new Vector(-distance, -distance, -distance),
-                new Vector(distance, distance, distance));
+        return line;
     }
 
     /**
-     * <code>setupJoints</code> initializes the joint information for
-     * animation.
+     * Reloads the textures.
      */
-    private void setupJoints() {
-        for (int i = 0; i < numJoints; i++) {
-            joints[i].relative = new Matrix();
-            joints[i].absolute = new Matrix();
-            joints[i].finalMatrix = new Matrix();
-
-            joints[i].relative.setRotationRadians(joints[i].rotation);
-            joints[i].relative.setTranslation(joints[i].translation);
-
-            if (joints[i].parent != -1) {
-                joints[i].absolute.set(
-                    joints[joints[i].parent].absolute.getMatrix());
-                joints[i].absolute.multiply(joints[i].relative);
-            } else {
-                joints[i].absolute.set(joints[i].relative.getMatrix());
-            }
-        }
-
-        for (int i = 0; i < numVertices; i++) {
-            if (vertices[i].boneId != -1) {
-                joints[vertices[i].boneId].absolute.inverseTranslateVect(
-                    vertices[i].point);
-                joints[vertices[i].boneId].absolute.inverseRotateVect(
-                    vertices[i].point);
-            }
-        }
-
-        for (int i = 0; i < numTriangles; i++) {
-            Triangle tri = triangles[i];
-            for (int j = 0; j < 3; j++) {
-                Vertex vert = vertices[tri.vertexIndices[j]];
-                if (vert.boneId != -1) {
-                    joints[vert.boneId].absolute.inverseRotateVect(
-                        tri.vertexNormals[j]);
+    private final void reloadTextures() {
+        for (int i = 0; i < numberMaterials; i++) {
+            if (materials[i].name.length() > 0) {
+                try {
+                    materials[i].glTextureAddress = loadTexture(absoluteFilePath + materials[i].name);
+                } catch (Exception e) {
+                    materials[i].glTextureAddress = 0;
                 }
+            } else {
+                materials[i].glTextureAddress = 0;
             }
         }
     }
 
     /**
-     * 
-     * <code>restart</code> sets the animation to the initial key frame.
-     *
+     * Loads a bitmap (*.bmp image file) texture in opengl memory
+     * @param the relative filename to the bmp
+     * @return the image address in memory
      */
-    private void restart() {
-        for (int i = 0; i < numJoints; i++) {
-            joints[i].currentRotationKeyframe =
-                joints[i].currentTranslationKeyframe = 0;
-            joints[i].finalMatrix.set(joints[i].absolute.getMatrix());
-        }
+    private final int loadTexture(String file) throws Exception {
+        return TextureManager.getTextureManager().loadTexture(file, GL.GL_LINEAR_MIPMAP_LINEAR,
+        GL.GL_LINEAR,
+        true, false);
+        
     }
 
+
+    /* FIXME: these methods do not change the state of opengl so they can not
+              be used on the fly to change between modes since the opengl
+              state is currently created in the init method */
+
     /**
-     * <code>loadTextures</code> makes the appropriate call to have
-     * OpenGL load all needed textures for the given model.
-     *
+     * Determine is the model is going to run animations, if it has them.
+     * @return the animation mode.
      */
-    private void loadTextures() {
-        for (int i = 0; i < numMaterials; i++) {
-            if (materials[i].textureFilename.length() > 0) {
-                String fullFilename = getPath(materials[i].textureFilename);
-                materials[i].texture =
-                    TextureManager.getTextureManager().loadTexture(
-                        fullFilename,
-                        GL.GL_LINEAR_MIPMAP_LINEAR,
-                        GL.GL_LINEAR,
-                        true);
-            } else
-                materials[i].texture = 0;
-        }
+    public boolean isAnimated() {
+        return animated;
     }
 
     /**
-     * <code>getPath</code> returns the path of the file.
-     * @param name the file name.
-     * @return the full resolved file path.
+     * Set the new animation mode.
+     * @param animated the new animation mode.
      */
-    private String getPath(String name) {
-        if (name.indexOf(".\\") != -1) {
-            name = name.substring(1);
-        }
-        return path + name;
+    public void setAnimated(boolean animated) {
+        this.animated = animated;
     }
-
-}
+}
\ No newline at end of file

--- a/src/jme/math/Matrix.java
+++ b/src/jme/math/Matrix.java
@@ -39,11 +39,11 @@ import jme.exception.MonkeyRuntimeException;
  * convinience methods for creating the matrix from a multitude of sources.
  * 
  * @author Mark Powell
- * @version $Id: Matrix.java,v 1.5 2003-08-28 18:48:21 mojomonkey Exp $
+ * @version $Id: Matrix.java,v 1.6 2003-09-04 21:17:51 mojomonkey Exp $
  */
 public class Matrix {
-    private float matrix[];
-
+    public float matrix[][];
+    
     /**
      * Constructor instantiates a new <code>Matrix</code> that is set to the
      * identity matrix.
@@ -64,9 +64,11 @@ public class Matrix {
     	if(null == mat) {
     		loadIdentity();
     	} else {
-	    	for(int i = 0; i < 16; i++) {
-	    		matrix[i] = mat.getMatrix()[i];
-	    	}
+	    	for(int i = 0; i < 4; i++) {
+                for(int j = 0; j < 4; j++) {
+	    		 matrix[i][j] = mat.getMatrix()[i][j];
+	    	  }
+            }
     	}
     }
 
@@ -76,8 +78,8 @@ public class Matrix {
      *
      */
     public void loadIdentity() {
-        matrix = new float[16];
-        matrix[0] = matrix[5] = matrix[10] = matrix[15] = 1;
+        matrix = new float[4][4];
+        matrix[0][0] = matrix[1][1] = matrix[2][2] = matrix[3][3] = 1;
     }
 
     /**
@@ -86,19 +88,62 @@ public class Matrix {
      * @param matrix the matrix to set the value to.
      * @throws MonkeyRuntimeException if the array is not of size 16.
      */
-    public void set(float[] matrix) {
-        if (matrix.length != 16) {
+    public void set(float[][] matrix) {
+        if (matrix.length != 4 || matrix[0].length != 4) {
             throw new MonkeyRuntimeException("Array must be of size 16.");
         }
 
-        for (int i = 0; i < 16; i++) {
-            this.matrix[i] = matrix[i];
+        for (int i = 0; i < 4; i++) {
+            for(int j = 0; j < 4; j++ ) {
+                this.matrix[i][j] = matrix[i][j];
+            }
+        }
+    }
+    
+    public void set(float[] matrix) {
+        for(int i = 0; i < 4; i++) {
+            for(int j = 0; j < 4; j++) {
+                this.matrix[i][j] = matrix[j*4 + i];
+            }
+        }
+    }
+    
+    public void set(Quaternion quaternion) {
+        matrix[0][0] = (float) (1.0 - 2.0 * quaternion.y * quaternion.y - 2.0 * quaternion.z * quaternion.z);
+        matrix[1][0] = (float) (2.0 * quaternion.x * quaternion.y + 2.0 * quaternion.w * quaternion.z);
+        matrix[2][0] = (float) (2.0 * quaternion.x * quaternion.z - 2.0 * quaternion.w * quaternion.y);
+
+        matrix[0][1] = (float) (2.0 * quaternion.x * quaternion.y - 2.0 * quaternion.w * quaternion.z);
+        matrix[1][1] = (float) (1.0 - 2.0 * quaternion.x * quaternion.x - 2.0 * quaternion.z * quaternion.z);
+        matrix[2][1] = (float) (2.0 * quaternion.y * quaternion.z + 2.0 * quaternion.w * quaternion.x);
+
+        matrix[0][2] = (float) (2.0 * quaternion.x * quaternion.z + 2.0 * quaternion.w * quaternion.y);
+        matrix[1][2] = (float) (2.0 * quaternion.y * quaternion.z - 2.0 * quaternion.w * quaternion.x);
+        matrix[2][2] = (float) (1.0 - 2.0 * quaternion.x * quaternion.x - 2.0 * quaternion.y * quaternion.y);
+    
+    }
+    
+    public void copy(Matrix matrix) {
+        if(null == matrix) {
+            loadIdentity();
+        } else {
+            for(int i = 0; i < 4; i++) {
+                for(int j = 0; j < 4; j++) {
+                 this.matrix[i][j] = matrix.matrix[i][j];
+              }
+            }
         }
     }
     
+    /**
+     * <code>add</code> adds the values of a parameter matrix to this matrix.
+     * @param matrix the matrix to add to this.
+     */
     public void add(Matrix matrix) {
-        for(int i = 0; i < 16; i++) {
-            this.matrix[i] += matrix.getMatrix()[i];
+        for(int i = 0; i < 4; i++) {
+            for(int j = 0; j < 4; j++) {
+                this.matrix[i][j] += matrix.getMatrix()[i][j];
+            }
         }
     }
     
@@ -107,81 +152,53 @@ public class Matrix {
      * @param scalar the scalar to multiply this matrix by.
      */
     public void multiply(float scalar) {
-        for(int i = 0; i < 16; i++) {
-            matrix[i] *= scalar;
+        for(int i = 0; i < 4; i++) {
+            for(int j = 0; j < 4; j++) {
+                matrix[i][j] *= scalar;
+            }
         }
     }
 
     /**
-     * <code>multiply</code> multiplies this matrix with another matrix.
+     * <code>multiply</code> multiplies this matrix with another matrix. The
+     * result matrix will then be returned.
      * This matrix will be on the left hand side, while the parameter matrix
      * will be on the right.
-     * @param matrix the matrix to multiply this matrix by.
+     * @param in2 the matrix to multiply this matrix by.
+     * @return the resultant matrix
      * @throws MonkeyRuntimeException if matrix is null.
      */
-    public void multiply(Matrix matrix) {
-        if(null == matrix) {
-            throw new MonkeyRuntimeException("Matrix may not be null.");
-        }
-        this.matrix[0] =
-            this.matrix[0] * matrix.getMatrix()[0]
-                + this.matrix[4] * matrix.getMatrix()[1]
-                + this.matrix[8] * matrix.getMatrix()[2];
-        this.matrix[1] =
-            this.matrix[1] * matrix.getMatrix()[0]
-                + this.matrix[5] * matrix.getMatrix()[1]
-                + this.matrix[9] * matrix.getMatrix()[2];
-        this.matrix[2] =
-            this.matrix[2] * matrix.getMatrix()[0]
-                + this.matrix[6] * matrix.getMatrix()[1]
-                + this.matrix[10] * matrix.getMatrix()[2];
-        this.matrix[3] = 0;
-
-        this.matrix[4] =
-            this.matrix[0] * matrix.getMatrix()[4]
-                + this.matrix[4] * matrix.getMatrix()[5]
-                + this.matrix[8] * matrix.getMatrix()[6];
-        this.matrix[5] =
-            this.matrix[1] * matrix.getMatrix()[4]
-                + this.matrix[5] * matrix.getMatrix()[5]
-                + this.matrix[9] * matrix.getMatrix()[6];
-        this.matrix[6] =
-            this.matrix[2] * matrix.getMatrix()[4]
-                + this.matrix[6] * matrix.getMatrix()[5]
-                + this.matrix[10] * matrix.getMatrix()[6];
-        this.matrix[7] = 0;
-
-        this.matrix[8] =
-            this.matrix[0] * matrix.getMatrix()[8]
-                + this.matrix[4] * matrix.getMatrix()[9]
-                + this.matrix[8] * matrix.getMatrix()[10];
-        this.matrix[9] =
-            this.matrix[1] * matrix.getMatrix()[8]
-                + this.matrix[5] * matrix.getMatrix()[9]
-                + this.matrix[9] * matrix.getMatrix()[10];
-        this.matrix[10] =
-            this.matrix[2] * matrix.getMatrix()[8]
-                + this.matrix[6] * matrix.getMatrix()[9]
-                + this.matrix[10] * matrix.getMatrix()[10];
-        this.matrix[11] = 0;
-
-        this.matrix[12] =
-            this.matrix[0] * matrix.getMatrix()[12]
-                + this.matrix[4] * matrix.getMatrix()[13]
-                + this.matrix[8] * matrix.getMatrix()[14]
-                + this.matrix[12];
-        this.matrix[13] =
-            this.matrix[1] * matrix.getMatrix()[12]
-                + this.matrix[5] * matrix.getMatrix()[13]
-                + this.matrix[9] * matrix.getMatrix()[14]
-                + this.matrix[13];
-        this.matrix[14] =
-            this.matrix[2] * matrix.getMatrix()[12]
-                + this.matrix[6] * matrix.getMatrix()[13]
-                + this.matrix[10] * matrix.getMatrix()[14]
-                + this.matrix[14];
-        this.matrix[15] = 1;
-
+    public Matrix multiply(Matrix in2) {
+        Matrix out = new Matrix();
+        out.matrix[0][0] = matrix[0][0] * in2.matrix[0][0] + matrix[0][1] * in2.matrix[1][0] + matrix[0][2] * in2.matrix[2][0];
+        out.matrix[0][1] = matrix[0][0] * in2.matrix[0][1] + matrix[0][1] * in2.matrix[1][1] + matrix[0][2] * in2.matrix[2][1];
+        out.matrix[0][2] = matrix[0][0] * in2.matrix[0][2] + matrix[0][1] * in2.matrix[1][2] + matrix[0][2] * in2.matrix[2][2];
+        out.matrix[0][3] = matrix[0][0] * in2.matrix[0][3] + matrix[0][1] * in2.matrix[1][3] + matrix[0][2] * in2.matrix[2][3] + matrix[0][3];
+        out.matrix[1][0] = matrix[1][0] * in2.matrix[0][0] + matrix[1][1] * in2.matrix[1][0] + matrix[1][2] * in2.matrix[2][0];
+        out.matrix[1][1] = matrix[1][0] * in2.matrix[0][1] + matrix[1][1] * in2.matrix[1][1] + matrix[1][2] * in2.matrix[2][1];
+        out.matrix[1][2] = matrix[1][0] * in2.matrix[0][2] + matrix[1][1] * in2.matrix[1][2] + matrix[1][2] * in2.matrix[2][2];
+        out.matrix[1][3] = matrix[1][0] * in2.matrix[0][3] + matrix[1][1] * in2.matrix[1][3] + matrix[1][2] * in2.matrix[2][3] + matrix[1][3];
+        out.matrix[2][0] = matrix[2][0] * in2.matrix[0][0] + matrix[2][1] * in2.matrix[1][0] + matrix[2][2] * in2.matrix[2][0];
+        out.matrix[2][1] = matrix[2][0] * in2.matrix[0][1] + matrix[2][1] * in2.matrix[1][1] + matrix[2][2] * in2.matrix[2][1];
+        out.matrix[2][2] = matrix[2][0] * in2.matrix[0][2] + matrix[2][1] * in2.matrix[1][2] + matrix[2][2] * in2.matrix[2][2];
+        out.matrix[2][3] = matrix[2][0] * in2.matrix[0][3] + matrix[2][1] * in2.matrix[1][3] + matrix[2][2] * in2.matrix[2][3] + matrix[2][3];
+        out.matrix[3][0] =
+                    this.matrix[0][0] * in2.getMatrix()[3][0]
+                        + this.matrix[1][0] * in2.getMatrix()[3][1]
+                        + this.matrix[2][0] * in2.getMatrix()[3][2]
+                        + this.matrix[3][0];
+                out.matrix[3][1] =
+                    this.matrix[0][1] * in2.getMatrix()[3][0]
+                        + this.matrix[1][1] * in2.getMatrix()[3][1]
+                        + this.matrix[2][1] * in2.getMatrix()[3][2]
+                        + this.matrix[3][1];
+                out.matrix[3][2] =
+                    this.matrix[0][2] * in2.getMatrix()[3][0]
+                        + this.matrix[1][2] * in2.getMatrix()[3][1]
+                        + this.matrix[2][2] * in2.getMatrix()[3][2]
+                        + this.matrix[3][2];
+                out.matrix[3][3] = 1;
+        return out;
     }
     
     /**
@@ -193,9 +210,9 @@ public class Matrix {
         if (translation.length != 3) {
             throw new MonkeyRuntimeException("Translation size must be 3.");
         }
-        matrix[12] = translation[0];
-        matrix[13] = translation[1];
-        matrix[14] = translation[2];
+        matrix[3][0] = translation[0];
+        matrix[3][1] = translation[1];
+        matrix[3][2] = translation[2];
     }
 
     /**
@@ -208,59 +225,63 @@ public class Matrix {
         if (translation.length != 3) {
             throw new MonkeyRuntimeException("Translation size must be 3.");
         }
-        matrix[12] = -translation[0];
-        matrix[13] = -translation[1];
-        matrix[14] = -translation[2];
+        matrix[3][0] = -translation[0];
+        matrix[3][1] = -translation[1];
+        matrix[3][2] = -translation[2];
     }
 
-    /**
-     * <code>setRotationRadians</code> builds a rotation from Euler angles that
-     * are in radians.
-     * @param angles the Euler angles in radians.
-     * @throws MonkeyRuntimeException if angles is not size 3.
-     */
-    public void setRotationRadians(float[] angles) {
-        if (angles.length != 3) {
-            throw new MonkeyRuntimeException("Angles must be of size 3.");
-        }
-        double cr = Math.cos(angles[0]);
-        double sr = Math.sin(angles[0]);
-        double cp = Math.cos(angles[1]);
-        double sp = Math.sin(angles[1]);
-        double cy = Math.cos(angles[2]);
-        double sy = Math.sin(angles[2]);
+    public void angleRotationRadians(Vector angles) {
+        float sr, sp, sy, cr, cp, cy;
 
-        matrix[0] = (float) (cp * cy);
-        matrix[1] = (float) (cp * sy);
-        matrix[2] = (float) (-sp);
+        sy = (float) java.lang.Math.sin(angles.z);
+        cy = (float) java.lang.Math.cos(angles.z);
+        sp = (float) java.lang.Math.sin(angles.y);
+        cp = (float) java.lang.Math.cos(angles.y);
+        sr = (float) java.lang.Math.sin(angles.x);
+        cr = (float) java.lang.Math.cos(angles.x);
 
-        double srsp = sr * sp;
-        double crsp = cr * sp;
-
-        matrix[4] = (float) (srsp * cy - cr * sy);
-        matrix[5] = (float) (srsp * sy + cr * cy);
-        matrix[6] = (float) (sr * cp);
-
-        matrix[8] = (float) (crsp * cy + sr * sy);
-        matrix[9] = (float) (crsp * sy - sr * cy);
-        matrix[10] = (float) (cr * cp);
+        // matrix = (Z * Y) * X
+        matrix[0][0] = cp * cy;
+        matrix[1][0] = cp * sy;
+        matrix[2][0] = -sp;
+        matrix[0][1] = sr * sp * cy + cr * -sy;
+        matrix[1][1] = sr * sp * sy + cr * cy;
+        matrix[2][1] = sr * cp;
+        matrix[0][2] = (cr * sp * cy + -sr * -sy);
+        matrix[1][2] = (cr * sp * sy + -sr * cy);
+        matrix[2][2] = cr * cp;
+        matrix[0][3] = 0.0f;
+        matrix[1][3] = 0.0f;
+        matrix[2][3] = 0.0f;
     }
+    
+    public void angleRotationDegrees(Vector angles) {
+        float angle;
+        float sr, sp, sy, cr, cp, cy;
 
-    /**
-    * <code>setRotationDegrees</code> builds a rotation from Euler angles that
-    * are in degrees.
-    * @param angles the Euler angles in degrees.
-    * @throws MonkeyRuntimeException if angles is not size 3.
-    */
-    public void setRotationDegrees(float[] angles) {
-        if (angles.length != 3) {
-            throw new MonkeyRuntimeException("Angles must be of size 3.");
-        }
-        float vec[] = new float[3];
-        vec[0] = (float) (angles[0] * 180.0 / Math.PI);
-        vec[1] = (float) (angles[1] * 180.0 / Math.PI);
-        vec[2] = (float) (angles[2] * 180.0 / Math.PI);
-        setRotationRadians(vec);
+        angle = (float) (angles.z * (Math.PI * 2 / 360));
+        sy = (float) java.lang.Math.sin(angle);
+        cy = (float) java.lang.Math.cos(angle);
+        angle = (float) (angles.y * (Math.PI * 2 / 360));
+        sp = (float) java.lang.Math.sin(angle);
+        cp = (float) java.lang.Math.cos(angle);
+        angle = (float) (angles.x * (Math.PI * 2 / 360));
+        sr = (float) java.lang.Math.sin(angle);
+        cr = (float) java.lang.Math.cos(angle);
+
+        // matrix = (Z * Y) * X
+        matrix[0][0] = cp * cy;
+        matrix[1][0] = cp * sy;
+        matrix[2][0] = -sp;
+        matrix[0][1] = sr * sp * cy + cr * -sy;
+        matrix[1][1] = sr * sp * sy + cr * cy;
+        matrix[2][1] = sr * cp;
+        matrix[0][2] = (cr * sp * cy + -sr * -sy);
+        matrix[1][2] = (cr * sp * sy + -sr * cy);
+        matrix[2][2] = cr * cp;
+        matrix[0][3] = 0.0f;
+        matrix[1][3] = 0.0f;
+        matrix[2][3] = 0.0f;
     }
 
     /**
@@ -273,19 +294,19 @@ public class Matrix {
         if(null == quat) {
             throw new MonkeyRuntimeException("Quat may not be null.");
         }
-        matrix[0] =
+        matrix[0][0] =
             (float) (1.0 - 2.0 * quat.y * quat.y - 2.0 * quat.z * quat.z);
-        matrix[1] = (float) (2.0 * quat.x * quat.y + 2.0 * quat.w * quat.z);
-        matrix[2] = (float) (2.0 * quat.x * quat.z - 2.0 * quat.w * quat.y);
+        matrix[0][1] = (float) (2.0 * quat.x * quat.y + 2.0 * quat.w * quat.z);
+        matrix[0][2] = (float) (2.0 * quat.x * quat.z - 2.0 * quat.w * quat.y);
 
-        matrix[4] = (float) (2.0 * quat.x * quat.y - 2.0 * quat.w * quat.z);
-        matrix[5] =
+        matrix[1][0] = (float) (2.0 * quat.x * quat.y - 2.0 * quat.w * quat.z);
+        matrix[1][1] =
             (float) (1.0 - 2.0 * quat.x * quat.x - 2.0 * quat.z * quat.z);
-        matrix[6] = (float) (2.0 * quat.y * quat.z + 2.0 * quat.w * quat.x);
+        matrix[1][2] = (float) (2.0 * quat.y * quat.z + 2.0 * quat.w * quat.x);
 
-        matrix[8] = (float) (2.0 * quat.x * quat.z + 2.0 * quat.w * quat.y);
-        matrix[9] = (float) (2.0 * quat.y * quat.z - 2.0 * quat.w * quat.x);
-        matrix[10] =
+        matrix[2][0] = (float) (2.0 * quat.x * quat.z + 2.0 * quat.w * quat.y);
+        matrix[2][1] = (float) (2.0 * quat.y * quat.z - 2.0 * quat.w * quat.x);
+        matrix[2][2] =
             (float) (1.0 - 2.0 * quat.x * quat.x - 2.0 * quat.y * quat.y);
     }
 
@@ -306,20 +327,20 @@ public class Matrix {
         double cy = Math.cos(angles[2]);
         double sy = Math.sin(angles[2]);
 
-        matrix[0] = (float) (cp * cy);
-        matrix[4] = (float) (cp * sy);
-        matrix[8] = (float) (-sp);
+        matrix[0][0] = (float) (cp * cy);
+        matrix[1][0] = (float) (cp * sy);
+        matrix[2][0] = (float) (-sp);
 
         double srsp = sr * sp;
         double crsp = cr * sp;
 
-        matrix[1] = (float) (srsp * cy - cr * sy);
-        matrix[5] = (float) (srsp * sy + cr * cy);
-        matrix[9] = (float) (sr * cp);
+        matrix[0][1] = (float) (srsp * cy - cr * sy);
+        matrix[1][1] = (float) (srsp * sy + cr * cy);
+        matrix[2][1] = (float) (sr * cp);
 
-        matrix[2] = (float) (crsp * cy + sr * sy);
-        matrix[6] = (float) (crsp * sy - sr * cy);
-        matrix[10] = (float) (cr * cp);
+        matrix[0][2] = (float) (crsp * cy + sr * sy);
+        matrix[1][2] = (float) (crsp * sy - sr * cy);
+        matrix[2][2] = (float) (cr * cp);
     }
 
     /**
@@ -344,7 +365,7 @@ public class Matrix {
      * floats. Size 16.
      * @return the array of floats that represent this matrix.
      */
-    public float[] getMatrix() {
+    public float[][] getMatrix() {
         return matrix;
     }
     
@@ -360,9 +381,9 @@ public class Matrix {
             throw new MonkeyRuntimeException("Vector must be of size 3.");
         }
 
-        vector[0] = vector[0] - matrix[12];
-        vector[1] = vector[1] - matrix[13];
-        vector[2] = vector[2] - matrix[14];
+        vector[0] = vector[0] - matrix[3][0];
+        vector[1] = vector[1] - matrix[3][1];
+        vector[2] = vector[2] - matrix[3][2];
     }
 
     /**
@@ -378,28 +399,28 @@ public class Matrix {
         }
 
         vector[0] =
-            vector[0] * matrix[0]
-                + vector[1] * matrix[1]
-                + vector[2] * matrix[2];
+            vector[0] * matrix[0][0]
+                + vector[1] * matrix[0][1]
+                + vector[2] * matrix[0][2];
         vector[1] =
-            vector[0] * matrix[4]
-                + vector[1] * matrix[5]
-                + vector[2] * matrix[6];
+            vector[0] * matrix[1][0]
+                + vector[1] * matrix[1][1]
+                + vector[2] * matrix[1][2];
         vector[2] =
-            vector[0] * matrix[8]
-                + vector[1] * matrix[9]
-                + vector[2] * matrix[10];
+            vector[0] * matrix[2][0]
+                + vector[1] * matrix[2][1]
+                + vector[2] * matrix[2][2];
     }
     
     public void tensorProduct (Vector u, Vector v) {
-        matrix[0] = u.x * v.x;
-        matrix[1] = u.x * v.y;
-        matrix[2] = u.x * v.z;
-        matrix[4] = u.y * v.x;
-        matrix[5] = u.y * v.y;
-        matrix[6] = u.y * v.z;
-        matrix[8] = u.z * v.x;
-        matrix[9] = u.z * v.y;
-        matrix[10] = u.z * v.z;
+        matrix[0][0] = u.x * v.x;
+        matrix[0][1] = u.x * v.y;
+        matrix[0][2] = u.x * v.z;
+        matrix[1][0] = u.y * v.x;
+        matrix[1][1] = u.y * v.y;
+        matrix[1][2] = u.y * v.z;
+        matrix[2][0] = u.z * v.x;
+        matrix[2][1] = u.z * v.y;
+        matrix[2][2] = u.z * v.z;
     }
 }

--- a/src/jme/math/Vector.java
+++ b/src/jme/math/Vector.java
@@ -36,7 +36,7 @@ import jme.exception.MonkeyRuntimeException;
 /**
  * <code>Vector</code> defines a three dimensional vector of (x,y,z). 
  * @author Mark Powell
- * @version $Id: Vector.java,v 1.7 2003-08-22 02:26:48 mojomonkey Exp $
+ * @version $Id: Vector.java,v 1.8 2003-09-04 21:17:51 mojomonkey Exp $
  */
 public class Vector {
 	public float x;
@@ -181,6 +181,28 @@ public class Vector {
 			((z * v.x) - (x * v.z)),
 			((x * v.y) - (y * v.x)));
 	}
+    
+    /**
+     * <code>rotate</code> rotates a vector about a rotation matrix. The
+     * resulting vector is returned.
+     * @param m the rotation matrix.
+     * @return the rotated vector.
+     */
+    public Vector rotate(Matrix m) {
+       Vector out = new Vector();
+       out.x = dot(new Vector(m.matrix[0][0], m.matrix[0][1], m.matrix[0][2]));
+       out.y = dot(new Vector(m.matrix[1][0], m.matrix[1][1], m.matrix[1][2]));
+       out.z = dot(new Vector(m.matrix[2][0], m.matrix[2][1], m.matrix[2][2]));
+       return out;
+    }
+    
+    public Vector inverseRotate(Matrix m) {
+        Vector out = new Vector();
+        out.x = x * m.matrix[0][0] + y * m.matrix[1][0] + z * m.matrix[2][0];
+        out.y = x * m.matrix[0][1] + y * m.matrix[1][1] + z * m.matrix[2][1];
+        out.z = x * m.matrix[0][2] + y * m.matrix[1][2] + z * m.matrix[2][2];
+        return out;
+    }
 
 	/**
 	 * <code>negate</code> sets this vector to the negative (-x, -y, -z).

--- a/src/jme/system/DisplaySystem.java
+++ b/src/jme/system/DisplaySystem.java
@@ -423,7 +423,7 @@ public class DisplaySystem {
 
             if (fullscreen) {
                 Display.setDisplayMode(mode);
-                Window.create(title, bpp, 0, 16, 0);
+                Window.create(title, bpp, 0, 8, 0);
             } else {
                 int x, y;
                 x =
@@ -433,7 +433,7 @@ public class DisplaySystem {
                     (Toolkit.getDefaultToolkit().getScreenSize().height
                         - height)
                         / 2;
-                Window.create(title, x, y, width, height, bpp, 0, 16, 0);
+                Window.create(title, x, y, width, height, bpp, 0, 8, 0);
             }
 
             GLCaps.determineAvailableExtensions();

--- a/src/jme/texture/TextureManager.java
+++ b/src/jme/texture/TextureManager.java
@@ -130,14 +130,24 @@ public class TextureManager {
         keyList = new ArrayList();
         previousKeys = new ArrayList();
     }
-
+    
     /**
      * <code>reload</code> reloads all loaded textures after making a call
      * to <code>saveKeys</code>. This is useful for
      * reloading textures if the GL object has been recreated.
-     * 
      */
     public void reload() {
+        reload(true);
+    }
+
+    /**
+     * <code>reload</code> reloads all loaded textures after making a call
+     * to <code>saveKeys</code>. This is useful for
+     * reloading textures if the GL object has been recreated.
+     * @param flipped true flips the bits of the image, false does not. True
+     *      by default.
+     */
+    public void reload(boolean flipped) {
         saveKeys();
         deleteAll();
 
@@ -158,17 +168,31 @@ public class TextureManager {
                 tempData.image,
                 tempData.minFilter,
                 tempData.magFilter,
-                tempData.mipmapped);
+                tempData.mipmapped, flipped);
         }
     }
-
+    
     /**
      * <code>batchLoad</code> loads a collection of textures defined by an
      * <code>ArrayList</code>. 
      * 
      * @param keys the list of files to open.
+     * @param flipped true flips the bits of the image, false does not. True
+     *      by default.
      */
     public void batchLoad(ArrayList keys) {
+        batchLoad(keys, true);
+    }
+
+    /**
+     * <code>batchLoad</code> loads a collection of textures defined by an
+     * <code>ArrayList</code>. 
+     * 
+     * @param keys the list of files to open.
+     * @param flipped true flips the bits of the image, false does not. True
+     *      by default.
+     */
+    public void batchLoad(ArrayList keys, boolean flipped) {
 
         TextureData tempData;
         for (int i = 0; i < keys.size(); i++) {
@@ -178,7 +202,7 @@ public class TextureManager {
                 tempData.image,
                 tempData.minFilter,
                 tempData.magFilter,
-                tempData.mipmapped);
+                tempData.mipmapped, flipped);
         }
     }
 
@@ -192,6 +216,27 @@ public class TextureManager {
         previousKeys = (ArrayList) keyList.clone();
         return previousKeys;
     }
+    
+    /**
+     * <code>loadTexture</code> loads a new texture defined by a loaded 
+     * ImageIcon. If a texture with the same filename has previously been loaded,
+     * that id is returned rather than reloading. Filter parameters are used
+     * to define the filtering of the texture. Whether the texture is to be
+     * mipmapped or not is denoted by the isMipmapped boolean flag. If there
+     * is an error loading the file, -1 is returned.
+     * 
+     * @param image the ImageIcon of the texture image.
+     * @param minFilter the filter for the near values.
+     * @param magFilter the filter for the far values.
+     * @param isMipmapped determines if we will load the texture mipmapped
+     *      or not. True load the texture mipmapped, false do not.
+     * 
+     * @return an integer for the loaded texture id. If there is a problem
+     *      loading the texture -1 is returned.
+     */
+    public int loadTexture(ImageIcon image, int minFilter, int magFilter, boolean isMipMapped) {
+        return loadTexture(image, minFilter, magFilter, isMipMapped, true);
+    }
 
     /**
      * <code>loadTexture</code> loads a new texture defined by a loaded 
@@ -206,6 +251,8 @@ public class TextureManager {
      * @param magFilter the filter for the far values.
      * @param isMipmapped determines if we will load the texture mipmapped
      *      or not. True load the texture mipmapped, false do not.
+     * @param flipped true flips the bits of the image, false does not. True
+     *      by default.
      * 
      * @return an integer for the loaded texture id. If there is a problem
      *      loading the texture -1 is returned.
@@ -214,7 +261,8 @@ public class TextureManager {
         ImageIcon image,
         int minFilter,
         int magFilter,
-        boolean isMipmapped) {
+        boolean isMipmapped,
+        boolean flipped) {
 
         //check if the texture is already loaded.  
         Object obj = textureList.get(image.getDescription());
@@ -228,9 +276,32 @@ public class TextureManager {
             image.getImage(),
             minFilter,
             magFilter,
-            isMipmapped);
+            isMipmapped, true);
 
     }
+    
+    /**
+     * <code>loadTexture</code> loads a new texture defined by the parameter
+     * string. If a texture with the same filename has previously been loaded,
+     * that id is returned rather than reloading. Filter parameters are used
+     * to define the filtering of the texture. Whether the texture is to be
+     * mipmapped or not is denoted by the isMipmapped boolean flag. If there
+     * is an error loading the file, -1 is returned.
+     * 
+     * @param file the filename of the texture image.
+     * @param minFilter the filter for the near values.
+     * @param magFilter the filter for the far values.
+     * @param isMipmapped determines if we will load the texture mipmapped
+     *      or not. True load the texture mipmapped, false do not.
+     * @param flipped true flips the bits of the image, false does not. True
+     *      by default.
+     * 
+     * @return an integer for the loaded texture id. If there is a problem
+     *      loading the texture -1 is returned.
+     */
+    public int loadTexture(String file, int minFilter, int magFilter, boolean isMipMapped) {
+        return loadTexture(file, minFilter, magFilter, isMipMapped, true);
+    }
 
     /**
      * <code>loadTexture</code> loads a new texture defined by the parameter
@@ -253,7 +324,8 @@ public class TextureManager {
         String file,
         int minFilter,
         int magFilter,
-        boolean isMipmapped) {
+        boolean isMipmapped,
+        boolean flipped) {
 
         //check if the texture is already loaded.  
         Object obj = textureList.get(file);
@@ -282,7 +354,7 @@ public class TextureManager {
             return -1;
         }
 
-        return loadImage(file, image, minFilter, magFilter, isMipmapped);
+        return loadImage(file, image, minFilter, magFilter, isMipmapped, flipped);
 
     }
 
@@ -468,7 +540,8 @@ public class TextureManager {
         Image image,
         int minFilter,
         int magFilter,
-        boolean isMipmapped) {
+        boolean isMipmapped,
+        boolean flipImage) {
         //      Obtain the image data.
         BufferedImage tex = null;
         try {
@@ -487,12 +560,14 @@ public class TextureManager {
         g.drawImage(image, null, null);
         g.dispose();
 
-        //Flip the image
-        AffineTransform tx = AffineTransform.getScaleInstance(1, -1);
-        tx.translate(0, -image.getHeight(null));
-        AffineTransformOp op =
-            new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
-        tex = op.filter(tex, null);
+        if(flipImage) {
+            //Flip the image
+            AffineTransform tx = AffineTransform.getScaleInstance(1, -1);
+            tx.translate(0, -image.getHeight(null));
+            AffineTransformOp op =
+                new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
+            tex = op.filter(tex, null);
+        }
 
         //Get a pointer to the image memory
         ByteBuffer scratch =

--- a/src/test/general/TestMain.java
+++ b/src/test/general/TestMain.java
@@ -235,23 +235,20 @@ public class TestMain extends AbstractGame {
 	}
 
 	private void initGL() {
-		GL.glShadeModel(GL.GL_SMOOTH);
+
         GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
         GL.glClearDepth(1.0);
         GL.glEnable(GL.GL_DEPTH_TEST);
-        GL.glDepthFunc(GL.GL_LESS);
+        GL.glDepthFunc(GL.GL_LEQUAL);
+
         GL.glMatrixMode(GL.GL_PROJECTION);
         GL.glLoadIdentity();
-		// Calculate The Aspect Ratio Of The Window
-        GLU.gluPerspective(
-			45.0f,
-			(float) Display.getWidth() / (float) Display.getHeight(),
-			0.1f,
-			500.0f);
-		GL.glMatrixMode(GL.GL_MODELVIEW);
-		GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
-		GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE);
-		DisplaySystem.getDisplaySystem().cullMode(GL.GL_BACK, true);
+
+        GLU.gluPerspective(45.0f, (float) Display.getWidth() / (float) Display.getHeight(), 1.0f, 750.0f);
+        GL.glMatrixMode(GL.GL_MODELVIEW);
+
+        GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
+        DisplaySystem.getDisplaySystem().cullMode(GL.GL_BACK, true);
 
 	}
 	protected void reinit() {

--- /dev/null
+++ b/src/test/model/ms3dAscii/TestAsciiMilkshape.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2003 najgl Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1) Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2) Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3) Neither the name of 'najgl' nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package test.model.ms3dAscii;
+
+import jme.geometry.model.Model;
+import jme.geometry.model.ms.MilkshapeModel;
+
+import org.lwjgl.Display;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.opengl.GL;
+import org.lwjgl.opengl.GLCaps;
+import org.lwjgl.opengl.GLU;
+import org.lwjgl.opengl.Window;
+
+/**
+ * A basic lwjgl game skeleton.  Starts up opengl.  The game loop executes
+ * forever, or until the escape key is pressed or the window is closed.  Can
+ * be run in windowed or fullscreen mode.
+ *
+ * The demo will load a Milkshape 3D model, rotate it around the y-axis, and
+ * play its animation.
+ *
+ * @author naj
+ * @version 0.1
+ */
+public class TestAsciiMilkshape {
+
+    private static final boolean WIREFRAME = false;
+    private static final boolean ANIMATED = true;
+
+    private static boolean fullscreen = false;
+    private static String modelFilename = "data/run.txt";
+//    private static String modelFilename = "data/diablo.txt";
+
+    private static boolean finished;
+    private static float yrot;
+    private static int count;
+    private static Model model;
+
+    public static float dt = 0.2f;
+
+    public static void main(String[] args) {
+        if (args.length == 1) {
+            modelFilename = args[0];
+        } else if (args.length == 2) {
+            modelFilename = args[0];
+            fullscreen = (args[1] != null && args[1].equalsIgnoreCase("fullscreen")) ? true : false;
+        } else {
+            System.out.println("Usage: java -jar example1.jar <filename> [fullscreen]");
+            System.out.println("      - filename must be a ms3d ascii text file");
+            System.out.println("      - add the optional word 'fullscreen' for fullscreen mode");
+            System.exit(1);
+        }
+        model = new MilkshapeModel(ANIMATED);
+        try {
+            init();
+            while (!finished) {
+                Keyboard.poll();
+                mainLoop();
+                render();
+                Window.update();
+                Window.paint();
+            }
+        } catch (Throwable t) {
+            t.printStackTrace();
+        } finally {
+            cleanup();
+        }
+    }
+
+    /**
+     * Start up and initialize OpenGL.
+     */
+    private final static void init() throws Exception {
+        if (fullscreen) {
+            Window.create("Milkshape Model Animation (Fullscreen)", 16, 0, 8, 0);
+        } else {
+            Window.create("Milkshape Model Animation", 50, 50, 640, 480, 16, 0, 8, 0);
+        }
+        Keyboard.create();
+
+        model.load(modelFilename);
+
+        if (WIREFRAME) {
+            GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE);
+        } else {
+            GL.glEnable(GL.GL_TEXTURE_2D);
+            GL.glShadeModel(GL.GL_SMOOTH);
+        }
+        GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+        GL.glClearDepth(1.0);
+        GL.glEnable(GL.GL_DEPTH_TEST);
+        GL.glDepthFunc(GL.GL_LEQUAL);
+
+        GL.glMatrixMode(GL.GL_PROJECTION);
+        GL.glLoadIdentity();
+
+        GLU.gluPerspective(45.0f, (float) Display.getWidth() / (float) Display.getHeight(), 100.0f, 2000.0f);
+        GL.glMatrixMode(GL.GL_MODELVIEW);
+
+        GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
+
+        GLCaps.determineAvailableExtensions();
+        if (GLCaps.WGL_EXT_swap_control) {
+            GL.wglSwapIntervalEXT(1);
+        }
+    }
+
+    /**
+     *  Rendering method.
+     */
+    private final static void render() {
+        if (!fullscreen && count++ > 20) {
+            Window.setTitle("Milkshape Model Animation");
+            count = 0;
+        }
+
+        GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+        GL.glLoadIdentity();
+        GLU.gluLookAt(50, 0, 300, 0, 0, 0, 0, 1, 0);
+        GL.glRotatef(yrot, 0.0f, 1.0f, 0.0f);
+        yrot += 0.3f;
+        model.render();
+    }
+
+    /**
+     * Main loop.
+     */
+    private final static void mainLoop() {
+        processKeyboard();
+        processWindow();
+    }
+
+    /**
+     * Process keyboard events.
+     */
+    private final static void processKeyboard() {
+        if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
+            finished = true;
+        }
+        if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {
+            dt += 0.01;
+        }
+        if (Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
+            dt -= 0.01; dt = Math.max(0.05f, dt);
+        }
+    }
+
+    /**
+     * Process window events.
+     */
+    private final static void processWindow() {
+        if (Window.isCloseRequested()) {
+            finished = true;
+        }
+    }
+
+    /**
+     * Cleanup.
+     */
+    private final static void cleanup() {
+        Keyboard.destroy();
+        Window.destroy();
+    }
+
+}
\ No newline at end of file

--- a/src/test/model/TestMilkshape.java
+++ b/src/test/model/ms3dAscii/TestMilkshape.java
@@ -29,41 +29,44 @@
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
- 
-package test.model;
+package test.model.ms3dAscii;
 
-import org.lwjgl.Display; 
-import org.lwjgl.opengl.GL; 
+
+import org.lwjgl.Display;
+import org.lwjgl.opengl.GL;
 import org.lwjgl.opengl.GLU;
 import org.lwjgl.opengl.Window;
 
-import jme.AbstractGame; 
+import jme.AbstractGame;
 import jme.controller.BaseFPSController;
 import jme.entity.camera.Camera;
+import jme.geometry.model.Model;
 import jme.geometry.model.ms.MilkshapeModel;
 import jme.system.DisplaySystem;
 import jme.utility.Timer;
 
 /**
- * 
  * @author Mark Powell
+ *
+ * To change the template for this generated type comment go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
  */
-
 public class TestMilkshape extends AbstractGame {
-    //our model object
-    private MilkshapeModel model;
     
-    BaseFPSController controller;
-    Timer timer;
-    Camera camera;
+    private Model model;
+    private float yrot;
+    private BaseFPSController cc;
+    private Timer timer;
+    private Camera camera;
+    
     /**
      * This is where we'll do any updating
      */
     protected void update() {
-        timer.update();
-        if(!controller.update(timer.getFrameRate())) { 
+        if(!cc.update(timer.getFrameRate())) { 
           finish();
         }
+        timer.update();
     }
     
     /**
@@ -72,7 +75,7 @@ public class TestMilkshape extends AbstractGame {
     protected void render() {
         GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
         GL.glLoadIdentity();
-        controller.render();
+        cc.render();
         model.render();
     }
     
@@ -95,20 +98,17 @@ public class TestMilkshape extends AbstractGame {
         //Define the clear color to be black
                 
         GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+        GL.glClearDepth(1.0);
+        GL.glEnable(GL.GL_DEPTH_TEST);
+        GL.glDepthFunc(GL.GL_LEQUAL);
 
         GL.glMatrixMode(GL.GL_PROJECTION);
         GL.glLoadIdentity();
-        
-        
-         // Calculate the aspect ratio
-        GLU.gluPerspective(
-            45.0f,
-            (float)Display.getWidth() / (float)Display.getHeight(),
-            0.01f,
-            750.0f);
-        
+
+        GLU.gluPerspective(45.0f, (float) Display.getWidth() / (float) Display.getHeight(), 100.0f, 2000.0f);
         GL.glMatrixMode(GL.GL_MODELVIEW);
-        GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);     
+
+        GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
     }
 
     /**
@@ -117,15 +117,16 @@ public class TestMilkshape extends AbstractGame {
     protected void initSystem() {
         initDisplay();
         initGL();
+        camera = new Camera(1,50, 0, 300, 0, 0, 0, 0, 1, 0);
+        cc = new BaseFPSController(camera);
+        timer = Timer.getTimer();
     }
     /** 
      * Nothing here yet.
      */
     protected void initGame() {
-        model = new MilkshapeModel("./data/model/arab/ak47.ms3d");
-        camera = new Camera(1,0,0,100,0,10,0,0,1,0);
-        controller = new BaseFPSController(camera);
-        timer = Timer.getTimer();
+        model = new MilkshapeModel(true);
+        model.load("data/model/msascii/run.txt");
     }
 
     /** 
@@ -150,4 +151,4 @@ public class TestMilkshape extends AbstractGame {
        testApp.start(); 
     }   
 }
-    
\ No newline at end of file
+