/*
 * Copyright (c) 2003-2009 jMonkeyEngine
 * 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 'jMonkeyEngine' 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 com.jme.scene;
import java.io.IOException;
import java.io.Serializable;
//import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.logging.Logger;

import com.jme.bounding.CollisionTree;
import com.jme.bounding.CollisionTreeManager;
import com.jme.intersection.CollisionResults;
import com.jme.math.FastMath;
import com.jme.math.Ray;
import com.jme.math.Triangle;
import com.jme.math.Vector3f;
//import com.jme.renderer.Renderer;
import com.jme.system.JmeException;
import com.jme.util.export.InputCapsule;
import com.jme.util.export.JMEExporter;
import com.jme.util.export.JMEImporter;
import com.jme.util.export.OutputCapsule;
import com.jme.util.geom.BufferUtils;

//
import com.jme.scene.TexCoords;
import javax.media.opengl.GL;
import com.jme.renderer.ColorRGBA;

/**
 * <code>TriMesh</code> defines a geometry mesh. This mesh defines a three
 * dimensional object via a collection of points, colors, normals and textures.
 * The points are referenced via a indices array. This array instructs the
 * renderer the order in which to draw the points, creating triangles based on the mode set.
 * 
 * @author Mark Powell
 * @author Joshua Slack
 * @version $Id: TriMesh.java 4640 2009-08-29 02:28:57Z blaine.dev $
 */
public class TriMesh extends Geometry implements Serializable
{
    /**
     * <code>draw</code> renders a <code>TriMesh</code> object including
     * it's normals, colors, textures and vertices.
     *
     * @see Renderer#draw(TriMesh)
     * @param tris
     *            the mesh to render.
     */
    void DrawParticles(iCameraPane display, Object3D geo, boolean selected, boolean rotate) // TriMesh tris)
    {
            display.DrawParticles(this, geo, selected, rotate);
    }

    static final long serialVersionUID = 0;

    boolean IsStatic()
    {
        return false;
    }
    
    private static final Logger logger = Logger.getLogger(TriMesh.class.getName());
    
    //   private static final long serialVersionUID = 2L;
    public enum Mode
    {

        /**
         * Every three vertices referenced by the indexbuffer will be considered
         * a stand-alone triangle.
         */
        Triangles,
        /**
         * The first three vertices referenced by the indexbuffer create a
         * triangle, from there, every additional vertex is paired with the two
         * preceding vertices to make a new triangle.
         */
        Strip,
        /**
         * The first three vertices (V0, V1, V2) referenced by the indexbuffer
         * create a triangle, from there, every additional vertex is paired with
         * the preceding vertex and the initial vertex (V0) to make a new
         * triangle.
         */
        Fan;
    }
    protected transient IntBuffer indexBuffer;
    protected Mode mode = Mode.Triangles;
    protected int triangleQuantity;

    /**
     * Empty Constructor to be used internally only.
     */
    public TriMesh()
    {
        super();
    }

    /**
     * Constructor instantiates a new <code>TriMesh</code> object.
     * 
     * @param name
     *            the name of the scene element. This is required for
     *            identification and comparison purposes.
     */
    public TriMesh(String name)
    {
        super(name);
    }

    /**
     * Constructor instantiates a new <code>TriMesh</code> object. Provided
     * are the attributes that make up the mesh all attributes may be null,
     * except for vertices and indices.
     * 
     * @param name
     *            the name of the scene element. This is required for
     *            identification and comparison purposes.
     * @param vertices
     *            the vertices of the geometry.
     * @param normal
     *            the normals of the geometry.
     * @param color
     *            the colors of the geometry.
     * @param coords
     *            the texture coordinates of the mesh.
     * @param indices
     *            the indices of the vertex array.
     */
    public TriMesh(String name, FloatBuffer vertices, FloatBuffer normal,
            FloatBuffer color, TexCoords coords, IntBuffer indices)
    {

        super(name);

        reconstruct(vertices, normal, color, coords);

        if (null == indices)
        {
            logger.severe("Indices may not be null.");
            throw new JmeException("Indices may not be null.");
        }
        setIndexBuffer(indices);
        logger.info("TriMesh created.");
    }

