/*
 * 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.util.ArrayList;
import java.util.Stack;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.jme.bounding.BoundingVolume;
import com.jme.intersection.PickResults;
import com.jme.math.FastMath;
import com.jme.math.Quaternion;
import com.jme.math.Ray;
import com.jme.math.Vector2f;
import com.jme.math.Vector3f;
import com.jme.renderer.ColorRGBA;
//import com.jme.renderer.Renderer;
//import com.jme.scene.state.LightState;
//import com.jme.scene.state.LightUtil;
//import com.jme.scene.state.RenderState;
//import com.jme.scene.state.TextureState;
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.export.Savable;
import com.jme.util.geom.BufferUtils;

//
import com.jme.scene.TexCoords;

/**
 * <code>Geometry</code> defines a leaf node of the scene graph. The leaf node
 * contains the geometric data for rendering objects. It manages all rendering
 * information such as a collection of states and the data for a model.
 * Subclasses define what the model data is.
 * 
 * @author Mark Powell
 * @author Joshua Slack
 */
public abstract class Geometry implements Serializable // extends Object3D // BoundaryRep // Spatial implements Serializable, Savable
{
    static final long serialVersionUID = 0;
    
    abstract void DrawParticles(iCameraPane display, Object3D geo, boolean selected, boolean rotate);

    private static final Logger logger = Logger.getLogger(Geometry.class.getName());
//    private static final long serialVersionUID = 1;
    /** The local bounds of this Geometry object. */
    protected BoundingVolume bound;
    /** The number of vertexes in this geometry. */
    protected int vertQuantity = 0;
    /** The geometry's per vertex color information. */
    protected FloatBuffer colorBuf;
    /** The geometry's per vertex normal information. */
    protected FloatBuffer normBuf;
    /** The geometry's vertex information. */
    protected FloatBuffer vertBuf;
    /** The geometry's vertex information. */
    protected FloatBuffer sizeBuf;
    /** The geometry's per Texture per vertex texture coordinate information. */
    protected transient ArrayList<TexCoords> texBuf;
    /** The geometry's per vertex color information. */
    protected FloatBuffer tangentBuf;
    /** The geometry's per vertex normal information. */
    protected FloatBuffer binormalBuf;
    /** The geometry's per vertex fog buffer depth values */
    protected FloatBuffer fogBuf;
    /** The geometry's VBO information. */
//    protected transient VBOInfo vboInfo;
    protected boolean enabled = true;
    protected boolean castsShadows = true;
    protected boolean hasDirtyVertices = false;
    /**
     * The compiled list of renderstates for this geometry, taking into account
     * ancestors' states - updated with updateRenderStates()
     */
//    public RenderState[] states = new RenderState[RenderState.StateType.values().length];

//    private LightState lightState;
    protected ColorRGBA defaultColor = new ColorRGBA(ColorRGBA.white);
    /**
     * Non -1 values signal that drawing this scene should use the provided
     * display list instead of drawing from the buffers.
     */
    protected int displayListID = -1;
    /** Static computation field */
    protected static final Vector3f compVect = new Vector3f();

    /**
     * Empty Constructor to be used internally only.
     */
    public Geometry()
    {
        super();
        texBuf = new ArrayList<TexCoords>(1);
        texBuf.add(null);
    }

    /**
     * Constructor instantiates a new <code>Geometry</code> object. This is
     * the default object which has an empty vertex array. All other data is
     * null.
     * 
     * @param name
     *            the name of the scene element. This is required for
     *            identification and comparision purposes.
     */
    public Geometry(String name)
    {
        //super(name);
        texBuf = new ArrayList<TexCoords>(1);
        texBuf.add(null);
    //    if (!(this instanceof SharedMesh))
        {
            reconstruct(null, null, null, null);
        }
    }

    /**
     * Constructor creates a new <code>Geometry</code> object. During
     * instantiation the geometry is set including vertex, normal, color and
     * texture information.
     * 
     * @param name
     *            the name of the scene element. This is required for
     *            identification and comparision purposes.
     * @param vertex
     *            the points that make up the geometry.
     * @param normal
     *            the normals of the geometry.
     * @param color
     *            the color of each point of the geometry.
     * @param coords
     *            the texture coordinates of the geometry (position 0.)
     */
    public Geometry(String name, FloatBuffer vertex, FloatBuffer normal,
            FloatBuffer color, TexCoords coords)
    {
        //super(name);
        texBuf = new ArrayList<TexCoords>(1);
        texBuf.add(null);
        reconstruct(vertex, normal, color, coords);
    }

