/*
 * Copyright 1996-2008 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 *
 */

package javax.media.j3d;

import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;

import javax.vecmath.Color3b;
import javax.vecmath.Color3f;
import javax.vecmath.Color4b;
import javax.vecmath.Color4f;
import javax.vecmath.Point2d;
import javax.vecmath.Point2f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Point4d;
import javax.vecmath.Point4f;
import javax.vecmath.TexCoord2f;
import javax.vecmath.TexCoord3f;
import javax.vecmath.TexCoord4f;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;


/**
 * The GeometryArray object contains arrays of positional coordinates,
 * colors, normals and/or texture coordinates that describe
 * point, line, or surface geometry.  It is extended to create
 * the various primitive types (e.g., lines, triangle_strips, etc.)
 */

abstract class GeometryArrayRetained extends GeometryRetained{

    // XXXX: Memory footprint reduction. Should have separate object to
    //       to contain specific data such as a ByRef object for
    //       all ByRef related data. So that incases where no
    //       ByRef is needed, the ByRef object reference is
    //       set to null. Hence saving memory!
    //       Need object such as Texture, D3d and ByRef ...
    //


    // Contains a bitset indicating which components are present
    int vertexFormat;

    // Whether this geometry was ever rendered as transparent
    int c4fAllocated =  0;

    // Total Number of vertices
    int vertexCount;

    // number of vertices used in rendering
    int validVertexCount;

    // The vertex data in packed format
    float vertexData[];

    // vertex data in packed format for each screen in multi-screen situation
    // if alpha values of each vertex are to be updated
    private float mvertexData[][];

    //
    // The following offset/stride values are internally computed
    // from the format
    //

    // Stride (in words) from one vertex to the next
    int stride;

    // Stride (in words) from one texture coordinate to the next
    int texCoordStride;

    // Offset (in words) within each vertex of the coordinate position
    int coordinateOffset;

    // Offset (in words) within each vertex of the normal
    int normalOffset;

    // Offset (in words) within each vertex of the color
    int colorOffset;

    // Offset (in words) within each vertex of the texture coordinate
    int textureOffset;

    // Offset (in words) within each vertex of each vertex attribute
    int[] vertexAttrOffsets;

    // Stride (size) of all vertex attributes
    int vertexAttrStride;

    // alpha value for transparency and texture blending
    private float[] lastAlpha = new float[1];
    float lastScreenAlpha = -1;

    int colorChanged = 0;

    // byte to float scale factor
    static final float ByteToFloatScale = 1.0f/255.0f;

    // float to byte scale factor
    static final float FloatToByteScale = 255.0f;

    // Set flag indicating that we are in the updater.  This flag
    // can be used by the various setRef methods to inhibit any
    // update messages
    boolean inUpdater = false;

// Array List used for messages
ArrayList<GeometryAtom> gaList = new ArrayList<GeometryAtom>(1);

    // Target threads to be notified when morph changes
    static final int targetThreads = (J3dThread.UPDATE_RENDER |
				      J3dThread.UPDATE_GEOMETRY);

    // used for byReference geometry
    float[] floatRefCoords = null;
    double[] doubleRefCoords = null;
    Point3d[] p3dRefCoords = null;
    Point3f[] p3fRefCoords = null;

    // Used for NIO buffer geometry
    J3DBuffer coordRefBuffer = null;
    FloatBuffer floatBufferRefCoords = null;
    DoubleBuffer doubleBufferRefCoords = null;

    // Initial index to use for rendering
    int initialCoordIndex = 0;
    int initialColorIndex = 0;
    int initialNormalIndex = 0;
    int[] initialTexCoordIndex = null;
    int[] initialVertexAttrIndex = null;
    int initialVertexIndex = 0;


    // used for byReference colors
    float[] floatRefColors = null;
    byte[] byteRefColors = null;
    Color3f[] c3fRefColors = null;
    Color4f[] c4fRefColors = null;
    Color3b[] c3bRefColors = null;
    Color4b[] c4bRefColors = null;

    // Used for NIO buffer colors
    J3DBuffer colorRefBuffer = null;
    FloatBuffer floatBufferRefColors = null;
    ByteBuffer byteBufferRefColors = null;

    // flag to indicate if the "by reference" component is already set
    int vertexType = 0;
    static  final int PF    = 0x1;
    static  final int PD    = 0x2;
    static  final int P3F   = 0x4;
    static  final int P3D   = 0x8;
    static final int VERTEX_DEFINED = PF | PD | P3F | P3D;

    static final int CF  = 0x10;
    static final int CUB = 0x20;
    static final int C3F = 0x40;
    static final int C4F = 0x80;
    static final int C3UB  = 0x100;
    static final int C4UB = 0x200;
    static final int COLOR_DEFINED = CF | CUB | C3F | C4F| C3UB | C4UB;

    static final int NF = 0x400;
    static final int N3F = 0x800;
    static final int NORMAL_DEFINED = NF | N3F;

    static final int TF = 0x1000;
    static final int T2F = 0x2000;
    static final int T3F = 0x4000;
    static final int TEXCOORD_DEFINED = TF | T2F | T3F;

    static final int AF = 0x8000;
    static final int VATTR_DEFINED = AF;

    // Flag word indicating the type of by-ref texCoord. We will copy this to
    // the vertexType field only when the references for all texture coordinate
    // sets are set to non-null values.
    private int texCoordType = 0;

    // Flag word indicating the type of by-ref vertex attr. We will copy this to
    // the vertexType field only when the references for all vertex attrs
    // are set to non-null values.
    private int vertexAttrType = 0;

    // flag for execute geometry array when by reference
    static final int COORD_FLOAT  = 0x01;
    static final int COORD_DOUBLE = 0x02;
    static final int COLOR_FLOAT  = 0x04;
    static final int COLOR_BYTE   = 0x08;
    static final int NORMAL_FLOAT = 0x10;
    static final int TEXCOORD_FLOAT = 0x20;
    static final int VATTR_FLOAT = 0x40;


    // used by "by reference" normals
    float[] floatRefNormals = null;
    Vector3f[] v3fRefNormals = null;

    // Used for NIO buffer normals
    J3DBuffer normalRefBuffer = null;
    FloatBuffer floatBufferRefNormals = null;

    // used for "by reference" vertex attrs
    float[][] floatRefVertexAttrs = null;

    // Used for NIO buffer vertex attrs
    J3DBuffer[] vertexAttrsRefBuffer = null;
    FloatBuffer[] floatBufferRefVertexAttrs = null;

    // used by "by reference" tex coords
    Object[] refTexCoords = null;
    TexCoord2f[] t2fRefTexCoords = null;
    TexCoord3f[] t3fRefTexCoords = null;

    // Used for NIO buffer tex coords
    J3DBuffer[] refTexCoordsBuffer = null;
    //FloatBufferWrapper[] floatBufferRefTexCoords = null;


    // used by interleaved array
    float[] interLeavedVertexData = null;

    // used by interleaved NIO buffer
    J3DBuffer interleavedVertexBuffer = null;
    FloatBuffer interleavedFloatBufferImpl = null;

    // pointers used, when transparency is turned on
    // or when its an object such as C3F, P3F etc ..
    float[] mirrorFloatRefCoords = null;
    double[] mirrorDoubleRefCoords = null;
    float[] mirrorFloatRefNormals = null;
    float[][] mirrorFloatRefVertexAttrs = null;
    float[] mirrorFloatRefTexCoords = null;
    Object[] mirrorRefTexCoords = null;

    float[][] mirrorFloatRefColors = new float[1][];
    byte[][] mirrorUnsignedByteRefColors= new byte[1][];
    float[][] mirrorInterleavedColorPointer = null;

    // boolean to determine if a mirror was allocated
    int mirrorVertexAllocated = 0;
    int mirrorColorAllocated = 0;
    boolean mirrorNormalAllocated = false;

    // Some dirty bits for GeometryArrays
    static final int COORDINATE_CHANGED 	= 0x01;
    static final int NORMAL_CHANGED 		= 0x02;
    static final int COLOR_CHANGED 		= 0x04;
    static final int TEXTURE_CHANGED 		= 0x08;
    static final int BOUNDS_CHANGED 		= 0x10;
    static final int INDEX_CHANGED 		= 0x20;
    static final int STRIPCOUNT_CHANGED 	= 0x40;
    static final int VATTR_CHANGED 		= 0x80;
    static final int VERTEX_CHANGED             = COORDINATE_CHANGED |
                                                  NORMAL_CHANGED |
                                                  COLOR_CHANGED |
                                                  TEXTURE_CHANGED |
                                                  VATTR_CHANGED;

    static final int defaultTexCoordSetMap[] = {0};
    int texCoordSetCount = 0;
    int [] texCoordSetMap = null;

    // this array contains offset to the texCoord data for each
    // texture unit.  -1 means no corresponding texCoord data offset
    int [] texCoordSetMapOffset = null;

    // Vertex attribute information
    int vertexAttrCount = 0;
    int[] vertexAttrSizes = null;


    // This point to a list of VertexBuffers in a Vector structure
    // Each element correspond to a D3D context that create this VB.
    // Note that this GeometryArray can be used by multiple ctx.
    int dirtyFlag;

    // each bit corresponds to a unique renderer if shared context
    // or a unique canvas otherwise
    int resourceCreationMask = 0x0;

    // Fix for Issue 5
    //
    // Replace the per-canvas reference count with a per-RenderBin set
    // of users.  The per-RenderBin set of users of this display list
    // is defined as a HashMap where:
    //
    //   key   = the RenderBin
    //   value = a set of RenderAtomListInfo objects using this
    //           geometry array for display list purposes
private HashMap<RenderBin, HashSet<RenderAtomListInfo>> dlistUsers = null;

    // timestamp used to create display list. This is either
    // one per renderer for useSharedCtx, or one per Canvas for non-shared
    // ctx
    private long[] timeStampPerDlist = new long[2];

    // Unique display list Id, if this geometry is shared
    int dlistId = -1;
    Integer dlistObj = null;

    // A list of pre-defined bits to indicate which component
    // in this Texture object changed.
    //    static final int DLIST_CREATE_CHANGED      = 0x01;
    static final int INIT_MIRROR_GEOMETRY      = 0x02;


// A list of Universes that this Geometry is referenced in Morph from
ArrayList<VirtualUniverse> morphUniverseList = null;

// A list of ArrayLists which contain all the MorphRetained objects
// refering to this geometry. Each list corresponds to the universe
// above.
ArrayList<ArrayList<MorphRetained>> morphUserLists = null;

    // The following variables are only used in compile mode

    // Offset of a geometry array into the merged array
    int[] geoOffset;

    // vertexcount of a geometry array in a merge array
    int[] compileVcount;

    boolean isCompiled = false;

    boolean isShared = false;

    IndexedGeometryArrayRetained cloneSourceArray = null;

    static final double EPS = 1.0e-13;

    GeometryArrayRetained() {
	dirtyFlag = INDEX_CHANGED|VERTEX_CHANGED;
        lastAlpha[0] = 1.0f;
    }


    @Override
    void setLive(boolean inBackgroundGroup, int refCount) {
	dirtyFlag = VERTEX_CHANGED|INDEX_CHANGED;
        isEditable = !isWriteStatic();
        super.doSetLive(inBackgroundGroup, refCount);
	super.markAsLive();
	// Send message to RenderingAttribute structure to obtain a dlistId
	//	System.err.println("Geometry - "+this+"refCount = "+this.refCount);
	if (this.refCount > 1) {
	    // Send to rendering attribute structure,
	    /*
	    J3dMessage createMessage = new J3dMessage();
	    createMessage.threads = J3dThread.UPDATE_RENDERING_ATTRIBUTES;
	    createMessage.type = J3dMessage.GEOMETRYARRAY_CHANGED;
	    createMessage.universe = null;
	    createMessage.args[0] = this;
	    createMessage.args[1]= new Integer(DLIST_CREATE_CHANGED);
	    VirtualUniverse.mc.processMessage(createMessage);
	    */
	    isShared = true;
	} // Clone geometry only for the first setLive
	else {
	    // If geometry is indexed and use_index_coord is false, unindexify
	    // otherwise, set mirrorGeometry to null (from previous clearLive)
	    if (this instanceof IndexedGeometryArrayRetained) {
		// Send to rendering attribute structure,
		J3dMessage createMessage = new J3dMessage();
		createMessage.threads = J3dThread.UPDATE_RENDERING_ATTRIBUTES;
		createMessage.type = J3dMessage.GEOMETRY_CHANGED;
		createMessage.universe = null;
		createMessage.args[0] = null;
		createMessage.args[1]= this;
		createMessage.args[2]= new Integer(INIT_MIRROR_GEOMETRY);
		VirtualUniverse.mc.processMessage(createMessage);
	    }
	}

    }

    @Override
    void clearLive(int refCount) {
	super.clearLive(refCount);

	if (this.refCount <= 0) {
	    isShared = false;
	}
    }