    /**
     * Recreates the geometric information of this TriMesh from scratch. The
     * index and vertex array must not be null, but the others may be. Every 3
     * indices define an index in the <code>vertices</code> array that
     * references a vertex of a triangle.
     * 
     * @param vertices
     *            The vertex information for this TriMesh.
     * @param normal
     *            The normal information for this TriMesh.
     * @param color
     *            The color information for this TriMesh.
     * @param coords
     *            The texture information for this TriMesh.
     * @param indices
     *            The index information for this TriMesh.
     */
    public void reconstruct(FloatBuffer vertices, FloatBuffer normal,
            FloatBuffer color, TexCoords coords, IntBuffer indices)
    {
        super.reconstruct(vertices, normal, color, coords);

        if (null == indices)
        {
            logger.severe("Indices may not be null.");
            throw new JmeException("Indices may not be null.");
        }
        setIndexBuffer(indices);
    }

    public void setMode(Mode mode)
    {
        this.mode = mode;
    }

    public Mode getMode()
    {
        return mode;
    }

    public IntBuffer getIndexBuffer()
    {
        return indexBuffer;
    }

    public void setIndexBuffer(IntBuffer indices)
    {
        this.indexBuffer = indices;
        recalcTriangleQuantity();
    }

    protected void recalcTriangleQuantity()
    {
        if (indexBuffer == null)
        {
            triangleQuantity = 0;
            return;
        }

        switch (mode)
        {
            case Triangles:
                triangleQuantity = indexBuffer.limit() / 3;
                break;
            case Strip:
            case Fan:
                triangleQuantity = indexBuffer.limit() - 2;
                break;
        }
    }

    /**
     * Returns the number of triangles contained in this mesh.
     */
    @Override
    public int getTriangleCount()
    {
        return triangleQuantity;
    }

    public void setTriangleQuantity(int triangleQuantity)
    {
        this.triangleQuantity = triangleQuantity;
    }

//    /**
//     * <code>draw</code> calls super to set the render state then passes
//     * itself to the renderer. LOGIC: 1. If we're not RenderQueue calling draw
//     * goto 2, if we are, goto 3 2. If we are supposed to use queue, add to
//     * queue and RETURN, else 3 3. call super draw 4. tell renderer to draw me.
//     * 
//     * @param r
//     *            the renderer to display
//     */
//    public void draw(Renderer r)
//    {
//        if (!r.isProcessingQueue())
//        {
//            if (r.checkAndAdd(this))
//            {
//                return;
//            }
//        }
//
//        super.draw(r);
//        r.draw(this);
//    }

    float[] texmat = { 1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 };
    
    final boolean supportsVBO = false;
    private FloatBuffer prevVerts;
    
    private FloatBuffer prevNorms;

    private FloatBuffer prevColor;

    private FloatBuffer[] prevTex;

    private int prevNormMode = GL.GL_ZERO;
    