    /**
     * returns the number of vertices contained in this geometry.
     */
//    @Override
    public int getVertexCount()
    {
        //if (bRep == null)
        //    return 0;
        
        return vertQuantity; //bRep.VertexCount(); // vertQuantity;
    }

    public void setVertexCount(int vertQuantity)
    {
//        assert(false);
        this.vertQuantity = vertQuantity;
    }

//    @Override
    public int getTriangleCount()
    {
        return 0; // bRep.FaceCount(); // 0;
    }

    /**
     * <code>reconstruct</code> reinitializes the geometry with new data. This
     * will reuse the geometry object.
     * 
     * @param vertices
     *            the new vertices to use.
     * @param normals
     *            the new normals to use.
     * @param colors
     *            the new colors to use.
     * @param coords
     *            the new texture coordinates to use (position 0).
     */
    public void reconstruct(FloatBuffer vertices, FloatBuffer normals,
            FloatBuffer colors, TexCoords coords)
    {
        if (vertices == null)
        {
            setVertexCount(0);
        } else
        {
            setVertexCount(vertices.limit() / 3);
        }

        setVertexBuffer(vertices);
        setNormalBuffer(normals);
        setColorBuffer(colors);
        if (getTextureCoords() == null)
        {
            setTextureCoords(new ArrayList<TexCoords>(1));
        }

        clearTextureBuffers();
        addTextureCoordinates(coords);

   //     if (getVBOInfo() != null)
   //     {
   //         resizeTextureIds(1);
   //     }
    }

//    /**
//     * Sets VBO info on this Geometry.
//     * 
//     * @param info
//     *            the VBO info to set
//     * @see VBOInfo
//     */
//    public void setVBOInfo(VBOInfo info) {
//        vboInfo = info;
//        if (vboInfo != null) {
//            vboInfo.resizeTextureIds(texBuf.size());
//        }
//    }
//
//    /**
//     * @return VBO info object
//     * @see VBOInfo
//     */
//    public VBOInfo getVBOInfo() {
//        return vboInfo;
//    }
    /**
     * <code>setSolidColor</code> sets the color array of this geometry to a
     * single color. For greater efficiency, try setting the the ColorBuffer to
     * null and using DefaultColor instead.
     * 
     * @param color
     *            the color to set.
     */
//    public void setSolidColor(ColorRGBA color)
//    {
//        if (colorBuf == null)
//        {
//            colorBuf = FloatBuffer.allocate(vertQuantity * 4); // BufferUtils.createColorBuffer(vertQuantity);
//        }
//
//        colorBuf.rewind();
//        for (int x = 0,  cLength = colorBuf.remaining(); x < cLength; x += 4)
//        {
//            colorBuf.put(color.r);
//            colorBuf.put(color.g);
//            colorBuf.put(color.b);
//            colorBuf.put(color.a);
//        }
//        colorBuf.flip();
//    }

    /**
     * Sets every color of this geometry's color array to a random color.
     */
//    public void setRandomColors()
//    {
//        if (colorBuf == null)
//        {
//            colorBuf = BufferUtils.createColorBuffer(vertQuantity);
//        }
//
//        for (int x = 0,  cLength = colorBuf.limit(); x < cLength; x += 4)
//        {
//            colorBuf.put(FastMath.nextRandomFloat());
//            colorBuf.put(FastMath.nextRandomFloat());
//            colorBuf.put(FastMath.nextRandomFloat());
//            colorBuf.put(1);
//        }
//        colorBuf.flip();
//    }

    /**
     * <code>getVertexBuffer</code> returns the float buffer that contains
     * this geometry's vertex information.
     * 
     * @return the float buffer that contains this geometry's vertex
     *         information.
     */
    public FloatBuffer getVertexBuffer()
    {
        return vertBuf;
    }

    /**
     * <code>setVertexBuffer</code> sets this geometry's vertices via a float
     * buffer consisting of groups of three floats: x,y and z.
     * 
     * @param vertBuf
     *            the new vertex buffer.
     */
    public void setVertexBuffer(FloatBuffer vertBuf)
    {
        this.vertBuf = vertBuf;
        if (vertBuf != null)
        {
            vertQuantity = vertBuf.limit() / 3;
        } else
        {
            vertQuantity = 0;
        }
    }