    @Override
    void computeBoundingBox() {

	//	System.err.println("computeBoundingBox ....");

        if (boundsDirty && VirtualUniverse.mc.cacheAutoComputedBounds) {
            for(ArrayList<Shape3DRetained> users : userLists) {
                for(Shape3DRetained shape : users)
                    shape.dirtyBoundsCache();
            }
        }

	if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
	    // by copy
	    computeBoundingBox(initialVertexIndex, vertexData);

	} else if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) { // USE_NIO_BUFFER
	    //System.err.println("vertexFormat & GeometryArray.USE_NIO_BUFFER");
	    if((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
		computeBoundingBox(initialCoordIndex, interleavedFloatBufferImpl);
	    } else if((vertexType & PF) != 0) {
		computeBoundingBox(floatBufferRefCoords);
	    } else if((vertexType & PD) != 0) {
		computeBoundingBox(doubleBufferRefCoords);
	    }

	} else if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
	    //System.err.println("vertexFormat & GeometryArray.INTERLEAVED");
	    computeBoundingBox(initialCoordIndex, interLeavedVertexData);
	} else if ((vertexType & PF) != 0) {
	    //System.err.println("vertexType & PF");
	    computeBoundingBox(floatRefCoords);
	} else if ((vertexType & P3F) != 0) {
	    //System.err.println("vertexType & P3F");
	    computeBoundingBox(p3fRefCoords);
	} else if ((vertexType & P3D) != 0) {
	    //System.err.println("vertexType & P3D");
	    computeBoundingBox(p3dRefCoords);
	} else if ((vertexType & PD) != 0) {
	    //System.err.println("vertexType & PD");
	    computeBoundingBox(doubleRefCoords);
	}

    }


    // NullGeometry is true only for byRef case
    void processCoordsChanged(boolean nullGeo) {

	/*
	  System.err.println("processCoordsChanged : nullGeo " + nullGeo);
	  System.err.println("Before :processCoordsChanged : geoBounds ");
	  System.err.println(geoBounds);
	*/
	if (nullGeo) {
	    synchronized(geoBounds) {
		geoBounds.setLower(-1.0, -1.0, -1.0);
		geoBounds.setUpper(1.0, 1.0, 1.0);
		boundsDirty = false;
	    }
	    synchronized(centroid) {
		recompCentroid = false;
			geoBounds.getCenter(this.centroid);
	    }

	}
	else {
	    // re-compute centroid if used
	    synchronized(centroid) {
		recompCentroid = true;
	    }

	    synchronized(geoBounds) {
		boundsDirty = true;
		computeBoundingBox();
	    }

	    /*
	      System.err.println("After :processCoordsChanged : geoBounds ");
	      System.err.println(geoBounds);
	    */
	}
    }


    void computeBoundingBox(int vIndex, float[] vdata) {
	int i, offset;
	double xmin, xmax, ymin, ymax, zmin, zmax;


	//System.err.println("Before : computeBoundingBox : geoBounds ");
	//  System.err.println(geoBounds);

	synchronized(geoBounds) {

	    // If autobounds compute is false  then return
	    // It is possible that user call getBounds() before
	    // this Geometry add to live scene graph.
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
	    	return;
	    }
	    if (!boundsDirty)
		return;

	    // Initial offset
	    offset = vIndex * stride+coordinateOffset;
	    // Compute the bounding box
	    xmin = xmax = vdata[offset];
	    ymin = ymax = vdata[offset+1];
	    zmin = zmax = vdata[offset+2];
	    offset += stride;
	    for (i=1; i<validVertexCount; i++) {
		if (vdata[offset] > xmax)
		    xmax = vdata[offset];
		if (vdata[offset] < xmin)
		    xmin = vdata[offset];

		if (vdata[offset+1] > ymax)
		    ymax = vdata[offset+1];
		if (vdata[offset+1] < ymin)
		    ymin = vdata[offset+1];

		if (vdata[offset+2] > zmax)
		    zmax = vdata[offset+2];
		if (vdata[offset+2] < zmin)
		    zmin = vdata[offset+2];

		offset += stride;
	    }

	    geoBounds.setUpper(xmax, ymax, zmax);
	    geoBounds.setLower(xmin, ymin, zmin);
	    boundsDirty = false;
	}
	/*
	  System.err.println("After : computeBoundingBox : geoBounds ");
	  System.err.println(geoBounds);
	*/
    }

    // Compute boundingbox for interleaved nio buffer
    void computeBoundingBox(int vIndex,   FloatBuffer vdata) {
	int i, offset;
	double xmin, xmax, ymin, ymax, zmin, zmax;


	synchronized(geoBounds) {
	    // If autobounds compute is false  then return
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
		return;
	    }

	    if (!boundsDirty)
		return;

	    // Initial offset
	    offset = vIndex * stride+coordinateOffset;
	    // Compute the bounding box
	    xmin = xmax = vdata.get(offset);
	    ymin = ymax = vdata.get(offset+1);
	    zmin = zmax = vdata.get(offset+2);
	    offset += stride;
	    for (i=1; i<validVertexCount; i++) {
		if (vdata.get(offset) > xmax)
		    xmax = vdata.get(offset);
		if (vdata.get(offset) < xmin)
		    xmin = vdata.get(offset);

		if (vdata.get(offset+1) > ymax)
		    ymax = vdata.get(offset+1);
		if (vdata.get(offset+1) < ymin)
		    ymin = vdata.get(offset+1);

		if (vdata.get(offset+2) > zmax)
		    zmax = vdata.get(offset+2);
		if (vdata.get(offset+2) < zmin)
		    zmin = vdata.get(offset+2);

		offset += stride;
	    }

	    geoBounds.setUpper(xmax, ymax, zmax);
	    geoBounds.setLower(xmin, ymin, zmin);
	    boundsDirty = false;
	}
    }


    // compute bounding box for coord with nio buffer
    void computeBoundingBox( DoubleBuffer buffer) {
	int i, j, k, sIndex;
	double xmin, xmax, ymin, ymax, zmin, zmax;

	synchronized(geoBounds) {
	    // If autobounds compute is false  then return
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
		return;
	    }

	    if (!boundsDirty)
		return;

	    sIndex = initialCoordIndex;
	    int maxIndex = 3*validVertexCount;

	    // Compute the bounding box
	    xmin = xmax = buffer.get(sIndex++);
	    ymin = ymax = buffer.get(sIndex++);
	    zmin = zmax = buffer.get(sIndex++);

	    for (i=sIndex; i<maxIndex; i+=3) {
		j = i + 1;
		k = i + 2;

		if (buffer.get(i) > xmax)
		    xmax = buffer.get(i);
		if (buffer.get(i) < xmin)
		    xmin = buffer.get(i);

		if (buffer.get(j) > ymax)
		    ymax = buffer.get(j);
		if (buffer.get(j) < ymin)
		    ymin = buffer.get(j);

		if (buffer.get(k) > zmax)
		    zmax = buffer.get(k);
		if (buffer.get(k) < zmin)
		    zmin = buffer.get(k);

	    }
	    geoBounds.setUpper(xmax, ymax, zmax);
	    geoBounds.setLower(xmin, ymin, zmin);
	    boundsDirty = false;
	}
    }

    // compute bounding box for coord with nio buffer
    void computeBoundingBox( FloatBuffer buffer) {
	int i, j, k, sIndex;
	double xmin, xmax, ymin, ymax, zmin, zmax;


	synchronized(geoBounds) {
	    // If autobounds compute is false  then return
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
		return;
	    }

	    if (!boundsDirty)
		return;


	    sIndex = initialCoordIndex;
	    int maxIndex = 3*validVertexCount;

	    // Compute the bounding box
	    xmin = xmax = buffer.get(sIndex++);
	    ymin = ymax = buffer.get(sIndex++);
	    zmin = zmax = buffer.get(sIndex++);

	    for (i=sIndex; i<maxIndex; i+=3) {
		j = i + 1;
		k = i + 2;

		if (buffer.get(i) > xmax)
		    xmax = buffer.get(i);
		if (buffer.get(i) < xmin)
		    xmin = buffer.get(i);

		if (buffer.get(j) > ymax)
		    ymax = buffer.get(j);
		if (buffer.get(j) < ymin)
		    ymin = buffer.get(j);

		if (buffer.get(k) > zmax)
		    zmax = buffer.get(k);
		if (buffer.get(k) < zmin)
		    zmin = buffer.get(k);

	    }
	    geoBounds.setUpper(xmax, ymax, zmax);
	    geoBounds.setLower(xmin, ymin, zmin);
	    boundsDirty = false;
	}
    }

    void computeBoundingBox(float[] coords) {
	// System.err.println("GeometryArrayRetained : computeBoundingBox(float[] coords)");
	int i, j, k, sIndex;
	double xmin, xmax, ymin, ymax, zmin, zmax;

	synchronized(geoBounds) {
	    // If autobounds compute is false  then return
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
		return;
	    }

	    if (!boundsDirty)
		return;

	    sIndex = initialCoordIndex;
	    int maxIndex = 3*validVertexCount;

	// Compute the bounding box
	    xmin = xmax = coords[sIndex++];
	    ymin = ymax = coords[sIndex++];
	    zmin = zmax = coords[sIndex++];

	    for (i=sIndex; i<maxIndex; i+=3) {
		j = i + 1;
		k = i + 2;

		if (coords[i] > xmax)
		    xmax = coords[i];
		if (coords[i] < xmin)
		    xmin = coords[i];

		if (coords[j] > ymax)
		    ymax = coords[j];
		if (coords[j] < ymin)
		    ymin = coords[j];

		if (coords[k] > zmax)
		    zmax = coords[k];
		if (coords[k] < zmin)
		    zmin = coords[k];

	    }
	    geoBounds.setUpper(xmax, ymax, zmax);
	    // System.err.println("max(" + xmax + ", " + ymax + ", " + zmax + ")");
	    geoBounds.setLower(xmin, ymin, zmin);
	    // System.err.println("min(" + xmin + ", " + ymin + ", " + zmin + ")");

	    boundsDirty = false;
	}

    }

    void computeBoundingBox(double[] coords) {
	int i, j, k, sIndex;
	double xmin, xmax, ymin, ymax, zmin, zmax;

	synchronized(geoBounds) {
	    // If autobounds compute is false  then return
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
		return;
	    }

	    if (!boundsDirty)
		return;


	    sIndex = initialCoordIndex;
	    int maxIndex = 3*validVertexCount;

	    // Compute the bounding box
	    xmin = xmax = coords[sIndex++];
	    ymin = ymax = coords[sIndex++];
	    zmin = zmax = coords[sIndex++];

	    for (i=sIndex; i<maxIndex; i+=3) {
		j = i + 1;
		k = i + 2;

		if (coords[i] > xmax)
		    xmax = coords[i];
		if (coords[i] < xmin)
		    xmin = coords[i];

		if (coords[j] > ymax)
		    ymax = coords[j];
		if (coords[j] < ymin)
		    ymin = coords[j];

		if (coords[k] > zmax)
		    zmax = coords[k];
		if (coords[k] < zmin)
		    zmin = coords[k];

	    }
	    geoBounds.setUpper(xmax, ymax, zmax);
	    geoBounds.setLower(xmin, ymin, zmin);
	    boundsDirty = false;
	}

    }

    void computeBoundingBox(Point3f[] coords) {

	double xmin, xmax, ymin, ymax, zmin, zmax;
	Point3f p;

	synchronized(geoBounds) {
	    // If autobounds compute is false  then return
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
		return;
	    }

	    if (!boundsDirty)
		return;



	// Compute the bounding box
	    xmin = xmax = coords[initialCoordIndex].x;
	    ymin = ymax = coords[initialCoordIndex].y;
	    zmin = zmax = coords[initialCoordIndex].z;

	    for (int i=initialCoordIndex+1; i<validVertexCount; i++) {
		p = coords[i];
		if (p.x > xmax) xmax = p.x;
		if (p.x < xmin) xmin = p.x;

		if (p.y > ymax) ymax = p.y;
		if (p.y < ymin) ymin = p.y;

		if (p.z > zmax) zmax = p.z;
		if (p.z < zmin) zmin = p.z;

	    }
	    geoBounds.setUpper(xmax, ymax, zmax);
	    geoBounds.setLower(xmin, ymin, zmin);
	    boundsDirty = false;
	}

    }

    void computeBoundingBox(Point3d[] coords) {

	double xmin, xmax, ymin, ymax, zmin, zmax;
	Point3d p;

	synchronized(geoBounds) {
	    // If autobounds compute is false  then return
	    if ((computeGeoBounds == 0) && (refCount > 0)) {
		return;
	    }

	    if (!boundsDirty)
		return;


	// Compute the bounding box
	    xmin = xmax = coords[initialCoordIndex].x;
	    ymin = ymax = coords[initialCoordIndex].y;
	    zmin = zmax = coords[initialCoordIndex].z;

	    for (int i=initialCoordIndex+1; i<validVertexCount; i++) {
		p = coords[i];
		if (p.x > xmax) xmax = p.x;
		if (p.x < xmin) xmin = p.x;

		if (p.y > ymax) ymax = p.y;
		if (p.y < ymin) ymin = p.y;

		if (p.z > zmax) zmax = p.z;
		if (p.z < zmin) zmin = p.z;

	    }
	    geoBounds.setUpper(xmax, ymax, zmax);
	    geoBounds.setLower(xmin, ymin, zmin);
	    boundsDirty = false;
	}

    }


    @Override
    synchronized void update() {
    }

    void setupMirrorVertexPointer(int vType) {
	int i, index;

	switch (vType) {
	case PF:
	    if (floatRefCoords == null) {
		if ((vertexType & VERTEX_DEFINED) == PF) {
		    vertexType &= ~PF;
		    mirrorFloatRefCoords = null;
		    mirrorVertexAllocated &= ~PF;
		}
	    }
	    else {
		vertexType |= PF;
		mirrorFloatRefCoords = floatRefCoords;
		mirrorVertexAllocated &= ~PF;
	    }

	    break;
	case PD:
	    if (doubleRefCoords == null) {
		if ((vertexType & VERTEX_DEFINED) == PD) {
		    mirrorDoubleRefCoords = null;
		    mirrorVertexAllocated &= ~PD;
		    vertexType &= ~PD;
		}
		vertexType &= ~PD;
	    }
	    else {
		vertexType |= PD;
		mirrorDoubleRefCoords = doubleRefCoords;
		mirrorVertexAllocated &= ~PD;
	    }

	    break;
	case P3F:
	    if (p3fRefCoords == null) {
		vertexType &= ~P3F;
		// Don't set the mirrorFloatRefCoords to null,
		// may be able to re-use
		//	    mirrorFloatRefCoords = null;
	    }
	    else {
		vertexType |= P3F;

		if ((mirrorVertexAllocated & PF) == 0) {
		    mirrorFloatRefCoords = new float[vertexCount * 3];
		    mirrorVertexAllocated |= PF;
		}

		index = initialCoordIndex * 3;
		for ( i=initialCoordIndex; i<validVertexCount; i++) {
		    mirrorFloatRefCoords[index++] = p3fRefCoords[i].x;
		    mirrorFloatRefCoords[index++] = p3fRefCoords[i].y;
		    mirrorFloatRefCoords[index++] = p3fRefCoords[i].z;
		}
	    }
	    break;
	case P3D:
	    if (p3dRefCoords == null) {
		vertexType &= ~P3D;
		// Don't set the mirrorDoubleRefCoords to null,
		// may be able to re-use
		//	    mirrorDoubleRefCoords = null;
	    }
	    else {
		vertexType |= P3D;

		if ((mirrorVertexAllocated & PD) == 0) {
		    mirrorDoubleRefCoords = new double[vertexCount * 3];
		    mirrorVertexAllocated |= PD;
		}

		index = initialCoordIndex * 3;
		for ( i=initialCoordIndex; i<validVertexCount; i++) {
		    mirrorDoubleRefCoords[index++] = p3dRefCoords[i].x;
		    mirrorDoubleRefCoords[index++] = p3dRefCoords[i].y;
		    mirrorDoubleRefCoords[index++] = p3dRefCoords[i].z;
		}
	    }
	    break;
	default:
	    break;

	}

    }

    // If turned transparent the first time, then force it to allocate
    void setupMirrorInterleavedColorPointer(boolean force) {
	int index, length, offset;
	int i;

	if (force || (c4fAllocated != 0)) { // Color is present

	    length = 4 * vertexCount;

	    if (mirrorInterleavedColorPointer == null) {
		mirrorInterleavedColorPointer = new float[1][length];
	    }

	    index = 4 * initialVertexIndex;
	    offset = stride * initialVertexIndex + colorOffset;

	    if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0 &&
		interLeavedVertexData != null ) { // java array
		if ((vertexFormat  & GeometryArray.WITH_ALPHA) != 0) {

		    for (i = initialVertexIndex; i < validVertexCount; i++) {
			mirrorInterleavedColorPointer[0][index++] =
			    interLeavedVertexData[offset];
			mirrorInterleavedColorPointer[0][index++] =
			    interLeavedVertexData[offset+1];
			mirrorInterleavedColorPointer[0][index++] =
			    interLeavedVertexData[offset+2];
			mirrorInterleavedColorPointer[0][index++] =
			    interLeavedVertexData[offset+3];
			offset += stride;
		    }
		}
		else {
		    for (i = initialVertexIndex; i < validVertexCount; i++) {
			mirrorInterleavedColorPointer[0][index++] =
			    interLeavedVertexData[offset];
			mirrorInterleavedColorPointer[0][index++] =
			    interLeavedVertexData[offset+1];
			mirrorInterleavedColorPointer[0][index++] =
			    interLeavedVertexData[offset+2];
			mirrorInterleavedColorPointer[0][index++] = 1.0f;
			offset += stride;
		    }
		}

	    } else { // NIO BUFFER
		if ((vertexFormat  & GeometryArray.WITH_ALPHA) != 0 &&
		    interleavedFloatBufferImpl != null) {
		    for (i = initialVertexIndex; i < validVertexCount; i++) {
			interleavedFloatBufferImpl.position(offset);
			interleavedFloatBufferImpl.get(mirrorInterleavedColorPointer[0],
						       index , 4);
			index += 4;
			offset += stride;
		    }
		}
		else {
		    for (i = initialVertexIndex; i < validVertexCount; i++) {
			interleavedFloatBufferImpl.position(offset);
			interleavedFloatBufferImpl.get(mirrorInterleavedColorPointer[0],
						       index, 3);
			mirrorInterleavedColorPointer[0][index+3] = 1.0f;
			index += 4;
			offset += stride;

		    }
		}
	    }
	    c4fAllocated = GeometryArray.WITH_ALPHA;
	}
    }

    // If turned transparent the first time, then force it to allocate
    void setupMirrorColorPointer(int ctype, boolean force) {
	int i, srcIndex = 0, dstIndex = 0;
	int multiplier;

 	if (c4fAllocated == 0 && !force) {
	    multiplier = 3;
	} else {

	    // If the first time, we are forced to allocate 4f, then
	    // we need to force the allocation of the colors again
	    // for the case when allocation has previously occurred
	    // only for RGB
	    if (force && (c4fAllocated == 0) &&
		(vertexFormat & GeometryArray.WITH_ALPHA) == 0)  {
		mirrorColorAllocated = 0;
	    }
	    c4fAllocated = GeometryArray.WITH_ALPHA;
	    multiplier = 4;
	}

	if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) { // java array
	    switch (ctype) {
	    case CF:
		if (floatRefColors == null) {
		    if ((c4fAllocated == 0) && !force &&
			(vertexType & COLOR_DEFINED) == CF) {
			mirrorFloatRefColors[0] = null;
			mirrorColorAllocated &= ~CF;
		    }
		    vertexType &= ~CF;
		    return;
		}

		vertexType |= CF;
		if (c4fAllocated == 0 && !force) {
		    mirrorFloatRefColors[0] = floatRefColors;
		    mirrorColorAllocated &= ~CF;
		}
		else {
 		    if ((mirrorColorAllocated & CF) == 0) {
			mirrorFloatRefColors[0] = new float[4 * vertexCount];
			mirrorColorAllocated |= CF;
		    }

		    if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {

			srcIndex = initialColorIndex * 3;
			dstIndex = initialColorIndex * 4;

			for (i = initialColorIndex; i < validVertexCount; i++) {
			    mirrorFloatRefColors[0][dstIndex++] =
				floatRefColors[srcIndex++];
			    mirrorFloatRefColors[0][dstIndex++] =
				floatRefColors[srcIndex++];
			    mirrorFloatRefColors[0][dstIndex++] =
				floatRefColors[srcIndex++];
			    mirrorFloatRefColors[0][dstIndex++] = 1.0f;
			}

		    }
		    else {
			srcIndex = initialColorIndex * 4;
			System.arraycopy(floatRefColors, srcIndex,
					 mirrorFloatRefColors[0], srcIndex,
					 (4*validVertexCount));
		    }
		}
		break;
	    case CUB:
		if (byteRefColors == null) {
		    if (c4fAllocated == 0 && !force &&
			((vertexType & COLOR_DEFINED) == CUB) ) {
			mirrorUnsignedByteRefColors[0] = null;
			mirrorColorAllocated &= ~CUB;
		    }
		    vertexType &= ~CUB;
		    return;
		}
		vertexType |= CUB;
		if (c4fAllocated == 0 && !force) {
		    mirrorUnsignedByteRefColors[0] = byteRefColors;
		    mirrorColorAllocated &= ~CUB;;
		}
		else {
		    if ((mirrorColorAllocated & CUB) == 0) {
			mirrorUnsignedByteRefColors[0] = new byte[4 * vertexCount];
			mirrorColorAllocated |= CUB;
		    }
		    if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {

			srcIndex = initialColorIndex * 3;
			dstIndex = initialColorIndex * 4;

			for (i = initialColorIndex; i < validVertexCount; i++) {
			    mirrorUnsignedByteRefColors[0][dstIndex++] =
				byteRefColors[srcIndex++];
			    mirrorUnsignedByteRefColors[0][dstIndex++] =
				byteRefColors[srcIndex++];
			    mirrorUnsignedByteRefColors[0][dstIndex++] =
				byteRefColors[srcIndex++];
			    mirrorUnsignedByteRefColors[0][dstIndex++] =
				(byte)(255.0);
			}
		    }
		    else {
			srcIndex = initialColorIndex * 4;
			System.arraycopy(byteRefColors, srcIndex,
					 mirrorUnsignedByteRefColors[0], srcIndex,
					 (4*validVertexCount));
		    }
		}

		break;
	    case C3F:
		if (c3fRefColors == null) {
		    vertexType &= ~C3F;
		    return;
		}
		vertexType |=C3F ;

		if ((mirrorColorAllocated & CF) == 0) {
		    mirrorFloatRefColors[0] = new float[vertexCount * multiplier];
		    mirrorColorAllocated |= CF;
		}
		if ((c4fAllocated & GeometryArray.WITH_ALPHA) == 0) {

		    dstIndex = initialColorIndex * 3;
		    for (i = initialColorIndex; i < validVertexCount; i++) {
			mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].x;
			mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].y;
			mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].z;
		    }
		} else {

		    dstIndex = initialColorIndex * 4;
		    for (i = initialColorIndex; i < validVertexCount; i++) {
			mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].x;
			mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].y;
			mirrorFloatRefColors[0][dstIndex++] = c3fRefColors[i].z;
			mirrorFloatRefColors[0][dstIndex++] = 1.0f;
		    }
		}

		break;
	    case C4F:
		if (c4fRefColors == null) {
		    vertexType &= ~C4F;
		    return;
		}
		vertexType |=C4F ;

		if ((mirrorColorAllocated & CF) == 0) {
		    mirrorFloatRefColors[0] = new float[vertexCount << 2];
		    mirrorColorAllocated |= CF;
		}

		dstIndex = initialColorIndex * 4;
		for (i = initialColorIndex; i < validVertexCount; i++) {
		    mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].x;
		    mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].y;
		    mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].z;
		    mirrorFloatRefColors[0][dstIndex++] = c4fRefColors[i].w;
		}
		break;
	    case C3UB:
		if (c3bRefColors == null) {
		    vertexType &= ~C3UB;
		    return;
		}
		vertexType |=C3UB ;

		if ((mirrorColorAllocated & CUB) == 0) {
		    mirrorUnsignedByteRefColors[0] =
			new byte[vertexCount * multiplier];
		    mirrorColorAllocated |= CUB;
		}
		if ((c4fAllocated & GeometryArray.WITH_ALPHA) == 0) {
		    dstIndex = initialColorIndex * 3;
		    for (i = initialColorIndex; i < validVertexCount; i++) {
			mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].x;
			mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].y;
			mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].z;
		    }
		} else {
		    dstIndex = initialColorIndex * 4;
		    for (i = initialColorIndex; i < validVertexCount; i++) {
			mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].x;
			mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].y;
			mirrorUnsignedByteRefColors[0][dstIndex++] = c3bRefColors[i].z;
			mirrorUnsignedByteRefColors[0][dstIndex++] = (byte)255;
		    }
		}
		break;
	    case C4UB:
		if (c4bRefColors == null) {
		    vertexType &= ~C4UB;
		    return;
		}
		vertexType |=C4UB ;
		if ((mirrorColorAllocated & CUB) == 0) {
		    mirrorUnsignedByteRefColors[0] = new byte[vertexCount << 2];
		    mirrorColorAllocated |= CUB;
		}

		dstIndex = initialColorIndex * 4;
		for (i = initialColorIndex; i < validVertexCount; i++) {
		    mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].x;
		    mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].y;
		    mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].z;
		    mirrorUnsignedByteRefColors[0][dstIndex++] = c4bRefColors[i].w;
		}
		break;
	    default:
		break;
	    }
	}
	else {  //USE_NIO_BUFFER is set
	    if(	colorRefBuffer == null) {
		if (c4fAllocated == 0 && !force &&
		    (vertexType & COLOR_DEFINED) == CF) {
		    mirrorFloatRefColors[0] = null;
		    mirrorColorAllocated &= ~CF;
		}
		vertexType &= ~CF;

		if (c4fAllocated == 0 && !force &&
		    ((vertexType & COLOR_DEFINED) == CUB) ) {
		    mirrorUnsignedByteRefColors[0] = null;
		    mirrorColorAllocated &= ~CUB;
		}
		vertexType &= ~CUB;
		return;

	    } else if( floatBufferRefColors != null) {
		vertexType |= CF;
		vertexType &= ~CUB;
		if (c4fAllocated == 0 && !force) {
		    // NOTE: make suren mirrorFloatRefColors[0] is set right
		    mirrorFloatRefColors[0] = null;
		    mirrorColorAllocated &= ~CF;
		}
		else {
		    if ((mirrorColorAllocated & CF) == 0) {
			mirrorFloatRefColors[0] = new float[4 * vertexCount];
			mirrorColorAllocated |= CF;
		    }
		    floatBufferRefColors.rewind();
		    if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
			srcIndex = initialColorIndex * 3;
			dstIndex = initialColorIndex * 4;
			floatBufferRefColors.position(srcIndex);

			for (i = initialColorIndex; i < validVertexCount; i++) {
			    floatBufferRefColors.get(mirrorFloatRefColors[0], dstIndex, 3);
			    mirrorFloatRefColors[0][dstIndex+3] = 1.0f;
			    dstIndex += 4;
			}
		    }
		    else {

			srcIndex = initialColorIndex * 4;
			dstIndex = initialColorIndex * 4;
			floatBufferRefColors.position(srcIndex);
			for (i = initialColorIndex; i < validVertexCount; i++) {
			    floatBufferRefColors.get(mirrorFloatRefColors[0], dstIndex, 4);
			    dstIndex+= 4;
			}
		    }
		}
	    } else if ( byteBufferRefColors != null) {
		vertexType |= CUB;
		vertexType &= ~CF;
		if (c4fAllocated == 0 && !force) {
		    // NOTE: make sure mirrorUnsignedByteRefColors[0] is set right
		    mirrorUnsignedByteRefColors[0] = null;
		    mirrorColorAllocated &= ~CUB;;
		}
		else {
		    if ((mirrorColorAllocated & CUB) == 0) {
			mirrorUnsignedByteRefColors[0] = new byte[4 * vertexCount];
			mirrorColorAllocated |= CUB;
		    }

		    byteBufferRefColors.rewind();
		    if ((vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
			srcIndex = initialColorIndex * 3;
			dstIndex = initialColorIndex * 4;
			byteBufferRefColors.position(srcIndex);
			for (i = initialColorIndex; i < validVertexCount; i++) {
			    byteBufferRefColors.get(mirrorUnsignedByteRefColors[0],
						    dstIndex, 3);
			    mirrorUnsignedByteRefColors[0][dstIndex+3] = (byte)(255.0);
			    dstIndex += 4;
			}
		    }
		    else {
			srcIndex = initialColorIndex * 4;
			dstIndex = initialColorIndex * 4;
			byteBufferRefColors.position(srcIndex);
			for (i = initialColorIndex; i < validVertexCount; i++) {
			    byteBufferRefColors.get(mirrorUnsignedByteRefColors[0], dstIndex, 4);
			    dstIndex+= 4;
			}
		    }
		} // end of else
	    }//end of else if ( byteBufferRefColors != null)
	}//end of NIO BUFFER case

	colorChanged = 0xffff;
    }


    void setupMirrorNormalPointer(int ntype) {
	int i, index;

	switch (ntype) {
	case NF:
	    if (floatRefNormals == null) {
		if ((vertexType & NORMAL_DEFINED) == NF) {
		    vertexType &= ~NF;
		    mirrorFloatRefNormals = null;
		    mirrorNormalAllocated = false;
		}
	    }
	    else {
		vertexType |= NF;
		mirrorFloatRefNormals = floatRefNormals;
		mirrorNormalAllocated = false;
	    }
	    break;
	case N3F:
	    if (v3fRefNormals == null) {
		if ((vertexType & NORMAL_DEFINED) == N3F) {
		    vertexType &= ~N3F;
		}
		return;
	    }
	    else {
		vertexType |= N3F;
	    }
	    if (!mirrorNormalAllocated) {
		mirrorFloatRefNormals = new float[vertexCount * 3];
		mirrorNormalAllocated = true;
	    }

	    index = initialNormalIndex * 3;
	    for (i = initialNormalIndex; i < validVertexCount; i++) {
		mirrorFloatRefNormals[index++] = v3fRefNormals[i].x;
		mirrorFloatRefNormals[index++] = v3fRefNormals[i].y;
		mirrorFloatRefNormals[index++] = v3fRefNormals[i].z;
	    }
	    break;
	default:
	    break;	}
    }

    void setupMirrorTexCoordPointer(int type) {
	for (int i = 0; i < texCoordSetCount; i++) {
	     doSetupMirrorTexCoordPointer(i, type);
	}

        validateTexCoordPointerType();
    }

    void setupMirrorTexCoordPointer(int texCoordSet, int type) {
        doSetupMirrorTexCoordPointer(texCoordSet, type);
        validateTexCoordPointerType();
    }

    // If all texCoord pointers are set to a non-null value, then set the
    // texcoord type in the vertexType flag word, else clear the texcoord type
    private void validateTexCoordPointerType() {
        boolean allNonNull = true;
        boolean allNull = true;
        for (int i = 0; i < texCoordSetCount; i++) {
            if (refTexCoords[i] == null) {
                allNonNull = false;
            } else {
                allNull = false;
            }
        }

        // Reset texCoordType if all references are null
        if (allNull) {
            texCoordType = 0;
        }

        // Copy texCoordType to vertexType if all references are non-null
        vertexType &= ~TEXCOORD_DEFINED;
        if (allNonNull) {
            vertexType |= texCoordType;
        }
    }

    private void doSetupMirrorTexCoordPointer(int texCoordSet, int type) {
	int i, index;

        switch (type) {
	case TF:
            texCoordType = TF;
            mirrorRefTexCoords[texCoordSet] = refTexCoords[texCoordSet];
	    break;

        case T2F:
            texCoordType = T2F;
	    t2fRefTexCoords = (TexCoord2f[])refTexCoords[texCoordSet];

	    if (t2fRefTexCoords == null) {
                mirrorRefTexCoords[texCoordSet] = null;
		break;
	    }

            mirrorFloatRefTexCoords = (float[])mirrorRefTexCoords[texCoordSet];
            if (mirrorFloatRefTexCoords != null) {
                if (mirrorFloatRefTexCoords.length < (vertexCount * 2))
                    mirrorRefTexCoords[texCoordSet] =
                        mirrorFloatRefTexCoords = new float[vertexCount * 2];
            }
            else {
                mirrorRefTexCoords[texCoordSet] =
                        mirrorFloatRefTexCoords = new float[vertexCount * 2];
            }

	    index = initialTexCoordIndex[texCoordSet] * 2;
	    for (i = initialTexCoordIndex[texCoordSet]; i < validVertexCount; i++) {
		mirrorFloatRefTexCoords[index++] = t2fRefTexCoords[i].x;
		mirrorFloatRefTexCoords[index++] = t2fRefTexCoords[i].y;
	    }
	    break;

	case T3F:
            texCoordType = T3F;
	    t3fRefTexCoords = (TexCoord3f[])refTexCoords[texCoordSet];

            if (t3fRefTexCoords == null) {
                mirrorRefTexCoords[texCoordSet] = null;
		break;
	    }

            mirrorFloatRefTexCoords = (float[])mirrorRefTexCoords[texCoordSet];
            if (mirrorFloatRefTexCoords != null) {
                if (mirrorFloatRefTexCoords.length < (vertexCount * 3))
                    mirrorRefTexCoords[texCoordSet] =
                        mirrorFloatRefTexCoords = new float[vertexCount * 3];
            }
            else {
                mirrorRefTexCoords[texCoordSet] =
                    mirrorFloatRefTexCoords = new float[vertexCount * 3];
            }

	    index =  initialTexCoordIndex[texCoordSet] * 3;
	    for (i = initialTexCoordIndex[texCoordSet]; i < validVertexCount; i++) {
		mirrorFloatRefTexCoords[index++] = t3fRefTexCoords[i].x;
		mirrorFloatRefTexCoords[index++] = t3fRefTexCoords[i].y;
		mirrorFloatRefTexCoords[index++] = t3fRefTexCoords[i].z;
	    }
	    break;

	default:
	    break;
	}
    }

    void setupMirrorVertexAttrPointer(int type) {
        for (int i = 0; i < vertexAttrCount; i++) {
            doSetupMirrorVertexAttrPointer(i, type);
        }

        validateVertexAttrPointerType();
    }

    void setupMirrorVertexAttrPointer(int vertexAttrNum, int type) {
        doSetupMirrorVertexAttrPointer(vertexAttrNum, type);
        validateVertexAttrPointerType();
    }

    // If all vertex attr pointers are set to a non-null value, then set the
    // vertex attr type in the vertexType flag word, else clear the
    // vertex attr type
    private void validateVertexAttrPointerType() {
        boolean allNonNull = true;
        boolean allNull = true;

        if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
            for (int i = 0; i < vertexAttrCount; i++) {
                if (floatRefVertexAttrs[i] == null) {
                    allNonNull = false;
                } else {
                    allNull = false;
                }
            }
        } else {
            for (int i = 0; i < vertexAttrCount; i++) {
                if (floatBufferRefVertexAttrs[i] == null) {
                    allNonNull = false;
                } else {
                    allNull = false;
                }
            }
        }

        // Reset vertexAttrType if all references are null
        if (allNull) {
            vertexAttrType = 0;
        }

        // Copy vertexAttrType to vertexType if all references are non-null
        vertexType &= ~VATTR_DEFINED;
        if (allNonNull) {
            vertexType |= vertexAttrType;
        }
    }

    private void doSetupMirrorVertexAttrPointer(int vertexAttrNum, int type) {
        switch (type) {
        case AF:
            vertexAttrType = AF;
            mirrorFloatRefVertexAttrs[vertexAttrNum] =
                floatRefVertexAttrs[vertexAttrNum];
            break;
        default:
            break;
        }
    }


    void createGeometryArrayData(int vertexCount, int vertexFormat) {
	if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
	    createGeometryArrayData(vertexCount, vertexFormat, 1,
				    defaultTexCoordSetMap);
	} else {
	    createGeometryArrayData(vertexCount, vertexFormat, 0, null);
	}
    }

    void createGeometryArrayData(int vertexCount, int vertexFormat,
				 int texCoordSetCount, int[] texCoordSetMap) {

	createGeometryArrayData(vertexCount, vertexFormat,
				texCoordSetCount, texCoordSetMap,
				0, null);
    }

    void createGeometryArrayData(int vertexCount, int vertexFormat,
				 int texCoordSetCount, int[] texCoordSetMap,
				 int vertexAttrCount, int[] vertexAttrSizes) {
	this.vertexFormat = vertexFormat;
	this.vertexCount = vertexCount;
	this.validVertexCount = vertexCount;

	this.texCoordSetCount = texCoordSetCount;
	if (texCoordSetMap == null) {
	    this.texCoordSetMap = null;
	}
	else {
	    this.texCoordSetMap = Arrays.copyOf(texCoordSetMap, texCoordSetMap.length);
	}

        this.vertexAttrCount = vertexAttrCount;
	if (vertexAttrSizes == null) {
	    this.vertexAttrSizes = null;
	}
	else {
	    this.vertexAttrSizes = Arrays.copyOf(vertexAttrSizes, vertexAttrSizes.length);
	}

        this.vertexAttrStride = this.vertexAttrStride();
	this.stride = this.stride();

	this.vertexAttrOffsets = this.vertexAttrOffsets();
	this.texCoordSetMapOffset = this.texCoordSetMapOffset();
	this.textureOffset = this.textureOffset();
	this.colorOffset = this.colorOffset();
	this.normalOffset = this.normalOffset();
	this.coordinateOffset = this.coordinateOffset();

	if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
	    this.vertexData = new float[this.vertexCount * this.stride];
	}
	else { // By reference geometry
	    this.vertexData = null;
            if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
                this.mirrorRefTexCoords = new Object[texCoordSetCount];
                this.refTexCoords = new Object[texCoordSetCount]; // keep J3DBufferImp object in nio buffer case
		if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0 )
		    this.refTexCoordsBuffer = new J3DBuffer[texCoordSetCount]; // keep J3DBuffer object
	    }
            if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
                this.floatRefVertexAttrs = new float[vertexAttrCount][];
                this.mirrorFloatRefVertexAttrs = new float[vertexAttrCount][];
		if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
		    this.vertexAttrsRefBuffer = new J3DBuffer[vertexAttrCount];
                    this.floatBufferRefVertexAttrs = new FloatBuffer[vertexAttrCount];
                }
	    }
	}
        if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
            this.initialTexCoordIndex = new int[texCoordSetCount];
        }
        if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
            this.initialVertexAttrIndex = new int[vertexAttrCount];
        }
	noAlpha = ((vertexFormat & GeometryArray.WITH_ALPHA) == 0);
	lastAlpha[0] = 1.0f;

    }

    void setVertexFormat(boolean useAlpha, boolean ignoreVC, Context ctx) {
	Pipeline.getPipeline().setVertexFormat(ctx,
                this, vertexFormat, useAlpha, ignoreVC);
    }

    float[] updateAlphaInFloatRefColors(Canvas3D cv, int screen, float alpha) {

	//System.err.println("updateAlphaInFloatRefColors  screen = " + screen +
	//		   " alpha " + alpha );

    	// update alpha only if vertex format includes alpha
	if (((vertexFormat | c4fAllocated) & GeometryArray.WITH_ALPHA) == 0)
	    return mirrorFloatRefColors[0];

	// if alpha is smaller than EPSILON, set it to EPSILON, so that
	// even if alpha is equal to 0, we will not completely lose
	// the original alpha value
	if (alpha <= EPSILON) {
	    alpha = (float)EPSILON;
	}

        assert lastAlpha != null;
        assert mirrorFloatRefColors != null;
        assert mirrorFloatRefColors.length == lastAlpha.length;

	// Issue 113 - reallocate lastAlpha array if needed, but no need to
        // update the values here
	if (lastAlpha.length <= screen) {
	    float[] la = new float[screen + 1];
	    for (int i = 0; i < lastAlpha.length; i++) {
		la[i] = lastAlpha[i];
	    }
	    lastAlpha = la;
	}

	//System.err.println("updateAlphaInFloatRefColors screen is " + screen
	//		     + " mirrorFloatRefColors.length " +
	//		     mirrorFloatRefColors.length);

	// allocate a copy of the color data for the screen if needed.
	// this piece of code is only for multi-screens case
	if (mirrorFloatRefColors.length <= screen) {
	    float[][] cfData = new float[screen + 1][];

	    for (int i = 0; i < mirrorFloatRefColors.length; i++) {
		cfData[i] = mirrorFloatRefColors[i];
	    }

            // Issue 113 - allocate entries for [oldSize..screen];
            // copy cfData[0] to cfData[oldsize..screen-1] and
            // lastAlpha[0] to lastAlpha[oldsize..screen-1].
            for (int i = mirrorFloatRefColors.length; i < screen+1; i++) {
                cfData[i] = new float[4 * vertexCount];
                System.arraycopy(cfData[0], 0, cfData[i], 0, 4 * vertexCount);
                lastAlpha[i] = lastAlpha[0];
            }

            mirrorFloatRefColors = cfData;

            // Issue 113 - since we copied the data from screen 0, we don't need
            // to do any further special processing.
	}

        assert lastAlpha[screen] >= 0.0;
	/*
	  System.err.println("updateAlphaInFloatRefColors ** : lastAlpha[screen] " +
			     lastAlpha[screen]);

	  System.err.println("((colorChanged & (1<<screen)) == 0) " +
			     ((colorChanged & (1<<screen)) == 0));
	*/

	if ((colorChanged & (1<<screen)) == 0) {
	    // color data is not modified
	    if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
		// and if alpha is the same as the last one,
		// just return the data
		//System.err.println("updateAlphaInFloatRefColors 0 : alpha is the same as the last one " + alpha);

	        return mirrorFloatRefColors[screen];
	    } else {

		// if alpha is different, update the alpha values
		//System.err.println("updateAlphaInFloatRefColors 1 : alpha is different, update the alpha values " + alpha);

		float m = alpha / lastAlpha[screen];

		float[] cdata = mirrorFloatRefColors[screen];

		// We've to traverse the whole due to BugId : 4676483
		for (int i = 0, j = 0; i < vertexCount; i++, j+=4) {
	    	    cdata[j+3] = cdata[j+3] * m;
		}
	    }
	} else {
	    // color data is modified
	    if (screen == 0) {

		// just update alpha values since screen 0 data is
		// already updated in setupMirrorColorPointer

		//System.err.println("updateAlphaInFloatRefColors 2 : just update alpha = " + alpha);

		float[] cdata = mirrorFloatRefColors[screen];


		// This part is also incorrect due to BugId : 4676483
		// But traversing the whole array doesn't help either, as there
		// isn't a mechanism to indicate the the alpha component has
		// not changed by user.
		int j = initialColorIndex * 4;
		for (int i = initialColorIndex; i < validVertexCount; i++, j+=4) {
	    	    cdata[j+3] = cdata[j+3] * alpha;
		}
	    } else {
		// update color values from screen 0 data
		//System.err.println("updateAlphaInFloatRefColors 3 : update color values from screen 0 data " + alpha);

		float m;

		if ((colorChanged & 1) == 0) {
		    // alpha is up to date in screen 0
		    m = alpha / lastAlpha[0];
		} else {
		    m = alpha;
		}

		float[] sdata = mirrorFloatRefColors[0];
		float[] cdata = mirrorFloatRefColors[screen];

		int j = initialColorIndex * 4;
		for (int i = initialColorIndex; i < validVertexCount; i++) {
		    cdata[j] = sdata[j++];
		    cdata[j] = sdata[j++];
		    cdata[j] = sdata[j++];
		    cdata[j] = sdata[j++] * m;
		}
	    }
	}

	lastAlpha[screen] = alpha;
	colorChanged &= ~(1 << screen);
	dirtyFlag |= COLOR_CHANGED;
	return mirrorFloatRefColors[screen];
    }


    byte[] updateAlphaInByteRefColors(Canvas3D cv, int screen, float alpha) {

	/*
	  System.err.println("updateAlphaInByteRefColors  screen = " + screen +
	  " alpha " + alpha );
	*/

	// update alpha only if vertex format includes alpha
	if (((vertexFormat | c4fAllocated) & GeometryArray.WITH_ALPHA) == 0)
	    return mirrorUnsignedByteRefColors[0];

	// if alpha is smaller than EPSILON, set it to EPSILON, so that
	// even if alpha is equal to 0, we will not completely lose
	// the original alpha value
	if (alpha <= EPSILON) {
	    alpha = (float)EPSILON;
	}

        assert lastAlpha != null;
        assert mirrorUnsignedByteRefColors != null;
        assert mirrorUnsignedByteRefColors.length == lastAlpha.length;

	// Issue 113 - reallocate lastAlpha array if needed, but no need to
        // update the values here
	if (lastAlpha.length <= screen) {
	    float[] la = new float[screen + 1];
	    for (int i = 0; i < lastAlpha.length; i++) {
		la[i] = lastAlpha[i];
	    }
	    lastAlpha = la;
	}

	// allocate a copy of the color data for the screen if needed.
	// this piece of code is only for multi-screens case
	if (mirrorUnsignedByteRefColors.length <= screen) {
	    byte[][] cbData = new byte[screen + 1][];
	    for (int i = 0; i < mirrorUnsignedByteRefColors.length; i++) {
		cbData[i] = mirrorUnsignedByteRefColors[i];
	    }

            // Issue 113 - allocate entries for [oldSize..screen];
            // copy cbData[0] to cbData[oldsize..screen-1] and
            // lastAlpha[0] to lastAlpha[oldsize..screen-1].
            for (int i = mirrorUnsignedByteRefColors.length; i < screen+1; i++) {
                cbData[i] = new byte[4 * vertexCount];
                System.arraycopy(cbData[0], 0, cbData[i], 0, 4 * vertexCount);
                lastAlpha[i] = lastAlpha[0];
            }

            mirrorUnsignedByteRefColors = cbData;

            // Issue 113 - since we copied the data from screen 0, we don't need
            // to do any further special processing.
	}

        assert lastAlpha[screen] >= 0.0;
        /*
	System.err.println("updateAlphaInByteRefColors ## : lastAlpha[screen] " +
			   lastAlpha[screen]);

	System.err.println("((colorChanged & (1<<screen)) == 0) " +
			   ((colorChanged & (1<<screen)) == 0));
	*/

        if ((colorChanged & (1<<screen)) == 0) {
            // color data is not modified
            if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
                // and if alpha is the same as the last one,
                // just return the data
		//System.err.println("updateAlphaInByteRefColors 0 : alpha is the same as the last one " + alpha);

                return mirrorUnsignedByteRefColors[screen];
            } else {
                // if alpha is different, update the alpha values

		//System.err.println("updateAlphaInByteRefColors 1 : alpha is different, update the alpha values " + alpha);

                float m = alpha / lastAlpha[screen];

                byte[] cdata = mirrorUnsignedByteRefColors[screen];

		// We've to traverse the whole due to BugId : 4676483
		for (int i = 0, j = 0; i < vertexCount; i++, j+=4) {
                    cdata[j+3] = (byte)( ((int)cdata[j+3] & 0xff) * m);
                }
            }
        } else {
            // color data is modified
            if (screen == 0) {
		//System.err.println("updateAlphaInByteRefColors 2 : just update alpha =" + alpha);

                // just update alpha values since screen 0 data is
                // already updated in setupMirrorColorPointer

                byte[] cdata = mirrorUnsignedByteRefColors[screen];

		// This part is also incorrect due to BugId : 4676483
		// But traversing the whole array doesn't help either, as there
		// isn't a mechanism to indicate the the alpha component has
		// not changed by user.
		int j = initialColorIndex * 4;
		for (int i = initialColorIndex; i < validVertexCount; i++, j+=4) {
                    cdata[j+3] = (byte)(((int)cdata[j+3] & 0xff) * alpha);
                }
            } else {
                // update color values from screen 0 data
                float m;

		//System.err.println("updateAlphaInByteRefColors 3 : update color values from screen 0 data " + alpha);

                if ((colorChanged & 1) == 0) {
                    // alpha is up to date in screen 0
                    m = alpha / lastAlpha[0];
                } else {
                    m = alpha;
                }
                byte[] sdata = mirrorUnsignedByteRefColors[0];
                byte[] cdata = mirrorUnsignedByteRefColors[screen];

		int j = initialColorIndex * 4;
		for (int i = initialColorIndex; i < validVertexCount; i++) {
		    cdata[j] = sdata[j++];
		    cdata[j] = sdata[j++];
		    cdata[j] = sdata[j++];
		    cdata[j] = (byte)(((int)sdata[j++]& 0xff) * m);
                }
            }
        }

        lastAlpha[screen] = alpha;
        colorChanged &= ~(1 << screen);
	dirtyFlag |= COLOR_CHANGED;
        return mirrorUnsignedByteRefColors[screen];
    }


    Object[] updateAlphaInVertexData(Canvas3D cv, int screen, float alpha) {

	Object[] retVal = new Object[2];
	retVal[0] = Boolean.FALSE;

	// update alpha only if vertex format includes alpha
	if ((vertexFormat & GeometryArray.COLOR) == 0) {
	    retVal[1] = vertexData;
	    return retVal;
	}

	// if alpha is smaller than EPSILON, set it to EPSILON, so that
	// even if alpha is equal to 0, we will not completely lose
	// the original alpha value
	if (alpha <= EPSILON) {
	    alpha = (float)EPSILON;
	}
	retVal[0] = Boolean.TRUE;

        assert lastAlpha != null;
        assert mvertexData == null || mvertexData.length == lastAlpha.length;

	// Issue 113 - reallocate lastAlpha array if needed, but no need to
        // update the values here
	if (lastAlpha.length <= screen) {
	    float[] la = new float[screen + 1];
	    for (int i = 0; i < lastAlpha.length; i++) {
		la[i] = lastAlpha[i];
	    }
	    lastAlpha = la;
	}

	// allocate a copy of the vertex data for the screen if needed.
	// Note that a copy operation only happens in the multi-screens case.
        // We always use the existing vertexData for screen 0.
	if (mvertexData == null || mvertexData.length <= screen) {

	    float[][] cfData = new float[screen + 1][];
            int oldSize = 1;

	    if (mvertexData != null) {
                oldSize = mvertexData.length;
	        for (int i = 0; i < mvertexData.length; i++) {
		    cfData[i] = mvertexData[i];
		}
	    }

	    if (cfData[0] == null)  {
		cfData[0] = vertexData;
	    }

            // Issue 113 - allocate entries for [oldSize..screen];
            // copy cfData[0] to cfData[oldsize..screen-1] and
            // lastAlpha[0] to lastAlpha[oldsize..screen-1].
            if (screen > 0) {
                for (int i = oldSize; i < screen+1; i++) {
                    cfData[i] = new float[stride * vertexCount];
                    System.arraycopy(cfData[0], 0, cfData[i], 0,
                            stride * vertexCount);
                    lastAlpha[i] = lastAlpha[0];
                }
            }

            mvertexData = cfData;

            // Issue 113 - since we copied the data from screen 0, we don't need
            // to do any further special processing.
	}

        assert lastAlpha[screen] >= 0.0;

	if ((colorChanged & (1<<screen)) == 0) {
	    // color data is not modified
	    if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
		// and if alpha is the same as the last one,
		// just return the data
		retVal[1] = mvertexData[screen];
	        return retVal;
	    } else {
		// if alpha is different, update the alpha values
		float m = alpha / lastAlpha[screen];

		float[] cdata = mvertexData[screen];
		for (int i = 0, j = colorOffset; i < vertexCount;
					i++, j+=stride) {
	    	    cdata[j+3] *= m;
		}
	    }
	} else {
	    // color data is modified
	    if (screen == 0) {
		// just update alpha values since screen 0 data is
		// already updated in setupMirrorColorPointer

		float[] cdata = mvertexData[screen];
		double m = alpha / lastAlpha[0];

		for (int i = 0, j = colorOffset; i < vertexCount;
					i++, j+=stride) {
	    	    cdata[j+3] *= m;
		}
	    } else {
		// update color values from screen 0 data

		float m = alpha / lastAlpha[0];
		float[] sdata = mvertexData[0];
		float[] cdata = mvertexData[screen];

		for (int i = 0, j = colorOffset; i < vertexCount;
					i++, j+=stride) {
		    System.arraycopy(sdata, j, cdata, j, 3);
		    cdata[j+3] = sdata[j+3] * m;
		}
	    }
	}

	lastAlpha[screen] = alpha;
	colorChanged &= ~(1 << screen);
	dirtyFlag |= COLOR_CHANGED;
	retVal[1] = mvertexData[screen];
	return retVal;
    }

    Object[] updateAlphaInInterLeavedData(Canvas3D cv, int screen, float alpha) {

	Object[] retVal = new Object[2];
	retVal[0] = Boolean.FALSE;

	// update alpha only if vertex format includes alpha
	if (((vertexFormat | c4fAllocated) & GeometryArray.WITH_ALPHA) == 0) {
	    retVal[1] = mirrorInterleavedColorPointer[0];
	    return retVal;
	}
        int coffset = initialColorIndex << 2; // Each color is 4 floats

	// if alpha is smaller than EPSILON, set it to EPSILON, so that
	// even if alpha is equal to 0, we will not completely lose
	// the original alpha value
	if (alpha <= EPSILON) {
	    alpha = (float)EPSILON;
	}
	retVal[0] = Boolean.TRUE;

        assert lastAlpha != null;
        assert mirrorInterleavedColorPointer != null;
        assert mirrorInterleavedColorPointer.length == lastAlpha.length;

	// Issue 113 - reallocate lastAlpha array if needed, but no need to
        // update the values here
	if (lastAlpha.length <= screen) {
	    float[] la = new float[screen + 1];
	    for (int i = 0; i < lastAlpha.length; i++) {
		la[i] = lastAlpha[i];
	    }
	    lastAlpha = la;
	}

	// allocate a copy of the vertex data for the screen if needed.
	// this piece of code is only for multi-screens case
	if (mirrorInterleavedColorPointer.length <= screen) {

	    float[][] cfData = new float[screen + 1][];

	    for (int i = 0; i < mirrorInterleavedColorPointer.length; i++) {
		cfData[i] = mirrorInterleavedColorPointer[i];
	    }

            // Issue 113 - allocate entries for [oldSize..screen];
            // copy cfData[0] to cfData[oldsize..screen-1] and
            // lastAlpha[0] to lastAlpha[oldsize..screen-1].
            for (int i = mirrorInterleavedColorPointer.length; i < screen+1; i++) {
                cfData[i] = new float[4 * vertexCount];
                System.arraycopy(cfData[0], 0, cfData[i], 0, 4 * vertexCount);
                lastAlpha[i] = lastAlpha[0];
            }

	    mirrorInterleavedColorPointer = cfData;

            // Issue 113 - since we copied the data from screen 0, we don't need
            // to do any further special processing.
	}

        assert lastAlpha[screen] >= 0.0;

        if ((colorChanged & (1<<screen)) == 0) {
	    // color data is not modified
	    if (Math.abs(lastAlpha[screen] - alpha) <= EPSILON) {
		// and if alpha is the same as the last one,
		// just return the data
		retVal[1] = mirrorInterleavedColorPointer[screen];
	        return retVal;
	    } else {

		// if alpha is different, update the alpha values

		float m = alpha / lastAlpha[screen];

		float[] cdata = mirrorInterleavedColorPointer[screen];

		coffset = initialColorIndex << 2;
		for (int i = coffset; i < coffset + (vertexCount << 2); i+=4) {
	    	    cdata[i+3] = cdata[i+3] * m;
		}
	    }
	} else {
	    // color data is modified
	    if (screen == 0) {

		// just update alpha values since screen 0 data is
		// already updated in setupMirrorInterleavedColorPointer

		float[] cdata = mirrorInterleavedColorPointer[screen];

		for (int i = coffset; i < coffset + (vertexCount << 2); i+=4) {
	    	    cdata[i+3] = cdata[i+3] * alpha;
		}
	    } else {
		// update color values from screen 0 data

		float m;

		if ((colorChanged & 1) == 0) {
		    // alpha is up to date in screen 0
		    m = alpha / lastAlpha[0];
		} else {
		    m = alpha;
		}

		float[] sdata = mirrorInterleavedColorPointer[0];
		float[] cdata = mirrorInterleavedColorPointer[screen];

		for (int i = coffset; i < coffset + (vertexCount << 2);) {
		    // System.arraycopy(sdata, i, cdata, i, 3);
		    cdata[i] = sdata[i++];
		    cdata[i] = sdata[i++];
		    cdata[i] = sdata[i++];
		    cdata[i] = sdata[i++] * m;
		}
	    }
	}

	lastAlpha[screen] = alpha;
	colorChanged &= ~(1 << screen);
	dirtyFlag |= COLOR_CHANGED;
	retVal[1] = mirrorInterleavedColorPointer[screen];
	return retVal;
    }


    // pass < 0  implies underlying library supports multiTexture, so
    // 		 use the multiTexture extension to send all texture units
    //		 data in one pass
    // pass >= 0 implies one pass for one texture unit state

    @Override
    void execute(Canvas3D cv, RenderAtom ra, boolean isNonUniformScale,
		 boolean updateAlpha, float alpha,
		 int screen,
                 boolean ignoreVertexColors) {

	int cdirty;
	boolean useAlpha = false;
	Object[] retVal;

        // Check for by-copy case
	if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
            float[] vdata;

	    synchronized (this) {
		cdirty = dirtyFlag;
		if (updateAlpha && !ignoreVertexColors) {
		    // update the alpha values
		    retVal = updateAlphaInVertexData(cv, screen, alpha);
		    useAlpha = (retVal[0] == Boolean.TRUE);
		    vdata = (float[])retVal[1];

		    // D3D only
		    if (alpha != lastScreenAlpha) {
			// handle multiple screen case
			lastScreenAlpha = alpha;
			cdirty |= COLOR_CHANGED;
		    }
		} else {
		    vdata = vertexData;
		    // if transparency switch between on/off
		    if (lastScreenAlpha != -1) {
			lastScreenAlpha = -1;
			cdirty |= COLOR_CHANGED;
		    }
		}
		// geomLock is get in MasterControl when
		// RenderBin render the geometry. So it is safe
		// just to set the dirty flag here
		dirtyFlag = 0;
	    }

	    Pipeline.getPipeline().execute(cv.ctx,
                    this, geoType, isNonUniformScale,
		    useAlpha,
		    ignoreVertexColors,
		    initialVertexIndex,
		     validVertexCount,
		    ((vertexFormat & GeometryArray.COLOR) != 0)?(vertexFormat|GeometryArray.COLOR_4):vertexFormat,
                    texCoordSetCount, texCoordSetMap,
                    (texCoordSetMap == null) ? 0 : texCoordSetMap.length,
                    texCoordSetMapOffset,
		    cv.numActiveTexUnit,
                    vertexAttrCount, vertexAttrSizes,
                    vdata, null,
                    cdirty);
	}

	//By reference with java array
	else if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
	    // interleaved data
	    if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
		if(interLeavedVertexData == null)
		    return;

		float[] cdata = null;

		synchronized (this) {
		    cdirty = dirtyFlag;
		    if (updateAlpha && !ignoreVertexColors) {
			// update the alpha values
			retVal = updateAlphaInInterLeavedData(cv, screen, alpha);
			useAlpha = (retVal[0] == Boolean.TRUE);
			cdata = (float[])retVal[1];
			if (alpha != lastScreenAlpha) {
			    lastScreenAlpha = alpha;
			    cdirty |= COLOR_CHANGED;
			}
		    } else {
			// if transparency switch between on/off
			if (lastScreenAlpha != -1) {
			    lastScreenAlpha = -1;
			    cdirty |= COLOR_CHANGED;
			}
		    }
		    dirtyFlag = 0;
		}

		Pipeline.getPipeline().execute(cv.ctx,
                        this, geoType, isNonUniformScale,
			useAlpha,
			ignoreVertexColors,
			initialVertexIndex,
			validVertexCount,
			vertexFormat,
			texCoordSetCount, texCoordSetMap,
			(texCoordSetMap == null) ? 0 : texCoordSetMap.length,
			texCoordSetMapOffset,
			cv.numActiveTexUnit,
                        vertexAttrCount, vertexAttrSizes,
                        interLeavedVertexData, cdata,
			cdirty);

	    } // end of interleaved case

	    // non interleaved data
	    else {

		// Check if a vertexformat is set, but the array is null
		// if yes, don't draw anything
		if ((vertexType == 0) ||
		    ((vertexType & VERTEX_DEFINED) == 0) ||
		    (((vertexFormat & GeometryArray.COLOR) != 0) &&
		     (vertexType & COLOR_DEFINED) == 0) ||
		    (((vertexFormat & GeometryArray.NORMALS) != 0) &&
		     (vertexType & NORMAL_DEFINED) == 0) ||
		    (((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
		     (vertexType & VATTR_DEFINED) == 0) ||
		    (((vertexFormat& GeometryArray.TEXTURE_COORDINATE) != 0) &&
		     (vertexType & TEXCOORD_DEFINED) == 0)) {
		    return;
		} else {
		    byte[] cbdata = null;
		    float[] cfdata = null;

		    if ((vertexType & (CF | C3F | C4F )) != 0) {

			synchronized (this) {
			    cdirty = dirtyFlag;
			    if (updateAlpha && !ignoreVertexColors) {
				cfdata = updateAlphaInFloatRefColors(cv, screen, alpha);
				if (alpha != lastScreenAlpha) {
				    lastScreenAlpha = alpha;
				    cdirty |= COLOR_CHANGED;
				}
			    } else {
				cfdata = mirrorFloatRefColors[0];
				// if transparency switch between on/off
				if (lastScreenAlpha != -1) {
				    lastScreenAlpha = -1;
				    cdirty |= COLOR_CHANGED;
				}

			    }
			    dirtyFlag = 0;
			}
		    } // end of color in float format
		    else if ((vertexType & (CUB| C3UB | C4UB)) != 0) {
			synchronized (this) {
			    cdirty = dirtyFlag;
			    if (updateAlpha && !ignoreVertexColors) {
				cbdata = updateAlphaInByteRefColors(cv, screen, alpha);
				if (alpha != lastScreenAlpha) {
				    lastScreenAlpha = alpha;
				    cdirty |= COLOR_CHANGED;
				}
			    } else {
				cbdata = mirrorUnsignedByteRefColors[0];
				// if transparency switch between on/off
				if (lastScreenAlpha != -1) {
				    lastScreenAlpha = -1;
				    cdirty |= COLOR_CHANGED;
				}
			    }
			    dirtyFlag = 0;
			}
		    } // end of color in byte format
		    else {
			cdirty = dirtyFlag;
		    }
		    // setup vdefined to passed to native code
		    int vdefined = 0;
		    if((vertexType & (PF | P3F)) != 0)
			vdefined |= COORD_FLOAT;
		    if((vertexType & (PD | P3D)) != 0)
			vdefined |= COORD_DOUBLE;
		    if((vertexType & (CF | C3F | C4F)) != 0)
			vdefined |= COLOR_FLOAT;
		    if((vertexType & (CUB| C3UB | C4UB)) != 0)
			vdefined |= COLOR_BYTE;
		    if((vertexType & NORMAL_DEFINED) != 0)
			vdefined |= NORMAL_FLOAT;
		    if((vertexType & VATTR_DEFINED) != 0)
			vdefined |= VATTR_FLOAT;
		    if((vertexType & TEXCOORD_DEFINED) != 0)
			vdefined |= TEXCOORD_FLOAT;

                    Pipeline.getPipeline().executeVA(cv.ctx,
                            this, geoType, isNonUniformScale,
                            ignoreVertexColors,
                            validVertexCount,
                            (vertexFormat | c4fAllocated),
                            vdefined,
                            initialCoordIndex,
                            mirrorFloatRefCoords, mirrorDoubleRefCoords,
                            initialColorIndex, cfdata, cbdata,
                            initialNormalIndex, mirrorFloatRefNormals,
                            vertexAttrCount, vertexAttrSizes,
                            initialVertexAttrIndex, mirrorFloatRefVertexAttrs,
                            ((texCoordSetMap == null) ? 0:texCoordSetMap.length),
                            texCoordSetMap,
                            cv.numActiveTexUnit,
                            initialTexCoordIndex,texCoordStride,
                            mirrorRefTexCoords, cdirty);
		}// end of all vertex data being set
	    }// end of non interleaved case
	}// end of by reference with java array

	//By reference with nio buffer
	else  {
	    // interleaved data
	    if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {

		if ( interleavedFloatBufferImpl == null)
		    return;

		float[] cdata = null;
		synchronized (this) {
		    cdirty = dirtyFlag;
		    if (updateAlpha && !ignoreVertexColors) {
			// update the alpha values
			// XXXX: to handle alpha case
			retVal = updateAlphaInInterLeavedData(cv, screen, alpha);
			useAlpha = (retVal[0] == Boolean.TRUE);
			cdata = (float[])retVal[1];

			if (alpha != lastScreenAlpha) {
			    lastScreenAlpha = alpha;
			    cdirty |= COLOR_CHANGED;
			}
		    } else {
			// XXXX: to handle alpha case
			cdata = null;
			// if transparency switch between on/off
			if (lastScreenAlpha != -1) {
			    lastScreenAlpha = -1;
			    cdirty |= COLOR_CHANGED;
			}
		    }
		    dirtyFlag = 0;
		}

                Pipeline.getPipeline().executeInterleavedBuffer(cv.ctx,
                        this, geoType, isNonUniformScale,
                        useAlpha,
                        ignoreVertexColors,
                        initialVertexIndex,
                        validVertexCount,
                        vertexFormat,
                        texCoordSetCount, texCoordSetMap,
                        (texCoordSetMap == null) ? 0 : texCoordSetMap.length,
                        texCoordSetMapOffset,
                        cv.numActiveTexUnit,
                        interleavedFloatBufferImpl, cdata,
                        cdirty);

	    } // end of interleaved case

	    // non interleaved data
	    else {

		// Check if a vertexformat is set, but the array is null
		// if yes, don't draw anything
		if ((vertexType == 0) ||
		    ((vertexType & VERTEX_DEFINED) == 0) ||
		    (((vertexFormat & GeometryArray.COLOR) != 0) &&
		     (vertexType & COLOR_DEFINED) == 0) ||
		    (((vertexFormat & GeometryArray.NORMALS) != 0) &&
		     (vertexType & NORMAL_DEFINED) == 0) ||
		    (((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
		     (vertexType & VATTR_DEFINED) == 0) ||
		    (((vertexFormat& GeometryArray.TEXTURE_COORDINATE) != 0) &&
		     (vertexType & TEXCOORD_DEFINED) == 0)) {
		    return;
		} else {
		    byte[] cbdata = null;
		    float[] cfdata = null;

		    if ((vertexType & CF ) != 0) {
			synchronized (this) {
			    cdirty = dirtyFlag;
			    if (updateAlpha && !ignoreVertexColors) {
				cfdata = updateAlphaInFloatRefColors(cv,
								     screen, alpha);
				if (alpha != lastScreenAlpha) {
				    lastScreenAlpha = alpha;
				    cdirty |= COLOR_CHANGED;
				}
			    } else {
				// XXXX: handle transparency case
				//cfdata = null;
				cfdata = mirrorFloatRefColors[0];
				// if transparency switch between on/off
				if (lastScreenAlpha != -1) {
				    lastScreenAlpha = -1;
				    cdirty |= COLOR_CHANGED;
				}

			    }
			    dirtyFlag = 0;
			}
		    } // end of color in float format
		    else if ((vertexType & CUB) != 0) {
			synchronized (this) {
			    cdirty = dirtyFlag;
			    if (updateAlpha && !ignoreVertexColors) {
				cbdata = updateAlphaInByteRefColors(
								    cv, screen, alpha);
				if (alpha != lastScreenAlpha) {
				    lastScreenAlpha = alpha;
				    cdirty |= COLOR_CHANGED;
				}
			    } else {
				// XXXX: handle transparency case
				//cbdata = null;
				cbdata = mirrorUnsignedByteRefColors[0];
				// if transparency switch between on/off
				if (lastScreenAlpha != -1) {
				    lastScreenAlpha = -1;
				    cdirty |= COLOR_CHANGED;
				}
			    }
			    dirtyFlag = 0;
			}
		    } // end of color in byte format
		    else {
			cdirty = dirtyFlag;
		    }

		    Buffer vcoord = null;
		    Buffer cdataBuffer = null;
		    FloatBuffer normal=null;

		    int vdefined = 0;
		    if((vertexType & PF)  != 0) {
			vdefined |= COORD_FLOAT;
			vcoord = floatBufferRefCoords;
		    } else if((vertexType & PD ) != 0) {
			vdefined |= COORD_DOUBLE;
			vcoord = doubleBufferRefCoords;
		    }

		    if((vertexType & CF ) != 0) {
			vdefined |= COLOR_FLOAT;
			cdataBuffer = floatBufferRefColors;
		    } else if((vertexType & CUB) != 0) {
			vdefined |= COLOR_BYTE;
			cdataBuffer = byteBufferRefColors;
		    }

		    if((vertexType & NORMAL_DEFINED) != 0) {
			vdefined |= NORMAL_FLOAT;
			normal = floatBufferRefNormals;
                    }

                    if ((vertexType & VATTR_DEFINED) != 0) {
                        vdefined |= VATTR_FLOAT;
                    }

                    if((vertexType & TEXCOORD_DEFINED) != 0)
		       vdefined |= TEXCOORD_FLOAT;

                    Pipeline.getPipeline().executeVABuffer(cv.ctx,
                            this, geoType, isNonUniformScale,
                            ignoreVertexColors,
                            validVertexCount,
                            (vertexFormat | c4fAllocated),
                            vdefined,
                            initialCoordIndex,
                            vcoord,
                            initialColorIndex,
                            cdataBuffer,
                            cfdata, cbdata,
                            initialNormalIndex,
                            normal,
                            vertexAttrCount, vertexAttrSizes,
                            initialVertexAttrIndex,
                            floatBufferRefVertexAttrs,
                            ((texCoordSetMap == null) ? 0:texCoordSetMap.length),
                            texCoordSetMap,
                            cv.numActiveTexUnit,
                            initialTexCoordIndex,texCoordStride,
                            refTexCoords, cdirty);
		}// end of all vertex data being set
	    }// end of non interleaved case
	}// end of by reference with nio-buffer case
    }

    void buildGA(Canvas3D cv, RenderAtom ra, boolean isNonUniformScale,
		 boolean updateAlpha, float alpha, boolean ignoreVertexColors,
		 Transform3D xform, Transform3D nxform) {

        float[] vdata = null;

        // NIO buffers are no longer supported in display lists
        assert (vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0;

	if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
	    vdata = vertexData;
	}
	else if ((vertexFormat & GeometryArray.INTERLEAVED) != 0 &&
		 ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0)) {
	    vdata = interLeavedVertexData;
	}
	if (vdata != null) {
	    /*
	     System.err.println("calling native buildGA()");
	     System.err.println("geoType = "+geoType+" initialVertexIndex = "+initialVertexIndex+" validVertexCount = "+validVertexCount+" vertexFormat = "+vertexFormat+"  vertexData = "+vertexData);
	     */
	    Pipeline.getPipeline().buildGA(cv.ctx,
                    this, geoType, isNonUniformScale,
		    updateAlpha, alpha, ignoreVertexColors,
		    initialVertexIndex,
		    validVertexCount, vertexFormat,
		    texCoordSetCount, texCoordSetMap,
		    (texCoordSetMap == null) ? 0 : texCoordSetMap.length,
		    texCoordSetMapOffset,
                    vertexAttrCount, vertexAttrSizes,
                    (xform == null) ? null : xform.mat,
		    (nxform == null) ? null : nxform.mat,
		    vdata);
	}
	else {
            // Check if a vertexformat is set, but the array is null
            // if yes, don't draw anything
            if ((vertexType == 0) ||
		((vertexType & VERTEX_DEFINED) == 0) ||
		(((vertexFormat & GeometryArray.COLOR) != 0) &&
		 (vertexType & COLOR_DEFINED) == 0) ||
		(((vertexFormat & GeometryArray.NORMALS) != 0) &&
		 (vertexType & NORMAL_DEFINED) == 0) ||
		(((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
		 (vertexType & VATTR_DEFINED) == 0) ||
		(((vertexFormat& GeometryArray.TEXTURE_COORDINATE) != 0) &&
		 (vertexType & TEXCOORD_DEFINED) == 0)) {

                return;
            }

            // Either non-interleaved, by-ref or nio buffer
	    if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
                // Java array case
		    // setup vdefined to passed to native code
		    int vdefined = 0;
		    if((vertexType & (PF | P3F)) != 0)
			vdefined |= COORD_FLOAT;
		    if((vertexType & (PD | P3D)) != 0)
			vdefined |= COORD_DOUBLE;
		    if((vertexType & (CF | C3F | C4F)) != 0)
			vdefined |= COLOR_FLOAT;
		    if((vertexType & (CUB| C3UB | C4UB)) != 0)
			vdefined |= COLOR_BYTE;
		    if((vertexType & NORMAL_DEFINED) != 0)
			vdefined |= NORMAL_FLOAT;
		    if((vertexType & VATTR_DEFINED) != 0)
			vdefined |= VATTR_FLOAT;
		    if((vertexType & TEXCOORD_DEFINED) != 0)
			vdefined |= TEXCOORD_FLOAT;

		    Pipeline.getPipeline().buildGAForByRef(cv.ctx,
                            this, geoType, isNonUniformScale,
			    updateAlpha, alpha,
			    ignoreVertexColors,
			    validVertexCount,
			    vertexFormat,
			    vdefined,
			    initialCoordIndex,
			    mirrorFloatRefCoords, mirrorDoubleRefCoords,
			    initialColorIndex, mirrorFloatRefColors[0], mirrorUnsignedByteRefColors[0],
			    initialNormalIndex, mirrorFloatRefNormals,
			    vertexAttrCount, vertexAttrSizes,
                            initialVertexAttrIndex, mirrorFloatRefVertexAttrs,
			    ((texCoordSetMap == null) ? 0:texCoordSetMap.length),
			    texCoordSetMap,
			    initialTexCoordIndex,texCoordStride,
			    mirrorRefTexCoords,
			    (xform == null) ? null : xform.mat,
			    (nxform == null) ? null : nxform.mat);
	    }
            /*
            // NOTE: NIO buffers are no longer supported in display lists.
            // This was never enabled by default anyway (only when the
            // optimizeForSpace property was set to false), so it wasn't
            // well-tested. If future support is desired, we will need to
            // add vertex attributes to buildGAForBuffer. There are no plans
            // to ever do this.
	    else {
                // NIO Buffer case
                Object vcoord = null, cdataBuffer=null, normal=null;

                int vdefined = 0;
                if((vertexType & PF)  != 0) {
                    vdefined |= COORD_FLOAT;
                    vcoord = floatBufferRefCoords.getBufferAsObject();
                } else if((vertexType & PD ) != 0) {
                    vdefined |= COORD_DOUBLE;
                    vcoord = doubleBufferRefCoords.getBufferAsObject();
                }

                if((vertexType & CF ) != 0) {
                    vdefined |= COLOR_FLOAT;
                    cdataBuffer = floatBufferRefColors.getBufferAsObject();
                } else if((vertexType & CUB) != 0) {
                    vdefined |= COLOR_BYTE;
                    cdataBuffer = byteBufferRefColors.getBufferAsObject();
                }

                if((vertexType & NORMAL_DEFINED) != 0) {
                    vdefined |= NORMAL_FLOAT;
                    normal = floatBufferRefNormals.getBufferAsObject();
                }

                if((vertexType & TEXCOORD_DEFINED) != 0)
                    vdefined |= TEXCOORD_FLOAT;
                // NOTE : need to add vertex attrs
                Pipeline.getPipeline().buildGAForBuffer(cv.ctx,
                        this, geoType, isNonUniformScale,
                        updateAlpha, alpha,
                        ignoreVertexColors,
                        validVertexCount,
                        vertexFormat,
                        vdefined,
                        initialCoordIndex,
                        vcoord,
                        initialColorIndex,cdataBuffer,
                        initialNormalIndex, normal,
                        ((texCoordSetMap == null) ? 0:texCoordSetMap.length),
                        texCoordSetMap,
                        initialTexCoordIndex,texCoordStride,
                        refTexCoords,
                        (xform == null) ? null : xform.mat,
                        (nxform == null) ? null : nxform.mat);
	    }
            */

	}

    }

    void unIndexify(IndexedGeometryArrayRetained src) {
	if ((src.vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
	    unIndexifyJavaArray(src);
	}
	else {
	    unIndexifyNIOBuffer(src);
	}
    }

    private void unIndexifyJavaArray(IndexedGeometryArrayRetained src) {
//        System.err.println("unIndexifyJavaArray");

        int vOffset = 0, srcOffset, tOffset = 0;
        int index, colorStride = 0;
	float[] vdata = null;
        int i;
	int start, end;
	start = src.initialIndexIndex;
	end = src.initialIndexIndex + src.validIndexCount;
	// If its either "normal" data or interleaved data then ..
	if (((src.vertexFormat & GeometryArray.BY_REFERENCE) == 0) ||
	    ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0)) {

	    if ((src.vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
		vdata = src.vertexData;
		if ((src.vertexFormat & GeometryArray.COLOR) != 0)
		    colorStride = 4;
	    }
	    else if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) {
		vdata = src.interLeavedVertexData;
		if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
		    colorStride = 4;
		else if ((src.vertexFormat & GeometryArray.COLOR) != 0)
		    colorStride = 3;
	    }

	    //	    System.err.println("===> start = "+start+" end = "+end);
	    for (index= start; index < end; index++) {
		if ((vertexFormat & GeometryArray.NORMALS) != 0){
		    System.arraycopy(vdata,
			src.indexNormal[index]*src.stride + src.normalOffset,
			vertexData, vOffset + normalOffset, 3);
		}
		if (colorStride == 4){
		    //		    System.err.println("===> copying color3");
		    System.arraycopy(vdata,
			src.indexColor[index]*src.stride + src.colorOffset,
			vertexData, vOffset + colorOffset, colorStride);
		} else if (colorStride == 3) {
		    //		    System.err.println("===> copying color4");
		    System.arraycopy(vdata,
			src.indexColor[index]*src.stride + src.colorOffset,
			vertexData, vOffset + colorOffset, colorStride);
		    vertexData[vOffset + colorOffset + 3] = 1.0f;
		}

		if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
		    int tcOffset = vOffset + textureOffset;
                    int interleavedOffset = 0;

		    for (i = 0; i < texCoordSetCount;
				i++, tcOffset += texCoordStride) {

                        if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) {
                            interleavedOffset = i * texCoordStride;
                        }

			 System.arraycopy(vdata,
			    (src.indexTexCoord[i][index])*src.stride + src.textureOffset + interleavedOffset,
			    vertexData, tcOffset, texCoordStride);
		    }
		}

                if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
                    // vertex attributes can't be interleaved
                    assert (src.vertexFormat & GeometryArray.INTERLEAVED) == 0;

		    for (i = 0; i < vertexAttrCount; i++) {
                        int vaOffset = vOffset + vertexAttrOffsets[i];

			 System.arraycopy(vdata,
			    (src.indexVertexAttr[i][index])*src.stride + src.vertexAttrOffsets[i],
			    vertexData, vaOffset, vertexAttrSizes[i]);
		    }
                }

		if ((vertexFormat & GeometryArray.COORDINATES) != 0){
		    //		    System.err.println("===> copying coords");
		    System.arraycopy(vdata,
			src.indexCoord[index]*src.stride
				+ src.coordinateOffset,
			vertexData,
			vOffset + coordinateOffset, 3);
		}
		vOffset += stride;
	    }

	} else {
	    if ((vertexFormat & GeometryArray.NORMALS) != 0) {
		vOffset = normalOffset;
		switch ((src.vertexType & NORMAL_DEFINED)) {
		case NF:
		    for (index=start; index < end; index++) {
			System.arraycopy(src.floatRefNormals,
					 src.indexNormal[index]*3,
					 vertexData,
					 vOffset, 3);
			vOffset += stride;
		    }
		    break;
		case N3F:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexNormal[index];
			vertexData[vOffset] = src.v3fRefNormals[srcOffset].x;
			vertexData[vOffset+1] = src.v3fRefNormals[srcOffset].y;
			vertexData[vOffset+2] = src.v3fRefNormals[srcOffset].z;
			vOffset += stride;
		    }
		    break;
		default:
		    break;
		}
	    }

	    if ((vertexFormat & GeometryArray.COLOR) != 0) {
		vOffset = colorOffset;
		int multiplier = 3;
		if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
		    multiplier = 4;

		switch ((src.vertexType & COLOR_DEFINED)) {
		case CF:
		    for (index=start; index < end; index++) {
			if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
			    System.arraycopy(src.floatRefColors,
					     src.indexColor[index]*multiplier,
					     vertexData,
					     vOffset, 4);
			}
			else {
			    System.arraycopy(src.floatRefColors,
					     src.indexColor[index]*multiplier,
					     vertexData,
					     vOffset, 3);
			    vertexData[vOffset+3] = 1.0f;
			}
			vOffset += stride;
		    }
		    break;
		case CUB:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexColor[index] * multiplier;
			vertexData[vOffset] = (src.byteRefColors[srcOffset] & 0xff) * ByteToFloatScale;
			vertexData[vOffset+1] = (src.byteRefColors[srcOffset+1] & 0xff) * ByteToFloatScale;
			vertexData[vOffset+2] = (src.byteRefColors[srcOffset+2] & 0xff) * ByteToFloatScale;
			if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
			    vertexData[vOffset+3] = (src.byteRefColors[srcOffset+3] & 0xff) * ByteToFloatScale;
			}
			else {
			    vertexData[vOffset+3] = 1.0f;
			}
			vOffset += stride;
		    }
		    break;
		case C3F:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexColor[index];
			vertexData[vOffset] = src.c3fRefColors[srcOffset].x;
			vertexData[vOffset+1] = src.c3fRefColors[srcOffset].y;
			vertexData[vOffset+2] = src.c3fRefColors[srcOffset].z;
			vertexData[vOffset+3] = 1.0f;
			vOffset += stride;
		    }
		    break;
		case C4F:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexColor[index];
			vertexData[vOffset] = src.c4fRefColors[srcOffset].x;
			vertexData[vOffset+1] = src.c4fRefColors[srcOffset].y;
			vertexData[vOffset+2] = src.c4fRefColors[srcOffset].z;
			vertexData[vOffset+3] = src.c4fRefColors[srcOffset].w;
			vOffset += stride;
		    }
		    break;
		case C3UB:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexColor[index];
			vertexData[vOffset] = (src.c3bRefColors[srcOffset].x & 0xff) * ByteToFloatScale;
			vertexData[vOffset+1] = (src.c3bRefColors[srcOffset].y & 0xff) * ByteToFloatScale;
			vertexData[vOffset+2] = (src.c3bRefColors[srcOffset].z & 0xff) * ByteToFloatScale;
			vertexData[vOffset+3] = 1.0f;
			vOffset += stride;
		    }
		    break;
		case C4UB:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexColor[index];
			vertexData[vOffset] = (src.c4bRefColors[srcOffset].x & 0xff) * ByteToFloatScale;
			vertexData[vOffset+1] = (src.c4bRefColors[srcOffset].y & 0xff) * ByteToFloatScale;
			vertexData[vOffset+2] = (src.c4bRefColors[srcOffset].z & 0xff) * ByteToFloatScale;
			vertexData[vOffset+3] = (src.c4bRefColors[srcOffset].w & 0xff) * ByteToFloatScale;
			vOffset += stride;
		    }
		    break;
		default:
		    break;
		}
	    }

	    if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
		vOffset = textureOffset;
		switch ((src.vertexType & TEXCOORD_DEFINED)) {
		case TF:
		    for (index=start; index < end; index++) {
			for (i = 0, tOffset = vOffset;
				i < texCoordSetCount; i++) {
			    System.arraycopy(src.refTexCoords[i],
				src.indexTexCoord[i][index]*texCoordStride,
				vertexData, tOffset, texCoordStride);
			    tOffset += texCoordStride;
			}
			vOffset += stride;
		    }
		    break;
		case T2F:
		    for (index=start; index < end; index++) {
			for (i = 0, tOffset = vOffset;
			        i < texCoordSetCount; i++) {
			     srcOffset = src.indexTexCoord[i][index];
			     vertexData[tOffset] =
			      ((TexCoord2f[])src.refTexCoords[i])[srcOffset].x;
			     vertexData[tOffset+1] =
			      ((TexCoord2f[])src.refTexCoords[i])[srcOffset].y;
			     tOffset += texCoordStride;
			}
			vOffset += stride;
		    }
		    break;
		case T3F:
		    for (index=start; index < end; index++) {
			for (i = 0, tOffset = vOffset;
			        i < texCoordSetCount; i++) {
			     srcOffset = src.indexTexCoord[i][index];
			     vertexData[tOffset] =
			      ((TexCoord3f[])src.refTexCoords[i])[srcOffset].x;
			     vertexData[tOffset+1] =
			      ((TexCoord3f[])src.refTexCoords[i])[srcOffset].y;
			     vertexData[tOffset+2] =
			      ((TexCoord3f[])src.refTexCoords[i])[srcOffset].z;
			     tOffset += texCoordStride;
			}
			vOffset += stride;
		    }
		    break;
		default:
		    break;
		}
	    }

            if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
		vOffset = 0;
		switch (src.vertexType & VATTR_DEFINED) {
		case AF:
		    for (index=start; index < end; index++) {
			for (i = 0; i < vertexAttrCount; i++) {
                            int vaOffset = vOffset + vertexAttrOffsets[i];
			    System.arraycopy(src.floatRefVertexAttrs[i],
				src.indexVertexAttr[i][index]*vertexAttrSizes[i],
				vertexData, vaOffset, vertexAttrSizes[i]);
			}
			vOffset += stride;
		    }
		    break;
		}
            }

	    if ((vertexFormat & GeometryArray.COORDINATES) != 0) {
		vOffset = coordinateOffset;
		switch ((src.vertexType & VERTEX_DEFINED)) {
		case PF:
		    for (index=start; index < end; index++) {
			System.arraycopy(src.floatRefCoords,
					 src.indexCoord[index]*3,
					 vertexData,
					 vOffset, 3);
			vOffset += stride;
		    }
		    break;
		case PD:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexCoord[index] * 3;
			vertexData[vOffset] = (float)src.doubleRefCoords[srcOffset];
			vertexData[vOffset+1] = (float)src.doubleRefCoords[srcOffset+1];
			vertexData[vOffset+2] = (float)src.doubleRefCoords[srcOffset+2];
			vOffset += stride;
		    }
		    break;
		case P3F:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexCoord[index];
			vertexData[vOffset] = src.p3fRefCoords[srcOffset].x;
			vertexData[vOffset+1] = src.p3fRefCoords[srcOffset].y;
			vertexData[vOffset+2] = src.p3fRefCoords[srcOffset].z;
			vOffset += stride;
		    }
		    break;
		case P3D:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexCoord[index];
			vertexData[vOffset] = (float)src.p3dRefCoords[srcOffset].x;
			vertexData[vOffset+1] = (float)src.p3dRefCoords[srcOffset].y;
			vertexData[vOffset+2] = (float)src.p3dRefCoords[srcOffset].z;
			vOffset += stride;
		    }
		    break;
		default:
		    break;
		}
	    }

	}
    }


    private void unIndexifyNIOBuffer(IndexedGeometryArrayRetained src) {
//        System.err.println("unIndexifyNIOBuffer");

        int vOffset = 0, srcOffset, tOffset = 0;
        int index, colorStride = 0;
        int i;
	int start, end;
	start = src.initialIndexIndex;
	end = src.initialIndexIndex + src.validIndexCount;
	// If its interleaved data then ..
	if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) {
	    if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
		colorStride = 4;
	    else if ((src.vertexFormat & GeometryArray.COLOR) != 0)
		colorStride = 3;

	    //	    System.err.println("===> start = "+start+" end = "+end);
	    for (index= start; index < end; index++) {
		if ((vertexFormat & GeometryArray.NORMALS) != 0){
		    src.interleavedFloatBufferImpl.position(src.indexNormal[index]*src.stride + src.normalOffset);
		    src.interleavedFloatBufferImpl.get(vertexData, vOffset + normalOffset, 3);
		}

		if (colorStride == 4){
		    src.interleavedFloatBufferImpl.position(src.indexColor[index]*src.stride + src.colorOffset);
		    src.interleavedFloatBufferImpl.get(vertexData, vOffset + colorOffset, colorStride);
		} else if (colorStride == 3) {
		    src.interleavedFloatBufferImpl.position(src.indexColor[index]*src.stride + src.colorOffset);
		    src.interleavedFloatBufferImpl.get(vertexData, vOffset + colorOffset, colorStride);
		    vertexData[vOffset + colorOffset + 3] = 1.0f;
		}

		if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
		    int tcOffset = vOffset + textureOffset;
		    for (i = 0; i < texCoordSetCount;
				i++, tcOffset += texCoordStride) {

			src.interleavedFloatBufferImpl.position((src.indexTexCoord[i][index])*src.stride +
							    src.textureOffset);
			src.interleavedFloatBufferImpl.get(vertexData, tcOffset, texCoordStride);
		    }
		}
		if ((vertexFormat & GeometryArray.COORDINATES) != 0){
		    src.interleavedFloatBufferImpl.position(src.indexCoord[index]*src.stride + src.coordinateOffset );
		    src.interleavedFloatBufferImpl.get(vertexData, vOffset + coordinateOffset, 3);
		}
		vOffset += stride;
	    }

	} else {
	    if ((vertexFormat & GeometryArray.NORMALS) != 0){
		vOffset = normalOffset;
		if ((src.vertexType & NORMAL_DEFINED) != 0) {
		    for (index=start; index < end; index++) {
			src.floatBufferRefNormals.position(src.indexNormal[index]*3);
			src.floatBufferRefNormals.get(vertexData, vOffset, 3);
			vOffset += stride;
		    }
		}
	    }

            if ((vertexFormat & GeometryArray.COLOR) != 0){
		vOffset = colorOffset;
		int multiplier = 3;
		if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
		    multiplier = 4;

		switch ((src.vertexType & COLOR_DEFINED)) {
		case CF:
		    for (index=start; index < end; index++) {
			if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
			    src.floatBufferRefColors.position(src.indexColor[index]*multiplier);
			    src.floatBufferRefColors.get(vertexData, vOffset, 4);
			}
			else {
			    src.floatBufferRefColors.position(src.indexColor[index]*multiplier);
			    src.floatBufferRefColors.get(vertexData, vOffset, 3);
			    vertexData[vOffset+3] = 1.0f;
			}
			vOffset += stride;
		    }
		    break;
		case CUB:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexColor[index] * multiplier;
			vertexData[vOffset] = (src.byteBufferRefColors.get(srcOffset) & 0xff) * ByteToFloatScale;
			vertexData[vOffset+1] = (src.byteBufferRefColors.get(srcOffset+1) & 0xff) * ByteToFloatScale;
			vertexData[vOffset+2] = (src.byteBufferRefColors.get(srcOffset+2) & 0xff) * ByteToFloatScale;

			if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
			    vertexData[vOffset+3] = (src.byteBufferRefColors.get(srcOffset+3) & 0xff) * ByteToFloatScale;
			}
			else {
			    vertexData[vOffset+3] = 1.0f;
			}
			vOffset += stride;
		    }
		    break;
		default:
		    break;
		}
	    }

            if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
		vOffset = textureOffset;
		if ((src.vertexType & TEXCOORD_DEFINED) != 0) {
		    for (index=start; index < end; index++) {
			for (i = 0, tOffset = vOffset;
				i < texCoordSetCount; i++) {
			    FloatBuffer texBuffer = (FloatBuffer)src.refTexCoordsBuffer[i].getROBuffer();
			    texBuffer.position(src.indexTexCoord[i][index]*texCoordStride);
			    texBuffer.get(vertexData, tOffset, texCoordStride);
			    tOffset += texCoordStride;
			}
			vOffset += stride;
		    }
		}
	    }

            if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
		vOffset = 0;
		if ((src.vertexType & VATTR_DEFINED) == AF) {
		    for (index=start; index < end; index++) {
			for (i = 0; i < vertexAttrCount; i++) {
                            int vaOffset = vOffset + vertexAttrOffsets[i];
			    FloatBuffer vaBuffer = src.floatBufferRefVertexAttrs[i];
			    vaBuffer.position(src.indexVertexAttr[i][index]*vertexAttrSizes[i]);
			    vaBuffer.get(vertexData, vaOffset, vertexAttrSizes[i]);
			}
			vOffset += stride;
		    }
		}
	    }

            if ((vertexFormat & GeometryArray.COORDINATES) != 0){
		vOffset = coordinateOffset;
		switch ((src.vertexType & VERTEX_DEFINED)) {
		case PF:
		    for (index=start; index < end; index++) {
			src.floatBufferRefCoords.position(src.indexCoord[index]*3);
			src.floatBufferRefCoords.get(vertexData, vOffset, 3);
			vOffset += stride;
		    }
		    break;
		case PD:
		    for (index=start; index < end; index++) {
			srcOffset = src.indexCoord[index] * 3;
			vertexData[vOffset] = (float)src.doubleBufferRefCoords.get(srcOffset);
			vertexData[vOffset+1] = (float)src.doubleBufferRefCoords.get(srcOffset+1);
			vertexData[vOffset+2] = (float)src.doubleBufferRefCoords.get(srcOffset+2);
			vOffset += stride;
		    }
		    break;
		default:
		    break;
		}
	    }

	}
    }


    /**
     * Returns the vertex stride in numbers of floats as a function
     * of the vertexFormat.
     * @return the stride in floats for this vertex array
     */
    int stride()
    {
	int stride = 0;

	if((this.vertexFormat & GeometryArray.COORDINATES) != 0) stride += 3;
	if((this.vertexFormat & GeometryArray.NORMALS) != 0) stride += 3;

	if ((this.vertexFormat & GeometryArray.COLOR) != 0) {
	    if ((this.vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
		// By copy
		stride += 4;
	    } else {
		if ((this.vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
		    stride += 3;
		}
		else {
		    stride += 4;
		}
	    }
	}

	if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {

	    if ((this.vertexFormat &
			GeometryArray.TEXTURE_COORDINATE_2) != 0) {
	        texCoordStride = 2;
	    } else if ((this.vertexFormat &
			GeometryArray.TEXTURE_COORDINATE_3) != 0) {
		texCoordStride = 3;
	    } else if ((this.vertexFormat &
			GeometryArray.TEXTURE_COORDINATE_4) != 0) {
		texCoordStride = 4;
	    }

	    stride += texCoordStride * texCoordSetCount;
	}

	if ((this.vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
	    stride += vertexAttrStride;
	}

	//System.err.println("stride() = " + stride);
	return stride;
    }

    int[] texCoordSetMapOffset()
    {
	if (texCoordSetMap == null)
	    return null;

        texCoordSetMapOffset = new int[texCoordSetMap.length];
	for (int i = 0; i < texCoordSetMap.length; i++) {
	     if (texCoordSetMap[i] == -1) {
		 texCoordSetMapOffset[i] = -1;
	     } else {
	         texCoordSetMapOffset[i] = texCoordSetMap[i] * texCoordStride;
	     }
	}
	return texCoordSetMapOffset;
    }

    /**
     * Returns the stride of the set of vertex attributes. This is the
     * sum of the sizes of each vertex attribute.
     * @return the stride of the vertex attribute data
     */
    int vertexAttrStride() {
        int sum = 0;
        for (int i = 0; i < vertexAttrCount; i++) {
            sum += vertexAttrSizes[i];
        }
        return sum;
    }

    /**
     * Returns the offset in number of floats from the start of a vertex to
     * each per-vertex vertex attribute.
     * @return array of offsets in floats vertex start to the vertex attribute data
     */
    int[] vertexAttrOffsets() {
	int[] offsets;

        // Create array of offsets to the start of each vertex attribute.
        // The offset of the first attribute is always 0. If no vertex attributes exist,
        // then we will allocate an array of length 1 to avoid some checking elsewhere.
        if (vertexAttrCount > 0) {
            offsets = new int[vertexAttrCount];
        }
        else {
            offsets = new int[1];
        }
        offsets[0] = 0;
        for (int i = 1; i < vertexAttrCount; i++) {
            offsets[i] = offsets[i-1] + vertexAttrSizes[i-1];
        }

        return offsets;
    }

    /**
     * Returns the offset in number of floats from the start of a vertex to
     * the per-vertex texture coordinate data.
     * texture coordinate data always follows vertex attribute data
     * @return the offset in floats vertex start to the tetxure data
     */
    int textureOffset()
    {
	int offset = vertexAttrOffsets[0];

	if ((this.vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
	    offset += vertexAttrStride;
	}

	return offset;
    }

    /**
     * Returns the offset in number of floats from the start of a vertex to
     * the per-vertex color data.
     * color data always follows texture data
     * @param vertexFormat the vertex format for this array
     * @return the offset in floats vertex start to the color data
     */
    int colorOffset()
    {
	int offset = textureOffset;

	if((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0)
	    offset += 2 * texCoordSetCount;
	else if((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0)
	    offset += 3 * texCoordSetCount;
	else if((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0)
	    offset += 4 * texCoordSetCount;

	return offset;
    }

    /**
     * Returns the offset in number of floats from the start of a vertex to
     * the per-vertex normal data.
     * normal data always follows color data
     * @return the offset in floats from the start of a vertex to the normal
     */
    int normalOffset()
    {
	int offset = colorOffset;

	if ((this.vertexFormat & GeometryArray.COLOR) != 0) {
	    if ((this.vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
		offset += 4;
	    } else {
		if ((this.vertexFormat & GeometryArray.WITH_ALPHA) == 0) {
		    offset += 3;
		}
		else {
		    offset += 4;
		}
	    }
	}
	return offset;
    }

    /**
     * Returns the offset in number of floats from the start of a vertex to
     * the per vertex coordinate data.
     * @return the offset in floats vertex start to the coordinate data
     */
    int coordinateOffset()
    {
	int offset = normalOffset;

	if ((this.vertexFormat & GeometryArray.NORMALS) != 0) offset += 3;
	return offset;
    }

    /**
     * Returns number of vertices in the GeometryArray
     * @return vertexCount number of vertices in the GeometryArray
     */
    int getVertexCount(){
	return vertexCount;
    }

    /**
     * Returns vertexFormat in the GeometryArray
     * @return vertexFormat format of vertices in the GeometryArray
     */
    @Override
    int getVertexFormat(){
	return vertexFormat;
    }

    /**
     * Retrieves the number of vertex attributes in this GeometryArray
     * object.
     *
     * @return the number of vertex attributes in this GeometryArray
     * object
     */
    int getVertexAttrCount() {
        return vertexAttrCount;
    }


    /**
     * Retrieves the vertex attribute sizes array from this
     * GeometryArray object.
     *
     * @param vertexAttrSizes an array that will receive a copy of
     * the vertex attribute sizes array.  The array must hold at least
     * <code>vertexAttrCount</code> elements.
     */
    void getVertexAttrSizes(int[] vertexAttrSizes) {
        for (int i = 0; i < vertexAttrCount; i++) {
            vertexAttrSizes[i] = this.vertexAttrSizes[i];
        }
    }



    void sendDataChangedMessage(boolean coordinatesChanged) {
	J3dMessage[] m;
	int i, j, k, numShapeMessages, numMorphMessages;

	synchronized(liveStateLock) {
	    if (source != null && source.isLive()) {
		// System.err.println("In GeometryArrayRetained - ");

		// Send a message to renderBin to rebuild the display list or
		// process the vertex array accordingly
		// XXXX: Should I send one per universe, isn't display list
		// shared by all context/universes?
		int threads = J3dThread.UPDATE_RENDER;
		// If the geometry type is Indexed then we need to clone the geometry
		// We also need to update the cachedChangedFrequent flag
		threads |= J3dThread.UPDATE_RENDERING_ATTRIBUTES;

		synchronized (universeList) {
		    numShapeMessages = universeList.size();
		    m = new J3dMessage[numShapeMessages];

		    k = 0;

		    for (i = 0; i < numShapeMessages; i++, k++) {
			gaList.clear();

			ArrayList<Shape3DRetained> shapeList = userLists.get(i);
			for (j = 0; j < shapeList.size(); j++) {
				Shape3DRetained s = shapeList.get(j);
			    LeafRetained src = (LeafRetained)s.sourceNode;
			    // Should only need to update distinct localBounds.
			    if (coordinatesChanged && src.boundsAutoCompute) {
				src.boundsDirty = true;
			    }
			}

			for (j = 0; j < shapeList.size(); j++) {
				Shape3DRetained s = shapeList.get(j);
			    LeafRetained src = (LeafRetained)s.sourceNode;
			    if (src.boundsDirty) {
				// update combine bounds of mirrorShape3Ds. So we need to
				// use its bounds and not localBounds.
				// bounds is actually a reference to
				// mirrorShape3D.source.localBounds.
				src.updateBounds();
				src.boundsDirty = false;
			    }
			    gaList.add(Shape3DRetained.getGeomAtom(s));
			}

			m[k] = new J3dMessage();

			m[k].type = J3dMessage.GEOMETRY_CHANGED;
			// Who to send this message to ?
			m[k].threads = threads;
			m[k].args[0] = gaList.toArray();
			m[k].args[1] = this;
			m[k].args[2]= null;
			m[k].args[3] = new Integer(changedFrequent);
			m[k].universe = universeList.get(i);
		    }
		    VirtualUniverse.mc.processMessage(m);
		}

		if (morphUniverseList != null) {
		    synchronized (morphUniverseList) {
			numMorphMessages = morphUniverseList.size();

			// take care of morph that is referencing this geometry
			if (numMorphMessages > 0) {
			    synchronized (morphUniverseList) {
				for (i = 0; i < numMorphMessages; i++, k++) {
					ArrayList<MorphRetained> morphList = morphUserLists.get(i);
					for (j = 0; j < morphList.size(); j++) {
						morphList.get(j).updateMorphedGeometryArray(this, coordinatesChanged);
					}
				}
			    }
			}
		    }
		}
	    }
	}

    }
    /**
     * Sets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate an array of 3 values containing the new coordinate
     */
    void setCoordinate(int index, float coordinate[]) {
	int offset = this.stride * index + coordinateOffset;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	this.vertexData[offset]  = coordinate[0];
	this.vertexData[offset+1]= coordinate[1];
	this.vertexData[offset+2]= coordinate[2];

        if (isLive) {
            geomLock.unLock();
        }
        if (inUpdater || (source == null)) {
            return;
        }
	if (!isLive) {
		boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);
	sendDataChangedMessage(true);

    }

    /**
     * Sets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate an array of 3 values containing the new coordinate
     */
    void setCoordinate(int index, double coordinate[]) {
	int offset = this.stride * index + coordinateOffset;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	this.vertexData[offset]  = (float)coordinate[0];
	this.vertexData[offset+1]= (float)coordinate[1];
	this.vertexData[offset+2]= (float)coordinate[2];

	if(isLive) {
            geomLock.unLock();
	}

        if (inUpdater || (source == null)) {
	    return;
	}
	if (!isLive) {
            boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);
	sendDataChangedMessage(true);
    }

    /**
     * Sets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate a vector containing the new coordinate
     */
    void setCoordinate(int index, Point3f coordinate) {
	int offset = this.stride * index + coordinateOffset;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	this.vertexData[offset]  = coordinate.x;
	this.vertexData[offset+1]= coordinate.y;
	this.vertexData[offset+2]= coordinate.z;

	if(isLive) {
            geomLock.unLock();
	}
        if (inUpdater || (source == null)) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);
	sendDataChangedMessage(true);
    }

    /**
     * Sets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate a vector containing the new coordinate
     */
    void setCoordinate(int index, Point3d coordinate) {
	int offset = this.stride * index + coordinateOffset;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	this.vertexData[offset]  = (float)coordinate.x;
	this.vertexData[offset+1]= (float)coordinate.y;
	this.vertexData[offset+2]= (float)coordinate.z;
	if(isLive) {
            geomLock.unLock();
	}
	if (inUpdater || source == null ) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}
	// Compute geo's bounds
	processCoordsChanged(false);
	sendDataChangedMessage(true);
    }

    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of 3*n values containing n new coordinates
     */
    void setCoordinates(int index, float coordinates[]) {
	int offset = this.stride * index + coordinateOffset;
	int i, j, num = coordinates.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	for (i=0, j= offset;i < num; i+=3, j+= this.stride)
	    {
		this.vertexData[j]  = coordinates[i];
		this.vertexData[j+1]= coordinates[i+1];
		this.vertexData[j+2]= coordinates[i+2];
	    }

	if(isLive) {
            geomLock.unLock();
	}
	if (inUpdater ||source == null ) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);

    }

    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of 3*n values containing n new coordinates
     */
    void setCoordinates(int index, double coordinates[]) {
	int offset = this.stride * index + coordinateOffset;
	int i, j, num = coordinates.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	for (i=0, j= offset;i < num; i+=3, j+= this.stride)
	    {
		this.vertexData[j]  = (float)coordinates[i];
		this.vertexData[j+1]= (float)coordinates[i+1];
		this.vertexData[j+2]= (float)coordinates[i+2];
	    }

	if(isLive) {
            geomLock.unLock();
	}

	if (inUpdater ||source == null ) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);
    }

    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of vectors containing new coordinates
     */
    void setCoordinates(int index, Point3f coordinates[]) {
	int offset = this.stride * index + coordinateOffset;
	int i, j, num = coordinates.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		this.vertexData[j]  = coordinates[i].x;
		this.vertexData[j+1]= coordinates[i].y;
		this.vertexData[j+2]= coordinates[i].z;
	    }
	if(isLive) {
            geomLock.unLock();
	}

	if (inUpdater ||source == null ) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);

    }

    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of vectors containing new coordinates
     */
    void setCoordinates(int index, Point3d coordinates[]) {
	int offset = this.stride * index + coordinateOffset;
	int i, j, num = coordinates.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		this.vertexData[j]  = (float)coordinates[i].x;
		this.vertexData[j+1]= (float)coordinates[i].y;
		this.vertexData[j+2]= (float)coordinates[i].z;
	    }
        if(isLive) {
            geomLock.unLock();
        }

        if (inUpdater ||source == null ) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);
    }


    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index for this object using coordinate data starting
     * from vertex index <code>start</code> for <code>length</code> vertices.
     * @param index the vertex index
     * @param coordinates an array of vectors containing new coordinates
     * @param start starting vertex index of data in <code>coordinates</code>  .
     * @param length number of vertices to be copied.
     */
    void setCoordinates(int index, float coordinates[], int start, int length) {
	int offset = this.stride * index + coordinateOffset;
	int i, j;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	for (i= start * 3, j= offset; i < (start+length) * 3;
	     i+=3, j+= this.stride) {
	    this.vertexData[j]  = coordinates[i];
	    this.vertexData[j+1]= coordinates[i+1];
	    this.vertexData[j+2]= coordinates[i+2];
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (inUpdater ||source == null ) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);
    }

    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index for this object  using coordinate data starting
     * from vertex index <code>start</code> for <code>length</code> vertices.
     * @param index the vertex index
     * @param coordinates an array of 3*n values containing n new coordinates
     * @param start starting vertex index of data in <code>coordinates</code>  .
     * @param length number of vertices to be copied.
     */
    void setCoordinates(int index, double coordinates[], int start, int length) {
	int offset = this.stride * index + coordinateOffset;
	int i, j;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	for (i= start*3, j= offset; i < (start+length)*3;
	     i+=3, j+= this.stride) {
	    this.vertexData[j]  = (float)coordinates[i];
	    this.vertexData[j+1]= (float)coordinates[i+1];
	    this.vertexData[j+2]= (float)coordinates[i+2];
	}

	if(isLive) {
            geomLock.unLock();
	}
        if (inUpdater || (source == null)) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}


	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);
    }

    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index for this object using coordinate data starting
     * from vertex index <code>start</code> for <code>length</code> vertices.
     * @param index the vertex index
     * @param coordinates an array of vectors containing new coordinates
     * @param start starting vertex index of data in <code>coordinates</code>  .
     * @param length number of vertices to be copied.
     */
    void setCoordinates(int index, Point3f coordinates[], int start,
			int length) {
	int offset = this.stride * index + coordinateOffset;
	int i, j;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	for (i=start, j= offset;i < start + length; i++, j+= this.stride) {
	    this.vertexData[j]  = coordinates[i].x;
	    this.vertexData[j+1]= coordinates[i].y;
	    this.vertexData[j+2]= coordinates[i].z;
	}

	if(isLive) {
            geomLock.unLock();
        }

        if (inUpdater || (source == null)) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}


	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);
    }

    /**
     * Sets the coordinates associated with the vertices starting at
     * the specified index for this object using coordinate data starting
     * from vertex index <code>start</code> for <code>length</code> vertices.
     * @param index the vertex index
     * @param coordinates an array of vectors containing new coordinates
     * @param start starting vertex index of data in <code>coordinates</code>  .
     * @param length number of vertices to be copied.
     */
    void setCoordinates(int index, Point3d coordinates[], int start,
			int length) {
	int offset = this.stride * index + coordinateOffset;
	int i, j;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	for (i=start, j= offset;i < start + length; i++, j+= this.stride) {
	    this.vertexData[j]  = (float)coordinates[i].x;
	    this.vertexData[j+1]= (float)coordinates[i].y;
	    this.vertexData[j+2]= (float)coordinates[i].z;
	}

	if(isLive) {
            geomLock.unLock();
        }
        if (inUpdater || (source == null)) {
	    return;
	}
	if (!isLive) {
	    boundsDirty = true;
	    return;
	}

	// Compute geo's bounds
	processCoordsChanged(false);

	sendDataChangedMessage(true);
    }

    /**
     * Sets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color an array of 3 or 4 values containing the new color
     */
    void setColor(int index, float color[]) {
	int offset = this.stride*index + colorOffset;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	this.vertexData[offset]   = color[0];
	this.vertexData[offset+1] = color[1];
	this.vertexData[offset+2] = color[2];
	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    this.vertexData[offset+3] = color[3]*lastAlpha[0];
	else
	    this.vertexData[offset+3] = lastAlpha[0];

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color an array of 3 or 4 values containing the new color
     */
    void setColor(int index, byte color[]) {
	int offset = this.stride*index + colorOffset;

	boolean isLive = source!=null && source.isLive();
	if(isLive) {
            geomLock.getLock();
	}

	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	this.vertexData[offset]   = (color[0] & 0xff) * ByteToFloatScale;
	this.vertexData[offset+1] = (color[1] & 0xff) * ByteToFloatScale;
	this.vertexData[offset+2] = (color[2] & 0xff) * ByteToFloatScale;
	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    this.vertexData[offset+3] = ((color[3] & 0xff)* ByteToFloatScale)*lastAlpha[0];
        else
	    this.vertexData[offset+3] = lastAlpha[0];

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector containing the new color
     */
    void setColor(int index, Color3f color) {
	int offset = this.stride*index + colorOffset;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
        }

	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	this.vertexData[offset]   = color.x;
	this.vertexData[offset+1] = color.y;
	this.vertexData[offset+2] = color.z;
        this.vertexData[offset+3] = lastAlpha[0];

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}


    }

    /**
     * Sets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector containing the new color
     */
    void setColor(int index, Color4f color) {
	int offset = this.stride*index + colorOffset;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	this.vertexData[offset]   = color.x;
	this.vertexData[offset+1] = color.y;
	this.vertexData[offset+2] = color.z;
	this.vertexData[offset+3] = color.w*lastAlpha[0];

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector containing the new color
     */
    void setColor(int index, Color3b color) {
	int offset = this.stride*index + colorOffset;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}

	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	this.vertexData[offset]   = (color.x & 0xff) * ByteToFloatScale;
	this.vertexData[offset+1] = (color.y & 0xff) * ByteToFloatScale;
	this.vertexData[offset+2] = (color.z & 0xff) * ByteToFloatScale;
        this.vertexData[offset+3] = lastAlpha[0];

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector containing the new color
     */
    void setColor(int index, Color4b color) {
	int offset = this.stride*index + colorOffset;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	this.vertexData[offset]   = (color.x & 0xff) * ByteToFloatScale;
	this.vertexData[offset+1] = (color.y & 0xff) * ByteToFloatScale;
	this.vertexData[offset+2] = (color.z & 0xff) * ByteToFloatScale;
	this.vertexData[offset+3] = ((color.w & 0xff) * ByteToFloatScale)*lastAlpha[0];

	if(isLive){
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     */
    void setColors(int index, float colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    {
		for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
		    {
			this.vertexData[j]   = colors[i];
			this.vertexData[j+1] = colors[i+1];
			this.vertexData[j+2] = colors[i+2];
			this.vertexData[j+3] = colors[i+3]*lastAlpha[0];
		    }
	    }
	else
	    {
		for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
		    {
			this.vertexData[j]   = colors[i];
			this.vertexData[j+1] = colors[i+1];
			this.vertexData[j+2] = colors[i+2];
			this.vertexData[j+3] = lastAlpha[0];
		    }
	    }

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     */
    void setColors(int index, byte colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    {
		for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
		    {
			this.vertexData[j]   = (colors[i] & 0xff) * ByteToFloatScale;
			this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
			this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
			this.vertexData[j+3] = ((colors[i+3] & 0xff) * ByteToFloatScale)*lastAlpha[0];
		    }
	    }
	else
	    {
		for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
		    {
			this.vertexData[j]   = (colors[i] & 0xff) * ByteToFloatScale;
			this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
			this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
			this.vertexData[j+3] = lastAlpha[0];
		    }
	    }


	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors containing new colors
     */
    void setColors(int index, Color3f colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		this.vertexData[j]   = colors[i].x;
		this.vertexData[j+1] = colors[i].y;
		this.vertexData[j+2] = colors[i].z;
		this.vertexData[j+3] = lastAlpha[0];
	    }
        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors containing new colors
     */
    void setColors(int index, Color4f colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		this.vertexData[j]   = colors[i].x;
		this.vertexData[j+1] = colors[i].y;
		this.vertexData[j+2] = colors[i].z;
		this.vertexData[j+3] = colors[i].w*lastAlpha[0];
	    }
        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors containing new colors
     */
    void setColors(int index, Color3b colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		this.vertexData[j]   = (colors[i].x & 0xff) * ByteToFloatScale;
		this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
		this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
		this.vertexData[j+3] = lastAlpha[0];
	    }

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }
    }


    /**
     * Sets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors containing new colors
     */
    void setColors(int index, Color4b colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		this.vertexData[j]   = (colors[i].x & 0xff) * ByteToFloatScale;
		this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
		this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
		this.vertexData[j+3] = ((colors[i].w & 0xff) * ByteToFloatScale)*lastAlpha[0];
	    }

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index for this object using data in <code>color</code>s
     * starting at index <code>start</code> for <code>length</code> colors.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     * @param start starting color index of data in <code>colors</code>.
     * @param length number of colors to be copied.
     */
    void setColors(int index, float colors[], int start, int length) {
        int offset = this.stride*index + colorOffset;
        int i, j;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
            for (i = start * 4, j = offset; i < (start + length) * 4;
		 i += 4, j += this.stride) {
                this.vertexData[j]   = colors[i];
                this.vertexData[j+1] = colors[i+1];
                this.vertexData[j+2] = colors[i+2];
                this.vertexData[j+3] = colors[i+3]*lastAlpha[0];
            }
        } else {
            for (i = start * 3, j = offset; i < (start + length) * 3;
		 i += 3, j += this.stride) {
                this.vertexData[j]   = colors[i];
                this.vertexData[j+1] = colors[i+1];
                this.vertexData[j+2] = colors[i+2];
                this.vertexData[j+3] = lastAlpha[0];
            }
        }

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index for this object using data in <code>color</code>s
     * starting at index <code>start</code> for <code>length</code> colors.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     * @param start starting color index of data in <code>colors</code>.
     * @param length number of colors to be copied.
     */
    void setColors(int index, byte colors[], int start, int length) {
        int offset = this.stride*index + colorOffset;
        int i, j;

        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
            for (i = start * 4, j = offset; i < (start + length) * 4;
		 i += 4, j += this.stride) {
                this.vertexData[j]   = (colors[i] & 0xff) * ByteToFloatScale;
                this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
                this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
                this.vertexData[j+3] = ((colors[i+3] & 0xff) * ByteToFloatScale)*lastAlpha[0];
            }
        } else {
            for (i = start * 3, j = offset; i < (start + length) * 3;
		 i += 3, j += this.stride) {
                this.vertexData[j]   = (colors[i] & 0xff) * ByteToFloatScale;
                this.vertexData[j+1] = (colors[i+1] & 0xff) * ByteToFloatScale;
                this.vertexData[j+2] = (colors[i+2] & 0xff) * ByteToFloatScale;
                this.vertexData[j+3] = lastAlpha[0];
            }
        }

        if(isLive) {
            geomLock.unLock();
	    sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index for this object using data in <code>color</code>s
     * starting at index <code>start</code> for <code>length</code> colors.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     * @param start starting color index of data in <code>colors</code>.
     * @param length number of colors to be copied.
     */
    void setColors(int index, Color3f colors[], int start, int length) {
        int offset = this.stride*index + colorOffset;
        int i, j;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = colors[i].x;
            this.vertexData[j+1] = colors[i].y;
            this.vertexData[j+2] = colors[i].z;
            this.vertexData[j+3] = lastAlpha[0];
        }

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index for this object using data in <code>color</code>s
     * starting at index <code>start</code> for <code>length</code> colors.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     * @param start starting color index of data in <code>colors</code>.
     * @param length number of colors to be copied.
     */
    void setColors(int index, Color4f colors[], int start, int length) {
        int offset = this.stride*index + colorOffset;
        int i, j;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = colors[i].x;
            this.vertexData[j+1] = colors[i].y;
            this.vertexData[j+2] = colors[i].z;
            this.vertexData[j+3] = colors[i].w*lastAlpha[0];
        }

        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index for this object using data in <code>color</code>s
     * starting at index <code>start</code> for <code>length</code> colors.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     * @param start starting color index of data in <code>colors</code>.
     * @param length number of colors to be copied.
     */
    void setColors(int index, Color3b colors[], int start, int length) {
        int offset = this.stride*index + colorOffset;
        int i, j;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = (colors[i].x & 0xff) * ByteToFloatScale;
            this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
            this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
            this.vertexData[j+3] = lastAlpha[0];
        }

        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the colors associated with the vertices starting at
     * the specified index for this object using data in <code>color</code>s
     * starting at index <code>start</code> for <code>length</code> colors.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values containing n new colors
     * @param start starting color index of data in <code>colors</code>.
     * @param length number of colors to be copied.
     */
    void setColors(int index, Color4b colors[], int start, int length) {
        int offset = this.stride*index + colorOffset;
        int i, j;
        boolean isLive = source!=null && source.isLive();
    	if(isLive){
            geomLock.getLock();
    	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
	    this.vertexData[j]   = (colors[i].x & 0xff) * ByteToFloatScale;
	    this.vertexData[j+1] = (colors[i].y & 0xff) * ByteToFloatScale;
	    this.vertexData[j+2] = (colors[i].z & 0xff) * ByteToFloatScale;
	    this.vertexData[j+3] = ((colors[i].w & 0xff) * ByteToFloatScale)*lastAlpha[0];
        }

	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the normal associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param normal the new normal
     */
    void setNormal(int index, float normal[]) {
	int offset = this.stride*index + normalOffset;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	this.vertexData[offset]   = normal[0];
	this.vertexData[offset+1] = normal[1];
	this.vertexData[offset+2] = normal[2];

        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the normal associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param normal the vector containing the new normal
     */
    void setNormal(int index, Vector3f normal) {
	int offset = this.stride*index + normalOffset;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	this.vertexData[offset]   = normal.x;
	this.vertexData[offset+1] = normal.y;
	this.vertexData[offset+2] = normal.z;

	if(isLive){
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the normals associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param normals the new normals
     */
    void setNormals(int index, float normals[]) {
	int offset = this.stride*index + normalOffset;
	int i, j, num = normals.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	for (i=0, j= offset;i < num;i += 3, j+= this.stride)
	    {
		this.vertexData[j]   = normals[i];
		this.vertexData[j+1] = normals[i+1];
		this.vertexData[j+2] = normals[i+2];
	    }
	if(isLive) {
		geomLock.unLock();
		sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the normals associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param normals the vector containing the new normals
     */
    void setNormals(int index, Vector3f normals[]) {
	int offset = this.stride*index + normalOffset;
	int i, j, num = normals.length;
	boolean isLive = source!=null && source.isLive();
	if(isLive){
	   geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	for (i=0, j= offset;i < num;i++, j+= this.stride)
	    {
		this.vertexData[j]   = normals[i].x;
		this.vertexData[j+1] = normals[i].y;
		this.vertexData[j+2] = normals[i].z;
	    }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the normals associated with the vertices starting at
     * the specified index for this object using data in <code>normals</code>
     * starting at index <code>start</code> and  ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param normals the new normals
     * @param start starting normal index of data in <code>colors</code>  .
     * @param length number of normals to be copied.
     */
    void setNormals(int index, float normals[], int start, int length) {
        int offset = this.stride*index + normalOffset;
        int i, j;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= NORMAL_CHANGED;
	for (i = start * 3, j = offset; i < (start + length) * 3;
	     i+=3, j += this.stride) {
	    this.vertexData[j]   = normals[i];
	    this.vertexData[j+1] = normals[i+1];
	    this.vertexData[j+2] = normals[i+2];
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }

    }

    /**
     * Sets the normals associated with the vertices starting at
     * the specified index for this object using data in <code>normals</code>
     * starting at index <code>start</code> and  ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param normals the new normals
     * @param start starting normal index of data in <code>colors</code>  .
     * @param length number of normals to be copied.
     */
    void setNormals(int index, Vector3f normals[], int start, int length) {
        int offset = this.stride*index + normalOffset;
        int i, j;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= NORMAL_CHANGED;
	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
	    this.vertexData[j]   = normals[i].x;
	    this.vertexData[j+1] = normals[i].y;
	    this.vertexData[j+2] = normals[i].z;
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }


    /**
     * Sets the texture coordinates associated with the vertices starting at
     * the specified index for this object using data in <code>texCoords</code>
     * starting at index <code>start</code> and ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param texCoords the new texture coordinates
     * @param start starting texture coordinate index of data in <code>texCoords</code>  .
     * @param length number of texture Coordinates to be copied.
     */
    void setTextureCoordinates(int texCoordSet, int index, float texCoords[],
				int start, int length) {

	if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
            throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));

        if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
            throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));

	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
        int i, j, k;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= TEXTURE_CHANGED;

	if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
            for (i = start * 4, j = offset, k = 0; k < length;
		 	j += this.stride, k++) {
                this.vertexData[j]   = texCoords[i++];
                this.vertexData[j+1] = texCoords[i++];
                this.vertexData[j+2] = texCoords[i++];
                this.vertexData[j+3] = texCoords[i++];
            }
	} else if ((this.vertexFormat &
			GeometryArray.TEXTURE_COORDINATE_3) != 0) {
            for (i = start * 3, j = offset, k = 0; k < length;
		 	j += this.stride, k++) {
                this.vertexData[j]   = texCoords[i++];
                this.vertexData[j+1] = texCoords[i++];
                this.vertexData[j+2] = texCoords[i++];
            }
        } else {
            for (i = start * 2, j = offset, k = 0; k < length;
		 	j += this.stride, k++) {
                this.vertexData[j]   = texCoords[i++];
                this.vertexData[j+1] = texCoords[i++];
            }
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the texture coordinates associated with the vertices starting at
     * the specified index for this object using data in <code>texCoords</code>
     * starting at index <code>start</code> and ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param texCoords the new texture coordinates
     * @param start starting texture coordinate index of data in <code>texCoords</code>  .
     * @param length number of texture Coordinates to be copied.
     */
    void setTextureCoordinates(int texCoordSet, int index, Point2f texCoords[],
				int start, int length) {

	if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
            throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));

        if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
            throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));

	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
        int i, j;

        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= TEXTURE_CHANGED;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = texCoords[i].x;
            this.vertexData[j+1] = texCoords[i].y;
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the texture coordinates associated with the vertices starting at
     * the specified index for this object using data in <code>texCoords</code>
     * starting at index <code>start</code> and ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param texCoords the new texture coordinates
     * @param start starting texture coordinate index of data in <code>texCoords</code>  .
     * @param length number of texture Coordinates to be copied.
     */
    void setTextureCoordinates(int texCoordSet, int index, Point3f texCoords[],
				int start, int length) {

	if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
            throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));

        if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
            throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));

	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
        int i, j;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= TEXTURE_CHANGED;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = texCoords[i].x;
            this.vertexData[j+1] = texCoords[i].y;
            this.vertexData[j+2] = texCoords[i].z;
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the texture coordinates associated with the vertices starting at
     * the specified index for this object using data in <code>texCoords</code>
     * starting at index <code>start</code> and ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param texCoords the new texture coordinates
     * @param start starting texture coordinate index of data in <code>texCoords</code>  .
     * @param length number of texture Coordinates to be copied.
     */
    void setTextureCoordinates(int texCoordSet, int index, TexCoord2f texCoords[],
				int start, int length) {
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= TEXTURE_CHANGED;
	if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
            throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));

        if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
            throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));

	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
        int i, j;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = texCoords[i].x;
            this.vertexData[j+1] = texCoords[i].y;
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}

    }

    /**
     * Sets the texture coordinates associated with the vertices starting at
     * the specified index for this object using data in <code>texCoords</code>
     * starting at index <code>start</code> and ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param texCoords the new texture coordinates
     * @param start starting texture coordinate index of data in <code>texCoords</code>  .
     * @param length number of texture Coordinates to be copied.
     */
    void setTextureCoordinates(int texCoordSet, int index,
				TexCoord3f texCoords[],
				int start, int length) {
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= TEXTURE_CHANGED;

	if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
            throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));

        if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
            throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));

	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
        int i, j;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = texCoords[i].x;
            this.vertexData[j+1] = texCoords[i].y;
            this.vertexData[j+2] = texCoords[i].z;
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}
    }

    /**
     * Sets the texture coordinates associated with the vertices starting at
     * the specified index for this object using data in <code>texCoords</code>
     * starting at index <code>start</code> and ending at index <code>start+length</code>.
     * @param index the vertex index
     * @param texCoords the new texture coordinates
     * @param start starting texture coordinate index of data in <code>texCoords</code>  .
     * @param length number of texture Coordinates to be copied.
     */
    void setTextureCoordinates(int texCoordSet, int index,
				TexCoord4f texCoords[],
				int start, int length) {
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= TEXTURE_CHANGED;

	if ((this.vertexFormat & GeometryArray.BY_REFERENCE) != 0)
            throw new IllegalStateException(J3dI18N.getString("GeometryArray82"));

        if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE ) == 0)
            throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray79"));

	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
        int i, j;

	for (i = start, j = offset; i < start+length; i++, j += this.stride) {
            this.vertexData[j]   = texCoords[i].x;
            this.vertexData[j+1] = texCoords[i].y;
            this.vertexData[j+2] = texCoords[i].z;
            this.vertexData[j+3] = texCoords[i].w;
        }
	if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}
    }


    /**
     * Sets the vertex attribute associated with the vertex at the
     * specified index in the specified vertex attribute number for
     * this object.
     *
     * @param vertexAttrNum vertex attribute number in this geometry array
     * @param index destination vertex index in this geometry array
     * @param vertexAttr the Point2f containing the new vertex attribute
     */
    void setVertexAttr(int vertexAttrNum, int index,
		       Point2f vertexAttr) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
	boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= VATTR_CHANGED;

	this.vertexData[offset] = vertexAttr.x;
	this.vertexData[offset+1] = vertexAttr.y;

        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }
    }

    /**
     * Sets the vertex attribute associated with the vertex at the
     * specified index in the specified vertex attribute number for
     * this object.
     *
     * @param vertexAttrNum vertex attribute number in this geometry array
     * @param index destination vertex index in this geometry array
     * @param vertexAttr the Point3f containing the new vertex attribute
     */
    void setVertexAttr(int vertexAttrNum, int index,
		       Point3f vertexAttr) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
	boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= VATTR_CHANGED;

	this.vertexData[offset] = vertexAttr.x;
	this.vertexData[offset+1] = vertexAttr.y;
	this.vertexData[offset+2] = vertexAttr.z;

	if (isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
	}
    }

    /**
     * Sets the vertex attribute associated with the vertex at the
     * specified index in the specified vertex attribute number for
     * this object.
     *
     * @param vertexAttrNum vertex attribute number in this geometry array
     * @param index destination vertex index in this geometry array
     * @param vertexAttr the Point4f containing the new vertex attribute
     */
    void setVertexAttr(int vertexAttrNum, int index,
		       Point4f vertexAttr) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
	boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= VATTR_CHANGED;

	this.vertexData[offset] = vertexAttr.x;
	this.vertexData[offset+1] = vertexAttr.y;
	this.vertexData[offset+2] = vertexAttr.z;
	this.vertexData[offset+3] = vertexAttr.w;

        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }
    }

    /**
     * Sets the vertex attributes associated with the vertices
     * starting at the specified index in the specified vertex
     * attribute number for this object using data in
     * <code>vertexAttrs</code> starting at index <code>start</code> and
     * ending at index <code>start+length</code>.
     *
     * @param index starting destination vertex index in this geometry array
     * @param vertexAttrs source array of 1*n, 2*n, 3*n, or 4*n values
     * containing n new vertex attributes
     * @param start starting source vertex index in <code>vertexAttrs</code>
     * array.
     * @param length number of vertex attributes to be copied.
     */
    void setVertexAttrs(int vertexAttrNum, int index,
			float[] vertexAttrs,
			int start, int length) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int size = vertexAttrSizes[vertexAttrNum];
        int i, j, k;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= VATTR_CHANGED;

        for (i = start * size, j = offset, k = 0; k < length; i += size, j += this.stride, k++) {
            for (int ii = 0; ii < size; ii++) {
                this.vertexData[j+ii] = vertexAttrs[i+ii];
            }
        }

        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }
    }

    /**
     * Sets the vertex attributes associated with the vertices
     * starting at the specified index in the specified vertex
     * attribute number for this object using data in
     * <code>vertexAttrs</code> starting at index <code>start</code> and
     * ending at index <code>start+length</code>.
     *
     * @param vertexAttrNum vertex attribute number in this geometry array
     * @param index starting destination vertex index in this geometry array
     * @param vertexAttrs source array of Point2f objects containing new
     * vertex attributes
     * @param start starting source vertex index in <code>vertexAttrs</code>
     * array.
     * @param length number of vertex attributes to be copied.
     */
    void setVertexAttrs(int vertexAttrNum, int index,
			Point2f[] vertexAttrs,
			int start, int length) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int i, j, k;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= VATTR_CHANGED;

        for (i = start, j = offset, k = 0; k < length; i++, j += this.stride, k++) {
	    this.vertexData[j] = vertexAttrs[i].x;
	    this.vertexData[j+1] = vertexAttrs[i].y;
        }
        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }
    }

    /**
     * Sets the vertex attributes associated with the vertices
     * starting at the specified index in the specified vertex
     * attribute number for this object using data in
     * <code>vertexAttrs</code> starting at index <code>start</code> and
     * ending at index <code>start+length</code>.
     *
     * @param vertexAttrNum vertex attribute number in this geometry array
     * @param index starting destination vertex index in this geometry array
     * @param vertexAttrs source array of Point3f objects containing new
     * vertex attributes
     * @param start starting source vertex index in <code>vertexAttrs</code>
     * array.
     * @param length number of vertex attributes to be copied.
     */
    void setVertexAttrs(int vertexAttrNum, int index,
			Point3f[] vertexAttrs,
			int start, int length) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int i, j, k;
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= VATTR_CHANGED;

        for (i = start, j = offset, k = 0; k < length; i++, j += this.stride, k++) {
	    this.vertexData[j] = vertexAttrs[i].x;
	    this.vertexData[j+1] = vertexAttrs[i].y;
	    this.vertexData[j+2] = vertexAttrs[i].z;
        }
        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }
    }

    /**
     * Sets the vertex attributes associated with the vertices
     * starting at the specified index in the specified vertex
     * attribute number for this object using data in
     * <code>vertexAttrs</code> starting at index <code>start</code> and
     * ending at index <code>start+length</code>.
     *
     * @param vertexAttrNum vertex attribute number in this geometry array
     * @param index starting destination vertex index in this geometry array
     * @param vertexAttrs source array of Point4f objects containing new
     * vertex attributes
     * @param start starting source vertex index in <code>vertexAttrs</code>
     * array.
     * @param length number of vertex attributes to be copied.
     */
    void setVertexAttrs(int vertexAttrNum, int index,
			Point4f[] vertexAttrs,
			int start, int length) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int i, j, k;

        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= VATTR_CHANGED;

        for (i = start, j = offset, k = 0; k < length; i++, j += this.stride, k++) {
	    this.vertexData[j] = vertexAttrs[i].x;
	    this.vertexData[j+1] = vertexAttrs[i].y;
	    this.vertexData[j+2] = vertexAttrs[i].z;
	    this.vertexData[j+3] = vertexAttrs[i].w;
        }
        if(isLive) {
            geomLock.unLock();
            sendDataChangedMessage(false);
        }
    }


    /**
     * Gets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate an array of 3 values that will receive the new coordinate
     */
    void getCoordinate(int index, float coordinate[]) {
	int offset = this.stride*index + coordinateOffset;

	coordinate[0]= this.vertexData[offset];
	coordinate[1]= this.vertexData[offset+1];
	coordinate[2]= this.vertexData[offset+2];
    }

    /**
     * Gets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate an array of 3 values that will receive the new coordinate
     */
    void getCoordinate(int index, double coordinate[]) {
	int offset = this.stride*index + coordinateOffset;

	coordinate[0]= (double)this.vertexData[offset];
	coordinate[1]= (double)this.vertexData[offset+1];
	coordinate[2]= (double)this.vertexData[offset+2];
    }

    /**
     * Gets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate a vector that will receive the new coordinate
     */
    void getCoordinate(int index, Point3f coordinate) {
	int offset = this.stride*index + coordinateOffset;

	coordinate.x = this.vertexData[offset];
	coordinate.y = this.vertexData[offset+1];
	coordinate.z = this.vertexData[offset+2];
    }

    /**
     * Gets the coordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param coordinate a vector that will receive the new coordinate
     */
    void getCoordinate(int index, Point3d coordinate) {
	int offset = this.stride*index + coordinateOffset;

	coordinate.x = (double)this.vertexData[offset];
	coordinate.y = (double)this.vertexData[offset+1];
	coordinate.z = (double)this.vertexData[offset+2];
    }

    /**
     * Gets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of 3*n values that will receive new coordinates
     */
    void getCoordinates(int index, float coordinates[]) {
	int offset = this.stride*index + coordinateOffset;
	int i, j, num = coordinates.length;

	for (i=0,j= offset;i < num;i +=3, j += this.stride)
	    {
		coordinates[i]  = this.vertexData[j];
		coordinates[i+1]= this.vertexData[j+1];
		coordinates[i+2]= this.vertexData[j+2];
	    }
    }


    /**
     * Gets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of 3*n values that will receive new coordinates
     */
    void getCoordinates(int index, double coordinates[]) {
	int offset = this.stride*index + coordinateOffset;
	int i, j, num = coordinates.length;

	for (i=0,j= offset;i < num;i +=3, j += this.stride)
	    {
		coordinates[i]  = (double)this.vertexData[j];
		coordinates[i+1]= (double)this.vertexData[j+1];
		coordinates[i+2]= (double)this.vertexData[j+2];
	    }
    }

    /**
     * Gets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of vectors that will receive new coordinates
     */
    void getCoordinates(int index, Point3f coordinates[]) {
	int offset = this.stride*index + coordinateOffset;
	int i, j, num = coordinates.length;

	for (i=0,j= offset;i < num;i++, j += this.stride)
	    {
		coordinates[i].x  = this.vertexData[j];
		coordinates[i].y  = this.vertexData[j+1];
		coordinates[i].z  = this.vertexData[j+2];
	    }
    }

    /**
     * Gets the coordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param coordinates an array of vectors that will receive new coordinates
     */
    void getCoordinates(int index, Point3d coordinates[]) {
	int offset = this.stride*index + coordinateOffset;
	int i, j, num = coordinates.length;

	for (i=0,j= offset;i < num;i++, j += this.stride)
	    {
		coordinates[i].x  = (double)this.vertexData[j];
		coordinates[i].y  = (double)this.vertexData[j+1];
		coordinates[i].z  = (double)this.vertexData[j+2];
	    }
    }

    /**
     * Gets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color an array of 3 or 4 values that will receive the new color
     */
    void getColor(int index, float color[]) {
	int offset = this.stride*index + colorOffset;

	color[0]= this.vertexData[offset];
	color[1]= this.vertexData[offset+1];
	color[2]= this.vertexData[offset+2];
	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    color[3]= this.vertexData[offset+3]/lastAlpha[0];
    }

    /**
     * Gets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color an array of 3 or 4 values that will receive the new color
     */
    void getColor(int index, byte color[]) {
	int offset = this.stride*index + colorOffset;

	color[0]= (byte)(this.vertexData[offset] * FloatToByteScale);
	color[1]= (byte)(this.vertexData[offset+1] * FloatToByteScale);
	color[2]= (byte)(this.vertexData[offset+2] * FloatToByteScale);
	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    color[3]= (byte)((this.vertexData[offset+3]/lastAlpha[0]) * FloatToByteScale);
    }

    /**
     * Gets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector that will receive the new color
     */
    void getColor(int index, Color3f color) {
	int offset = this.stride*index + colorOffset;

	color.x = this.vertexData[offset];
	color.y = this.vertexData[offset+1];
	color.z = this.vertexData[offset+2];
    }

    /**
     * Gets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector that will receive the new color
     */
    void getColor(int index, Color4f color) {
	int offset = this.stride*index + colorOffset;

	color.x = this.vertexData[offset];
	color.y = this.vertexData[offset+1];
	color.z = this.vertexData[offset+2];
	color.w= this.vertexData[offset+3]/lastAlpha[0];
    }

    /**
     * Gets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector that will receive the new color
     */
    void getColor(int index, Color3b color) {
	int offset = this.stride*index + colorOffset;

	color.x = (byte)(this.vertexData[offset] * FloatToByteScale);
	color.y = (byte)(this.vertexData[offset+1] * FloatToByteScale);
	color.z = (byte)(this.vertexData[offset+2] * FloatToByteScale);
    }

    /**
     * Gets the color associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param color a vector that will receive the new color
     */
    void getColor(int index, Color4b color) {
	int offset = this.stride*index + colorOffset;

	color.x = (byte)(this.vertexData[offset] * FloatToByteScale);
	color.y = (byte)(this.vertexData[offset+1] * FloatToByteScale);
	color.z = (byte)(this.vertexData[offset+2] * FloatToByteScale);
	color.w = (byte)((this.vertexData[offset+3]/lastAlpha[0]) * FloatToByteScale);
    }

    /**
     * Gets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values that will receive n new colors
     */
    void getColors(int index, float colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;
	float val = 1.0f/lastAlpha[0];

	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    {
		for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
		    {
			colors[i]  = this.vertexData[j];
			colors[i+1]= this.vertexData[j+1];
			colors[i+2]= this.vertexData[j+2];
			colors[i+3]= this.vertexData[j+3] * val;
		    }
	    }
	else
	    {
		for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
		    {
			colors[i]  = this.vertexData[j];
			colors[i+1]= this.vertexData[j+1];
			colors[i+2]= this.vertexData[j+2];
		    }
	    }
    }

    /**
     * Gets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of 3*n or 4*n values that will receive new colors
     */
    void getColors(int index, byte colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;
	float val = 1.0f/lastAlpha[0];


	if ((this.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
	    {
		for (i=0, j= offset;i < num; i+= 4, j+= this.stride)
		    {
			colors[i]  = (byte)(this.vertexData[j] * FloatToByteScale);
			colors[i+1]= (byte)(this.vertexData[j+1] * FloatToByteScale);
			colors[i+2]= (byte)(this.vertexData[j+2] * FloatToByteScale);
			colors[i+3]= (byte)((this.vertexData[j+3] * val) * FloatToByteScale);
		    }
	    }
	else
	    {
		for (i=0, j= offset;i < num; i+= 3, j+= this.stride)
		    {
			colors[i]  = (byte)(this.vertexData[j] * FloatToByteScale);
			colors[i+1]= (byte)(this.vertexData[j+1] * FloatToByteScale);
			colors[i+2]= (byte)(this.vertexData[j+2] * FloatToByteScale);
		    }
	    }
    }

    /**
     * Gets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors that will receive new colors
     */
    void getColors(int index, Color3f colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		colors[i].x  = this.vertexData[j];
		colors[i].y  = this.vertexData[j+1];
		colors[i].z  = this.vertexData[j+2];
	    }
    }

    /**
     * Gets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors that will receive new colors
     */
    void getColors(int index, Color4f colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;
	float val = 1.0f/lastAlpha[0];

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		colors[i].x  = this.vertexData[j];
		colors[i].y  = this.vertexData[j+1];
		colors[i].z  = this.vertexData[j+2];
		colors[i].w  = this.vertexData[j+3] * val;
	    }
    }

    /**
     * Gets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors that will receive new colors
     */
    void getColors(int index, Color3b colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		colors[i].x  = (byte)(this.vertexData[j] * FloatToByteScale);
		colors[i].y  = (byte)(this.vertexData[j+1] * FloatToByteScale);
		colors[i].z  = (byte)(this.vertexData[j+2] * FloatToByteScale);
	    }
    }

    /**
     * Gets the colors associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param colors an array of vectors that will receive new colors
     */
    void getColors(int index, Color4b colors[]) {
	int offset = this.stride*index + colorOffset;
	int i, j, num = colors.length;
	float val = 1.0f/lastAlpha[0];

	for (i=0, j= offset;i < num; i++, j+= this.stride)
	    {
		colors[i].x  = (byte)(this.vertexData[j] * FloatToByteScale);
		colors[i].y  = (byte)(this.vertexData[j+1] * FloatToByteScale);
		colors[i].z  = (byte)(this.vertexData[j+2] * FloatToByteScale);
		colors[i].w  = (byte)(this.vertexData[j+3] * val * FloatToByteScale);
	    }
    }

    /**
     * Gets the normal associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param normal array that will receive the new normal
     */
    void getNormal(int index, float normal[]) {
	int offset = this.stride*index + normalOffset;

	normal[0]= this.vertexData[offset];
	normal[1]= this.vertexData[offset+1];
	normal[2]= this.vertexData[offset+2];
    }

    /**
     * Gets the normal associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param normal the vector that will receive the new normal
     */
    void getNormal(int index, Vector3f normal) {
	int offset = this.stride*index + normalOffset;

	normal.x= this.vertexData[offset];
	normal.y= this.vertexData[offset+1];
	normal.z= this.vertexData[offset+2];
    }

    /**
     * Gets the normals associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param normals array that will receive the new normals
     */
    void getNormals(int index, float normals[]) {
	int offset = this.stride*index + normalOffset;
	int i, j, num = normals.length;

	for (i=0, j= offset;i < num;i+=3, j+= this.stride)
	    {
		normals[i]  = this.vertexData[j];
		normals[i+1]= this.vertexData[j+1];
		normals[i+2]= this.vertexData[j+2];
	    }
    }

    /**
     * Gets the normals associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param normals the vector that will receive the new normals
     */
    void getNormals(int index, Vector3f normals[]) {
	int offset = this.stride*index + normalOffset;
	int i, j, num = normals.length;

	for (i=0, j= offset;i < num;i++, j+= this.stride)
	    {
		normals[i].x= this.vertexData[j];
		normals[i].y= this.vertexData[j+1];
		normals[i].z= this.vertexData[j+2];
	    }
    }

    /**
     * Gets the texture co-ordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param texCoord array that will receive the new texture co-ordinate
     */
    void getTextureCoordinate(int texCoordSet, int index, float texCoord[]) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;

	texCoord[0]= this.vertexData[offset];
	texCoord[1]= this.vertexData[offset+1];
	if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
	    texCoord[2]= this.vertexData[offset+2];

	} else if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4)
				!= 0) {
	    texCoord[2]= this.vertexData[offset+2];
	    texCoord[3]= this.vertexData[offset+3];
	}
    }

    /**
     * Gets the texture co-ordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param texCoord the vector that will receive the new texture co-ordinates
     */
    void getTextureCoordinate(int texCoordSet, int index, TexCoord2f texCoord) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;

	texCoord.x= this.vertexData[offset];
	texCoord.y= this.vertexData[offset+1];
    }

    /**
     * Gets the texture co-ordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param texCoord the vector that will receive the new texture co-ordinates
     */
    void getTextureCoordinate(int texCoordSet, int index, TexCoord3f texCoord) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;

	texCoord.x= this.vertexData[offset];
	texCoord.y= this.vertexData[offset+1];
	texCoord.z= this.vertexData[offset+2];
    }

    /**
     * Gets the texture co-ordinate associated with the vertex at
     * the specified index.
     * @param index the vertex index
     * @param texCoord the vector that will receive the new texture co-ordinates
     */
    void getTextureCoordinate(int texCoordSet, int index, TexCoord4f texCoord) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;

	texCoord.x= this.vertexData[offset];
	texCoord.y= this.vertexData[offset+1];
	texCoord.z= this.vertexData[offset+2];
	texCoord.w= this.vertexData[offset+3];
    }

    /**
     * Gets the texture co-ordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param texCoords array that will receive the new texture co-ordinates
     */
    void getTextureCoordinates(int texCoordSet, int index, float texCoords[]) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
	int i, j, num = texCoords.length;

	if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
		for (i=0, j= offset;i < num;i+=4, j+= this.stride)
		    {
			texCoords[i]= this.vertexData[j];
			texCoords[i+1]= this.vertexData[j+1];
			texCoords[i+2]= this.vertexData[j+2];
			texCoords[i+3]= this.vertexData[j+3];
		    }
	} else if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE_3)
				!= 0) {
		for (i=0, j= offset;i < num;i+=3, j+= this.stride)
		    {
			texCoords[i]= this.vertexData[j];
			texCoords[i+1]= this.vertexData[j+1];
			texCoords[i+2]= this.vertexData[j+2];
		    }
	} else {
		for (i=0, j= offset;i < num;i+=2, j+= this.stride)
		    {
			texCoords[i]= this.vertexData[j];
			texCoords[i+1]= this.vertexData[j+1];
		    }
	}
    }

    /**
     * Gets the texture co-ordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param texCoords the vector that will receive the new texture co-ordinates
     */
    void getTextureCoordinates(int texCoordSet, int index,
					TexCoord2f texCoords[]) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
	int i, j, num = texCoords.length;

	for (i=0, j= offset;i < num;i++, j+= this.stride)
	    {
		texCoords[i].x= this.vertexData[j];
		texCoords[i].y= this.vertexData[j+1];
	    }
    }

    /**
     * Gets the texture co-ordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param texCoords the vector that will receive the new texture co-ordinates
     */
    void getTextureCoordinates(int texCoordSet, int index, TexCoord3f texCoords[]) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
	int i, j, num = texCoords.length;

	for (i=0, j= offset;i < num;i++, j+= this.stride)
	    {
		texCoords[i].x= this.vertexData[j];
		texCoords[i].y= this.vertexData[j+1];
		texCoords[i].z= this.vertexData[j+2];
	    }
    }

    /**
     * Gets the texture co-ordinates associated with the vertices starting at
     * the specified index.
     * @param index the vertex index
     * @param texCoords the vector that will receive the new texture co-ordinates
     */
    void getTextureCoordinates(int texCoordSet, int index, TexCoord4f texCoords[]) {
	int offset = this.stride*index + textureOffset +
			texCoordSet * texCoordStride;
	int i, j, num = texCoords.length;

	for (i=0, j= offset;i < num;i++, j+= this.stride)
	    {
		texCoords[i].x= this.vertexData[j];
		texCoords[i].y= this.vertexData[j+1];
		texCoords[i].z= this.vertexData[j+2];
		texCoords[i].w= this.vertexData[j+3];
	    }
    }

    void getTextureCoordinates(int texCoordSet, int index,
                                        Point2f texCoords[]) {
        int offset = this.stride*index + textureOffset +
                        texCoordSet * texCoordStride;
        int i, j, num = texCoords.length;

        for (i=0, j= offset;i < num;i++, j+= this.stride)
            {
                texCoords[i].x= this.vertexData[j];
                texCoords[i].y= this.vertexData[j+1];
            }
    }

    void getTextureCoordinates(int texCoordSet, int index, Point3f texCoords[]) {
        int offset = this.stride*index + textureOffset +
                        texCoordSet * texCoordStride;
        int i, j, num = texCoords.length;

        for (i=0, j= offset;i < num;i++, j+= this.stride)
            {
                texCoords[i].x= this.vertexData[j];
                texCoords[i].y= this.vertexData[j+1];
                texCoords[i].z= this.vertexData[j+2];
            }
    }


    /**
     * Gets the vertex attribute associated with the vertex at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttr(int vertexAttrNum, int index,
			      float[] vertexAttr) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int size = vertexAttrSizes[vertexAttrNum];

	for (int i = 0; i < size; i++) {
	    vertexAttr[i] = this.vertexData[offset+i];

        }

    }

    /**
     * Gets the vertex attribute associated with the vertex at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttr(int vertexAttrNum, int index,
			      Point2f vertexAttr) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];

	vertexAttr.x = this.vertexData[offset];
	vertexAttr.y = this.vertexData[offset+1];

    }

    /**
     * Gets the vertex attribute associated with the vertex at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttr(int vertexAttrNum, int index,
			      Point3f vertexAttr) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];

	vertexAttr.x = this.vertexData[offset];
	vertexAttr.y = this.vertexData[offset+1];
	vertexAttr.z = this.vertexData[offset+2];

    }

    /**
     * Gets the vertex attribute associated with the vertex at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttr(int vertexAttrNum, int index,
			      Point4f vertexAttr) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];

	vertexAttr.x = this.vertexData[offset];
	vertexAttr.y = this.vertexData[offset+1];
	vertexAttr.z = this.vertexData[offset+2];
	vertexAttr.w = this.vertexData[offset+3];

    }

    /**
     * Gets the vertex attributes associated with the vertices starting at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttrs(int vertexAttrNum, int index,
			       float[] vertexAttrs) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int size = vertexAttrSizes[vertexAttrNum];
        int i, j, k;

        for (i = 0, j = offset;
	     ((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
	     i += size, j += this.stride) {
            for (k = 0; k < size; k++) {
                vertexAttrs[i+k] = this.vertexData[j+k];
            }
        }

    }

    /**
     * Gets the vertex attributes associated with the vertices starting at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttrs(int vertexAttrNum, int index,
			       Point2f[] vertexAttrs) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int i, j;

        for (i = 0, j = offset;
	     ((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
	     i++, j += this.stride) {
	    vertexAttrs[i].x = this.vertexData[j];
	    vertexAttrs[i].y = this.vertexData[j+1];
        }

    }

    /**
     * Gets the vertex attributes associated with the vertices starting at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttrs(int vertexAttrNum, int index,
			       Point3f[] vertexAttrs) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int i, j;

        for (i = 0, j = offset;
	     ((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
	     i++, j += this.stride) {
	    vertexAttrs[i].x = this.vertexData[j];
	    vertexAttrs[i].y = this.vertexData[j+1];
	    vertexAttrs[i].z = this.vertexData[j+2];
        }

    }

    /**
     * Gets the vertex attributes associated with the vertices starting at
     * the specified index in the specified vertex attribute number
     * for this object.
     */
    public void getVertexAttrs(int vertexAttrNum, int index,
			       Point4f[] vertexAttrs) {

	int offset = this.stride*index + vertexAttrOffsets[vertexAttrNum];
        int i, j;

        for (i = 0, j = offset;
	     ((i < vertexAttrs.length) && (j < this.vertexData.length)) ;
	     i++, j += this.stride) {
	    vertexAttrs[i].x = this.vertexData[j];
	    vertexAttrs[i].y = this.vertexData[j+1];
	    vertexAttrs[i].z = this.vertexData[j+2];
	    vertexAttrs[i].w = this.vertexData[j+3];
        }

    }


    /**
     * Updates geometry array data.
     */
    void updateData(GeometryUpdater updater) {
	boolean nullGeo = false;

 	// Add yourself to obtain the geometry lock
 	// and Thread.currentThread().sleep until you get the lock
 	geomLock.getLock();

	inUpdater = true;
	updater.updateData((Geometry)source);
	inUpdater = false;
	if ((vertexFormat & GeometryArray.BY_REFERENCE) != 0) {
	    if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
		// XXXX: handle the nio buffer
		if (!(this instanceof IndexedGeometryArrayRetained) ||
		    (vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) != 0) {
		    if (((vertexFormat & GeometryArray.INTERLEAVED) != 0)) {
			setupMirrorInterleavedColorPointer(false);
			nullGeo = (interleavedFloatBufferImpl == null);
		    }
		    else {
			setupMirrorColorPointer((vertexType & COLOR_DEFINED), false);
			nullGeo = ((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0);
		    }
		}
	    }
	    else {
		if (!(this instanceof IndexedGeometryArrayRetained) ||
		    (vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) != 0) {
		    if (((vertexFormat & GeometryArray.INTERLEAVED) != 0)) {
			setupMirrorInterleavedColorPointer(false);
			nullGeo = (interLeavedVertexData == null);
		    }
		    else {
			setupMirrorVertexPointer(vertexType & VERTEX_DEFINED);
			setupMirrorColorPointer((vertexType & COLOR_DEFINED), false);
			setupMirrorNormalPointer(vertexType & NORMAL_DEFINED);
			setupMirrorTexCoordPointer(texCoordType);
                        setupMirrorVertexAttrPointer(vertexAttrType);
			nullGeo = ((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0);
		    }
		}
	    }

            //NVaidya
            // User may or may not have changed indices in updater callback.
            // We need to presume that the user may indeed have and, thus, will
            // need to recompute maxCoordIndex unconditionally while
            // geomLock is still locked.
            if ((vertexFormat & GeometryArray.BY_REFERENCE_INDICES) != 0) {
                assert (this instanceof IndexedGeometryArrayRetained);

                if (((IndexedGeometryArrayRetained)this).getCoordIndicesRef() == null) {
                    nullGeo = true;
                }
                ((IndexedGeometryArrayRetained)this).doPostUpdaterUpdate();
            }
	}

        dirtyFlag |= VERTEX_CHANGED;
	colorChanged = 0xffff;
	geomLock.unLock();

	if (source != null && source.isLive()) {
	    processCoordsChanged(nullGeo);
	    sendDataChangedMessage(true);
	}
    }

    boolean intersectBoundingBox( Point3d coordinates[],
				  BoundingBox box,
				  double dist[],
				  Point3d iPnt) {
	int i;
	int out[] = new int[6];

	//Do trivial vertex test.
	for(i=0; i<6; i++)
	    out[i] = 0;
	for(i=0; i<coordinates.length; i++) {
	    if((coordinates[i].x >= box.lower.x) && (coordinates[i].x <= box.upper.x) &&
	       (coordinates[i].y >= box.lower.y) && (coordinates[i].y <= box.upper.y) &&
	       (coordinates[i].z >= box.lower.z) && (coordinates[i].z <= box.upper.z))
		// We're done! It's inside the boundingbox.
		return true;
	    else {
		if(coordinates[i].x < box.lower.x)
		    out[0]++; // left
		if(coordinates[i].y < box.lower.y)
		    out[1]++; // bottom
		if(coordinates[i].z < box.lower.z)
		    out[2]++; // back
		if(coordinates[i].x > box.upper.x)
		    out[3]++; // right
		if(coordinates[i].y > box.upper.y)
		    out[4]++; // top
		if(coordinates[i].z > box.upper.z)
		    out[5]++; // front
	    }

	}

	if((out[0] == coordinates.length) || (out[1] == coordinates.length) ||
	   (out[2] == coordinates.length) || (out[3] == coordinates.length) ||
	   (out[4] == coordinates.length) || (out[5] == coordinates.length))
	    // we're done. primitive is outside of boundingbox.
	    return false;

	// Setup bounding planes.
	Point3d pCoor[] = new Point3d[4];
	for(i=0; i<4; i++)
	    pCoor[i] = new Point3d();

	Point3d boxCenter = new Point3d();
	box.getCenter(boxCenter);

	// left plane.
	pCoor[0].set(box.lower.x, box.lower.y, box.lower.z);
	pCoor[1].set(box.lower.x, box.lower.y, box.upper.z);
	pCoor[2].set(box.lower.x, box.upper.y, box.upper.z);
	pCoor[3].set(box.lower.x, box.upper.y, box.lower.z);


	if (intersectPolygon(pCoor, coordinates)) {
	    if (dist != null) {
			computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
	    }
	    return true;
	}

	// right plane.
	pCoor[0].set(box.upper.x, box.lower.y, box.lower.z);
	pCoor[1].set(box.upper.x, box.upper.y, box.lower.z);
	pCoor[2].set(box.upper.x, box.upper.y, box.upper.z);
	pCoor[3].set(box.upper.x, box.lower.y, box.upper.z);
	if (intersectPolygon(pCoor, coordinates)) {
	    if (dist != null) {
			computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
	    }
	    return true;
	}

	// bottom plane.
	pCoor[0].set(box.upper.x, box.lower.y, box.upper.z);
	pCoor[1].set(box.lower.x, box.lower.y, box.upper.z);
	pCoor[2].set(box.lower.x, box.lower.y, box.lower.z);
	pCoor[3].set(box.upper.x, box.lower.y, box.lower.z);
	if (intersectPolygon(pCoor, coordinates)) {
	    if (dist != null) {
			computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
	    }
	    return true;
	}
	// top plane.
	pCoor[0].set(box.upper.x, box.upper.y, box.upper.z);
	pCoor[1].set(box.upper.x, box.upper.y, box.lower.z);
	pCoor[2].set(box.lower.x, box.upper.y, box.lower.z);
	pCoor[3].set(box.lower.x, box.upper.y, box.upper.z);
	if (intersectPolygon(pCoor, coordinates)) {
	    if (dist != null) {
			computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
	    }
	    return true;
	}

	// front plane.
	pCoor[0].set(box.upper.x, box.upper.y, box.upper.z);
	pCoor[1].set(box.lower.x, box.upper.y, box.upper.z);
	pCoor[2].set(box.lower.x, box.lower.y, box.upper.z);
	pCoor[3].set(box.upper.x, box.lower.y, box.upper.z);
	if (intersectPolygon(pCoor, coordinates)) {
	    if (dist != null) {
			computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
	    }
	    return true;
	}

	// back plane.
	pCoor[0].set(box.upper.x, box.upper.y, box.lower.z);
	pCoor[1].set(box.upper.x, box.lower.y, box.lower.z);
	pCoor[2].set(box.lower.x, box.lower.y, box.lower.z);
	pCoor[3].set(box.lower.x, box.upper.y, box.lower.z);
	if (intersectPolygon(pCoor, coordinates)) {
	    if (dist != null) {
			computeMinDistance(pCoor, boxCenter, null, dist, iPnt);
	    }
	    return true;
	}
	return false;
    }


    boolean intersectBoundingSphere(Point3d coordinates[],
				    BoundingSphere sphere,
				    double dist[],
				    Point3d iPnt)
    {
	int i, j;
	Vector3d tempV3D = new Vector3d();
	boolean esFlag;

	//Do trivial vertex test.

	for (i=0; i<coordinates.length; i++) {
	    tempV3D.x = coordinates[i].x - sphere.center.x;
	    tempV3D.y = coordinates[i].y - sphere.center.y;
	    tempV3D.z = coordinates[i].z - sphere.center.z;

	    if (tempV3D.length() <= sphere.radius) {
		// We're done! It's inside the boundingSphere.
		if (dist != null) {
		    computeMinDistance(coordinates,
				       sphere.getCenter(),
				       null, dist, iPnt);
		}

		return true;
	    }
	}

	for (i=0; i<coordinates.length; i++) {
	    if (i < (coordinates.length-1))
		esFlag = edgeIntersectSphere(sphere, coordinates[i],
					     coordinates[i+1]);
	    else
		esFlag = edgeIntersectSphere(sphere, coordinates[i],
					     coordinates[0]);
	    if (esFlag == true) {
		if (dist != null) {
		    computeMinDistance(coordinates,
				       sphere.getCenter(),
				       null,
				       dist, iPnt);
		}

		return true;
	    }
	}


	if (coordinates.length < 3) {
	    return false; // We're done with line.
	}

	    // Find rho.
	    // Compute plane normal.
	    Vector3d vec0 = new Vector3d(); // Edge vector from point 0 to point 1;
	    Vector3d vec1 = new Vector3d(); // Edge vector from point 0 to point 2 or 3;
	    Vector3d pNrm = new Vector3d();
	    Vector3d pa = new Vector3d();
	    Point3d q = new Point3d();
	    double nLenSq, pqLen, pNrmDotPa, tq;

	    // compute plane normal for coordinates.
	    for(i=0; i<coordinates.length-1;) {
		vec0.x = coordinates[i+1].x - coordinates[i].x;
		vec0.y = coordinates[i+1].y - coordinates[i].y;
		vec0.z = coordinates[i+1].z - coordinates[i++].z;
		if(vec0.length() > 0.0)
		    break;
	    }

	    for(j=i; j<coordinates.length-1; j++) {
		vec1.x = coordinates[j+1].x - coordinates[j].x;
		vec1.y = coordinates[j+1].y - coordinates[j].y;
		vec1.z = coordinates[j+1].z - coordinates[j].z;
		if(vec1.length() > 0.0)
		    break;
	    }

	    if(j == (coordinates.length-1)) {
		// System.err.println("(1) Degenerate polygon.");
		return false;  // Degenerate polygon.
	    }

	    /*
	      for(i=0; i<coordinates.length; i++)
	      System.err.println("coordinates P" + i + " " + coordinates[i]);
	      for(i=0; i<coord2.length; i++)
	      System.err.println("coord2 P" + i + " " + coord2[i]);
	      */

	    pNrm.cross(vec0,vec1);

	    nLenSq = pNrm.lengthSquared();
	    if( nLenSq == 0.0) {
		// System.err.println("(2) Degenerate polygon.");
		return false;  // Degenerate polygon.
	    }

	    pa.x = coordinates[0].x - sphere.center.x;
	    pa.y = coordinates[0].y - sphere.center.y;
	    pa.z = coordinates[0].z - sphere.center.z;

	    pNrmDotPa = pNrm.dot(pa);

	    pqLen = Math.sqrt(pNrmDotPa * pNrmDotPa/ nLenSq);

	    if(pqLen > sphere.radius) {
		return false;
	    }

	    tq = pNrmDotPa / nLenSq;

	    q.x = sphere.center.x + tq * pNrm.x;
	    q.y = sphere.center.y + tq * pNrm.y;
	    q.z = sphere.center.z + tq * pNrm.z;

	    // PolyPnt2D Test.
	    if (pointIntersectPolygon2D( pNrm, coordinates, q)) {
		if (dist != null) {
		    computeMinDistance(coordinates,
				       sphere.getCenter(),
				       pNrm,
				       dist, iPnt);
		}
		return true;
	    }
	    return false;

    }


    boolean intersectBoundingPolytope(Point3d coordinates[],
				      BoundingPolytope polytope,
				      double dist[],
				      Point3d iPnt)
    {
	boolean debug = false;

	Point4d tP4d = new Point4d();

	// this is a multiplier to the halfplane distance coefficients
	double distanceSign = -1.0;

	    if(coordinates.length == 2) {
		// we'll handle line separately.
		if (polytope.intersect( coordinates[0],
					coordinates[1], tP4d)) {
			if (dist != null) {
				polytope.getCenter(iPnt);

				double x = tP4d.x - iPnt.x;
				double y = tP4d.y - iPnt.y;
				double z = tP4d.z - iPnt.z;
				dist[0] = Math.sqrt(x * x + y * y + z * z);
				iPnt.x = tP4d.x;
				iPnt.y = tP4d.y;
				iPnt.z = tP4d.z;
			}
		    return true;
		}
		return false;
	    }

	    // It is a triangle or a quad.

	    // first test to see if any of the coordinates are all inside of the
	    // intersection polytope's half planes
	    // essentially do a matrix multiply of the constraintMatrix K*3 with
	    // the input coordinates 3*1 = K*1 vector

	    if (debug) {
		System.err.println("The value of the input vertices are: ");
		for(int i=0; i < coordinates.length; i++) {
		    System.err.println("The " +i+ " th vertex is: " + coordinates[i]);
		}

		System.err.println("The value of the input bounding Polytope's planes =");
		for(int i=0; i < polytope.planes.length; i++) {
		    System.err.println("The " +i+ " th plane is: " + polytope.planes[i]);
		}

	    }

	    // the direction for the intersection cost function
	    double centers[] = new double[4];
	    centers[0] = 0.8; centers[1] = 0.9; centers[2] = 1.1; centers[3] = 1.2;

	    boolean intersection = true;
	    boolean PreTest = false;

	    if(PreTest) {
		// for each coordinate, test it with each half plane
		for( int i=0; i < coordinates.length; i++) {
		    for (int j=0; j < polytope.planes.length; j++) {
			if ( ( polytope.planes[j].x * coordinates[i].x +
			       polytope.planes[j].y * coordinates[i].y +
			       polytope.planes[j].z*coordinates[i].z) <=
			     (distanceSign)*polytope.planes[j].w){
			    // the point satisfies this particular hyperplane
			    intersection = true;
			} else {
			    // the point fails this hyper plane try with a new hyper plane
			    intersection = false;
			    break;
			}
		    }
		    if(intersection) {
			// a point was found to be completely inside the bounding hull
			if (dist != null) {
			    computeMinDistance(coordinates,
					       polytope.getCenter(),
					       null,
					       dist, iPnt);
			}
			return true;
		    }
		}
	    }  // end of pretest

	    // at this point all points are outside of the bounding hull
	    // build the problem tableau for the linear program

	    int numberCols = polytope.planes.length + 2 + coordinates.length + 1;
	    int numberRows = 1 + coordinates.length;

	    double problemTableau[][] = new double[numberRows][numberCols];

	    // compute -Mtrans = -A*P

	    for( int i = 0; i < polytope.planes.length; i++) {
		for( int j=0; j < coordinates.length;  j++) {
		    problemTableau[j][i] = (-1.0)* (polytope.planes[i].x*coordinates[j].x+
						    polytope.planes[i].y*coordinates[j].y+
						    polytope.planes[i].z*coordinates[j].z);
		}
	    }

	    // add the other rows
	    for(int i = 0; i < coordinates.length; i++) {
		problemTableau[i][polytope.planes.length] = -1.0;
		problemTableau[i][polytope.planes.length + 1] =  1.0;

		for(int j=0; j < coordinates.length; j++) {
		    if ( i==j ) {
			problemTableau[i][j + polytope.planes.length + 2] = 1.0;
		    } else {
			problemTableau[i][j + polytope.planes.length + 2] = 0.0;
		    }

		    // place the last column elements the Ci's
		    problemTableau[i][numberCols - 1] = centers[i];
		}
	    }

	    // place the final rows value
	    for(int j = 0; j < polytope.planes.length; j++) {
		problemTableau[numberRows - 1][j] =
		    (distanceSign)*polytope.planes[j].w;
	    }
	    problemTableau[numberRows - 1][polytope.planes.length] =  1.0;
	    problemTableau[numberRows - 1][polytope.planes.length+1] = -1.0;
	    for(int j = 0; j < coordinates.length; j++) {
		problemTableau[numberRows - 1][polytope.planes.length+2+j] = 0.0;
	    }

	    if(debug) {
		System.err.println("The value of the problem tableau is: " );
		for(int i=0; i < problemTableau.length; i++) {
		    for(int j=0; j < problemTableau[0].length; j++) {
			System.err.print(problemTableau[i][j] + "  ");
		    }
		    System.err.println();
		}
	    }

	    double distance = generalStandardSimplexSolver(problemTableau,
							   Float.NEGATIVE_INFINITY);
	    if(debug) {
		System.err.println("The value returned by the general standard simplex = " +
				   distance);
	    }
	    if (distance == Float.POSITIVE_INFINITY) {
		return false;
	    }
	    if (dist != null) {
		computeMinDistance(coordinates,
				   polytope.getCenter(),
				   null,
				   dist, iPnt);
	    }
	    return true;

	}


    // optimized version using arrays of doubles, but using the standard simplex
    // method to solve the LP tableau.  This version has not been optimized to
    // work with a particular size input tableau and is much slower than some
    // of the other variants...supposedly
    double generalStandardSimplexSolver(double problemTableau[][],
					double stopingValue) {
	boolean debug = false;
	int numRow = problemTableau.length;
	int numCol = problemTableau[0].length;
	boolean optimal = false;
	int i, pivotRowIndex, pivotColIndex;
	double maxElement, element, endElement, ratio, prevRatio;
	double multiplier;

	if(debug) {
	    System.err.println("The number of rows is : " + numRow);
	    System.err.println("The number of columns is : " + numCol);
	}

	// until the optimal solution is found continue to do
	// iterations of the simplex method
	while(!optimal) {

	    if(debug) {
		System.err.println("input problem tableau is:");
		for(int k=0; k < numRow; k++) {
		    for(int j=0; j < numCol; j++) {
			System.err.println("kth, jth value is:" +k+" "+j+" : " +
					   problemTableau[k][j]);
		    }
		}
	    }

	    // test to see if the current solution is optimal
	    // check all bottom row elements except the right most one and
	    // if all positive or zero its optimal
	    for(i = 0, maxElement = 0, pivotColIndex = -1; i < numCol - 1; i++) {
		// a bottom row element
		element = problemTableau[numRow - 1][i];
		if( element < maxElement) {
		    maxElement = element;
		    pivotColIndex = i;
		}
	    }

	    // if there is no negative non-zero element then we
	    // have found an optimal solution (the last row of the tableau)
	    if(pivotColIndex == -1) {
		// found an optimal solution
		//System.err.println("Found an optimal solution");
		optimal = true;
	    }

	    //System.err.println("The value of maxElement is:" + maxElement);

	    if(!optimal) {
		// Case when the solution is not optimal but not known to be
		// either unbounded or infeasable

		// from the above we have found the maximum negative element in
		// bottom row, we have also found the column for this value
		// the pivotColIndex represents this

		// initialize the values for the algorithm, -1 for pivotRowIndex
		// indicates no solution

		prevRatio = Float.POSITIVE_INFINITY;
		ratio = 0.0;
		pivotRowIndex = -1;

		// note if all of the elements in the pivot column are zero or
		// negative the problem is unbounded.
		for(i = 0; i < numRow - 1; i++) {
		    element = problemTableau[i][pivotColIndex]; // r value
		    endElement = problemTableau[i][numCol-1]; // s value

		    // pivot according to the rule that we want to choose the row
		    // with smallest s/r ratio see third case
		    // currently we ignore valuse of r==0 (case 1) and cases where the
		    // ratio is negative, i.e. either r or s are negative (case 2)
		    if(element == 0) {
			if(debug) {
			    System.err.println("Division by zero has occurred");
			    System.err.println("Within the linear program solver");
			    System.err.println("Ignoring the zero as a potential pivot");
			}
		    } else if ( (element < 0.0) || (endElement < 0.0) ){
			if(debug) {
			    System.err.println("Ignoring cases where element is negative");
			    System.err.println("The value of element is: " + element);
			    System.err.println("The value of end Element is: " + endElement);
			}
		    } else {
			ratio = endElement/element;  // should be s/r
			if(debug) {
			    System.err.println("The value of element is: " + element);
			    System.err.println("The value of endElement is: " + endElement);
			    System.err.println("The value of ratio is: " + ratio);
			    System.err.println("The value of prevRatio is: " + prevRatio);
			    System.err.println("Value of ratio <= prevRatio is :" +
					       (ratio <= prevRatio));
			}
			if(ratio <= prevRatio) {
			    if(debug) {
				System.err.println("updating prevRatio with ratio");
			    }
			    prevRatio = ratio;
			    pivotRowIndex = i;
			}
		    }
		}

		// if the pivotRowIndex is still -1 then we know the pivotColumn
		// has no viable pivot points and the solution is unbounded or
		// infeasable (all pivot elements were either zero or negative or
		// the right most value was negative (the later shouldn't happen?)
		if(pivotRowIndex == -1) {
		    if(debug) {
			System.err.println("UNABLE TO FIND SOLUTION");
			System.err.println("The system is infeasable or unbounded");
		    }
		    return(Float.POSITIVE_INFINITY);
		}

		// we now have the pivot row and col all that remains is
		// to divide through by this value and subtract the appropriate
		// multiple of the pivot row from all other rows to obtain
		// a tableau which has a column of all zeros and one 1 in the
		// intersection of pivot row and col

		// divide through by the pivot value
		double pivotValue = problemTableau[pivotRowIndex][pivotColIndex];

		if(debug) {
		    System.err.println("The value of row index is: " + pivotRowIndex);
		    System.err.println("The value of col index is: " + pivotColIndex);
		    System.err.println("The value of pivotValue is: " + pivotValue);
		}
		// divide through by s on the pivot row to obtain a 1 in pivot col
		for(i = 0; i < numCol; i++) {
		    problemTableau[pivotRowIndex][i] =
			problemTableau[pivotRowIndex][i] / pivotValue;
		}

		// subtract appropriate multiple of pivot row from all other rows
		// to zero out all rows except the final row and the pivot row
		for(i = 0; i < numRow; i++) {
		    if(i != pivotRowIndex) {
			multiplier = problemTableau[i][pivotColIndex];
			for(int j=0; j < numCol; j++) {
			    problemTableau[i][j] = problemTableau[i][j] -
				multiplier * problemTableau[pivotRowIndex][j];
			}
		    }
		}
	    }
	    // case when the element is optimal
	}
	return(problemTableau[numRow - 1][numCol - 1]);
    }



    boolean edgeIntersectSphere(BoundingSphere sphere, Point3d start,
				Point3d end)
	{
	    double abLenSq, acLenSq, apLenSq, abDotAp, radiusSq;
	    Vector3d ab = new Vector3d();
	    Vector3d ap = new Vector3d();

	    ab.x = end.x - start.x;
	    ab.y = end.y - start.y;
	    ab.z = end.z - start.z;

	    ap.x = sphere.center.x - start.x;
	    ap.y = sphere.center.y - start.y;
	    ap.z = sphere.center.z - start.z;

	    abDotAp = ab.dot(ap);

	    if(abDotAp < 0.0) {
		return false; // line segment points away from sphere.
	    }

	    abLenSq = ab.lengthSquared();
	    acLenSq = abDotAp * abDotAp / abLenSq;

	    if(acLenSq < abLenSq) {
		return false; // C doesn't lies between end points of edge.
	    }

	    radiusSq = sphere.radius * sphere.radius;
	    apLenSq = ap.lengthSquared();

	    if((apLenSq - acLenSq) <= radiusSq) {
		return true;
	    }

	    return false;

	}


    double det2D(Point2d a, Point2d b, Point2d p)
	{
	    return (((p).x - (a).x) * ((a).y - (b).y) +
		    ((a).y - (p).y) * ((a).x - (b).x));
	}

    // Assume coord is CCW.
    boolean pointIntersectPolygon2D(Vector3d normal, Point3d[] coord,
				    Point3d point)
	{

	    double  absNrmX, absNrmY, absNrmZ;
	    Point2d coord2D[] = new Point2d[coord.length];
	    Point2d pnt = new Point2d();

	    int i, j, axis;

	    // Project 3d points onto 2d plane.
	    // Note : Area of polygon is not preserve in this projection, but
	    // it doesn't matter here.

	    // Find the axis of projection.
	    absNrmX = Math.abs(normal.x);
	    absNrmY = Math.abs(normal.y);
	    absNrmZ = Math.abs(normal.z);

	    if(absNrmX > absNrmY)
		axis = 0;
	    else
		axis = 1;

	    if(axis == 0) {
		if(absNrmX < absNrmZ)
		    axis = 2;
	    }
	    else if(axis == 1) {
		if(absNrmY < absNrmZ)
		    axis = 2;
	    }

	    // System.err.println("Normal " + normal + " axis " + axis );

	    for(i=0; i<coord.length; i++) {
		coord2D[i] = new Point2d();

		switch (axis) {
		case 0:
		    coord2D[i].x = coord[i].y;
		    coord2D[i].y = coord[i].z;
		    break;

		case 1:
		    coord2D[i].x = coord[i].x;
		    coord2D[i].y = coord[i].z;
		    break;

		case 2:
		    coord2D[i].x = coord[i].x;
		    coord2D[i].y = coord[i].y;
		    break;
		}

		// System.err.println("i " + i + " u " + uCoor[i] + " v " + vCoor[i]);
	    }


	    switch (axis) {
	    case 0:
		pnt.x = point.y;
		pnt.y = point.z;
		break;

	    case 1:
		pnt.x = point.x;
		pnt.y = point.z;
		break;

	    case 2:
		pnt.x = point.x;
		pnt.y = point.y;
		break;
	    }

	    // Do determinant test.
	    for(j=0; j<coord.length; j++) {
		if(j<(coord.length-1))
		    if(det2D(coord2D[j], coord2D[j+1], pnt)>0.0)
			;
		    else
			return false;
		else
		    if(det2D(coord2D[j], coord2D[0], pnt)>0.0)
			;
		    else
			return false;
	    }

	    return true;

	}


    boolean edgeIntersectPlane(Vector3d normal, Point3d pnt, Point3d start,
			       Point3d end, Point3d iPnt)
	{

	    Vector3d tempV3d = new Vector3d();
	    Vector3d direction = new Vector3d();
	    double pD, pNrmDotrDir, tr;

	    // Compute plane D.
	    tempV3d.set(pnt);
	    pD = normal.dot(tempV3d);

	    direction.x = end.x - start.x;
	    direction.y = end.y - start.y;
	    direction.z = end.z - start.z;

	    pNrmDotrDir = normal.dot(direction);

	    // edge is parallel to plane.
	    if(pNrmDotrDir== 0.0) {
		// System.err.println("Edge is parallel to plane.");
		return false;
	    }

	    tempV3d.set(start);

	    tr = (pD - normal.dot(tempV3d))/ pNrmDotrDir;

	    // Edge intersects the plane behind the edge's start.
	    // or exceed the edge's length.
	    if((tr < 0.0 ) || (tr > 1.0 )) {
		// System.err.println("Edge intersects the plane behind the start or exceed end.");
		return false;
	    }

	    iPnt.x = start.x + tr * direction.x;
	    iPnt.y = start.y + tr * direction.y;
	    iPnt.z = start.z + tr * direction.z;

	    return true;

	}

    // Assume coord is CCW.
    boolean edgeIntersectPolygon2D(Vector3d normal, Point3d[] coord,
				   Point3d[] seg)
	{

	    double  absNrmX, absNrmY, absNrmZ;
	    Point2d coord2D[] = new Point2d[coord.length];
	    Point2d seg2D[] = new Point2d[2];

	    int i, j, axis;

	    // Project 3d points onto 2d plane.
	    // Note : Area of polygon is not preserve in this projection, but
	    // it doesn't matter here.

	    // Find the axis of projection.
	    absNrmX = Math.abs(normal.x);
	    absNrmY = Math.abs(normal.y);
	    absNrmZ = Math.abs(normal.z);

	    if(absNrmX > absNrmY)
		axis = 0;
	    else
		axis = 1;

	    if(axis == 0) {
		if(absNrmX < absNrmZ)
		    axis = 2;
	    }
	    else if(axis == 1) {
		if(absNrmY < absNrmZ)
		    axis = 2;
	    }

	    // System.err.println("Normal " + normal + " axis " + axis );

	    for(i=0; i<coord.length; i++) {
		coord2D[i] = new Point2d();

		switch (axis) {
		case 0:
		    coord2D[i].x = coord[i].y;
		    coord2D[i].y = coord[i].z;
		    break;

		case 1:
		    coord2D[i].x = coord[i].x;
		    coord2D[i].y = coord[i].z;
		    break;

		case 2:
		    coord2D[i].x = coord[i].x;
		    coord2D[i].y = coord[i].y;
		    break;
		}

		// System.err.println("i " + i + " u " + uCoor[i] + " v " + vCoor[i]);
	    }

	    for(i=0; i<2; i++) {
		seg2D[i] = new Point2d();
		switch (axis) {
		case 0:
		    seg2D[i].x = seg[i].y;
		    seg2D[i].y = seg[i].z;
		    break;

		case 1:
		    seg2D[i].x = seg[i].x;
		    seg2D[i].y = seg[i].z;
		    break;

		case 2:
		    seg2D[i].x = seg[i].x;
		    seg2D[i].y = seg[i].y;
		    break;
		}

		// System.err.println("i " + i + " u " + uSeg[i] + " v " + vSeg[i]);
	    }

	    // Do determinant test.
	    boolean pntTest[][] = new boolean[2][coord.length];
	    boolean testFlag;

	    for(j=0; j<coord.length; j++) {
		for(i=0; i<2; i++) {
		    if(j<(coord.length-1))
			pntTest[i][j] = (det2D(coord2D[j], coord2D[j+1], seg2D[i])<0.0);
		    else
			pntTest[i][j] = (det2D(coord2D[j], coord2D[0], seg2D[i])<0.0);
		}

		if((pntTest[0][j]==false) && (pntTest[1][j]==false))
		    return false;
	    }

	    testFlag = true;
	    for(i=0; i<coord.length; i++) {
		if(pntTest[0][i]==false) {
		    testFlag = false;
		    break;
		}
	    }

	    if(testFlag == true)
		return true; // start point is inside polygon.

	    testFlag = true;
	    for(i=0; i<coord.length; i++) {
		if(pntTest[1][i]==false) {
		    testFlag = false;
		    break;
		}
	    }

	    if(testFlag == true)
		return true; // end point is inside polygon.


	    int cnt = 0;
	    for(i=0; i<coord.length; i++) {
		if(det2D(seg2D[0], seg2D[1], coord2D[i])<0.0)
		    cnt++;
	    }

	    if((cnt==0)||(cnt==coord.length))
		return false;

	    return true;

	}


    // New stuffs .....
    double getCompValue(Point3d v, int i) {
	switch (i) {
	case 0: return v.x;
	case 1: return v.y;
	}
	// Has to return something, so set the default to z component.
	return v.z;
    }

    double getCompValue(Point3d v0, Point3d v1, int i) {
	switch (i) {
	case 0: return (v0.x - v1.x);
	case 1: return (v0.y - v1.y);
	}
	// Has to return some, so set the default to z component.
	return (v0.z - v1.z);
    }


    boolean pointInTri(Point3d v0, Point3d u0, Point3d u1, Point3d u2,
		       Vector3d normal) {

	double nAbsX, nAbsY, nAbsZ;
	int i0, i1;

	// first project onto an axis-aligned plane, that maximizes the area
	// of the triangles, compute indices i0, i1.
	nAbsX = Math.abs(normal.x);
	nAbsY = Math.abs(normal.y);
	nAbsZ = Math.abs(normal.z);

	if (nAbsX > nAbsY) {
	    if(nAbsX > nAbsZ) {
		i0 = 1; //  nAbsX is greatest.
		i1 = 2;
	    }
	    else {
		i0 = 0; //  nAbsZ is greatest.
		i1 = 1;
	    }
	} else { // nAbsX <= nAbsY
	    if(nAbsZ > nAbsY) {
		i0 = 0;  //  nAbsZ is greatest.
		i1 = 1;
	    }
	    else {
		i0 = 0; //  nAbsY is greatest.
		i1 = 2;
	    }
	}
	return pointInTri(v0, u0,  u1, u2, i0,  i1);
    }

    boolean pointInTri(Point3d v0, Point3d u0, Point3d u1, Point3d u2,
		       int i0, int i1) {

	double a, b, c, d0, d1, d2;
	// is T1 completely inside T2 ?
	// check if v0 is inside tri(u0,u1,u2)

	a = getCompValue(u1, u0, i1);
	b = -(getCompValue(u1, u0, i0));
	c = -a * getCompValue(u0, i0) - b * getCompValue(u0, i1);
	d0 = a * getCompValue(v0, i0) + b * getCompValue(v0, i1) + c;

	a = getCompValue(u2, u1, i1);
	b = -(getCompValue(u2, u1, i0));
	c = -a * getCompValue(u1, i0) - b * getCompValue(u1, i1);
	d1 = a * getCompValue(v0, i0) + b * getCompValue(v0, i1) + c;

	a = getCompValue(u0, u2, i1);
	b = -(getCompValue(u0, u2, i0));
	c = -a * getCompValue(u2, i0) - b * getCompValue(u2, i1);
	d2 = a * getCompValue(v0, i0) + b * getCompValue(v0, i1) + c;

	if(d0*d1>0.0) {
	    if(d0*d2>0.0) {
		return true;
	    }
	}
	return false;
    }


    // this edge to edge test is based on Franlin Antonio's gem:
    // "Faster line segment intersection", in Graphics Gems III, pp 199-202
    boolean edgeAgainstEdge(Point3d v0, Point3d u0, Point3d u1, double aX, double aY,
			    int i0, int i1) {
	double bX, bY, cX, cY, e, d, f;

	bX = getCompValue(u0, u1,i0);
	bY = getCompValue(u0, u1, i1);
	cX = getCompValue(v0, u0, i0);
	cY = getCompValue(v0, u0, i1);

	f = aY * bX - aX * bY;
	d = bY * cX - bX * cY;
	if((f>0 && d>=0 && d<=f) || (f<0 && d<=0 && d>=f)) {
	    e = aX * cY - aY * cX;
	    if(f>0) {
		if(e>=0 && e<=f)
		    return true;
	    }
	    else {
		if(e<=0 && e>=f)
		    return true;
	    }
	}

	return false;
    }


    boolean edgeAgainstTriEdges(Point3d v0, Point3d v1, Point3d u0,
				Point3d u1, Point3d u2, int i0, int i1) {
	double aX, aY;

	// aX = v1[i0] - v0[i0];
	// aY = v1[i1] - v0[i1];
	aX = getCompValue(v1, v0, i0);
	aY = getCompValue(v1, v0, i1);

	// test edge u0, u1 against v0, v1
	if(edgeAgainstEdge(v0, u0, u1, aX, aY, i0, i1))
	    return true;
	// test edge u1, u2 against v0, v1
	if(edgeAgainstEdge(v0, u1, u2, aX, aY, i0, i1))
	    return true;
	// test edge u2, u0 against v0, v1
	if(edgeAgainstEdge(v0, u2, u0, aX, aY, i0, i1))
	    return true;

	return false;

    }

    boolean coplanarTriTri(Vector3d normal, Point3d v0, Point3d v1, Point3d v2,
			   Point3d u0, Point3d u1, Point3d u2) {

	double nAbsX, nAbsY, nAbsZ;
	int i0, i1;

	// first project onto an axis-aligned plane, that maximizes the area
	// of the triangles, compute indices i0, i1.
	nAbsX = Math.abs(normal.x);
	nAbsY = Math.abs(normal.y);
	nAbsZ = Math.abs(normal.z);

	if(nAbsX > nAbsY) {
	    if(nAbsX > nAbsZ) {
		i0 = 1; //  nAbsX is greatest.
		i1 = 2;
	    }
	    else {
		i0 = 0; //  nAbsZ is greatest.
		i1 = 1;
	    }
	}
	else { // nAbsX <= nAbsY
	    if(nAbsZ > nAbsY) {
		i0 = 0;  //  nAbsZ is greatest.
		i1 = 1;
	    }
	    else {
		i0 = 0; //  nAbsY is greatest.
		i1 = 2;
	    }
	}

	// test all edges of triangle 1 against the edges of triangle 2
	if(edgeAgainstTriEdges(v0, v1, u0, u1, u2, i0, i1))
	    return true;

	if(edgeAgainstTriEdges(v1, v2, u0, u1, u2, i0, i1))
	    return true;

	if(edgeAgainstTriEdges(v2, v0, u0, u1, u2, i0, i1))
	    return true;

	// finally, test if tri1 is totally contained in tri2 or vice versa.
	if(pointInTri(v0, u0, u1, u2, i0, i1))
	    return true;

	if(pointInTri(u0, v0, v1, v2, i0, i1))
	    return true;

	return false;
    }





    boolean intersectTriPnt(Point3d v0, Point3d v1, Point3d v2, Point3d u) {

	Vector3d e1 = new Vector3d();
	Vector3d e2 = new Vector3d();
	Vector3d n1 = new Vector3d();
	Vector3d tempV3d = new Vector3d();

	double d1, du;

	// compute plane equation of triange(coord1)
	e1.x = v1.x - v0.x;
	e1.y = v1.y - v0.y;
	e1.z = v1.z - v0.z;

	e2.x = v2.x - v0.x;
	e2.y = v2.y - v0.y;
	e2.z = v2.z - v0.z;

	n1.cross(e1,e2);

	if(n1.length() == 0.0) {
	    // System.err.println("(1) Degenerate triangle.");
	    return false;  // Degenerate triangle.
	}

	tempV3d.set(v0);
	d1 = - n1.dot(tempV3d); // plane equation 1: n1.x + d1 = 0

	// put u to compute signed distance to the plane.
	tempV3d.set(u);
	du = n1.dot(tempV3d) + d1;

	// coplanarity robustness check
	if(Math.abs(du)<EPS) du = 0.0;

	// no intersection occurs
	if(du != 0.0) {
	    return false;
	}

	double nAbsX, nAbsY, nAbsZ;
	int i0, i1;

	// first project onto an axis-aligned plane, that maximizes the area
	// of the triangles, compute indices i0, i1.
	nAbsX = Math.abs(n1.x);
	nAbsY = Math.abs(n1.y);
	nAbsZ = Math.abs(n1.z);

	if(nAbsX > nAbsY) {
	    if(nAbsX > nAbsZ) {
		i0 = 1; //  nAbsX is greatest.
		i1 = 2;
	    }
	    else {
		i0 = 0; //  nAbsZ is greatest.
		i1 = 1;
	    }
	}
	else { // nAbsX <= nAbsY
	    if(nAbsZ > nAbsY) {
		i0 = 0;  //  nAbsZ is greatest.
		i1 = 1;
	    }
	    else {
		i0 = 0; //  nAbsY is greatest.
		i1 = 2;
	    }
	}


	// finally, test if u is totally contained in tri.
	if(pointInTri(u, v0, v1, v2, i0, i1)) {
	    return true;
	}

	return false;
    }


    /**
     * Return flag indicating whether two triangles intersect.  This
     * uses Tomas Moller's code for fast triangle-triangle
     * intersection from his "Real-Time Rendering" book.
     *
     * The code is now divisionless. It tests for separating by planes
     * parallel to either triangle.  If neither separate the
     * triangles, then two cases are considered. First case is if the
     * normals to the triangles are parallel. In that case, the
     * triangles are coplanar and a sequence of tests are made to see
     * if edges of each triangle intersect the other triangle. If the
     * normals are not parallel, then the two triangles can intersect
     * only on the line of intersection of the two planes. The
     * intervals of intersection of the triangles with the line of
     * intersection of the two planes are computed and tested for
     * overlap.
     */
    boolean intersectTriTri(Point3d v0, Point3d v1, Point3d v2,
			    Point3d u0, Point3d u1, Point3d u2) {

	// System.err.println("In intersectTriTri ...");
	Vector3d e1 = new Vector3d();
	Vector3d e2 = new Vector3d();
	Vector3d n1 = new Vector3d();
	Vector3d n2 = new Vector3d();
	Vector3d tempV3d = new Vector3d();

	double d1, d2;
	double du0, du1, du2, dv0, dv1, dv2;
	double du0du1, du0du2, dv0dv1, dv0dv2;
	int index;
	double vp0=0.0, vp1=0.0, vp2=0.0;
	double up0=0.0, up1=0.0, up2=0.0;
	double bb, cc, max;

	// compute plane equation of triange(coord1)
	e1.x = v1.x - v0.x;
	e1.y = v1.y - v0.y;
	e1.z = v1.z - v0.z;

	e2.x = v2.x - v0.x;
	e2.y = v2.y - v0.y;
	e2.z = v2.z - v0.z;

	n1.cross(e1,e2);

	if(n1.length() == 0.0) {
	    // System.err.println("(1) Degenerate triangle.");
	    return false;  // Degenerate triangle.
	}

	tempV3d.set(v0);
	d1 = - n1.dot(tempV3d); // plane equation 1: n1.x + d1 = 0

	// put u0, u1, and u2 into plane equation 1
	// to compute signed distance to the plane.
	tempV3d.set(u0);
	du0 = n1.dot(tempV3d) + d1;
	tempV3d.set(u1);
	du1 = n1.dot(tempV3d) + d1;
	tempV3d.set(u2);
	du2 = n1.dot(tempV3d) + d1;

	// coplanarity robustness check
	if(Math.abs(du0)<EPS) du0 = 0.0;
	if(Math.abs(du1)<EPS) du1 = 0.0;
	if(Math.abs(du2)<EPS) du2 = 0.0;

	du0du1 = du0 * du1;
	du0du2 = du0 * du2;

	// same sign on all of them + not equal 0 ?
	// no intersection occurs
	if(du0du1>0.0 && du0du2>0.0) {
	    // System.err.println("In intersectTriTri : du0du1>0.0 && du0du2>0.0");
	    return false;
	}

	// compute plane of triangle(coord2)
	e1.x = u1.x - u0.x;
	e1.y = u1.y - u0.y;
	e1.z = u1.z - u0.z;

	e2.x = u2.x - u0.x;
	e2.y = u2.y - u0.y;
	e2.z = u2.z - u0.z;

	n2.cross(e1,e2);

	if(n2.length() == 0.0) {
	    // System.err.println("(2) Degenerate triangle.");
	    return false;  // Degenerate triangle.
	}

	tempV3d.set(u0);
	d2 = - n2.dot(tempV3d); // plane equation 2: n2.x + d2 = 0

	// put v0, v1, and v2 into plane equation 2
	// to compute signed distance to the plane.
	tempV3d.set(v0);
	dv0 = n2.dot(tempV3d) + d2;
	tempV3d.set(v1);
	dv1 = n2.dot(tempV3d) + d2;
	tempV3d.set(v2);
	dv2 = n2.dot(tempV3d) + d2;

	// coplanarity robustness check
	if(Math.abs(dv0)<EPS) dv0 = 0.0;
	if(Math.abs(dv1)<EPS) dv1 = 0.0;
	if(Math.abs(dv2)<EPS) dv2 = 0.0;

	dv0dv1 = dv0 * dv1;
	dv0dv2 = dv0 * dv2;

	// same sign on all of them + not equal 0 ?
	// no intersection occurs
	if(dv0dv1>0.0 && dv0dv2>0.0) {
	    // System.err.println("In intersectTriTri : dv0dv1>0.0 && dv0dv2>0.0");
	    return false;
	}
	// compute direction of intersection line.
	tempV3d.cross(n1, n2);

	// compute and index to the largest component of tempV3d.
	max = Math.abs(tempV3d.x);
	index = 0;
	bb = Math.abs(tempV3d.y);
	cc = Math.abs(tempV3d.z);
	if(bb>max) {
	    max=bb;
	    index=1;
	}
	if(cc>max) {
	    max=cc;
	    index=2;
	}

	// this is the simplified projection onto L.

	switch (index) {
	case 0:
	    vp0 = v0.x;
	    vp1 = v1.x;
	    vp2 = v2.x;

	    up0 = u0.x;
	    up1 = u1.x;
	    up2 = u2.x;
	    break;
	case 1:
	    vp0 = v0.y;
	    vp1 = v1.y;
	    vp2 = v2.y;

	    up0 = u0.y;
	    up1 = u1.y;
	    up2 = u2.y;
	    break;
	case 2:
	    vp0 = v0.z;
	    vp1 = v1.z;
	    vp2 = v2.z;

	    up0 = u0.z;
	    up1 = u1.z;
	    up2 = u2.z;
	    break;
	}

	// compute intereval for triangle 1.
	double a=0.0, b=0.0, c=0.0, x0=0.0, x1=0.0;
	if(dv0dv1>0.0) {
	    // here we know that dv0dv2 <= 0.0 that is dv0 and dv1 are on the same side,
	    // dv2 on the other side or on the plane.
	    a = vp2; b = (vp0 - vp2) * dv2; c = (vp1 - vp2) * dv2;
	    x0 = dv2 - dv0; x1 = dv2 - dv1;
	}
	else if(dv0dv2>0.0) {
	    // here we know that dv0dv1<=0.0
	    a = vp1; b = (vp0 - vp1) * dv1; c = (vp2 - vp1) * dv1;
	    x0 = dv1 - dv0; x1 = dv1 - dv2;
	}
	else if((dv1*dv2>0.0) || (dv0 != 0.0)) {
	    // here we know that dv0vd1<=0.0 or that dv0!=0.0
	    a = vp0; b = (vp1 - vp0) * dv0; c = (vp2 - vp0) * dv0;
	    x0 = dv0 - dv1; x1 = dv0 - dv2;
	}
	else if(dv1 != 0.0) {
	    a = vp1; b = (vp0 - vp1) * dv1; c = (vp2 - vp1) * dv1;
	    x0 = dv1 - dv0; x1 = dv1 - dv2;
	}
	else if(dv2 != 0.0) {
	    a = vp2; b = (vp0 - vp2) * dv2; c = (vp1 - vp2) * dv2;
	    x0 = dv2 - dv0; x1 = dv2 - dv1;
	}
	else {
	    // triangles are coplanar
	    boolean toreturn = coplanarTriTri(n1, v0, v1, v2, u0, u1, u2);
	    return toreturn;
	}


	// compute intereval for triangle 2.
	double d=0.0, e=0.0, f=0.0, y0=0.0, y1=0.0;
	if(du0du1>0.0) {
	    // here we know that du0du2 <= 0.0 that is du0 and du1 are on the same side,
	    // du2 on the other side or on the plane.
	    d = up2; e = (up0 - up2) * du2; f = (up1 - up2) * du2;
	    y0 = du2 - du0; y1 = du2 - du1;
	}
	else if(du0du2>0.0) {
	    // here we know that du0du1<=0.0
	    d = up1; e = (up0 - up1) * du1; f = (up2 - up1) * du1;
	    y0 = du1 - du0; y1 = du1 - du2;
	}
	else if((du1*du2>0.0) || (du0 != 0.0)) {
	    // here we know that du0du1<=0.0 or that D0!=0.0
	    d = up0; e = (up1 - up0) * du0; f = (up2 - up0) * du0;
	    y0 = du0 - du1; y1 = du0 - du2;
	}
	else if(du1 != 0.0) {
	    d = up1; e = (up0 - up1) * du1; f = (up2 - up1) * du1;
	    y0 = du1 - du0; y1 = du1 - du2;
	}
	else if(du2 != 0.0) {
	    d = up2; e = (up0 - up2) * du2; f = (up1 - up2) * du2;
	    y0 = du2 - du0; y1 = du2 - du1;
	}
	else {
	    // triangles are coplanar
	    //	    System.err.println("In intersectTriTri : coplanarTriTri test 2");
	    boolean toreturn =  coplanarTriTri(n2, v0, v1, v2, u0, u1, u2);
	    return toreturn;
	}

	double xx, yy, xxyy, tmp, isect1S, isect1E, isect2S, isect2E;
	xx = x0 * x1;
	yy = y0 * y1;
	xxyy = xx * yy;

	tmp = a * xxyy;
	isect1S = tmp + b * x1 * yy;
	isect1E = tmp + c * x0 * yy;

	tmp = d * xxyy;
	isect2S = tmp + e * y1 * xx;
	isect2E = tmp + f * y0 * xx;

	// sort so that isect1S <= isect1E
	if(isect1S > isect1E) {
	    tmp = isect1S;
	    isect1S = isect1E;
	    isect1E = tmp;
	}

	// sort so that isect2S <= isect2E
	if(isect2S > isect2E) {
	    tmp = isect2S;
	    isect2S = isect2E;
	    isect2E = tmp;
	}

	if(isect1E<isect2S || isect2E<isect1S) {
	    // System.err.println("In intersectTriTri :isect1E<isect2S || isect2E<isect1S");
	    // System.err.println("In intersectTriTri : return false");
	    return false;
	}

	//	 System.err.println("In intersectTriTri : return true");
	return true;

    }



    boolean intersectPolygon(Point3d coord1[], Point3d coord2[]) {
	int i, j;
	Vector3d vec0 = new Vector3d(); // Edge vector from point 0 to point 1;
	Vector3d vec1 = new Vector3d(); // Edge vector from point 0 to point 2 or 3;
	Vector3d pNrm = new Vector3d();
	boolean epFlag;


	// compute plane normal for coord1.
	for(i=0; i<coord1.length-1;) {
	    vec0.x = coord1[i+1].x - coord1[i].x;
	    vec0.y = coord1[i+1].y - coord1[i].y;
	    vec0.z = coord1[i+1].z - coord1[i++].z;
	    if(vec0.length() > 0.0)
		break;
	}

	for(j=i; j<coord1.length-1; j++) {
	    vec1.x = coord1[j+1].x - coord1[j].x;
	    vec1.y = coord1[j+1].y - coord1[j].y;
	    vec1.z = coord1[j+1].z - coord1[j].z;
	    if(vec1.length() > 0.0)
		break;
	}

	if(j == (coord1.length-1)) {
	    // System.err.println("(1) Degenerate polygon.");
	    return false;  // Degenerate polygon.
	}

	/*
	  for(i=0; i<coord1.length; i++)
	  System.err.println("coord1 P" + i + " " + coord1[i]);
	  for(i=0; i<coord2.length; i++)
	  System.err.println("coord2 P" + i + " " + coord2[i]);
	  */

	pNrm.cross(vec0,vec1);

	if(pNrm.length() == 0.0) {
	    // System.err.println("(2) Degenerate polygon.");
	    return false;  // Degenerate polygon.
	}

	j = 0;
	Point3d seg[] = new Point3d[2];
	seg[0] = new Point3d();
	seg[1] = new Point3d();

	for(i=0; i<coord2.length; i++) {
	    if(i < (coord2.length-1))
		epFlag = edgeIntersectPlane(pNrm, coord1[0], coord2[i],
					    coord2[i+1], seg[j]);
	    else
		epFlag = edgeIntersectPlane(pNrm, coord1[0], coord2[i],
					    coord2[0], seg[j]);
	    if (epFlag) {
		if(++j>1) {
		    break;
		}
	    }
	}

	if (j==0) {
	    return false;
	}

	if (coord2.length < 3) {
	    boolean toreturn = pointIntersectPolygon2D(pNrm, coord1, seg[0]);
	    return toreturn;
	} else {
	    boolean toreturn = edgeIntersectPolygon2D(pNrm, coord1, seg);
	    return toreturn;
	}
    }


    /**
     * Return true if triangle or quad intersects with ray and the
     * distance is stored in dist[0] and the intersect point in iPnt
     * (if iPnt is not null).
     */
    boolean intersectRay(Point3d coordinates[], PickRay ray, double dist[],
			 Point3d iPnt) {

	return intersectRayOrSegment(coordinates, ray.direction, ray.origin,
				     dist, iPnt, false);

    }

    /**
     * Return true if triangle or quad intersects with segment and
     * the distance is stored in dist[0].
     */
    boolean intersectSegment( Point3d coordinates[], Point3d start, Point3d end,
			      double dist[], Point3d iPnt ) {
	boolean result;
	Vector3d direction = new Vector3d();
	direction.x = end.x - start.x;
	direction.y = end.y - start.y;
	direction.z = end.z - start.z;
	result = intersectRayOrSegment(coordinates, direction, start, dist, iPnt, true);
	return result;
    }



    /**
     *  Return true if triangle or quad intersects with ray and the distance is
     *  stored in pr.
     */
    boolean intersectRayOrSegment(Point3d coordinates[],
				  Vector3d direction, Point3d origin,
				  double dist[], Point3d iPnt, boolean isSegment) {
	Vector3d vec0, vec1, pNrm, tempV3d;
	vec0 = new Vector3d();
	vec1 = new Vector3d();
	pNrm = new Vector3d();

	double  absNrmX, absNrmY, absNrmZ, pD = 0.0;
	double pNrmDotrDir = 0.0;

	boolean isIntersect = false;
	int i, j, k=0, l = 0;

	// Compute plane normal.
	for (i=0; i<coordinates.length; i++) {
	    if (i != coordinates.length-1) {
		l = i+1;
	    } else {
		l = 0;
	    }
	    vec0.x = coordinates[l].x - coordinates[i].x;
	    vec0.y = coordinates[l].y - coordinates[i].y;
	    vec0.z = coordinates[l].z - coordinates[i].z;
	    if (vec0.length() > 0.0) {
		break;
	    }
	}


	for (j=l; j<coordinates.length; j++) {
	    if (j != coordinates.length-1) {
		k = j+1;
	    } else {
		k = 0;
	    }
	    vec1.x = coordinates[k].x - coordinates[j].x;
	    vec1.y = coordinates[k].y - coordinates[j].y;
	    vec1.z = coordinates[k].z - coordinates[j].z;
	    if (vec1.length() > 0.0) {
		break;
	    }
	}

	pNrm.cross(vec0,vec1);

	if ((vec1.length() == 0) || (pNrm.length() == 0)) {
	    // degenerate to line if vec0.length() == 0
	    // or vec0.length > 0 and vec0 parallel to vec1
	    k = (l == 0 ? coordinates.length-1: l-1);
	    isIntersect = intersectLineAndRay(coordinates[l],
					      coordinates[k],
					      origin,
					      direction,
					      dist,
					      iPnt);

	    // put the Vectors on the freelist
	    return isIntersect;
	}

	// It is possible that Quad is degenerate to Triangle
	// at this point

	pNrmDotrDir = pNrm.dot(direction);

    	// Ray is parallel to plane.
	if (pNrmDotrDir == 0.0) {
	    // Ray is parallel to plane
	    // Check line/triangle intersection on plane.
	    for (i=0; i < coordinates.length ;i++) {
		if (i != coordinates.length-1) {
		    k = i+1;
		} else {
		    k = 0;
		}
		if (intersectLineAndRay(coordinates[i],
					coordinates[k],
					origin,
					direction,
					dist,
					iPnt)) {
		    isIntersect = true;
		    break;
		}
	    }
	    return isIntersect;
	}

	// Plane equation: (p - p0)*pNrm = 0 or p*pNrm = pD;
	tempV3d = new Vector3d();
	tempV3d.set(coordinates[0]);
	pD = pNrm.dot(tempV3d);
	tempV3d.set(origin);

	// Substitute Ray equation:
	// p = origin + pi.distance*direction
	// into the above Plane equation

	dist[0] = (pD - pNrm.dot(tempV3d))/ pNrmDotrDir;

	// Ray intersects the plane behind the ray's origin.
	if ((dist[0] < -EPS ) ||
	    (isSegment && (dist[0] > 1.0+EPS))) {
	    // Ray intersects the plane behind the ray's origin
	    // or intersect point not fall in Segment
	    return false;
	}

	// Now, one thing for sure the ray intersect the plane.
	// Find the intersection point.
	if (iPnt == null) {
	    iPnt = new Point3d();
	}
	iPnt.x = origin.x + direction.x * dist[0];
	iPnt.y = origin.y + direction.y * dist[0];
	iPnt.z = origin.z + direction.z * dist[0];

	// Project 3d points onto 2d plane
	// Find the axis so that area of projection is maximize.
	absNrmX = Math.abs(pNrm.x);
	absNrmY = Math.abs(pNrm.y);
	absNrmZ = Math.abs(pNrm.z);

	// All sign of (y - y0) (x1 - x0) - (x - x0) (y1 - y0)
	// must agree.
	double sign, t, lastSign = 0;
	Point3d p0 = coordinates[coordinates.length-1];
	Point3d p1 = coordinates[0];

	isIntersect = true;

	if (absNrmX > absNrmY) {
	    if (absNrmX < absNrmZ) {
		for (i=0; i < coordinates.length; i++) {
		    p0 = coordinates[i];
		    p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
 		    sign = (iPnt.y - p0.y)*(p1.x - p0.x) -
			   (iPnt.x - p0.x)*(p1.y - p0.y);
		    if (isNonZero(sign)) {
			if (sign*lastSign < 0) {
			    isIntersect = false;
			    break;
			}
			lastSign = sign;
		    } else { // point on line, check inside interval
			t = p1.y - p0.y;
			if (isNonZero(t)) {
			    t = (iPnt.y - p0.y)/t;
			    isIntersect = ((t > -EPS) && (t < 1+EPS));
			    break;
			} else {
			    t = p1.x - p0.x;
			    if (isNonZero(t)) {
				t = (iPnt.x - p0.x)/t;
				isIntersect = ((t > -EPS) && (t < 1+EPS));
				break;
			    } else {
    // Ignore degenerate line=>point happen when Quad => Triangle.
    // Note that by next round sign*lastSign = 0 so it will
    // not pass the interest test. This should only happen once in the
    // loop because we already check for degenerate geometry before.
			    }
			}
		    }
		}
	    } else {
		for (i=0; i<coordinates.length; i++) {
		    p0 = coordinates[i];
		    p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
		    sign = (iPnt.y - p0.y)*(p1.z - p0.z) -
			   (iPnt.z - p0.z)*(p1.y - p0.y);
		    if (isNonZero(sign)) {
			if (sign*lastSign < 0) {
			    isIntersect = false;
			    break;
			}
			lastSign = sign;
		    } else { // point on line, check inside interval
			t = p1.y - p0.y;

			if (isNonZero(t)) {
			    t = (iPnt.y - p0.y)/t;
			    isIntersect = ((t > -EPS) && (t < 1+EPS));
			    break;

			} else {
			    t = p1.z - p0.z;
			    if (isNonZero(t)) {
				t = (iPnt.z - p0.z)/t;
				isIntersect = ((t > -EPS) && (t < 1+EPS));
				break;
			    } else {
				//degenerate line=>point
			    }
			}
		    }
		}
	    }
	} else {
	    if (absNrmY < absNrmZ) {
		for (i=0; i<coordinates.length; i++) {
		    p0 = coordinates[i];
		    p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
		    sign = (iPnt.y - p0.y)*(p1.x - p0.x) -
			   (iPnt.x - p0.x)*(p1.y - p0.y);
		    if (isNonZero(sign)) {
			if (sign*lastSign < 0) {
			    isIntersect = false;
			    break;
			}
			lastSign = sign;
		    } else { // point on line, check inside interval
			t = p1.y - p0.y;
			if (isNonZero(t)) {
			    t = (iPnt.y - p0.y)/t;
			    isIntersect = ((t > -EPS) && (t < 1+EPS));
			    break;
			} else {
			    t = p1.x - p0.x;
			    if (isNonZero(t)) {
				t = (iPnt.x - p0.x)/t;
				isIntersect = ((t > -EPS) && (t < 1+EPS));
				break;
			    } else {
				//degenerate line=>point
			    }
			}
		    }
		}
	    } else {
		for (i=0; i<coordinates.length; i++) {
		    p0 = coordinates[i];
		    p1 = (i != coordinates.length-1 ? coordinates[i+1]: coordinates[0]);
		    sign = (iPnt.x - p0.x)*(p1.z - p0.z) -
			   (iPnt.z - p0.z)*(p1.x - p0.x);
		    if (isNonZero(sign)) {
			if (sign*lastSign < 0) {
			    isIntersect = false;
			    break;
			}
			lastSign = sign;
		    } else { // point on line, check inside interval
			t = p1.x - p0.x;
			if (isNonZero(t)) {
			    t = (iPnt.x - p0.x)/t;
			    isIntersect = ((t > -EPS) && (t < 1+EPS));
			    break;
			} else {
			    t = p1.z - p0.z;
			    if (isNonZero(t)) {
				t = (iPnt.z - p0.z)/t;
				isIntersect = ((t > -EPS) && (t < 1+EPS));
				break;
			    } else {
				//degenerate line=>point
			    }
			}
		    }
		}
	    }
	}

	if (isIntersect) {
	    dist[0] *= direction.length();
	}
	return isIntersect;
    }



    static final boolean isNonZero(double v) {
	return ((v > EPS) || (v < -EPS));

    }

    /**
     * Return true if point is on the inside of halfspace test. The
     * halfspace is partition by the plane of triangle or quad.
     */
    boolean inside( Point3d coordinates[], PickPoint point, int ccw ) {

	Vector3d vec0 = new Vector3d(); // Edge vector from point 0 to point 1;
	Vector3d vec1 = new Vector3d(); // Edge vector from point 0 to point 2 or 3;
	Vector3d pNrm = new Vector3d();
	double pD = 0.0;
	Vector3d tempV3d = new Vector3d();

	int i, j;

	// Compute plane normal.
	for(i=0; i<coordinates.length-1;) {
	    vec0.x = coordinates[i+1].x - coordinates[i].x;
	    vec0.y = coordinates[i+1].y - coordinates[i].y;
	    vec0.z = coordinates[i+1].z - coordinates[i++].z;
	    if(vec0.length() > 0.0)
		break;
	}

	for(j=i; j<coordinates.length-1; j++) {
	    vec1.x = coordinates[j+1].x - coordinates[j].x;
	    vec1.y = coordinates[j+1].y - coordinates[j].y;
	    vec1.z = coordinates[j+1].z - coordinates[j].z;
	    if(vec1.length() > 0.0)
		break;
	}

	if(j == (coordinates.length-1)) {
	    // System.err.println("(1) Degenerate polygon.");
	    return false;  // Degenerate polygon.
	}

	/*
	   System.err.println("Ray orgin : " + ray.origin + " dir " + ray.direction);
	   System.err.println("Triangle/Quad :");
	   for(i=0; i<coordinates.length; i++)
	   System.err.println("P" + i + " " + coordinates[i]);
	   */

	if( ccw == 0x1)
	    pNrm.cross(vec0,vec1);
	else
	    pNrm.cross(vec1,vec0);

	if(pNrm.length() == 0.0) {
	    // System.err.println("(2) Degenerate polygon.");
	    return false;  // Degenerate polygon.
	}
	// Compute plane D.
	tempV3d.set(coordinates[0]);
	pD = pNrm.dot(tempV3d);
	tempV3d.set(point.location);

	return ((pD - pNrm.dot(tempV3d)) <= 0);
    }

    boolean intersectPntAndPnt( Point3d pnt1, Point3d pnt2 ) {
	return ((pnt1.x == pnt2.x) &&
		(pnt1.y == pnt2.y) &&
		(pnt1.z == pnt2.z));
    }

    boolean intersectPntAndRay(Point3d pnt, Point3d ori, Vector3d dir,
			       double dist[]) {
	int flag = 0;
	double temp;

	if(dir.x != 0.0) {
	    flag = 0;
	    dist[0] = (pnt.x - ori.x)/dir.x;
	}
	else if(dir.y != 0.0) {
	    if(pnt.x != ori.x)
		return false;
	    flag = 1;
	    dist[0] = (pnt.y - ori.y)/dir.y;
	}
	else if(dir.z != 0.0) {
	    if((pnt.x != ori.x)||(pnt.y != ori.y))
		return false;
	    flag = 2;
	    dist[0] = (pnt.z - ori.z)/dir.z;

	}
	else
	    return false;

	if(dist[0] < 0.0)
	    return false;

	if(flag == 0) {
	    temp = ori.y + dist[0] * dir.y;
	    if((pnt.y < (temp - EPS)) || (pnt.y > (temp + EPS)))
		return false;
	}

	if(flag < 2) {
	    temp = ori.z + dist[0] * dir.z;
	    if((pnt.z < (temp - EPS)) || (pnt.z > (temp + EPS)))
		return false;
	}

	return true;

    }

    boolean intersectLineAndRay(Point3d start, Point3d end,
				Point3d ori, Vector3d dir, double dist[],
				Point3d iPnt) {

	double m00, m01, m10, m11;
	double mInv00, mInv01, mInv10, mInv11;
	double dmt, t, s, tmp1, tmp2;
	Vector3d lDir;

	//     System.err.println("GeometryArrayRetained : intersectLineAndRay");
	//     System.err.println("start " + start + " end " + end );
	//     System.err.println("ori " + ori + " dir " + dir);

	lDir = new Vector3d();
	lDir.x = (end.x - start.x);
	lDir.y = (end.y - start.y);
	lDir.z = (end.z - start.z);

	m00 = lDir.x;
	m01 = -dir.x;
	m10 = lDir.y;
	m11 = -dir.y;

	// Get the determinant.
	dmt = (m00 * m11) - (m10 * m01);

	if (dmt==0.0) { // No solution, check degenerate line
	    boolean isIntersect = false;
	    if ((lDir.x == 0) && (lDir.y == 0) && (lDir.z == 0)) {
		isIntersect = intersectPntAndRay(start, ori, dir, dist);
		if (isIntersect && (iPnt != null)) {
		    iPnt.set(start);
		}
	    }
	    return isIntersect;
	}
	// Find the inverse.
	tmp1 = 1/dmt;

	mInv00 = tmp1 * m11;
	mInv01 = tmp1 * (-m01);
	mInv10 = tmp1 * (-m10);
	mInv11 = tmp1 * m00;

	tmp1 = ori.x - start.x;
	tmp2 = ori.y - start.y;

	t = mInv00 * tmp1 + mInv01 * tmp2;
	s = mInv10 * tmp1 + mInv11 * tmp2;

	if(s<0.0) { // Before the origin of ray.
	    // System.err.println("Before the origin of ray " + s);
	    return false;
	}
	if((t<0)||(t>1.0)) {// Before or after the end points of line.
	    // System.err.println("Before or after the end points of line. " + t);
	    return false;
	}

	tmp1 = ori.z + s * dir.z;
	tmp2 = start.z + t * lDir.z;

	if((tmp1 < (tmp2 - EPS)) || (tmp1 > (tmp2 + EPS))) {
	    // System.err.println("No intersection : tmp1 " + tmp1 + " tmp2 " + tmp2);
	    return false;
	}

	dist[0] = s;

	if (iPnt != null) {
	    // compute point of intersection.
	    iPnt.x = ori.x + dir.x * dist[0];
	    iPnt.y = ori.y + dir.y * dist[0];
	    iPnt.z = ori.z + dir.z * dist[0];
	}

	// System.err.println("Intersected : tmp1 " + tmp1 + " tmp2 " + tmp2);
	return true;
    }

    /**
      Return true if triangle or quad intersects with cylinder. The
      distance is stored in dist.
      */
    boolean intersectCylinder(Point3d coordinates[], PickCylinder cyl,
			      double dist[], Point3d iPnt) {

	Point3d origin = new Point3d();
	Point3d end = new Point3d();
	Vector3d direction = new Vector3d();
	Point3d iPnt1 = new Point3d();
	Vector3d originToIpnt = new Vector3d();

	if (iPnt == null) {
	    iPnt = new Point3d();
	}

	// Get cylinder information
	cyl.getOrigin (origin);
	cyl.getDirection (direction);
	double radius = cyl.getRadius ();

	if (cyl instanceof PickCylinderSegment) {
	    ((PickCylinderSegment)cyl).getEnd (end);
	}

	// If the ray intersects, we're good (do not do this if we only have
	// a segment
	if (coordinates.length > 2) {
	    if (cyl instanceof PickCylinderRay) {
		if (intersectRay(coordinates,
				 new PickRay(origin, direction),
				 dist, iPnt)) {
		    return true;
		}
	    }
	    else {
		if (intersectSegment(coordinates, origin, end, dist, iPnt)) {
		    return true;
		}
	    }
	}

	// Ray doesn't intersect, check distance to edges
	double sqDistToEdge;
	int j;
	for (int i=0; i<coordinates.length;i++) {
	    j = (i < coordinates.length-1 ? i+1: 0);
	    if (cyl instanceof PickCylinderSegment) {
		sqDistToEdge =
		    Utils.segmentToSegment(origin, end,
					      coordinates[i], coordinates[j],
					      iPnt1, iPnt, null);
	    }
	    else {
		sqDistToEdge =
		    Utils.rayToSegment(origin, direction,
					  coordinates[i], coordinates[j],
					  iPnt1, iPnt, null);
	    }
	    if (sqDistToEdge <= radius*radius) {
		originToIpnt.sub (iPnt1, origin);
		dist[0] = originToIpnt.length();
		return true;
	    }
	}
	return false;
    }

    /**
      Return true if triangle or quad intersects with cone. The
      distance is stored in dist.
      */
    boolean intersectCone(Point3d coordinates[], PickCone cone,
			  double[] dist, Point3d iPnt) {

	Point3d origin = new Point3d();
	Point3d end = new Point3d();
	Vector3d direction = new Vector3d();
	Vector3d originToIpnt = new Vector3d();
	double distance;

	Point3d iPnt1 = new Point3d();

	if (iPnt == null) {
	    iPnt = new Point3d();
	}
	// Get cone information
	cone.getOrigin (origin);
	cone.getDirection (direction);
	double radius;

	if (cone instanceof PickConeSegment) {
	    ((PickConeSegment)cone).getEnd (end);
	}

	// If the ray intersects, we're good (do not do this if we only have
	// a segment
	if (coordinates.length > 2) {
	    if (cone instanceof PickConeRay) {
		if (intersectRay(coordinates,
				 new PickRay (origin, direction),
				 dist, iPnt)) {
		    return true;
		}
	    }
	    else {
		if (intersectSegment(coordinates, origin, end, dist, iPnt)) {
		    return true;
		}
	    }
	}

	// Ray doesn't intersect, check distance to edges
	double sqDistToEdge;
	int j = 0;
	for (int i=0; i<coordinates.length;i++) {
	    j = (i < coordinates.length-1 ? i+1: 0);
	    if (cone instanceof PickConeSegment) {
		sqDistToEdge =
		    Utils.segmentToSegment (origin, end,
					       coordinates[i], coordinates[j],
					       iPnt1, iPnt, null);
	    }
	    else {
		sqDistToEdge =
		    Utils.rayToSegment (origin, direction,
					   coordinates[i], coordinates[j],
					   iPnt1, iPnt, null);
	    }
	    originToIpnt.sub(iPnt1, origin);
	    distance = originToIpnt.length();
	    radius = Math.tan (cone.getSpreadAngle()) * distance;
	    if (sqDistToEdge <= radius*radius) {
		//	System.err.println ("intersectCone: edge "+i+" intersected");
		dist[0] = distance;
		return true;
	    }
	}
	return false;
    }


    /**
      Return true if point intersects with cylinder and the distance is
      stored in dist.
      */
    boolean intersectCylinder(Point3d pt, PickCylinder cyl,
			      double[] dist) {

	Point3d origin = new Point3d();
	Point3d end = new Point3d();
	Vector3d direction = new Vector3d();
	Point3d iPnt = new Point3d();
	Vector3d originToIpnt = new Vector3d();

	// Get cylinder information
	cyl.getOrigin (origin);
	cyl.getDirection (direction);
	double radius = cyl.getRadius ();
	double sqDist;

	if (cyl instanceof PickCylinderSegment) {
	    ((PickCylinderSegment)cyl).getEnd (end);
	    sqDist = Utils.ptToSegSquare(pt, origin, end, iPnt);
	}
	else {
	    sqDist = Utils.ptToRaySquare(pt, origin, direction, iPnt);
	}
	if (sqDist <= radius*radius) {
	    originToIpnt.sub (iPnt, origin);
	    dist[0] = originToIpnt.length();
	    return true;
	}
	return false;
    }

    /**
      Return true if point intersects with cone and the
      distance is stored in pi.
      */
    boolean intersectCone(Point3d pt, PickCone cone, double[] dist)
    {
	Point3d origin = new Point3d();
	Point3d end = new Point3d();
	Vector3d direction = new Vector3d();
	Point3d iPnt = new Point3d();
	Vector3d originToIpnt = new Vector3d();

	// Get cone information
	cone.getOrigin (origin);
	cone.getDirection (direction);
	double radius;
	double distance;
	double sqDist;

	if (cone instanceof PickConeSegment) {
	    ((PickConeSegment)cone).getEnd (end);
	    sqDist = Utils.ptToSegSquare(pt, origin, end, iPnt);
	}
	else {
	    sqDist = Utils.ptToRaySquare(pt, origin, direction, iPnt);
	}
	originToIpnt.sub(iPnt, origin);
	distance = originToIpnt.length();
	radius = Math.tan (cone.getSpreadAngle()) * distance;
	if (sqDist <= radius*radius) {
	    dist[0] = distance;
	    return true;
	}
	return false;
    }


    void setCoordRefBuffer(J3DBuffer coords) {
	if (coords != null) {
	    switch (coords.bufferType) {
	    case FLOAT:
		assert ((FloatBuffer)coords.getROBuffer()).isDirect();
		break;
	    case DOUBLE:
		assert ((DoubleBuffer)coords.getROBuffer()).isDirect();
		break;
	    case NULL:
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray115"));

	    default:
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
		if (3 * idx.maxCoordIndex >= coords.getROBuffer().limit()) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}
	    } else if (coords.getROBuffer().limit() < (3*(initialCoordIndex+validVertexCount))) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
	    }
	}

	// lock the geometry and start to do real work
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	coordRefBuffer = coords;
	if(coords == null) {
	    floatBufferRefCoords = null;
	    doubleBufferRefCoords = null;
	    // XXXX: if not mix java array with nio buffer
	    // vertexType can be used as vertexTypeBuffer
	    vertexType &= ~PD;
	    vertexType &= ~PF;
	}else {
	    switch (coords.bufferType) {
	    case FLOAT:
		floatBufferRefCoords = (FloatBuffer)coords.getROBuffer();
		doubleBufferRefCoords = null;
		vertexType |= PF;
		vertexType &= ~PD;
		break;
	    case DOUBLE:
		floatBufferRefCoords = null;
		doubleBufferRefCoords = (DoubleBuffer)coords.getROBuffer();
		vertexType |= PD;
		vertexType &= ~PF;
		break;
	    default:
		break;
	    }
	}

	// need not call setupMirrorVertexPointer() since
	// we are not going to set mirror in NIO buffer case
	// XXXX: if we need to mix java array with buffer,
	//        we may need to consider setupMirrorVertexPointer()

	if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && source != null) {
	    if (isLive) {
		processCoordsChanged((coords == null));
		sendDataChangedMessage(true);
	    } else {
		boundsDirty = true;
	    }
	}

    }


    J3DBuffer getCoordRefBuffer() {
	return coordRefBuffer;
    }


    void setCoordRefFloat(float[] coords) {

	// If non-null coordinate and vertType is either  defined
	// to be something other than PF, then issue an error
	if (coords != null) {
	    if ((vertexType & VERTEX_DEFINED) != 0 &&
		(vertexType & VERTEX_DEFINED) != PF) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }


	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (3 * idx.maxCoordIndex >= coords.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}
	    } else if (coords.length < 3 * (initialCoordIndex+validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;

	floatRefCoords = coords;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (coords == null)
		vertexType &= ~PF;
	    else
		vertexType |= PF;
	}
	else {
	    setupMirrorVertexPointer(PF);
	}

	if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && source != null) {
            if (isLive) {
                processCoordsChanged(coords == null);
		sendDataChangedMessage(true);
            } else {
		boundsDirty = true;
	    }
	}
    }


    float[] getCoordRefFloat() {
	return floatRefCoords;
    }


    void setCoordRefDouble(double[] coords) {

	if (coords != null) {
	    if ((vertexType & VERTEX_DEFINED) != 0 &&
		(vertexType & VERTEX_DEFINED) != PD) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
		if (3 * idx.maxCoordIndex >= coords.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}
	    } else if (coords.length < 3 * (initialCoordIndex+validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	doubleRefCoords = coords;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (coords == null)
		vertexType &= ~PD;
	    else
		vertexType |= PD;
	}
	else {
	    setupMirrorVertexPointer(PD);
	}
	if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && source != null) {
	    if (isLive) {
		processCoordsChanged(coords == null);
		sendDataChangedMessage(true);
	    } else {
		boundsDirty = true;
	    }
	}
    }

    double[] getCoordRefDouble() {
	return doubleRefCoords;
    }

    void setCoordRef3f(Point3f[] coords) {

	if (coords != null) {
	    if ((vertexType & VERTEX_DEFINED) != 0 &&
		(vertexType & VERTEX_DEFINED) != P3F) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxCoordIndex >= coords.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}
	    } else if (coords.length < (initialCoordIndex+validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	p3fRefCoords = coords;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (coords == null)
		vertexType &= ~P3F;
	    else
		vertexType |= P3F;
	}
	else {
	    setupMirrorVertexPointer(P3F);
	}
	if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && source != null) {
	    if (isLive) {
		processCoordsChanged(coords == null);
		sendDataChangedMessage(true);
	    } else {
		boundsDirty = true;
	    }
	}
    }

    Point3f[] getCoordRef3f() {
	return p3fRefCoords;

    }

    void setCoordRef3d(Point3d[] coords) {

	if (coords != null) {
	    if ((vertexType & VERTEX_DEFINED) != 0 &&
		(vertexType & VERTEX_DEFINED) != P3D) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxCoordIndex >= coords.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}
	    } else if (coords.length <  (initialCoordIndex+validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	p3dRefCoords = coords;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (coords == null)
		vertexType &= ~P3D;
	    else
		vertexType |= P3D;
	} else {
	    setupMirrorVertexPointer(P3D);
	}
	if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && source != null) {
	    if (isLive) {
		processCoordsChanged(coords == null);
		sendDataChangedMessage(true);
	    } else {
		boundsDirty = true;
	    }
	}
    }

    Point3d[] getCoordRef3d() {
	return p3dRefCoords;
    }

    void setColorRefFloat(float[] colors) {

	if (colors != null) {
	    if ((vertexType & COLOR_DEFINED) != 0 &&
		(vertexType & COLOR_DEFINED) != CF) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if ((vertexFormat & GeometryArray.COLOR) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray123"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (getColorStride() * idx.maxColorIndex >= colors.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}
	    } else  if (colors.length < getColorStride() * (initialColorIndex+ validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
	    }
	}

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	floatRefColors = colors;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (colors == null)
		vertexType &= ~CF;
	    else
		vertexType |= CF;
	}
	else {
	    setupMirrorColorPointer(CF, false);
	}

	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}

    }

    float[] getColorRefFloat() {
	return floatRefColors;
    }


    // set the color with nio buffer
    void setColorRefBuffer(J3DBuffer colors) {
	if (colors != null) {
	    switch(colors.bufferType) {
	    case FLOAT:
		assert ((FloatBuffer)colors.getROBuffer()).isDirect();
		break;
	    case BYTE:
		assert ((ByteBuffer)colors.getROBuffer()).isDirect();
		break;
	    case NULL:
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray115"));

	    default:
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));
	    }

	    if ((vertexFormat & GeometryArray.COLOR) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray123"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (getColorStride() * idx.maxColorIndex >= colors.getROBuffer().limit()) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}
	    } else if (colors.getROBuffer().limit() <
		       getColorStride() * (initialColorIndex+validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
	    }
	}

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	colorRefBuffer = colors;
	if(colors == null) {
	    floatBufferRefColors = null;
	    byteBufferRefColors = null;
	} else {
	    switch (colors.bufferType) {
	    case FLOAT:
		floatBufferRefColors = (FloatBuffer)colors.getROBuffer();
		byteBufferRefColors = null;
		break;

	    case BYTE:
		byteBufferRefColors = (ByteBuffer)colors.getROBuffer();
		floatBufferRefColors = null;
		break;
	    default:
		break;
	    }
	}
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if(colors == null) {
		vertexType &= ~CF;
		vertexType &= ~CUB;
	    } else {
		switch (colors.bufferType) {
		case FLOAT:
		    vertexType |= CF;
		    vertexType &= ~CUB;
		    break;

		case BYTE:
		    vertexType |= CUB;
		    vertexType &= ~CF;
		    break;
		default:
		    break;
		}
	    }
	}
	else {
	    setupMirrorColorPointer(CF|CUB, false);
	}

	if(isLive) {
            geomLock.unLock();
	}

	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}
    }

    // return the color data in nio buffer format
    J3DBuffer getColorRefBuffer() {
	return colorRefBuffer;
    }

    void setColorRefByte(byte[] colors) {

	if (colors != null) {
	    if ((vertexType & COLOR_DEFINED) != 0 &&
		(vertexType & COLOR_DEFINED) != CUB) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if ((vertexFormat & GeometryArray.COLOR) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray123"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (getColorStride() * idx.maxColorIndex >= colors.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}
	    } else if (colors.length < getColorStride() * (initialColorIndex + validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	byteRefColors = colors;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (colors == null)
		vertexType &= ~CUB;
	    else
		vertexType |= CUB;
	}
	else {
	    setupMirrorColorPointer(CUB, false);
	}
	if(isLive){
            geomLock.unLock();
	}

	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}

    }

    byte[] getColorRefByte() {
	return byteRefColors;
    }

    void setColorRef3f(Color3f[] colors) {

	if (colors != null) {
	    if ((vertexType & COLOR_DEFINED) != 0 &&
		(vertexType & COLOR_DEFINED) != C3F) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if ((vertexFormat & GeometryArray.COLOR_3) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray92"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
		if (idx.maxColorIndex >= colors.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}
	    } else if (colors.length < (initialColorIndex + validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
	    }
	}

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	c3fRefColors = colors;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (colors == null)
		vertexType &= ~C3F;
	    else
		vertexType |= C3F;
	}
	else {
	    setupMirrorColorPointer(C3F, false);
	}

	if(isLive) {
            geomLock.unLock();
	}

	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}

    }

    Color3f[] getColorRef3f() {
	return c3fRefColors;
    }


    void setColorRef4f(Color4f[] colors) {

	if (colors != null) {
	    if ((vertexType & COLOR_DEFINED) != 0 &&
		(vertexType & COLOR_DEFINED) != C4F) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }
	    if ((vertexFormat & GeometryArray.COLOR_4) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray93"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
		if (idx.maxColorIndex >= colors.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}
	    } else if (colors.length < (initialColorIndex + validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	c4fRefColors = colors;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (colors == null)
		vertexType &= ~C4F;
	    else
		vertexType |= C4F;
	}
	else {
	    setupMirrorColorPointer(C4F, false);
	}
	if(isLive) {
            geomLock.unLock();
	}

	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}
    }

    Color4f[] getColorRef4f() {
	return c4fRefColors;
    }


    void setColorRef3b(Color3b[] colors) {

	if (colors != null) {

	    if ((vertexType & COLOR_DEFINED) != 0 &&
		(vertexType & COLOR_DEFINED) != C3UB) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if ((vertexFormat & GeometryArray.COLOR_3) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray92"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxColorIndex >= colors.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}
	    } else if (colors.length < (initialColorIndex + validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
	    }
	}

	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	c3bRefColors = colors;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (colors == null)
		vertexType &= ~C3UB;
	    else
		vertexType |= C3UB;
	}
	else {
	    setupMirrorColorPointer(C3UB, false);
	}

	if(isLive) {
            geomLock.unLock();
	}

	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
        }
    }


    Color3b[] getColorRef3b() {
	return c3bRefColors;
    }

    void setColorRef4b(Color4b[] colors) {

	if (colors != null) {
	    if ((vertexType & COLOR_DEFINED) != 0 &&
		(vertexType & COLOR_DEFINED) != C4UB) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if ((vertexFormat & GeometryArray.COLOR_4) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray93"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained) this;

		if (idx.maxColorIndex >= colors.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}
	    } else if (colors.length < (initialColorIndex + validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	c4bRefColors = colors;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (colors == null)
		vertexType &= ~C4UB;
	    else
		vertexType |= C4UB;
	}
	else {
	    setupMirrorColorPointer(C4UB, false);
	}

	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
        }
    }


    Color4b[] getColorRef4b() {
	return c4bRefColors;
    }

    void setNormalRefFloat(float[] normals) {

	if (normals != null) {
	    if ((vertexType & NORMAL_DEFINED) != 0 &&
		(vertexType & NORMAL_DEFINED) != NF) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if ((vertexFormat & GeometryArray.NORMALS) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray122"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxNormalIndex*3 >= normals.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
		}
	    } else if (normals.length < 3 * (initialNormalIndex + validVertexCount )) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	floatRefNormals = normals;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (normals == null)
		vertexType &= ~NF;
	    else
		vertexType |= NF;
	}
	else {
	    setupMirrorNormalPointer(NF);
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
		sendDataChangedMessage(false);
	}

    }

    float[] getNormalRefFloat() {
	return floatRefNormals;
    }

    // setup the normal with nio buffer
    void setNormalRefBuffer(J3DBuffer normals) {

	FloatBuffer bufferImpl = null;

	if (normals != null) {
	    if(normals.bufferType != J3DBuffer.Type.FLOAT)
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));

	    bufferImpl = (FloatBuffer)normals.getROBuffer();

	    assert bufferImpl.isDirect();

	    if ((vertexFormat & GeometryArray.NORMALS) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray122"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
		if (idx.maxNormalIndex * 3 >=
		    ((FloatBuffer)normals.getROBuffer()).limit()) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
		}
	    } else if (bufferImpl.limit() < 3 * (initialNormalIndex + validVertexCount )) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	normalRefBuffer = normals;

	if (normals == null) {
	    vertexType &= ~NF;
	    floatBufferRefNormals = null;
	}
	else {
	    vertexType |= NF;
	    floatBufferRefNormals = bufferImpl;
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
		sendDataChangedMessage(false);
	}
    }

    J3DBuffer getNormalRefBuffer() {
	return normalRefBuffer;
    }

    void setNormalRef3f(Vector3f[] normals) {

	if (normals != null) {
	    if ((vertexType & NORMAL_DEFINED) != 0 &&
		(vertexType & NORMAL_DEFINED) != N3F) {
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray98"));
	    }

	    if ((vertexFormat & GeometryArray.NORMALS) == 0) {
		throw new IllegalStateException(J3dI18N.getString("GeometryArray122"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
		if (idx.maxNormalIndex >= normals.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
		}
	    } else if (normals.length < (initialNormalIndex + validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	v3fRefNormals = normals;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    if (normals == null)
		vertexType &= ~N3F;
	    else
		vertexType |= N3F;
	}
	else {
	    setupMirrorNormalPointer(N3F);
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}
    }

    Vector3f[] getNormalRef3f() {
	return v3fRefNormals;
    }

    final int getColorStride() {
	return ((vertexFormat & GeometryArray.WITH_ALPHA) != 0 ? 4 : 3);
    }

    final int getTexStride() {
	if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
	    return 2;
	}
	if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
	    return 3;
	}
	if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
	    return 4;
	}

	throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray121"));
    }

    void setTexCoordRefFloat(int texCoordSet, float[] texCoords) {

        if (texCoordType != 0 && texCoordType != TF) {
            if (texCoords != null) {
                throw new IllegalArgumentException(
                        J3dI18N.getString("GeometryArray98"));
            }
            return;
        }

        if (texCoords != null) {

            int ts = getTexStride();

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxTexCoordIndices[texCoordSet]*ts >= texCoords.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
		}
	    } else if (texCoords.length < ts*(initialTexCoordIndex[texCoordSet]+validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
	    }
	}
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= TEXTURE_CHANGED;
	refTexCoords[texCoordSet] = texCoords;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    texCoordType = TF;
            validateTexCoordPointerType();
	}
	else {
	    setupMirrorTexCoordPointer(texCoordSet, TF);
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}
    }


    float[] getTexCoordRefFloat(int texCoordSet) {
	return ((float[])refTexCoords[texCoordSet]);
    }

    // set the tex coord with nio buffer
    void setTexCoordRefBuffer(int texCoordSet, J3DBuffer texCoords) {

	FloatBuffer bufferImpl = null;

	if (texCoords != null) {
	    if(texCoords.bufferType != J3DBuffer.Type.FLOAT)
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));

	    bufferImpl = (FloatBuffer)texCoords.getROBuffer();
	    int bufferSize = bufferImpl.limit();

	    assert bufferImpl.isDirect();

	    int ts = getTexStride();

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;
		if (idx.maxTexCoordIndices[texCoordSet] * ts >= bufferSize) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
		}
	    } else if (bufferSize < ts*(initialTexCoordIndex[texCoordSet] + validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= TEXTURE_CHANGED;
	// refTexCoordsBuffer contains J3DBuffer object for tex coord
	refTexCoordsBuffer[texCoordSet] = texCoords;
	if (texCoords == null) {
	    refTexCoords[texCoordSet] = null;
	}
	else {
	    // refTexCoords contains NIOBuffer object for tex coord
	    refTexCoords[texCoordSet] = bufferImpl;
	}
        texCoordType = TF;
        validateTexCoordPointerType();
        if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}
    }

    J3DBuffer getTexCoordRefBuffer(int texCoordSet) {
	return refTexCoordsBuffer[texCoordSet];
    }

    void setTexCoordRef2f(int texCoordSet, TexCoord2f[] texCoords) {

        if (texCoordType != 0 && texCoordType != T2F) {
            if (texCoords != null) {
                throw new IllegalArgumentException(
                        J3dI18N.getString("GeometryArray98"));
            }
            return;
        }

        if (texCoords != null) {
	    if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) == 0) {
		throw new IllegalStateException(
				J3dI18N.getString("GeometryArray94"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxTexCoordIndices[texCoordSet] >= texCoords.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
		}
	    } else if (texCoords.length < (initialTexCoordIndex[texCoordSet] + validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
	    }

	}
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= TEXTURE_CHANGED;
	refTexCoords[texCoordSet] = texCoords;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    texCoordType = T2F;
            validateTexCoordPointerType();
	}
	else {
	    setupMirrorTexCoordPointer(texCoordSet, T2F);
	}
	if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && isLive) {
		sendDataChangedMessage(false);
	}
    }


    TexCoord2f[] getTexCoordRef2f(int texCoordSet) {
	if (refTexCoords != null && refTexCoords[texCoordSet] != null &&
		refTexCoords[texCoordSet] instanceof TexCoord2f[]) {
	    return ((TexCoord2f[])refTexCoords[texCoordSet]);
	} else {
	    return null;
	}
    }


    void setTexCoordRef3f(int texCoordSet, TexCoord3f[] texCoords) {

        if (texCoordType != 0 && texCoordType != T3F) {
            if (texCoords != null) {
                throw new IllegalArgumentException(
                        J3dI18N.getString("GeometryArray98"));
            }
            return;
        }

	if (texCoords != null) {

	    if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) == 0) {
		throw new IllegalStateException(
				J3dI18N.getString("GeometryArray95"));
	    }

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxTexCoordIndices[texCoordSet] >= texCoords.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray25"));
		}

	    } else if (texCoords.length < (initialTexCoordIndex[texCoordSet] + validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray113"));
	    }

	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= TEXTURE_CHANGED;
	refTexCoords[texCoordSet] = texCoords;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    texCoordType = T3F;
            validateTexCoordPointerType();
	}
	else {
	    setupMirrorTexCoordPointer(texCoordSet, T3F);
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}
    }


    TexCoord3f[] getTexCoordRef3f(int texCoordSet) {
	if (refTexCoords != null && refTexCoords[texCoordSet] != null &&
		refTexCoords[texCoordSet] instanceof TexCoord3f[]) {
	    return ((TexCoord3f[])refTexCoords[texCoordSet]);
	} else {
	    return null;
	}
    }


    /**
     * Sets the float vertex attribute array reference for the
     * specified vertex attribute number to the specified array.
     */
    void setVertexAttrRefFloat(int vertexAttrNum, float[] vertexAttrs) {

        // XXXX: Add the following test if we ever add double-precision types
        /*
        if (vertexAttrType != 0 && vertexAttrType != AF) {
            if (vertexAttrs != null) {
                // XXXX: new exception string
                throw new IllegalArgumentException(
                        J3dI18N.getString("GeometryArray98-XXX"));
            }
            return;
        }
        */

        if (vertexAttrs != null) {
            int sz = vertexAttrSizes[vertexAttrNum];

            if (this instanceof IndexedGeometryArrayRetained) {
                IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (sz*idx.maxVertexAttrIndices[vertexAttrNum] >= vertexAttrs.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray30"));
		}

	    } else if (vertexAttrs.length < sz*(initialVertexAttrIndex[vertexAttrNum] + validVertexCount) ) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray129"));
	    }
	}
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= VATTR_CHANGED;
	floatRefVertexAttrs[vertexAttrNum] = vertexAttrs;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    vertexAttrType = AF;
            validateVertexAttrPointerType();
	}
	else {
	    setupMirrorVertexAttrPointer(vertexAttrNum, AF);
	}
	if(isLive) {
            geomLock.unLock();
        }
	if (!inUpdater && isLive) {
	    sendDataChangedMessage(false);
	}
    }

    /**
     * Gets the float vertex attribute array reference for the specified
     * vertex attribute number.
     */
    float[] getVertexAttrRefFloat(int vertexAttrNum) {
        return floatRefVertexAttrs[vertexAttrNum];
    }


    /**
     * Sets the vertex attribute buffer reference for the specified
     * vertex attribute number to the specified buffer object.
     */
    void setVertexAttrRefBuffer(int vertexAttrNum, J3DBuffer vertexAttrs) {

	FloatBuffer bufferImpl = null;

	if (vertexAttrs != null) {
	    if(vertexAttrs.bufferType != J3DBuffer.Type.FLOAT)
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));

	    bufferImpl = (FloatBuffer)vertexAttrs.getROBuffer();
	    int bufferSize = bufferImpl.limit();

	    assert bufferImpl.isDirect();

	    int sz = vertexAttrSizes[vertexAttrNum];

            if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (idx.maxVertexAttrIndices[vertexAttrNum] * sz >= bufferSize) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray30"));
		}
	    } else if (bufferSize < sz*(initialVertexAttrIndex[vertexAttrNum] + validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray129"));
            }
        }
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
        dirtyFlag |= VATTR_CHANGED;
        vertexAttrsRefBuffer[vertexAttrNum] = vertexAttrs;
        if (vertexAttrs == null) {
            floatBufferRefVertexAttrs[vertexAttrNum] = null;
        }
        else {
            floatBufferRefVertexAttrs[vertexAttrNum] = bufferImpl;
        }
        vertexAttrType = AF;
        validateVertexAttrPointerType();
        if(isLive) {
            geomLock.unLock();
        }
        if (!inUpdater && isLive) {
            sendDataChangedMessage(false);
        }

    }

    /**
     * Gets the vertex attribute array buffer reference for the specified
     * vertex attribute number.
     */
    J3DBuffer getVertexAttrRefBuffer(int vertexAttrNum) {
	return vertexAttrsRefBuffer[vertexAttrNum];
    }


    void setInterleavedVertices(float[] vertexData) {
	if (vertexData != null) {

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (stride * idx.maxCoordIndex >= vertexData.length) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}

		if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
		    for (int i = 0; i < texCoordSetCount; i++) {
			if (stride * idx.maxTexCoordIndices[i] >= vertexData.length) {
			    throw new ArrayIndexOutOfBoundsException(
                                      J3dI18N.getString("IndexedGeometryArray25"));
			}
		    }
		}

		if (((this.vertexFormat & GeometryArray.COLOR) != 0) &&
		    (stride * idx.maxColorIndex >= vertexData.length)) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}

		if (((this.vertexFormat & GeometryArray.NORMALS) != 0) &&
		    (stride * idx.maxNormalIndex >= vertexData.length)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray26"));
		}
	    } else {
		if (vertexData.length < (stride * (initialVertexIndex+validVertexCount)))
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
	    }
	}

	// If the geometry has been rendered transparent, then make a copy
	// of the color pointer with 4f
        boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= VERTEX_CHANGED;
	colorChanged = 0xffff;
	interLeavedVertexData = vertexData;
	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    setupMirrorInterleavedColorPointer(false);
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    processCoordsChanged(vertexData == null);
	    sendDataChangedMessage(true);
	}
    }

    // set the interleaved vertex with NIO buffer
    void setInterleavedVertexBuffer(J3DBuffer vertexData) {

	FloatBuffer bufferImpl = null;

	if (vertexData != null ){

	    if (vertexData.bufferType != J3DBuffer.Type.FLOAT)
		throw new IllegalArgumentException(J3dI18N.getString("GeometryArray116"));

	    bufferImpl = (FloatBuffer)vertexData.getROBuffer();

            assert bufferImpl.isDirect();

	    int bufferSize = bufferImpl.limit();

	    if (this instanceof IndexedGeometryArrayRetained) {
		IndexedGeometryArrayRetained idx = (IndexedGeometryArrayRetained)this;

		if (stride * idx.maxCoordIndex >= bufferSize) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}

		if ((this.vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
		    for (int i = 0; i < texCoordSetCount; i++) {
			if (stride * idx.maxTexCoordIndices[i] >= bufferSize) {
			    throw new ArrayIndexOutOfBoundsException(
                                  J3dI18N.getString("IndexedGeometryArray25"));
			}
		    }
		}

		if (((this.vertexFormat & GeometryArray.COLOR) != 0) &&
		    (stride * idx.maxColorIndex >= bufferSize)) {
		    	throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray24"));
		}

		if (((this.vertexFormat & GeometryArray.NORMALS) != 0) &&
		    (stride * idx.maxNormalIndex >= bufferSize)) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("IndexedGeometryArray23"));
		}
	    } else {
		if (bufferSize < (stride * (initialVertexIndex+validVertexCount)))
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
	    }
	}
	// If the geometry has been rendered transparent, then make a copy
	// of the color pointer with 4f
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= VERTEX_CHANGED;
	colorChanged = 0xffff;
	interleavedVertexBuffer = vertexData;

	if(vertexData == null)
	    interleavedFloatBufferImpl = null;
	else
	    interleavedFloatBufferImpl = bufferImpl;

	if (inUpdater || (this instanceof IndexedGeometryArrayRetained &&
			  ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0))) {
	    setupMirrorInterleavedColorPointer(false);
	}
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    processCoordsChanged(vertexData == null);
	    sendDataChangedMessage(true);
	}
    }

    float[] getInterleavedVertices() {
	return interLeavedVertexData;
    }

    J3DBuffer getInterleavedVertexBuffer() {
	return interleavedVertexBuffer;
    }

    void setValidVertexCount(int validVertexCount) {

	boolean nullGeo = false;
	if (validVertexCount < 0) {
	    throw new IllegalArgumentException(J3dI18N.getString("GeometryArray110"));
	}

        if ((initialVertexIndex + validVertexCount) > vertexCount) {
            throw new IllegalArgumentException(J3dI18N.getString("GeometryArray100"));
        }

        if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
            // Interleaved, by-ref

            // use nio buffer for interleaved data
	    if(( vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0 && interleavedFloatBufferImpl != null){
		if(interleavedFloatBufferImpl.limit() <  stride * (initialVertexIndex + validVertexCount)) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
		}
	    }
	    //use java array for interleaved data
	    else if( interLeavedVertexData != null) {
		if(interLeavedVertexData.length < stride * (initialVertexIndex + validVertexCount)) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
		}
	    }
	    else {
		nullGeo = true;
	    }
	} else if ((vertexFormat & GeometryArray.BY_REFERENCE) != 0) {
            // Non-interleaved, by-ref

            if ((initialCoordIndex + validVertexCount) > vertexCount) {
                throw new IllegalArgumentException(J3dI18N.getString("GeometryArray104"));
            }
            if ((initialColorIndex + validVertexCount) > vertexCount) {
                throw new IllegalArgumentException(J3dI18N.getString("GeometryArray101"));
            }
            if ((initialNormalIndex + validVertexCount) > vertexCount) {
                throw new IllegalArgumentException(J3dI18N.getString("GeometryArray102"));
            }

            if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
                for (int i = 0; i < texCoordSetCount; i++) {
                    if ((initialTexCoordIndex[i] + validVertexCount) > vertexCount) {
                        throw new IllegalArgumentException(J3dI18N.getString(
                                "GeometryArray103"));
                    }
                }
            }

            if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
                for (int i = 0; i < vertexAttrCount; i++) {
                    if ((initialVertexAttrIndex[i] + validVertexCount) > vertexCount) {
                        throw new IllegalArgumentException(J3dI18N.getString(
                                "GeometryArray130"));
                    }
                }
            }

            if ((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0) {
		nullGeo = true;
            }

	    if (( vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
		// by reference with nio buffer
		switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
		case PF:
		    if(floatBufferRefCoords.limit() < 3 * (initialCoordIndex+validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		    }
		    break;
		case PD:
		    if(doubleBufferRefCoords.limit() < 3 * (initialCoordIndex+validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		    }
		    break;
		}

		switch ((vertexType & COLOR_DEFINED)) {
		case CF:
		    if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			if (floatBufferRefColors.limit() < 3 * (initialColorIndex+validVertexCount)) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
			if (floatBufferRefColors.limit() < 4 * (initialColorIndex+validVertexCount)) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    break;
		case CUB:
		    if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			if (byteBufferRefColors.limit() < 3 * (initialColorIndex + validVertexCount)) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
			if (byteBufferRefColors.limit() < 4 * (initialColorIndex + validVertexCount) ) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    break;
		}
		switch ((vertexType & GeometryArrayRetained.TEXCOORD_DEFINED)) {
		case TF:
		    FloatBuffer texBuffer;
		    for (int i = 0; i < texCoordSetCount; i++) {
			texBuffer = (FloatBuffer)refTexCoordsBuffer[i].getROBuffer();
			if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
			    if (texBuffer.limit() <  2 * (initialTexCoordIndex[i] + validVertexCount) ) {
				throw new ArrayIndexOutOfBoundsException(
									 J3dI18N.getString("GeometryArray113"));
			    }
			} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
			    if (texBuffer.limit() < 3 * (initialTexCoordIndex[i] + validVertexCount) ) {
				throw new ArrayIndexOutOfBoundsException(
									 J3dI18N.getString("GeometryArray113"));
			    }
			} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
			    if (texBuffer.limit() < 4 * (initialTexCoordIndex[i] + validVertexCount)) {
				throw new ArrayIndexOutOfBoundsException(
									 J3dI18N.getString("GeometryArray113"));
			    }
			}
		    }
		    break;
		}
		switch ((vertexType & GeometryArrayRetained.NORMAL_DEFINED)) {
		case NF:
		    if (floatBufferRefNormals.limit() < 3 * (initialNormalIndex + validVertexCount )) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
		    }
		    break;
		}
		switch ((vertexType & GeometryArrayRetained.VATTR_DEFINED)) {
		case AF:
                    for (int i = 0; i < vertexAttrCount; i++) {
                        int sz = vertexAttrSizes[i];
                        if (floatBufferRefVertexAttrs[i].limit() <
                                (sz * (initialVertexAttrIndex[i] + validVertexCount)) ) {
                            throw new ArrayIndexOutOfBoundsException(
                                    J3dI18N.getString("GeometryArray129"));
                        }
                    }
		    break;
		}
	    }
	    // By reference with java array
	    else {
		switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
		case PF:
		    if (floatRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		    }
		    break;
		case PD:
		    if (doubleRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		    }
		    break;
		case P3F:
		    if (p3fRefCoords.length < (initialCoordIndex+validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		    }
		    break;
		case P3D:
		    if (p3dRefCoords.length <  (initialCoordIndex+validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		    }
		    break;
		}
		switch ((vertexType & COLOR_DEFINED)) {
		case CF:
		    if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			if (floatRefColors.length < 3 * (initialColorIndex+validVertexCount)) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
			if (floatRefColors.length < 4 * (initialColorIndex+ validVertexCount) ) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    break;
		case CUB:
		    if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			if (byteRefColors.length < 3 * (initialColorIndex + validVertexCount)) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
			if (byteRefColors.length < 4 * (initialColorIndex + validVertexCount) ) {
			    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
			}
		    }
		    break;
		case C3F:
		    if (c3fRefColors.length < (initialColorIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		    break;
		case C4F:
		    if (c4fRefColors.length < (initialColorIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		    break;
		case C3UB:
		    if (c3bRefColors.length < (initialColorIndex + validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		    break;
		case C4UB:
		    if (c4bRefColors.length < (initialColorIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		    break;
		}
		switch ((vertexType & GeometryArrayRetained.TEXCOORD_DEFINED)) {
		case TF:
		    for (int i = 0; i < texCoordSetCount; i++) {
			if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
			    if (((float[])refTexCoords[i]).length < 2 * (initialTexCoordIndex[i] + validVertexCount) ) {
				throw new ArrayIndexOutOfBoundsException(
									 J3dI18N.getString("GeometryArray113"));
			    }
			} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
			    if (((float[])refTexCoords[i]).length < 3 * (initialTexCoordIndex[i] + validVertexCount) ) {
				throw new ArrayIndexOutOfBoundsException(
									 J3dI18N.getString("GeometryArray113"));
			    } else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
				if (((float[])refTexCoords[i]).length < 4 * (initialTexCoordIndex[i] + validVertexCount)) {
				    throw new ArrayIndexOutOfBoundsException(
									     J3dI18N.getString("GeometryArray113"));
				}
			    }
			}
		    }
		    break;
		case T2F:
		    for (int i = 0; i < texCoordSetCount; i++) {
			if (((TexCoord2f[])refTexCoords[i]).length < (initialTexCoordIndex[i] + validVertexCount) ) {
			    throw new ArrayIndexOutOfBoundsException(
								     J3dI18N.getString("GeometryArray113"));
			}
		    }
		    break;
		case T3F:
		    for (int i = 0; i < texCoordSetCount; i++) {
			if (((TexCoord3f[])refTexCoords[i]).length < (initialTexCoordIndex[i] + validVertexCount) ) {
			    throw new ArrayIndexOutOfBoundsException(
								     J3dI18N.getString("GeometryArray113"));
			}
		    }
		    break;
		}
		switch ((vertexType & GeometryArrayRetained.NORMAL_DEFINED)) {
		case NF:
		    if (floatRefNormals.length < 3 * (initialNormalIndex + validVertexCount )) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
		    }
		    break;
		case N3F:
		    if (v3fRefNormals.length < (initialNormalIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
		    }
		}
		switch ((vertexType & GeometryArrayRetained.VATTR_DEFINED)) {
		case AF:
                    for (int i = 0; i < vertexAttrCount; i++) {
                        int sz = vertexAttrSizes[i];
                        if (floatRefVertexAttrs[i].length <
                                (sz * (initialVertexAttrIndex[i] + validVertexCount)) ) {
                            throw new ArrayIndexOutOfBoundsException(
                                    J3dI18N.getString("GeometryArray129"));
                        }
                    }
		    break;
		}
	    }
	}
        boolean isLive = source!=null && source.isLive();
        if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= VERTEX_CHANGED;
	this.validVertexCount = validVertexCount;

	if(isLive){
            geomLock.unLock();
	}

	if (!inUpdater && isLive) {
	    processCoordsChanged(nullGeo);
	    sendDataChangedMessage(true);
	}
    }


    int getValidVertexCount() {
	return validVertexCount;
    }

    //Used for interleaved data (array or nio buffer)
    void setInitialVertexIndex(int initialVertexIndex) {
	boolean nullGeo = false;

	if ((initialVertexIndex + validVertexCount) > vertexCount) {
	    throw new IllegalArgumentException(J3dI18N.getString("GeometryArray100"));
	}

	if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0 && interleavedFloatBufferImpl != null) {
	    if(interleavedFloatBufferImpl.limit() <  stride * (initialVertexIndex + validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
	    }
	}
	// interleaved data using java array
	else if(interLeavedVertexData != null) {
		if (interLeavedVertexData.length < stride * (initialVertexIndex + validVertexCount)) {
		throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray114"));
	    }
	}
	else {
	    nullGeo = (vertexFormat & GeometryArray.INTERLEAVED) != 0; // Only for byRef
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
        }
	dirtyFlag |= VERTEX_CHANGED;
	this.initialVertexIndex = initialVertexIndex;
	if(isLive) {
            geomLock.unLock();
	}
	if (!inUpdater && isLive) {
	    processCoordsChanged(nullGeo);
	    sendDataChangedMessage(true);
	}
    }

    int getInitialVertexIndex() {
	return initialVertexIndex;
    }

    void setInitialCoordIndex(int initialCoordIndex) {
	if ((initialCoordIndex + validVertexCount) > vertexCount) {
	    throw new IllegalArgumentException(J3dI18N.getString("GeometryArray104"));
	}
	// use NIO buffer
	if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
	    switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
	    case PF:
		if(floatBufferRefCoords.limit() < (initialCoordIndex+validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		}
		break;
	    case PD:
		if(doubleBufferRefCoords.limit() < (initialCoordIndex+validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		}
		break;
	    }
	} else {
	    switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
	    case PF:
		if (floatRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		}
		break;
	    case PD:
		if (doubleRefCoords.length < 3 * (initialCoordIndex+validVertexCount)) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		}
		break;
	    case P3F:
		if (p3fRefCoords.length < (initialCoordIndex+validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		}
		break;
	    case P3D:
		if (p3dRefCoords.length <  (initialCoordIndex+validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray99"));
		}
		break;
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COORDINATE_CHANGED;
	this.initialCoordIndex = initialCoordIndex;
	dirtyFlag |= COORDINATE_CHANGED;
	if(isLive) {
            geomLock.unLock();
	}
	// Send a message, since bounds changed
	if (!inUpdater && isLive) {
	    processCoordsChanged((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0);
	    sendDataChangedMessage(true);
	}
    }

    int getInitialCoordIndex() {
	return initialCoordIndex;
    }

    void setInitialColorIndex(int initialColorIndex) {
	if ((initialColorIndex + validVertexCount) > vertexCount) {
	    throw new IllegalArgumentException(J3dI18N.getString("GeometryArray101"));
	}
	// NIO BUFFER CASE
	if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
	    switch ((vertexType & COLOR_DEFINED)) {
	    case CF:
		if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
		    if (floatBufferRefColors.limit() < 3 * (initialColorIndex+validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
		    if (floatBufferRefColors.limit() < 4 * (initialColorIndex+validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		break;

	    case CUB:
		if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
		    if (byteBufferRefColors.limit() < 3 * (initialColorIndex + validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
		    if (byteBufferRefColors.limit() < 4 * (initialColorIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		break;
	    }
	}
	// Java ARRAY CASE
	else {
	    switch ((vertexType & COLOR_DEFINED)) {
	    case CF:
		if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
		    if (floatRefColors.length < 3 * (initialColorIndex+validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
		    if (floatRefColors.length < 4 * (initialColorIndex+ validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		break;
	    case CUB:
		if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
		    if (byteRefColors.length < 3 * (initialColorIndex + validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		else if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_4) {
		    if (byteRefColors.length < 4 * (initialColorIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		    }
		}
		break;
	    case C3F:
		if (c3fRefColors.length < (initialColorIndex + validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		}
		break;
	    case C4F:
		if (c4fRefColors.length < (initialColorIndex + validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		}
		break;
	    case C3UB:
		if (c3bRefColors.length < (initialColorIndex + validVertexCount)) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		}
		break;
	    case C4UB:
		if (c4bRefColors.length < (initialColorIndex + validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray112"));
		}
		break;
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= COLOR_CHANGED;
	colorChanged = 0xffff;
	this.initialColorIndex = initialColorIndex;
	if(isLive) {
            geomLock.unLock();
	}
	// There is no need to send message for by reference, since we
	// use VA

    }

    int getInitialColorIndex() {
	return initialColorIndex;
    }

    void setInitialNormalIndex(int initialNormalIndex) {
	if ((initialNormalIndex + validVertexCount) > vertexCount) {
	    throw new IllegalArgumentException(J3dI18N.getString("GeometryArray102"));
	}
	if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
	    if((vertexType & NORMAL_DEFINED) == NF){
		if (floatBufferRefNormals.limit() < 3 * (initialNormalIndex + validVertexCount )) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
		}
	    }
	} else {
	    switch((vertexType & NORMAL_DEFINED)){
	    case NF:
		if (floatRefNormals.length < 3 * (initialNormalIndex + validVertexCount )) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
		}
		break;
	    case N3F:
		if (v3fRefNormals.length < (initialNormalIndex + validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(J3dI18N.getString("GeometryArray111"));
		}
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= NORMAL_CHANGED;
	this.initialNormalIndex = initialNormalIndex;
	if(isLive) {
            geomLock.unLock();
	}
	// There is no need to send message for by reference, since we
	// use VA
    }

    int getInitialNormalIndex() {
	return initialNormalIndex;
    }

    /**
     * Sets the initial vertex attribute index for the specified
     * vertex attribute number for this GeometryArray object.
     */
    void setInitialVertexAttrIndex(int vertexAttrNum,
            int initialVertexAttrIndex) {

        if ((initialVertexAttrIndex + validVertexCount) > vertexCount) {
            throw new IllegalArgumentException(J3dI18N.getString("GeometryArray130"));
        }

        int sz = vertexAttrSizes[vertexAttrNum];
        int minLength = sz * (initialVertexAttrIndex + validVertexCount);
        if ((vertexType & VATTR_DEFINED) == AF) {
            if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) {
                if (floatBufferRefVertexAttrs[vertexAttrNum].limit() < minLength) {
                    throw new ArrayIndexOutOfBoundsException(
                            J3dI18N.getString("GeometryArray129"));
                }
            } else {
                if (floatRefVertexAttrs[vertexAttrNum].length < minLength ) {
                    throw new ArrayIndexOutOfBoundsException(
                            J3dI18N.getString("GeometryArray129"));
                }
            }
        }
        boolean isLive = source!=null && source.isLive();
    	if(isLive){
            geomLock.getLock();
    	}
        dirtyFlag |= VATTR_CHANGED;
        this.initialVertexAttrIndex[vertexAttrNum] = initialVertexAttrIndex;
        if(isLive) {
            geomLock.unLock();
    	}
        // There is no need to send message for by reference, since we
        // use VA
    }


    /**
     * Gets the initial vertex attribute index for the specified
     * vertex attribute number for this GeometryArray object.
     */
    int getInitialVertexAttrIndex(int vertexAttrNum) {
        return initialVertexAttrIndex[vertexAttrNum];
    }

    void setInitialTexCoordIndex(int texCoordSet, int initialTexCoordIndex) {
	if ((initialTexCoordIndex + validVertexCount) > vertexCount) {
	    throw new IllegalArgumentException(J3dI18N.getString("GeometryArray103"));
	}

	if((vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0){
	    if((vertexType & TEXCOORD_DEFINED) == TF) {
		FloatBuffer texBuffer = (FloatBuffer)refTexCoordsBuffer[texCoordSet].getROBuffer();
		if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
		    if (texBuffer.limit() < 2 * (initialTexCoordIndex+ validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(
								 J3dI18N.getString("GeometryArray113"));
		    }
		} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
		    if (texBuffer.limit() < 3 * (initialTexCoordIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(
								 J3dI18N.getString("GeometryArray113"));
		    }
		} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
		    if (texBuffer.limit() < 4 * (initialTexCoordIndex + validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(
								 J3dI18N.getString("GeometryArray113"));
		    }
		}
	    }
	} else {
	    switch ((vertexType & TEXCOORD_DEFINED)) {
	    case TF:
		if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
		    if (((float[])refTexCoords[texCoordSet]).length < 2 * (initialTexCoordIndex+ validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(
								 J3dI18N.getString("GeometryArray113"));
		    }
		} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
		    if (((float[])refTexCoords[texCoordSet]).length < 3 * (initialTexCoordIndex + validVertexCount) ) {
			throw new ArrayIndexOutOfBoundsException(
								 J3dI18N.getString("GeometryArray113"));
		    }
		} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
		    if (((float[])refTexCoords[texCoordSet]).length < 4 * (initialTexCoordIndex + validVertexCount)) {
			throw new ArrayIndexOutOfBoundsException(
								 J3dI18N.getString("GeometryArray113"));
		    }
		}
		break;
	    case T2F:
		if (((TexCoord2f[])refTexCoords[texCoordSet]).length < (initialTexCoordIndex+ validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(
							     J3dI18N.getString("GeometryArray113"));
		}
		break;
	    case T3F:
		if (((TexCoord3f[])refTexCoords[texCoordSet]).length < (initialTexCoordIndex+ validVertexCount) ) {
		    throw new ArrayIndexOutOfBoundsException(
							     J3dI18N.getString("GeometryArray113"));
		}
		break;
	    }
	}
	boolean isLive = source!=null && source.isLive();
	if(isLive){
            geomLock.getLock();
	}
	dirtyFlag |= TEXTURE_CHANGED;
	this.initialTexCoordIndex[texCoordSet] = initialTexCoordIndex;
	if(isLive) {
            geomLock.unLock();
	}
	// There is no need to send message for by reference, since we
	// use VA
    }

    int getInitialTexCoordIndex(int texCoordSet) {
	return initialTexCoordIndex[texCoordSet];
    }


    int getTexCoordSetCount() {
	return this.texCoordSetCount;
    }

    int getTexCoordSetMapLength() {
	if (this.texCoordSetMap != null)
	    return this.texCoordSetMap.length;
	else
	    return 0;
    }

    void getTexCoordSetMap(int [] texCoordSetMap) {

	if (this.texCoordSetMap!=null) {
	    for (int i = 0; i < this.texCoordSetMap.length; i++) {
	         texCoordSetMap[i] = this.texCoordSetMap[i];
	    }
	}
    }

    void freeDlistId() {
	if (dlistId != -1) {
	    VirtualUniverse.mc.freeDisplayListId(dlistObj);
	    dlistId = -1;
	}
    }

    void assignDlistId() {
	if (dlistId == -1) {
	    dlistObj = VirtualUniverse.mc.getDisplayListId();
	    dlistId = dlistObj.intValue();
	}
    }

// Add the specified render atom as a user of this geometry array
// (for the specified render bin)
void addDlistUser(RenderBin renderBin, RenderAtomListInfo ra) {
	if (dlistUsers == null)
		dlistUsers = new HashMap<RenderBin, HashSet<RenderAtomListInfo>>(2, 1.0f);

	HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
	if (raSet == null) {
		raSet = new HashSet<RenderAtomListInfo>();
		dlistUsers.put(renderBin, raSet);
	}
	raSet.add(ra);
}

// Remove the specified render atom from the set of users of this
// geometry array (for the specified render bin)
void removeDlistUser(RenderBin renderBin, RenderAtomListInfo ra) {
	if (dlistUsers == null)
		return;

	HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
	if (raSet == null)
		return;

	raSet.remove(ra);
}

// Returns true if the set of render atoms using this geometry
// array in the specified render bin is empty.
boolean isDlistUserSetEmpty(RenderBin renderBin) {
	if (dlistUsers == null)
		return true;

	HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
	if (raSet == null) {
		return true;
	}
	return raSet.isEmpty();
}

// This method is used for debugging only
int numDlistUsers(RenderBin renderBin) {
	if (isDlistUserSetEmpty(renderBin))
		return 0;

	HashSet<RenderAtomListInfo> raSet = dlistUsers.get(renderBin);
	return raSet.size();
}

    void setDlistTimeStamp(int rdrBit, long timeStamp) {
	int index = getIndex(rdrBit);
	if (index >= timeStampPerDlist.length) {
	    long[] newList = new long[index * 2];
	    for (int i = 0; i < timeStampPerDlist.length; i++) {
		 newList[i] = timeStampPerDlist[i];
	    }
	    timeStampPerDlist = newList;
	}
	timeStampPerDlist[index] = timeStamp;
    }

    long getDlistTimeStamp(int rdrBit) {
	int index = getIndex(rdrBit);
       // If index is greater than what currently exists, increase
       // the array and return zero
       if (index >= timeStampPerDlist.length) {
           setDlistTimeStamp(rdrBit, 0);
       }
       return timeStampPerDlist[index];
    }

    int getIndex(int bit) {
	int num = 0;

	while (bit > 0) {
	    num++;
	    bit >>= 1;
	}
	return num;
    }


    boolean isWriteStatic() {

	if (source.getCapability(GeometryArray.ALLOW_COORDINATE_WRITE ) ||
	    source.getCapability(GeometryArray.ALLOW_COLOR_WRITE) ||
	    source.getCapability(GeometryArray.ALLOW_NORMAL_WRITE) ||
	    source.getCapability(GeometryArray.ALLOW_TEXCOORD_WRITE) ||
            source.getCapability(GeometryArray.ALLOW_VERTEX_ATTR_WRITE) ||
	    source.getCapability(GeometryArray.ALLOW_COUNT_WRITE) ||
	    source.getCapability(GeometryArray.ALLOW_REF_DATA_WRITE))
	    return false;

	return true;
    }

    /**
     * The functions below are only used in compile mode
     */
    void setCompiled(ArrayList curList) {
	int i;
	int num = curList.size();
	int offset = 0;
	geoOffset = new int[num];
	compileVcount = new int[num];
	int vcount = 0, vformat = 0;
	vcount = 0;
	isCompiled = true;

	if (num > 0)
	    source = ((SceneGraphObjectRetained)curList.get(0)).source;
	for (i = 0; i < num; i++) {
	    // Build the back mapping
	    GeometryArrayRetained geo = (GeometryArrayRetained)curList.get(i);
	    ((GeometryArray)geo.source).retained = this;
	    compileVcount[i] = geo.getValidVertexCount();
	    vcount += geo.getValidVertexCount();
	    geoOffset[i] = offset;
	    offset += geo.stride() * compileVcount[i];
	    vformat = geo.getVertexFormat();
	}
	createGeometryArrayData(vcount, vformat);

	// Assign the initial and valid fields
	validVertexCount = vcount;
	initialVertexIndex = 0;

	mergeGeometryArrays(curList);

    }

    /*
    // Ununsed
    int getVertexCount(int index) {
	return compileVcount[index];
    }


    int getValidVertexCount(int index) {
	return compileVcount[index];
    }


    int getInitialVertexIndex(int index) {
	return 0;
    }
    */

    void mergeGeometryArrays(ArrayList list) {
	float[] curVertexData;
	int length, srcOffset;
	int curOffset = 0;
	// We only merge if the texCoordSetCount is 1 and there are no
        // vertex attrs
	if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
	    texCoordSetCount = 1;
	    texCoordSetMap = new int[1];
	    texCoordSetMap[0] = 1;
	}
	for (int i = 0; i < list.size(); i++) {
	    GeometryArrayRetained geo = (GeometryArrayRetained)list.get(i);
	    // Take into account the validVertexCount and initialVertexIndex
	    curVertexData = geo.vertexData;
	    length = geo.validVertexCount * stride;
	    srcOffset = geo.initialVertexIndex * stride;
	    System.arraycopy(curVertexData, srcOffset, this.vertexData, curOffset,
			     length);
	    curOffset += length;

	    // assign geoBounds
	    geoBounds.combine(geo.geoBounds);

	}
	geoBounds.getCenter(this.centroid);
    }

    boolean isMergeable() {

	// For now, turn off by ref geometry
	if ((vertexFormat & GeometryArray.BY_REFERENCE) != 0)
	    return false;

	if (!isStatic())
	    return false;

	// If there is more than one set of texture coordinate set defined
	// then don't merge geometry (we avoid dealing with texCoordSetMap
	if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0 &&
	    (texCoordSetCount > 1 ||
	     texCoordSetMap != null && texCoordSetMap.length > 1)) {
	    return false;
	}

        // We will avoid merging geometry if there are any vertex attributes.
        if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
            return false;
        }

	// If intersect is allowed turn off merging
	if (source.getCapability(Geometry.ALLOW_INTERSECT))
	    return false;

	return true;
    }

    @Override
    void compile(CompileState compState) {
        super.compile(compState);

	if ((vertexFormat & GeometryArray.NORMALS) != 0) {
	    compState.needNormalsTransform = true;
	}
    }

    @Override
    void mergeTransform(TransformGroupRetained xform) {
	if (geoBounds != null) {
	    geoBounds.transform(xform.transform);
	}
    }

    // This adds a MorphRetained to the list of users of this geometry
    void addMorphUser(MorphRetained m) {
        int index;

	if(morphUniverseList == null) {
	    morphUniverseList = new ArrayList<VirtualUniverse>(1);
	    morphUserLists = new ArrayList<ArrayList<MorphRetained>>(1);
	}
        synchronized (morphUniverseList) {
            if (morphUniverseList.contains(m.universe)) {
                index = morphUniverseList.indexOf(m.universe);
                morphUserLists.get(index).add(m);
            } else {
                morphUniverseList.add(m.universe);
                ArrayList<MorphRetained> morphList = new ArrayList<MorphRetained>(5);
                morphList.add(m);
                morphUserLists.add(morphList);
            }
        }
    }

    // This adds a MorphRetained to the list of users of this geometry
    void removeMorphUser(MorphRetained m) {
        int index;

	if(morphUniverseList == null)
	    return;

        synchronized (morphUniverseList) {
            index = morphUniverseList.indexOf(m.universe);
            ArrayList<MorphRetained> morphList = morphUserLists.get(index);
            morphList.remove(morphList.indexOf(m));
            if (morphList.size() == 0) {
                morphUserLists.remove(index);
                morphUniverseList.remove(index);
            }
        }
    }
    // Initialize mirror object when geometry is first setLived
    void initMirrorGeometry() {
	geomLock.getLock();
	if (this instanceof IndexedGeometryArrayRetained) {
	    if ((vertexFormat & GeometryArray.USE_COORD_INDEX_ONLY) == 0) {
		mirrorGeometry =
		    ((IndexedGeometryArrayRetained)this).cloneNonIndexedGeometry();
	    }
	    else {
		mirrorGeometry = null;
	    }
	}
	geomLock.unLock();

    }

    // Update Mirror Object in response to change in geometry
    void updateMirrorGeometry() {
	geomLock.getLock();
	if (this instanceof IndexedGeometryArrayRetained) {
	    if (mirrorGeometry != null) {
		mirrorGeometry =
		    ((IndexedGeometryArrayRetained)this).cloneNonIndexedGeometry();
	    }
	}
	geomLock.unLock();

    }


    // Used by the picking intersect routines
    void getVertexData(int i, Point3d pnts) {
	int offset;
	if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
	    offset = stride * i + coordinateOffset;
	    pnts.x = this.vertexData[offset];
	    pnts.y = this.vertexData[offset+1];
	    pnts.z = this.vertexData[offset+2];
	    return;
	}

	if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0 ) {
	    if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
		offset = stride * i + coordinateOffset;
		pnts.x = this.interLeavedVertexData[offset];
		pnts.y = this.interLeavedVertexData[offset+1];
		pnts.z = this.interLeavedVertexData[offset+2];
	    }
	    else {
		switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
		case GeometryArrayRetained.PF:
		    offset = i*3;
		    pnts.x = this.floatRefCoords[offset];
		    pnts.y = this.floatRefCoords[offset+1];
		    pnts.z = this.floatRefCoords[offset+2];
		    break;
		case GeometryArrayRetained.PD:
		    offset = i*3;
		    pnts.x = this.doubleRefCoords[offset];
		    pnts.y = this.doubleRefCoords[offset+1];
		    pnts.z = this.doubleRefCoords[offset+2];
		    break;
		case GeometryArrayRetained.P3F:
		    pnts.x = this.p3fRefCoords[i].x;
		    pnts.y = this.p3fRefCoords[i].y;
		    pnts.z = this.p3fRefCoords[i].z;
		    break;
		case GeometryArrayRetained.P3D:
		    pnts.x = this.p3dRefCoords[i].x;
		    pnts.y = this.p3dRefCoords[i].y;
		    pnts.z = this.p3dRefCoords[i].z;
		    break;
		}
	    }
	}// end of non nio buffer
	else { // NIO BUFFER
	    if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) {
		offset = stride * i + coordinateOffset;
		pnts.x = this.interleavedFloatBufferImpl.get(offset);
		pnts.y = this.interleavedFloatBufferImpl.get(offset+1);
		pnts.z = this.interleavedFloatBufferImpl.get(offset+2);
	    }
	    else {
		switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
		case GeometryArrayRetained.PF:
		    offset = i*3;
		    pnts.x = this.floatBufferRefCoords.get(offset);
		    pnts.y = this.floatBufferRefCoords.get(offset+1);
		    pnts.z = this.floatBufferRefCoords.get(offset+2);
		    break;
		case GeometryArrayRetained.PD:
		    offset = i*3;
		    pnts.x = this.doubleBufferRefCoords.get(offset);
		    pnts.y = this.doubleBufferRefCoords.get(offset+1);
		    pnts.z = this.doubleBufferRefCoords.get(offset+2);
		    break;
		}
	    }
	} // end of nio buffer
    }

    void getCrossValue(Point3d p1, Point3d p2, Vector3d value) {
        value.x += p1.y*p2.z - p1.z*p2.y;
	value.y += p2.x*p1.z - p2.z*p1.x;
        value.z += p1.x*p2.y - p1.y*p2.x;
    }


    @Override
    boolean intersect(Transform3D thisLocalToVworld,
		      Transform3D otherLocalToVworld, GeometryRetained  geom) {

	Transform3D t3d =  new Transform3D();
	boolean isIntersect = false;

	if (geom instanceof GeometryArrayRetained ) {
	    GeometryArrayRetained geomArray = (GeometryArrayRetained)  geom;

	    if (geomArray.validVertexCount >= validVertexCount) {
		t3d.invert(otherLocalToVworld);
		t3d.mul(thisLocalToVworld);
		isIntersect = intersect(t3d, geom);
	    } else {
		t3d.invert(thisLocalToVworld);
		t3d.mul(otherLocalToVworld);
		isIntersect = geomArray.intersect(t3d, this);
	    }
	} else {
		t3d.invert(thisLocalToVworld);
		t3d.mul(otherLocalToVworld);
		isIntersect = geom.intersect(t3d, this);
	}
	return isIntersect;
    }

    int getNumCoordCount() {
	int count = 0;
	if ((vertexFormat & GeometryArray.COORDINATES) != 0){
	    if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
		count = vertexCount;
		return count;
	    }

	    if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
		    case PF:
			count =  floatRefCoords.length/3;
			break;
		    case PD:
			count = doubleRefCoords.length/3;
			break;
		    case P3F:
			count = p3fRefCoords.length;
			break;
		    case P3D:
			count = p3dRefCoords.length;
			break;
		    }
		}
		else {
		    count = interLeavedVertexData.length/stride;
		}
	    }
	    else { // nio buffer
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    switch ((vertexType & GeometryArrayRetained.VERTEX_DEFINED)) {
		    case PF:
			count =  floatBufferRefCoords.limit()/3; // XXXX: limit or capacity?
			break;
		    case PD:
			count = doubleBufferRefCoords.limit()/3;
			break;
		    }
		}
		else {
		    count = interleavedFloatBufferImpl.limit()/stride;
		}
	    }
	}
	return count;
    }

    int getNumColorCount() {
	int count = 0;
	if ((vertexFormat & GeometryArray.COLOR) != 0){
	    if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
		count = vertexCount;
		return count;
	    }
	    if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    switch ((vertexType & GeometryArrayRetained.COLOR_DEFINED)) {
		    case CF:
			if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			    count =  floatRefColors.length/3;
			}
			else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
			    count =  floatRefColors.length/4;
			}
			break;
		    case CUB:
			if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			    count =  byteRefColors.length/3;
			}
			else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
			    count =  byteRefColors.length/4;
			}
			break;
		    case C3F:
			count = c3fRefColors.length;
			break;
		    case C4F:
			count = c4fRefColors.length;
			break;
		    case C3UB:
			count = c3bRefColors.length;
			break;
		    case C4UB:
			count = c4bRefColors.length;
			break;
		    }
		}
		else {
		    count = interLeavedVertexData.length/stride;
		}
	    } // end of non nio buffer
	    else {
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    switch ((vertexType & GeometryArrayRetained.COLOR_DEFINED)) {
		    case CF:
			if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			    count =  floatBufferRefColors.limit()/3;
			}
			else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
			    count =  floatBufferRefColors.limit()/4;
			}
			break;
		    case CUB:
			if ((vertexFormat & GeometryArray.COLOR_4) == GeometryArray.COLOR_3) {
			    count =  byteBufferRefColors.limit()/3;
			}
			else if ((vertexFormat & GeometryArray.COLOR_4)== GeometryArray.COLOR_4){
			    count =  byteBufferRefColors.limit()/4;
			}
			break;
		    }
		}
		else {
		    count = interleavedFloatBufferImpl.limit()/stride;
		}
	    } // end of nio buffer
	}
	return count;
    }

    int getNumNormalCount() {
	int count = 0;
	if ((vertexFormat & GeometryArray.NORMALS) != 0){
	    if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
		count = vertexCount;
		return count;
	    }

	    if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    switch ((vertexType & NORMAL_DEFINED)) {
		    case NF:
			count =  floatRefNormals.length/3;
			break;
		    case N3F:
			count = v3fRefNormals.length;
			break;
		    }
		}
		else {
		    count = interLeavedVertexData.length/stride;
		}
	    } // end of non nio buffer
	    else {
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    if ((vertexType & NORMAL_DEFINED) == NF ) {
			count =  floatBufferRefNormals.limit()/3;
		    }
		}
		else {
		    count = interleavedFloatBufferImpl.limit()/stride;
		}
	    }
	}
	return count;
    }

    int getNumTexCoordCount(int i) {
	int count = 0;
	if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0){
	    if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0){
		count = vertexCount;
		return count;
	    }

	    if ((vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) {
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    switch ((vertexType & TEXCOORD_DEFINED)) {
		    case TF:
			if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
			    count = ((float[])refTexCoords[i]).length/2;
			} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
			    count = ((float[])refTexCoords[i]).length/3;
			} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
			    count = ((float[])refTexCoords[i]).length/4;
			}

			break;
		    case T2F:
			count = ((TexCoord2f[])refTexCoords[i]).length;
			break;
		    case T3F:
			count = ((TexCoord3f[])refTexCoords[i]).length;
		    }
		}
		else {
		    count = interLeavedVertexData.length/stride;
		}
	    }
	    else { // nio buffer
		if ((vertexFormat & GeometryArray.INTERLEAVED) == 0){
		    if ((vertexType & TEXCOORD_DEFINED) == TF) {
			FloatBuffer texBuffer = (FloatBuffer)refTexCoordsBuffer[i].getROBuffer();
			if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_2) != 0) {
			    count = texBuffer.limit()/2;
			} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_3) != 0) {
			    count = texBuffer.limit()/3;
			} else if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE_4) != 0) {
			    count = texBuffer.limit()/4;
			}
		    }
		}
		else {
		    count = interleavedFloatBufferImpl.limit()/stride;
		}
	    }
	}
	return count;
    }

    // NOTE: we don't need a getNumVertexAttrCount method, since getNum*Count
    // is only called by Morph, which doesn't support vertex attrs


    // Found the min distance from center to the point/line/tri/quad
    // form by dist[]
    void computeMinDistance(Point3d coordinates[], Point3d center,
			    Vector3d normal,
			    double dist[], Point3d iPnt) {
	double x, y, z;
	int i, j;

	if (coordinates.length == 1) {
	    // a point
	    iPnt.x = coordinates[0].x;
	    iPnt.y = coordinates[0].y;
	    iPnt.z = coordinates[0].z;
	    x = iPnt.x - center.x;
	    y = iPnt.y - center.y;
	    z = iPnt.z - center.z;
	    dist[0] = Math.sqrt(x*x + y*y + z*z);
	    return;
	}


	if (coordinates.length == 2) {
	    // a line
	    dist[0] = Math.sqrt(Utils.ptToSegSquare(center, coordinates[0], coordinates[1], iPnt));
	    return;
	}

	double normalLen = 0;

	if (normal == null) {
	    Vector3d vec0 = new Vector3d();
	    Vector3d vec1 = new Vector3d();
	    normal = new Vector3d();
	    // compute plane normal for coordinates.
	    for (i=0; i<coordinates.length-1;) {
		vec0.x = coordinates[i+1].x - coordinates[i].x;
		vec0.y = coordinates[i+1].y - coordinates[i].y;
		vec0.z = coordinates[i+1].z - coordinates[i++].z;
		if(vec0.length() > 0.0)
		    break;
	    }

	    for (j=i; j<coordinates.length-1; j++) {
		vec1.x = coordinates[j+1].x - coordinates[j].x;
		vec1.y = coordinates[j+1].y - coordinates[j].y;
		vec1.z = coordinates[j+1].z - coordinates[j].z;
		if(vec1.length() > 0.0)
		    break;
	    }

	    if (j == (coordinates.length-1)) {
		// Degenerate polygon, check with edge only
		normal = null;
	    } else {
		normal.cross(vec0,vec1);
	    }
	}

	if (normal != null) {
	    normalLen = normal.length();
	    if ( normalLen == 0.0) {
		// Degenerate polygon, check with edge only
		normal = null;
	    }
	}


	if (coordinates.length == 3) {
	    // a triangle
	    if (normal != null) {
		double d = -(normal.x*coordinates[0].x +
			     normal.y*coordinates[0].y +
			     normal.z*coordinates[0].z);
		dist[0] = (normal.x*center.x + normal.y*center.y +
			   normal.z*center.z +
			   d)/normalLen;
		iPnt.x = center.x - dist[0]*normal.x/normalLen;
		iPnt.y = center.y - dist[0]*normal.y/normalLen;
		iPnt.z = center.z - dist[0]*normal.z/normalLen;

		 if (pointInTri(iPnt, coordinates[0], coordinates[1],
				coordinates[2], normal)) {
		     return;
		 }
	    }

	    // checking point to line distance
	    double minDist;
	    Point3d minPnt = new Point3d();

	    dist[0] = Utils.ptToSegSquare(center, coordinates[0], coordinates[1], iPnt);
	    minDist = Utils.ptToSegSquare(center, coordinates[1], coordinates[2], minPnt);
	    if (minDist < dist[0]) {
		dist[0] = minDist;
		iPnt.x = minPnt.x;
		iPnt.y = minPnt.y;
		iPnt.z = minPnt.z;
	    }
	    minDist = Utils.ptToSegSquare(center, coordinates[2], coordinates[0], minPnt);
	    if (minDist < dist[0]) {
		dist[0] = minDist;
		iPnt.x = minPnt.x;
		iPnt.y = minPnt.y;
		iPnt.z = minPnt.z;
	    }
	    dist[0] = Math.sqrt(dist[0]);
	    return;
	}

	// a quad
	if (normal != null) {
	    double d = -(normal.x*coordinates[0].x +
			 normal.y*coordinates[0].y +
			 normal.z*coordinates[0].z);
	    dist[0] = (normal.x*center.x + normal.y*center.y +
		       normal.z*center.z +
		       d)/normalLen;
	    iPnt.x = center.x - dist[0]*normal.x/normalLen;
	    iPnt.y = center.y - dist[0]*normal.y/normalLen;
	    iPnt.z = center.z - dist[0]*normal.z/normalLen;

	    if (pointInTri(iPnt, coordinates[0], coordinates[1],
			   coordinates[2], normal) ||
		pointInTri(iPnt, coordinates[1], coordinates[2],
			   coordinates[3], normal)) {
		return;
	    }
	}

	// checking point to line distance
	double minDist;
	Point3d minPnt = new Point3d();

	dist[0] = Utils.ptToSegSquare(center, coordinates[0], coordinates[1], iPnt);
	minDist = Utils.ptToSegSquare(center, coordinates[1], coordinates[2], minPnt);
	if (minDist < dist[0]) {
	    dist[0] = minDist;
	    iPnt.x = minPnt.x;
	    iPnt.y = minPnt.y;
	    iPnt.z = minPnt.z;
	}
	minDist = Utils.ptToSegSquare(center, coordinates[2], coordinates[3], minPnt);
	if (minDist < dist[0]) {
	    dist[0] = minDist;
	    iPnt.x = minPnt.x;
	    iPnt.y = minPnt.y;
	    iPnt.z = minPnt.z;
	}

	minDist = Utils.ptToSegSquare(center, coordinates[3], coordinates[0], minPnt);
	if (minDist < dist[0]) {
	    dist[0] = minDist;
	    iPnt.x = minPnt.x;
	    iPnt.y = minPnt.y;
	    iPnt.z = minPnt.z;
	}

	dist[0] = Math.sqrt(dist[0]);
    }

    @Override
    void handleFrequencyChange(int bit) {
	int mask = 0;
	if ((vertexFormat & GeometryArray.BY_REFERENCE) == 0) {
	    if ((bit == GeometryArray.ALLOW_COORDINATE_WRITE) ||
		(((vertexFormat & GeometryArray.COLOR) != 0) &&
		 bit == GeometryArray.ALLOW_COLOR_WRITE)||
		(((vertexFormat & GeometryArray.NORMALS) != 0) &&
		 bit == GeometryArray.ALLOW_NORMAL_WRITE) ||
		(((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) &&
		 bit == GeometryArray.ALLOW_TEXCOORD_WRITE) ||
		(((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) &&
		 bit == GeometryArray.ALLOW_VERTEX_ATTR_WRITE) ||
		(bit == GeometryArray.ALLOW_COUNT_WRITE)) {
		mask = 1;
	    }
	}
	else {
	    if (bit == GeometryArray.ALLOW_REF_DATA_WRITE)
		mask = 1;
	}
	if (mask != 0) {
	    setFrequencyChangeMask(bit, mask);
	}
    }

    int getTexCoordType() {
        return texCoordType;
    }

    int getVertexAttrType() {
        return vertexAttrType;
    }

}