    /**
     * Prepares the GL Context for rendering this geometry. This involves
     * initializing the VBO and obtaining the buffer data.
     *
     * @param g
     *            the geometry to process.
     * @return true if VBO is used for indicis, false if not
     */
//    protected boolean predrawGeometry(GL gl)
//    {
//        //    final GL gl = GLU.getCurrentGL();
//        Geometry g = this;
//
////        RenderContext<GLContext> context = display.getCurrentContext();
////        RendererRecord rendRecord = (RendererRecord) context.getRendererRecord();
//
////        VBOInfo vbo = !generatingDisplayList ? g.getVBOInfo() : null;
////        if (vbo != null && supportsVBO())
////        {
////            prepVBO(g);
////        }
//
////        indicesVBO = false;
//
//        // set up data to be sent to card
//        // first to go is vertices
//        int oldLimit = -1;
//        FloatBuffer vertices = g.getVertexBuffer();
//        if (vertices != null)
//        {
//            oldLimit = vertices.limit();
//            // make sure only the necessary verts are sent through on old cards.
//            vertices.limit(g.getVertexCount() * 3);
//        }
//        if (false) // (supportsVBO && vbo != null && vbo.getVBOVertexID() > 0))
//        { // use
//            // VBO
////            gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
////            rendRecord.setBoundVBO(vbo.getVBOVertexID());
////            gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
//        } else if (vertices == null)
//        {
//            gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
//        } else if (prevVerts != vertices)
//        {
//            // verts have changed
//            gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
//            // ensure no VBO is bound
//            if (supportsVBO)
//            {
////                rendRecord.setBoundVBO(0);
//            }
//            vertices.rewind();
//            gl.glVertexPointer(3, GL.GL_FLOAT, 0, vertices); // TODO Check assumed <type> GL_FLOAT
//        }
//        if (oldLimit != -1)
//        {
//            vertices.limit(oldLimit);
//        }
//        prevVerts = vertices;
//
////        // apply fogging coordinate if support and the buffer is set for this
////        // tri mesh
////        if (supportsFogCoords)
////        {
////            oldLimit = -1;
////            FloatBuffer fogCoords = g.getFogBuffer();
////            if (fogCoords != null)
////            {
////                oldLimit = fogCoords.limit();
////                // make sure only the necessary verts are sent through on old cards.
////                fogCoords.limit(g.getVertexCount());
////            }
////            if ((supportsVBO && vbo != null && vbo.getVBOVertexID() > 0))
////            { // use
////                // VBO
////                gl.glEnableClientState(GL.GL_FOG_COORDINATE_ARRAY_EXT);
////                rendRecord.setBoundVBO(vbo.getVBOVertexID());
////                gl.glFogCoordPointerEXT(GL.GL_FLOAT, 0, 0);
////            } else if (fogCoords == null)
////            {
////                gl.glDisableClientState(GL.GL_FOG_COORDINATE_ARRAY_EXT);
////            } else if (prevFogCoords != fogCoords)
////            {
////                // fog coords have changed
////                gl.glEnableClientState(GL.GL_FOG_COORDINATE_ARRAY_EXT);
////                // ensure no VBO is bound
////                if (supportsVBO)
////                {
////                    rendRecord.setBoundVBO(0);
////                }
////                fogCoords.rewind();
////                gl.glFogCoordPointerEXT(0, 0, g.getFogBuffer());
////            }
////            if (oldLimit != -1)
////            {
////                fogCoords.limit(oldLimit);
////            }
////            prevFogCoords = fogCoords;
////        }
//
//        if (g instanceof TriMesh)
//        {
////            if ((supportsVBO && vbo != null && vbo.getVBOIndexID() > 0))
////            { // use VBO
////                indicesVBO = true;
////                rendRecord.setBoundElementVBO(vbo.getVBOIndexID());
////            } else if (supportsVBO)
////            {
////                rendRecord.setBoundElementVBO(0);
////            }
//        }
//
////        Spatial.NormalsMode normMode = g.getNormalsMode();
//        if (true) // normMode != Spatial.NormalsMode.Off)
//        {
////            applyNormalMode(normMode, g);
//            FloatBuffer normals = g.getNormalBuffer();
//            oldLimit = -1;
//            if (normals != null)
//            {
//                // make sure only the necessary normals are sent through on old
//                // cards.
//                oldLimit = normals.limit();
//                normals.limit(g.getVertexCount() * 3);
//            }
//            if (false) //(supportsVBO && vbo != null && vbo.getVBONormalID() > 0))
//            { // use
//                // VBO
////                gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
////                rendRecord.setBoundVBO(vbo.getVBONormalID());
////                gl.glNormalPointer(GL.GL_FLOAT, 0, 0);
//            } else if (normals == null)
//            {
//                gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
//            } else if (prevNorms != normals)
//            {
//                // textures have changed
//                gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
//                // ensure no VBO is bound
//                if (supportsVBO)
//                {
////                    rendRecord.setBoundVBO(0);
//                }
//                normals.rewind();
//                gl.glNormalPointer(GL.GL_FLOAT, 0, normals); // TODO Check assumed <type> GL_FLOAT
//            }
//            if (oldLimit != -1)
//            {
//                normals.limit(oldLimit);
//            }
//            prevNorms = normals;
//        } else
//        {
//            if (prevNormMode == GL.GL_RESCALE_NORMAL)
//            {
//                gl.glDisable(GL.GL_RESCALE_NORMAL);
//                prevNormMode = GL.GL_ZERO;
//            } else if (prevNormMode == GL.GL_NORMALIZE)
//            {
//                gl.glDisable(GL.GL_NORMALIZE);
//                prevNormMode = GL.GL_ZERO;
//            }
//            oldLimit = -1;
//            gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
//            prevNorms = null;
//        }
//
//        FloatBuffer colors = g.getColorBuffer();
//        oldLimit = -1;
//        if (colors != null)
//        {
//            // make sure only the necessary colors are sent through on old
//            // cards.
//            oldLimit = colors.limit();
//            colors.limit(g.getVertexCount() * 4);
//        }
//        if (false) // (supportsVBO && vbo != null && vbo.getVBOColorID() > 0))
//        { // use
//            // VBO
////            gl.glEnableClientState(GL.GL_COLOR_ARRAY);
////            rendRecord.setBoundVBO(vbo.getVBOColorID());
////            gl.glColorPointer(4, GL.GL_FLOAT, 0, 0);
//        } else if (colors == null)
//        {
//            gl.glDisableClientState(GL.GL_COLOR_ARRAY);
//
//            // Disabling a color array causes the current color to be undefined.
//            // So enforce a current color here.
//            ColorRGBA defCol = g.getDefaultColor();
//            if (defCol != null)
//            {
////                rendRecord.setCurrentColor(defCol);
//            } else
//            {
//                // no default color, so set to white.
////                rendRecord.setCurrentColor(1, 1, 1, 1);
//            }
//        } else if (prevColor != colors)
//        {
//            // colors have changed
//            gl.glEnableClientState(GL.GL_COLOR_ARRAY);
//            // ensure no VBO is bound
//            if (supportsVBO)
//            {
////                rendRecord.setBoundVBO(0);
//            }
//            colors.rewind();
//            gl.glColorPointer(4, GL.GL_FLOAT, 0, colors); // TODO Check assumed <type> GL_FLOAT
//        }
//        if (oldLimit != -1)
//        {
//            colors.limit(oldLimit);
//        }
//        prevColor = colors;
//
////        TextureState ts = (TextureState) context.currentStates[RenderState.StateType.Texture.ordinal()];
////        int offset = 0;
////        if (ts != null)
////        {
////            offset = ts.getTextureCoordinateOffset();
////
////            for (int i = 0; i < ts.getNumberOfSetTextures() && i < TextureState.getNumberOfFragmentTexCoordUnits(); i++)
////            {
////                TexCoords texC = g.getTextureCoords(i + offset);
////                oldLimit = -1;
////                if (texC != null)
////                {
////                    // make sure only the necessary texture coords are sent
////                    // through on old cards.
////                    oldLimit = texC.coords.limit();
////                    texC.coords.limit(g.getVertexCount() * texC.perVert);
////                }
////                if (capabilities.GL_ARB_multitexture)
////                {
////                    gl.glClientActiveTexture(GL.GL_TEXTURE0 + i);
////                }
////                if ((supportsVBO && vbo != null && vbo.getVBOTextureID(i) > 0))
////                { // use
////                    // VBO
////                    gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
////                    rendRecord.setBoundVBO(vbo.getVBOTextureID(i));
////                    gl.glTexCoordPointer(texC.perVert, GL.GL_FLOAT, 0, 0);
////                } else if (texC == null)
////                {
////                    gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
////                } else if (prevTex[i] != texC.coords)
////                {
////                    // textures have changed
////                    gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
////                    // ensure no VBO is bound
////                    if (supportsVBO)
////                    {
////                        rendRecord.setBoundVBO(0);
////                    }
////                    // set data
////                    texC.coords.rewind();
////                    gl.glTexCoordPointer(texC.perVert, GL.GL_FLOAT, 0, texC.coords); // TODO Check assumed <type> GL_FLOAT
////                } else
////                {
////                    gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
////                }
////                prevTex[i] = texC != null ? texC.coords : null;
////                if (oldLimit != -1)
////                {
////                    texC.coords.limit(oldLimit);
////                }
////            }
////
////            if (ts.getNumberOfSetTextures() < prevTextureNumber)
////            {
////                for (int i = ts.getNumberOfSetTextures(); i < prevTextureNumber; i++)
////                {
////                    if (capabilities.GL_ARB_multitexture)
////                    {
////                        gl.glClientActiveTexture(GL.GL_TEXTURE0 + i);
////                    }
////                    gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
////                }
////            }
////
////            prevTextureNumber = ts.getNumberOfSetTextures() < TextureState.getNumberOfFixedUnits() ? ts.getNumberOfSetTextures()
////                    : TextureState.getNumberOfFixedUnits();
////        }
//
//        return false; // indicesVBO;
//    }