    /**
     * Set the fog coordinates buffer. This should have the vertex count entries
     * 
     * @param fogBuf The fog buffer to use in this geometry
     */
    public void setFogCoordBuffer(FloatBuffer fogBuf)
    {
        this.fogBuf = fogBuf;
    }

    /**
     * The fog depth coord buffer
     * 
     * @return The per vertex depth values for fog coordinates
     */
    public FloatBuffer getFogBuffer()
    {
        return fogBuf;
    }

    /**
     * <code>getNormalBuffer</code> retrieves this geometry's normal
     * information as a float buffer.
     * 
     * @return the float buffer containing the geometry information.
     */
    public FloatBuffer getNormalBuffer()
    {
        return normBuf;
    }

    /**
     * <code>setNormalBuffer</code> sets this geometry's normals via a float
     * buffer consisting of groups of three floats: x,y and z.
     * 
     * @param normBuf
     *            the new normal buffer.
     */
    public void setNormalBuffer(FloatBuffer normBuf)
    {
        this.normBuf = normBuf;
    }

    /**
     * <code>getColorBufferfer</code> retrieves the float buffer that contains
     * this geometry's color information.
     * 
     * @return the buffer that contains this geometry's color information.
     */
    public FloatBuffer getColorBuffer()
    {
        return colorBuf;
    }

    /**
     * <code>setColorBuffer</code> sets this geometry's colors via a float
     * buffer consisting of groups of four floats: r,g,b and a.
     * 
     * @param colorBuf
     *            the new color buffer.
     */
    public void setColorBuffer(FloatBuffer colorBuf)
    {
        this.colorBuf = colorBuf;
    }

    public FloatBuffer getSizeBuffer()
    {
        return sizeBuf;
    }

    public void setSizeBuffer(FloatBuffer sizeBuf)
    {
        this.sizeBuf = sizeBuf;
    }

    /**
     * <code>copyTextureCoords</code> copys the texture coordinates of a given
     * texture unit to another location. If the texture unit is not valid, then
     * the coordinates are ignored. Coords are multiplied by the given factor.
     * 
     * @param fromIndex
     *            the coordinates to copy.
     * @param toIndex
     *            the texture unit to set them to.
     * @param factor
     *            a multiple to apply when copying
     */
    public void copyTextureCoordinates(int fromIndex, int toIndex, float factor)
    {
        if (texBuf == null)
        {
            return;
        }

        if (fromIndex < 0 || fromIndex >= texBuf.size() || texBuf.get(fromIndex) == null)
        {
            return;
        }

        TexCoords src = texBuf.get(fromIndex);
        float[] factors = new float[src.perVert];
        for (int i = 0; i < factors.length; i++)
        {
            factors[i] = factor;
        }
        copyTextureCoordinates(fromIndex, toIndex, factors);

    }

    /**
     * <code>copyTextureCoords</code> copys the texture coordinates of a given
     * texture unit to another location. If the texture unit is not valid, then
     * the coordinates are ignored. Coords are multiplied by the given factor.
     * 
     * @param fromIndex
     *            the coordinates to copy.
     * @param toIndex
     *            the texture unit to set them to.
     * @param factor
     *            a multiple to apply when copying
     */
    public void copyTextureCoordinates(int fromIndex, int toIndex, float[] factor)
    {
        if (texBuf == null)
        {
            return;
        }

        if (fromIndex < 0 || fromIndex >= texBuf.size() || texBuf.get(fromIndex) == null)
        {
            return;
        }

        if (toIndex < 0 || toIndex == fromIndex)
        {
            return;
        }

        // make sure we are big enough
        while (toIndex >= texBuf.size())
        {
            texBuf.add(null);
        }

        TexCoords dest = texBuf.get(toIndex);
        TexCoords src = texBuf.get(fromIndex);
        if (dest == null || dest.coords.capacity() != src.coords.limit())
        {
            dest = new TexCoords(BufferUtils.createFloatBuffer(src.coords.capacity()), src.perVert);
            texBuf.set(toIndex, dest);
        }
        dest.coords.clear();
        int oldLimit = src.coords.limit();
        src.coords.clear();
        for (int i = 0,  len = dest.coords.capacity(); i < len; i += dest.perVert)
        {
            for (int j = 0; j < dest.perVert; j++)
            {
                dest.coords.put(factor[j] * src.coords.get());
            }
        }
        src.coords.limit(oldLimit);
        dest.coords.limit(oldLimit);

//        if (vboInfo != null)
//        {
//            vboInfo.resizeTextureIds(this.texBuf.size());
//        }

        checkTextureCoordinates();
    }