    /**
     * Clears the buffers of this TriMesh. The buffers include its indexBuffer
     * only.
     */
    public void clearBuffers()
    {
        super.clearBuffers();
        setIndexBuffer(null);
    }

//    /**
//     * determines if a collision between this trimesh and a given spatial occurs
//     * if it has true is returned, otherwise false is returned.
//     */
//    public boolean hasCollision(
//            Spatial scene, boolean checkTriangles, int requiredOnBits)
//    {
//        if (this == scene || !isCollidable(requiredOnBits) || !scene.isCollidable(requiredOnBits))
//        {
//            return false;
//        }
//        if (getWorldBound().intersects(scene.getWorldBound()))
//        {
//            if (scene instanceof Node)
//            {
//                Node parent = (Node) scene;
//                for (int i = 0; i < parent.getQuantity(); i++)
//                {
//                    if (hasCollision(parent.getChild(i),
//                            checkTriangles, requiredOnBits))
//                    {
//                        return true;
//                    }
//                }
//
//                return false;
//            }
//
//            if (!checkTriangles)
//            {
//                return true;
//            }
//
//            return hasTriangleCollision((TriMesh) scene, requiredOnBits);
//        }
//
//        return false;
//    }
//
//    /**
//     * determines if this TriMesh has made contact with the give scene. The
//     * scene is recursively transversed until a trimesh is found, at which time
//     * the two trimesh OBBTrees are then compared to find the triangles that
//     * hit.
//     */
//    public void findCollisions(
//            Spatial scene, CollisionResults results, int requiredOnBits)
//    {
//        if (this == scene || !isCollidable(requiredOnBits) || !scene.isCollidable(requiredOnBits))
//        {
//            return;
//        }
//
//        if (getWorldBound().intersects(scene.getWorldBound()))
//        {
//            if (scene instanceof Node)
//            {
//                Node parent = (Node) scene;
//                for (int i = 0; i < parent.getQuantity(); i++)
//                {
//                    findCollisions(parent.getChild(i), results, requiredOnBits);
//                }
//            } else
//            {
//                results.addCollision(this, (Geometry) scene);
//            }
//        }
//    }
    /**
     * Convenience wrapper for hasTriangleCollision(TriMesh, int) using default
     * collision mask (bit 1 set).
     */
    final public boolean hasTriangleCollision(TriMesh toCheck)
    {
        return hasTriangleCollision(toCheck, 1);
    }

    /**
     * This function checks for intersection between this trimesh and the given
     * one. On the first intersection, true is returned.
     * 
     * @param toCheck The intersection testing mesh.
     * @param requiredOnBits Collision will only be considered if both 'this'
     *        and 'toCheck' have these bits of their collision masks set.
     * @return True if they intersect.
     */
    public boolean hasTriangleCollision(TriMesh toCheck, int requiredOnBits)
    {
//        CollisionTree thisCT = CollisionTreeManager.getInstance().getCollisionTree(this);
//        CollisionTree checkCT = CollisionTreeManager.getInstance().getCollisionTree(toCheck);
//
//        if (thisCT == null || checkCT == null || !isCollidable(requiredOnBits) || !toCheck.isCollidable(requiredOnBits))
//        {
//            return false;
//        }
//        thisCT.getBounds().transform(worldRotation, worldTranslation,
//                worldScale, thisCT.getWorldBounds());
//        return thisCT.intersect(checkCT);
        return false;
    }

    /**
     * This function finds all intersections between this trimesh and the
     * checking one. The intersections are stored as Integer objects of Triangle
     * indexes in each of the parameters.
     * 
     * @param toCheck
     *            The TriMesh to check.
     * @param thisIndex
     *            The array of triangle indexes intersecting in this mesh.
     * @param otherIndex
     *            The array of triangle indexes intersecting in the given mesh.
     */
    public void findTriangleCollision(TriMesh toCheck,
            ArrayList<Integer> thisIndex, ArrayList<Integer> otherIndex)
    {

//        CollisionTree myTree = CollisionTreeManager.getInstance().getCollisionTree(this);
//        CollisionTree otherTree = CollisionTreeManager.getInstance().getCollisionTree(toCheck);
//
//        if (myTree == null || otherTree == null)
//        {
//            return;
//        }
//
//        myTree.getBounds().transform(worldRotation, worldTranslation,
//                worldScale, myTree.getWorldBounds());
//        myTree.intersect(otherTree, thisIndex, otherIndex);
    }