    /**
     * <code>getTextureBuffers</code> retrieves this geometry's texture
     * information contained within a float buffer array.
     * 
     * @return the float buffers that contain this geometry's texture
     *         information.
     */
    public ArrayList<TexCoords> getTextureCoords()
    {
        return texBuf;
    }

    /**
     * <code>getTextureAsFloatBuffer</code> retrieves the texture buffer of a
     * given texture unit.
     * 
     * @param textureUnit
     *            the texture unit to check.
     * @return the texture coordinates at the given texture unit.
     */
    public TexCoords getTextureCoords(int textureUnit)
    {
        if (texBuf == null)
        {
            return null;
        }
        if (textureUnit >= texBuf.size())
        {
            return null;
        }
        return texBuf.get(textureUnit);
    }

    /**
     * <code>setTextureBuffer</code> sets this geometry's textures (position
     * 0) via a float buffer. This convenience method assumes we are setting
     * coordinates for texture unit 0 and that there are 2 coordinate values per
     * vertex.
     * 
     * @param coords
     *            the new coords for unit 0.
     */
    public void setTextureCoords(TexCoords coords)
    {
        setTextureCoords(coords, 0);
    }

    /**
     * <code>setTextureBuffer</code> sets this geometry's textures at the
     * position given via a float buffer. This convenience method assumes that
     * there are 2 coordinate values per vertex.
     * 
     * @param coords
     *            the new coords.
     * @param unit
     *            the texture unit we are providing coordinates for.
     */
    public void setTextureCoords(TexCoords coords, int unit)
    {
        while (unit >= texBuf.size())
        {
            texBuf.add(null);
        }
        texBuf.set(unit, coords);

//        if (vboInfo != null)
//        {
//            vboInfo.resizeTextureIds(texBuf.size());
//        }
        checkTextureCoordinates();
    }

    /**
     * Clears all vertex, normal, texture, and color buffers by setting them to
     * null.
     */
    public void clearBuffers()
    {
        reconstruct(null, null, null, null);
    }

    /**
     * <code>updateBound</code> recalculates the bounding object assigned to
     * the geometry. This resets it parameters to adjust for any changes to the
     * vertex information.
     */
//    public void updateModelBound()
//    {
//        if (bound != null && getVertexBuffer() != null)
//        {
//            bound.computeFromPoints(getVertexBuffer());
////            updateWorldBound();
//        }
//    }