    /**
     * Stores in the <code>storage</code> array the indices of triangle
     * <code>i</code>. If <code>i</code> is an invalid index, or if
     * <code>storage.length<3</code>, then nothing happens
     * 
     * @param i
     *            The index of the triangle to get.
     * @param storage
     *            The array that will hold the i's indexes.
     */
    public void getTriangle(int i, int[] storage)
    {
        if (i < getTriangleCount() && storage.length >= 3)
        {
            IntBuffer indices = getIndexBuffer();
            storage[0] = indices.get(getVertIndex(i, 0));
            storage[1] = indices.get(getVertIndex(i, 1));
            storage[2] = indices.get(getVertIndex(i, 2));
        }
    }

    /**
     * Stores in the <code>vertices</code> array the vertex values of triangle
     * <code>i</code>. If <code>i</code> is an invalid triangle index,
     * nothing happens.
     * 
     * @param i
     * @param vertices
     */
    public void getTriangle(int i, Vector3f[] vertices)
    {
        if (vertices == null)
        {
            vertices = new Vector3f[3];
        }
        if (i < getTriangleCount() && i >= 0)
        {
            for (int x = 0; x < 3; x++)
            {
                if (vertices[x] == null)
                {
                    vertices[x] = new Vector3f();
                }

                //BufferUtils.populateFromBuffer(vertices[x], getVertexBuffer(), getIndexBuffer().get(getVertIndex(i, x)));
                getVertexBuffer().get(getIndexBuffer().get(getVertIndex(i, x)), vertices[x]);
            }
        }
    }

    /**
     * <code>findTrianglePick</code> determines the triangles of this trimesh
     * that are being touched by the ray. The indices of the triangles are
     * stored in the provided ArrayList.
     * 
     * @param toTest
     *            the ray to test. The direction of the ray must be normalized
     *            (length 1).
     * @param results
     *            the indices to the triangles.
     */
    public void findTrianglePick(Ray toTest, ArrayList<Integer> results)
    {
//        if (worldBound == null || !isCollidable())
//        {
//            return;
//        }
//
//        if (worldBound.intersects(toTest))
//        {
//            CollisionTree ct = CollisionTreeManager.getInstance().getCollisionTree(this);
//            if (ct != null)
//            {
//                ct.getBounds().transform(getWorldRotation(),
//                        getWorldTranslation(), getWorldScale(),
//                        ct.getWorldBounds());
//                ct.intersect(toTest, results);
//            }
//        }
    }

    /**
     * Return this mesh object as triangles. Every 3 vertices returned compose a
     * single triangle.
     * 
     * @param verts
     *            a storage array to place the results in
     * @return view of current mesh as group of triangle vertices
     */
    public Vector3f[] getMeshAsTrianglesVertices(Vector3f[] verts)
    {
        int maxCount = getTriangleCount() * 3;
        if (verts == null || verts.length != maxCount)
        {
            verts = new Vector3f[maxCount];
        }
        getIndexBuffer().rewind();
        for (int i = 0; i < maxCount; i++)
        {
            if (verts[i] == null)
            {
                verts[i] = new Vector3f();
            }
            int index = getVertIndex(i / 3, i % 3);
            //BufferUtils.populateFromBuffer(verts[i], getVertexBuffer(), getIndexBuffer().get(index));
            getVertexBuffer().get(getIndexBuffer().get(index), verts[i]);
        }
        return verts;
    }

    protected int getVertIndex(int triangle, int point)
    {
        int index = 0, i = (triangle * 3) + point;
        switch (mode)
        {
            case Triangles:
                index = i;
                break;
            case Strip:
                index = (i / 3) + (i % 3);
                break;
            case Fan:
                if (i % 3 == 0)
                {
                    index = 0;
                } else
                {
                    index = (i % 3);
                    index = ((i - index) / 3) + index;
                }
                break;
        }
        return index;
    }

    public int[] getTriangleIndices(int[] indices)
    {
        int maxCount = getTriangleCount();
        if (indices == null || indices.length != maxCount)
        {
            indices = new int[maxCount];
        }

        for (int i = 0,  tLength = maxCount; i < tLength; i++)
        {
            indices[i] = i;
        }
        return indices;
    }

    public Triangle[] getMeshAsTriangles(Triangle[] tris)
    {
        int maxCount = getTriangleCount();
        if (tris == null || tris.length != maxCount)
        {
            tris = new Triangle[maxCount];
        }

        for (int i = 0,  tLength = maxCount; i < tLength; i++)
        {
            Vector3f vec1 = new Vector3f();
            Vector3f vec2 = new Vector3f();
            Vector3f vec3 = new Vector3f();

            Triangle t = tris[i];
            if (t == null)
            {
                t = new Triangle(getVector(i * 3 + 0, vec1), getVector(
                        i * 3 + 1, vec2), getVector(i * 3 + 2, vec3));
                tris[i] = t;
            } else
            {
                t.set(0, getVector(i * 3 + 0, vec1));
                t.set(1, getVector(i * 3 + 1, vec2));
                t.set(2, getVector(i * 3 + 2, vec3));
            }
            // t.calculateCenter();
            t.setIndex(i);
        }
        return tris;
    }

    private Vector3f getVector(int index, Vector3f store)
    {
        int vertIndex = getVertIndex(index / 3, index % 3);
        //BufferUtils.populateFromBuffer(store, getVertexBuffer(), getIndexBuffer().get(vertIndex));
        getVertexBuffer().get(getIndexBuffer().get(vertIndex), store);
        return store;
    }