    /**
     * <code>setModelBound</code> sets the bounding object for this geometry.
     * 
     * @param modelBound
     *            the bounding object for this geometry.
     */
    public void setModelBound(BoundingVolume modelBound)
    {
//        this.worldBound = null;
        this.bound = modelBound;
    }

//    /**
//     * <code>draw</code> prepares the geometry for rendering to the display.
//     * The renderstate is set and the subclass is responsible for rendering the
//     * actual data.
//     * 
//     * @see com.jme.scene.Spatial#draw(com.jme.renderer.Renderer)
//     * @param r
//     *            the renderer that displays to the context.
//     */
//    @Override
//    public void draw(Renderer r) {
//    }
//
//    /**
//     * <code>updateWorldBound</code> updates the bounding volume that contains
//     * this geometry. The location of the geometry is based on the location of
//     * all this node's parents.
//     * 
//     * @see com.jme.scene.Spatial#updateWorldBound()
//     */
//    public void updateWorldBound() {
//        if (bound != null) {
//            worldBound = bound.transform(getWorldRotation(),
//                    getWorldTranslation(), getWorldScale(), worldBound);
//        }
//    }
//
//    /**
//     * <code>applyRenderState</code> determines if a particular render state
//     * is set for this Geometry. If not, the default state will be used.
//     */
//    @Override
//    protected void applyRenderState(Stack<? extends RenderState>[] states) {
//        for (int x = 0; x < states.length; x++) {
//            if (states[x].size() > 0) {
//                this.states[x] = ((RenderState) states[x].peek()).extract(
//                        states[x], this);
//            } else {
//                this.states[x] = Renderer.defaultStateList[x];
//            }
//        }
//    }
//
//    /**
//     * sorts the lights based on distance to geometry bounding volume
//     */
//    public void sortLights() {
//        if (lightState != null && lightState.getLightList().size() > LightState.MAX_LIGHTS_ALLOWED) {
//            LightUtil.sort(this, lightState.getLightList());
//        }
//    }
    /**
     * <code>randomVertex</code> returns a random vertex from the list of
     * vertices set to this geometry. If there are no vertices set, null is
     * returned.
     * 
     * @param fill
     *            a Vector3f to fill with the results. If null, one is created.
     *            It is more efficient to pass in a non-null vector.
     * @return Vector3f a random vertex from the vertex list. Null is returned
     *         if the vertex list is not set.
     */
    public Vector3f randomVertex(Vector3f fill)
    {
        if (getVertexBuffer() == null)
        {
            return null;
        }
        int i = (int) (FastMath.nextRandomFloat() * getVertexCount());

        if (fill == null)
        {
            fill = new Vector3f();
        }
        //BufferUtils.populateFromBuffer(fill, getVertexBuffer(), i);
        getVertexBuffer().get(i, fill);

//NOTODO        localToWorld(fill, fill);

        return fill;
    }

    /**
     * Check if this geometry intersects the ray if yes add it to the results.
     * 
     * @param ray ray to check intersection with. The direction of the ray must
     *            be normalized (length 1).
     * @param requiredOnBits Collision will only be considered if 'this'
     *        has these bits of its collision mask set.
     * @param results
     *            result list
     */
//    @Override
    public void findPick(Ray ray, PickResults results, int requiredOnBits)
    {
//        if (getWorldBound() == null || !isCollidable(requiredOnBits))
//        {
//            return;
//        }
//        if (getWorldBound().intersects(ray))
//        {
//            // find the triangle that is being hit.
//            // add this node and the triangle to the PickResults list.
//            results.addPick(ray, this);
//        }
    }

    /**
     * <code>setDefaultColor</code> sets the color to be used if no per vertex
     * color buffer is set.
     * 
     * @param color
     */
    public void setDefaultColor(ColorRGBA color)
    {
        defaultColor = color;
    }

    /**
     * <code>getWorldCoords</code> translates/rotates and scales the
     * coordinates of this Geometry to world coordinates based on its world
     * settings. The results are stored in the given FloatBuffer. If given
     * FloatBuffer is null, one is created.
     * 
     * @param store
     *            the FloatBuffer to store the results in, or null if you want
     *            one created.
     * @return store or new FloatBuffer if store == null.
     */
//    public FloatBuffer getWorldCoords(FloatBuffer store)
//    {
//        final FloatBuffer vertBuf = getVertexBuffer();
//        if (store == null || store.capacity() != vertBuf.limit())
//        {
//            store = BufferUtils.createFloatBuffer(vertBuf.limit());
//            if (store == null)
//            {
//                return null;
//            }
//        }
//
//        for (int v = 0,  vSize = store.capacity() / 3; v < vSize; v++)
//        {
//            BufferUtils.populateFromBuffer(compVect, vertBuf, v);
////            localToWorld(compVect, compVect);
//            BufferUtils.setInBuffer(compVect, store, v);
//        }
//        return store;
//    }

    /**
     * <code>getWorldNormals</code> rotates the normals of this Geometry to
     * world normals based on its world settings. The results are stored in the
     * given FloatBuffer. If given FloatBuffer is null, one is created.
     * 
     * @param store
     *            the FloatBuffer to store the results in, or null if you want
     *            one created.
     * @return store or new FloatBuffer if store == null.
     */
//    public FloatBuffer getWorldNormals(FloatBuffer store)
//    {
//        final FloatBuffer normBuf = getNormalBuffer();
//        if (store == null || store.capacity() != normBuf.limit())
//        {
//            store = BufferUtils.createFloatBuffer(normBuf.limit());
//            if (store == null)
//            {
//                return null;
//            }
//        }
//
//        for (int v = 0,  vSize = store.capacity() / 3; v < vSize; v++)
//        {
//            BufferUtils.populateFromBuffer(compVect, normBuf, v);
////            getWorldRotation().multLocal(compVect);
//            BufferUtils.setInBuffer(compVect, store, v);
//        }
//        return store;
//    }