    public int getMaxIndex()
    {
        if (indexBuffer == null)
        {
            return -1;
        }

        switch (mode)
        {
            case Triangles:
                return triangleQuantity * 3;
            case Strip:
            case Fan:
                triangleQuantity = indexBuffer.limit() - 2;
                return triangleQuantity + 2;
        }
        return -1;
    }

    /**
     * Returns a random point on the surface of a randomly selected triangle on
     * the mesh
     * 
     * @param fill
     *            The resulting selected point
     * @param work
     *            Used in calculations to minimize memory creation overhead
     * @return The resulting selected point
     */
    public Vector3f randomPointOnTriangles(Vector3f fill, Vector3f work)
    {
        if (getVertexBuffer() == null || getIndexBuffer() == null)
        {
            return null;
        }
        int tri = (int) (FastMath.nextRandomFloat() * getTriangleCount());
        int pntA = getIndexBuffer().get(getVertIndex(tri, 0));
        int pntB = getIndexBuffer().get(getVertIndex(tri, 1));
        int pntC = getIndexBuffer().get(getVertIndex(tri, 2));

        float b = FastMath.nextRandomFloat();
        float c = FastMath.nextRandomFloat();

        if (b + c > 1)
        {
            b = 1 - b;
            c = 1 - c;
        }

        float a = 1 - b - c;

        if (fill == null)
        {
            fill = new Vector3f();
        }

        //BufferUtils.populateFromBuffer(work, getVertexBuffer(), pntA);
        getVertexBuffer().get(pntA, work);
        work.multLocal(a);
        fill.set(work);

        //BufferUtils.populateFromBuffer(work, getVertexBuffer(), pntB);
        getVertexBuffer().get(pntB, work);
        work.multLocal(b);
        fill.addLocal(work);

        //BufferUtils.populateFromBuffer(work, getVertexBuffer(), pntC);
        getVertexBuffer().get(pntC, work);
        work.multLocal(c);
        fill.addLocal(work);

//        localToWorld(fill, fill);

        return fill;
    }

    /**
     * Used with Serialization. Do not call this directly.
     * 
     * @param s
     * @throws IOException
     * @see java.io.Serializable
     */
    private void writeObject(java.io.ObjectOutputStream s) throws IOException
    {
        s.defaultWriteObject();
        if (getIndexBuffer() == null)
        {
            s.writeInt(0);
        } else
        {
            s.writeInt(getIndexBuffer().limit());
            getIndexBuffer().rewind();
            for (int x = 0,  len = getIndexBuffer().limit(); x < len; x++)
            {
                s.writeInt(getIndexBuffer().get());
            }
        }
    }

    /**
     * Used with Serialization. Do not call this directly.
     * 
     * @param s
     * @throws IOException
     * @throws ClassNotFoundException
     * @see java.io.Serializable
     */
    private void readObject(java.io.ObjectInputStream s) throws IOException,
            ClassNotFoundException
    {
        s.defaultReadObject();
        int len = s.readInt();
        if (len == 0)
        {
            setIndexBuffer(null);
        } else
        {
            IntBuffer buf = BufferUtils.createIntBuffer(len);
            for (int x = 0; x < len; x++)
            {
                buf.put(s.readInt());
            }
            setIndexBuffer(buf);
        }
    }

//    public void write(JMEExporter e) throws IOException
//    {
//        super.write(e);
//        OutputCapsule capsule = null; // e.getCapsule(this);
//        capsule.write(indexBuffer, "indexBuffer", null);
//  //--      capsule.write(mode, "mode", Mode.Triangles);
//    }
//
//    public void read(JMEImporter e) throws IOException
//    {
//        super.read(e);
//        InputCapsule capsule = null; // e.getCapsule(this);
//        indexBuffer = capsule.readIntBuffer("indexBuffer", null);
//        recalcTriangleQuantity();
//  //--      mode = (Mode) capsule.readEnum("mode", Mode.class, Mode.Triangles);
//    }
}