    public int getDisplayListID()
    {
        return displayListID;
    }

    public void setDisplayListID(int displayListID)
    {
        this.displayListID = displayListID;
    }

    public void setTextureCoords(ArrayList<TexCoords> texBuf)
    {
        this.texBuf = texBuf;
        checkTextureCoordinates();
    }

    public void clearTextureBuffers()
    {
        if (texBuf != null)
        {
            texBuf.clear();
        }
    }

    public void addTextureCoordinates(TexCoords textureCoords)
    {
        addTextureCoordinates(textureCoords, 2);
    }

    public void addTextureCoordinates(TexCoords textureCoords, int coordSize)
    {
        if (texBuf != null)
        {
            texBuf.add(textureCoords);
        }
        checkTextureCoordinates();
    }

    public void resizeTextureIds(int i)
    {
//        vboInfo.resizeTextureIds(i);
    }

    protected void checkTextureCoordinates()
    {
        int max = -1; // TextureState.getNumberOfFragmentTexCoordUnits();
        if (max == -1)
        {
            return;
        } // No texture state created yet.
        if (texBuf != null && texBuf.size() > max)
        {
            for (int i = max; i < texBuf.size(); i++)
            {
                if (texBuf.get(i) != null)
                {
                    logger.log(Level.WARNING, "Texture coordinates set for unit {0}." + " Only {1} units are available.", new Integer[]{i, max});
                }
            }
        }
    }

    public void scaleTextureCoordinates(int index, float factor)
    {
        scaleTextureCoordinates(index, new Vector2f(factor, factor));
    }

    public void scaleTextureCoordinates(int index, Vector2f factor)
    {
        if (texBuf == null)
        {
            return;
        }

        if (index < 0 || index >= texBuf.size() || texBuf.get(index) == null)
        {
            return;
        }

        TexCoords tc = texBuf.get(index);

        for (int i = 0,  len = tc.coords.limit() / 2; i < len; i++)
        {
            BufferUtils.multInBuffer(factor, tc.coords, i);
        }

//        if (vboInfo != null)
//        {
//            vboInfo.resizeTextureIds(this.texBuf.size());
//        }
    }

    public boolean isCastsShadows()
    {
        return castsShadows;
    }

    public void setCastsShadows(boolean castsShadows)
    {
        this.castsShadows = castsShadows;
    }

    /**
     * <code>getNumberOfUnits</code> returns the number of texture units this
     * geometry is currently using.
     * 
     * @return the number of texture units in use.
     */
    public int getNumberOfUnits()
    {
        if (texBuf == null)
        {
            return 0;
        }
        return texBuf.size();
    }

//    @Override
//    public void lockMeshes(Renderer r) {
//        if (getDisplayListID() != -1) {
//            logger.warning("This Geometry already has locked meshes."
//                    + "(Use unlockMeshes to clear)");
//            return;
//        }
//
//        updateRenderState();
//        lockedMode |= LOCKED_MESH_DATA;
//
//        setDisplayListID(r.createDisplayList(this));
//    }
//
//    @Override
//    public void unlockMeshes(Renderer r) {
//        lockedMode &= ~LOCKED_MESH_DATA;
//
//        if (getDisplayListID() != -1) {
//            r.releaseDisplayList(getDisplayListID());
//            setDisplayListID(-1);
//        }
//    }
//
//    /**
//     * Called just before renderer starts drawing this geometry. If it returns
//     * false, we'll skip rendering.
//     */
//    public boolean predraw(Renderer r) {
//        return true;
//    }
//
//    /**
//     * Called after renderer finishes drawing this geometry.
//     */
//    public void postdraw(Renderer r) {
//    }
//    public void translatePoints(float x, float y, float z)
//    {
//        translatePoints(new Vector3f(x, y, z));
//    }
//
//    public void translatePoints(Vector3f amount)
//    {
//        for (int x = 0; x < vertQuantity; x++)
//        {
//            BufferUtils.addInBuffer(amount, vertBuf, x);
//        }
//    }
//
//    public void rotatePoints(Quaternion rotate)
//    {
//        Vector3f store = new Vector3f();
//        for (int x = 0; x < vertQuantity; x++)
//        {
//            BufferUtils.populateFromBuffer(store, vertBuf, x);
//            rotate.mult(store, store);
//            BufferUtils.setInBuffer(store, vertBuf, x);
//        }
//    }
//
//    public void rotateNormals(Quaternion rotate)
//    {
//        Vector3f store = new Vector3f();
//        for (int x = 0; x < vertQuantity; x++)
//        {
//            BufferUtils.populateFromBuffer(store, normBuf, x);
//            rotate.mult(store, store);
//            BufferUtils.setInBuffer(store, normBuf, x);
//        }
//    }

    /**
     * <code>getDefaultColor</code> returns the color used if no per vertex
     * colors are specified.
     * 
     * @return default color
     */
    public ColorRGBA getDefaultColor()
    {
        return defaultColor;
    }

//    public void write(JMEExporter e) throws IOException
//    {
////        super.write(e);
//        OutputCapsule capsule = null; // e.getCapsule(this);
//        capsule.write(colorBuf, "colorBuf", null);
//        capsule.write(normBuf, "normBuf", null);
//        capsule.write(vertBuf, "vertBuf", null);
//        capsule.writeSavableArrayList(texBuf, "texBuf",
//                new ArrayList<TexCoords>(1));
//        capsule.write(tangentBuf, "tangentBuf", null);
//        capsule.write(binormalBuf, "binormalBuf", null);
//        capsule.write(enabled, "enabled", true);
//        capsule.write(castsShadows, "castsShadows", true);
//        capsule.write(bound, "bound", null);
//        capsule.write(defaultColor, "defaultColor", ColorRGBA.white);
//   //     capsule.write(vboInfo, "vboInfo", null);
//    }
//
//    @SuppressWarnings("unchecked")
//    public void read(JMEImporter e) throws IOException
//    {
////        super.read(e);
//        InputCapsule capsule = null; // e.getCapsule(this);
//
//        colorBuf = capsule.readFloatBuffer("colorBuf", null);
//        normBuf = capsule.readFloatBuffer("normBuf", null);
//        vertBuf = capsule.readFloatBuffer("vertBuf", null);
//        if (vertBuf != null)
//        {
//            vertQuantity = vertBuf.limit() / 3;
//        } else
//        {
//            vertQuantity = 0;
//        }
//        tangentBuf = capsule.readFloatBuffer("tangentBuf", null);
//        binormalBuf = capsule.readFloatBuffer("binormalBuf", null);
//        texBuf = capsule.readSavableArrayList("texBuf",
//                new ArrayList<TexCoords>(1));
//        checkTextureCoordinates();
//
//        enabled = capsule.readBoolean("enabled", true);
//        castsShadows = capsule.readBoolean("castsShadows", true);
//        bound = (BoundingVolume) capsule.readSavable("bound", null);
////        if (bound != null)
////        {
////            worldBound = bound.clone(null);
////        }
//        defaultColor = (ColorRGBA) capsule.readSavable("defaultColor",
//                ColorRGBA.white.clone());
////        vboInfo = (VBOInfo) capsule.readSavable("vboInfo", null);
//    }

    /**
     * <code>getModelBound</code> retrieves the bounding object that contains
     * the geometry's vertices.
     * 
     * @return the bounding object for this geometry.
     */
    public BoundingVolume getModelBound()
    {
        return bound;
    }

    public boolean hasDirtyVertices()
    {
        return hasDirtyVertices;
    }

    public void setHasDirtyVertices(boolean flag)
    {
        hasDirtyVertices = flag;
    }

    public void setTangentBuffer(FloatBuffer tangentBuf)
    {
        this.tangentBuf = tangentBuf;
    }

    public FloatBuffer getTangentBuffer()
    {
        return this.tangentBuf;
    }

    public void setBinormalBuffer(FloatBuffer binormalBuf)
    {
        this.binormalBuf = binormalBuf;
    }

    public FloatBuffer getBinormalBuffer()
    {
        return binormalBuf;
    }
//    public void setLightState(LightState lightState) {
//        this.lightState = lightState;
//    }
//
//    public LightState getLightState() {
//        return lightState;
//    }
}