/*
 * $RCSfile$
 *
 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
 *
 * Use is subject to license terms.
 *
 * $Revision$
 * $Date$
 * $State$
 */

#include "StdAfx.h"


//#define VBDEBUG 
//#define TEXDEBUG 

#define getVertexFormat(texSize) \
                 (((texSize) << D3DFVF_TEXCOUNT_SHIFT) & D3DFVF_TEXCOUNT_MASK)

/*
 * This correspond to the constant in d3dtypes.h
 * under D3D 7.0/8.0 header and may not portable :
 * D3DFVF_TEXTUREFORMAT1 3       
 * D3DFVF_TEXTUREFORMAT2 0       
 * D3DFVF_TEXTUREFORMAT3 1       
 * D3DFVF_TEXTUREFORMAT4 2       
 */
CONST static DWORD TexFormatSizeTable[5] = {0, 3, 0, 1, 2};
static float defaultTexCoord[4] = {0, 0, 0, 0};

typedef struct _D3DDRAWPRIMITIVESTRIDEDDATA
{
    DWORD  positionStride;
    jfloat  *fpositionPtr;
    jdouble *dpositionPtr;
    DWORD  normalStride;
    jfloat *normalPtr;
    DWORD  diffuseStride;
    jfloat  *fdiffusePtr;
    jbyte   *bdiffusePtr;
    jint   *indexPtr;
    jint   initialIndexIndex; 
    DWORD  textureCoordsStride[D3DDP_MAXTEXCOORD];
    jfloat* textureCoordsPtr[D3DDP_MAXTEXCOORD];
    jint texCoordPosition[D3DDP_MAXTEXCOORD];
    boolean useAlpha; 
    boolean modulateAlpha;
    jfloat alpha;
} D3DDRAWPRIMITIVESTRIDEDDATA, *LPD3DDRAWPRIMITIVESTRIDEDDATA;


void copyIndexVertexToVB(D3dCtx *d3dCtx,
			 D3DDRAWPRIMITIVESTRIDEDDATA* strideData,
			 DWORD indexCount,
			 jint cDirty,
			 BOOL insertStrideToVB,
			 BOOL expandQuadIndex)
{
    HRESULT hr;

    if (cDirty & javax_media_j3d_GeometryArrayRetained_INDEX_CHANGED) {
	jint *src = strideData->indexPtr + strideData->initialIndexIndex;
	LPDIRECT3DINDEXBUFFER8 indexBuffer = d3dCtx->pVB->indexBuffer;
	D3DINDEXBUFFER_DESC desc;
	BYTE *bptr;

	indexBuffer->GetDesc(&desc);
	hr = indexBuffer->Lock(0, 0, &bptr,  0);
	if (FAILED(hr)) {
	    D3dCtx::d3dWarning(LOCKINDEXVBFAIL, hr);
	    return;
	}
	
	int i = indexCount;

	if (desc.Format == D3DFMT_INDEX16) {
	    USHORT *dst = (USHORT *) bptr;
	    
	    if (!expandQuadIndex) {
		while (--i >= 0) {
		    *dst++ = *src++;
		}
	    } else {
		USHORT *endptr = dst + (USHORT) 3*indexCount/2;

		while (dst < endptr) {
		    *dst++ = *src;   
		    *dst++ = *(src+1);
		    *dst++ = *(src+2);
		    *dst++ = *src;  
		    src++; 
		    src++; 
		    *dst++ = *src;
		    src++;
		    *dst++ = *src;  
		    src++;
		}
	    }
	} else {
	    UINT *dst = (UINT *) bptr;
	    
	    if (!expandQuadIndex) {
		while (--i >= 0) {
		    *dst++ = *src++;
		}
	    } else {
		UINT *endptr = dst + (UINT) 3*indexCount/2;
		while (dst < endptr) {
		    *dst++ = *src;   
		    *dst++ = *(src+1);
		    *dst++ = *(src+2);
		    *dst++ = *src;  
		    src++; 
		    src++; 
		    *dst++ = *src;
		    src++;
		    *dst++ = *src;  
		    src++;
		}

		dst = (UINT *) bptr;
	    }
	}
	
	indexBuffer->Unlock();
    }

    if (insertStrideToVB) {
	d3dCtx->pVB->addStride(d3dCtx->pVB->indexCount);
    }
}

// This function copy the stride vertex data into Vertex Buffer
// point by vbptr and update vbptr
void copyVertexToVB(D3dCtx *d3dCtx,
		    D3DDRAWPRIMITIVESTRIDEDDATA* strideData,
		    DWORD vcount,
		    float **vbptr,
		    jint cDirty,
		    BOOL insertStrideToVB, 
		    jdouble* xform,
		    jdouble* nxform)
{
    float *dst;
    float *src;
    double *dsrc;
    DWORD i;
    DWORD srcStride;
    DWORD currStride;

    DWORD dstStride = d3dCtx->pVB->stride >> 2;
    DWORD vertexFormat = d3dCtx->pVB->vertexFormat;
    float *endptr;

    // Copy Position
    if (cDirty & javax_media_j3d_GeometryArrayRetained_COORDINATE_CHANGED) {
	dst = *vbptr;
	// Before we call two times src++ in position and
	// normal copy so we only need to add dstStride - 2
	// at the end.
	srcStride = strideData->positionStride - 2;
	endptr = dst + vcount*dstStride;
	dstStride -= 2;
	src = strideData->fpositionPtr;

	if (xform == NULL) {
	    if (src != NULL) {
		while (dst < endptr) {
		    *dst++ = *src++;  // pos x
		    *dst++ = *src++;  // pos y
		    *dst   = *src;    // pos z
		    dst += dstStride;
		    src += srcStride;
		}
	    } else { 
		// double is used for position coordinate in executeVA()
		dsrc = strideData->dpositionPtr;
		while (dst < endptr) {
		    *dst++ = *dsrc++;  // pos x
		    *dst++ = *dsrc++;  // pos y
		    *dst   = *dsrc;    // pos z
		    dst += dstStride;
		    dsrc += srcStride;
		}
	    }
	} else {
	    if (src != NULL) {
		float x, y, z, w;
		while (dst < endptr) {
		    x = *src++;  
		    y = *src++; 
		    z = *src;    // pos z
		    w = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
		    *dst++ = (xform[0]*x + xform[1]*y + xform[2]*z + xform[3])*w;
		    *dst++ = (xform[4]*x + xform[5]*y + xform[6]*z + xform[7])*w;
		    *dst   = (xform[8]*x + xform[9]*y + xform[10]*z + xform[11])*w;
		    dst += dstStride;
		    src += srcStride;
		}
	    } else { 
		double x, y, z, w;
		// double is used for position coordinate in executeVA()
		dsrc = strideData->dpositionPtr;
		while (dst < endptr) {
		    x = *src++;  
		    y = *src++; 
		    z = *src;    // pos z
		    w = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
		    *dst++ = (xform[0]*x + xform[1]*y + xform[2]*z + xform[3])*w;
		    *dst++ = (xform[4]*x + xform[5]*y + xform[6]*z + xform[7])*w;
		    *dst   = (xform[8]*x + xform[9]*y + xform[10]*z + xform[11])*w;
		    dst += dstStride;
		    dsrc += srcStride;
		}
	    }

	}
	// restore value
	dstStride += 2;
    } 

    // Copy Normal
    if (vertexFormat & D3DFVF_NORMAL) { 
	if (cDirty & javax_media_j3d_GeometryArrayRetained_NORMAL_CHANGED) {
	    dst = *vbptr + 3;
	    src = strideData->normalPtr;
	    srcStride = strideData->normalStride - 2;
	    endptr = dst + vcount*dstStride;
	    dstStride -= 2;
	    if (nxform == NULL) {
		while (dst < endptr) {
		    *dst++ = *src++;  // norm x 
		    *dst++ = *src++;  // norm y
		    *dst   = *src;    // norm z
		    dst += dstStride;
		    src += srcStride;
		} 
	    } else {
		float nx, ny, nz, nw;
		while (dst < endptr) {
		    nx = *src++;  
		    ny = *src++; 
		    nz = *src;    // pos z
		    nw = 1/(nxform[12]*nx + nxform[13]*ny + nxform[14]*nz + nxform[15]);
		    *dst++ = (nxform[0]*nx + nxform[1]*ny + nxform[2]*nz + nxform[3])*nw;
		    *dst++ = (nxform[4]*nx + nxform[5]*ny + nxform[6]*nz + nxform[7])*nw;
		    *dst   = (nxform[8]*nx + nxform[9]*ny + nxform[10]*nz + nxform[11])*nw;
		    dst += dstStride;
		    dsrc += srcStride;
		}
	    }
	    // restore value
	    dstStride += 2;
	}
	// nx,ny,nz copy in addtion to x, y, z
	currStride = 6;
    } else {
	// This is used to keep track of the offset
	// from beginning of the current type copy.
	currStride = 3; // x,y,z already copy
    }

    // Copy Diffuse Color (DWORD & float are of the same size)

    if (vertexFormat & D3DFVF_DIFFUSE) {
	if (cDirty & javax_media_j3d_GeometryArrayRetained_COLOR_CHANGED) {

	    DWORD* wdst = (DWORD *) *vbptr + currStride;
	    DWORD* wendptr = wdst + vcount*dstStride;

	    if (strideData->fdiffusePtr) {
		float* wsrc = strideData->fdiffusePtr;
		float r, g, b, a;
		if ((d3dCtx->currDisplayListID <= 0) || 
		    !strideData->modulateAlpha) {
		    // execute() or executeVA()

		    if (strideData->useAlpha) {
			srcStride = strideData->diffuseStride - 3;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc++;
			    a = *wsrc;
			    *wdst = D3DCOLOR_COLORVALUE(r, g, b, a);
			    wdst += dstStride;
			    wsrc += srcStride;
			}
		    } else {
			srcStride = strideData->diffuseStride - 2;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc;
			    *wdst = D3DCOLOR_COLORVALUE(r, g, b, 0);
			    wdst += dstStride;
			    wsrc += srcStride;
			}			
		    }
		} else {  
		    // buildGA() & modulateAlpha
		    float alpha = strideData->alpha;
		    if (strideData->useAlpha) {
			srcStride = strideData->diffuseStride - 3;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc++;
			    a = *wsrc * alpha;
			    *wdst = D3DCOLOR_COLORVALUE(r, g, b, a);
			    wdst += dstStride;
			    wsrc += srcStride;
			}
		    } else {
			srcStride = strideData->diffuseStride - 2;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc;			    
			    *wdst = D3DCOLOR_COLORVALUE(r, g, b, alpha);
			    wdst += dstStride;
			    wsrc += srcStride;
			}			
		    }
		    
		}
	    } else {  // byte color pointer
		jbyte* wsrc = strideData->bdiffusePtr;
		jbyte r, g, b, a;
		if ((d3dCtx->currDisplayListID <= 0) || 
		    !strideData->modulateAlpha) {
		    // execute() or executeVA()

		    if (strideData->useAlpha) {
			srcStride = strideData->diffuseStride - 3;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc++;
			    a = *wsrc;			    
			    *wdst = D3DCOLOR_RGBA(r, g, b, a);
			    wdst += dstStride;
			    wsrc += srcStride;
			}
		    } else {
			srcStride = strideData->diffuseStride - 2;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc;			    
			    *wdst = D3DCOLOR_RGBA(r, g, b, 0);
			    wdst += dstStride;
			    wsrc += srcStride;
			}			
		    }
		} else {  
		    // buildGA() & modeulateAlpha
		    // Currently buildGA() will not use byte color
		    // so this code should never execute.
		    jbyte alpha = (jbyte) 255*strideData->alpha;
		    if (strideData->useAlpha) {
			srcStride = strideData->diffuseStride - 3;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc++;
			    a = (jbyte)(((int)(*wsrc) & 0xff) * strideData->alpha);
			    *wdst = D3DCOLOR_RGBA(r, g, b, a);
			    wdst += dstStride;
			    wsrc += srcStride;
			}
		    } else {
			srcStride = strideData->diffuseStride - 2;
			while (wdst < wendptr) {
			    r = *wsrc++;
			    g = *wsrc++;
			    b = *wsrc;			    
			    *wdst = D3DCOLOR_RGBA(r, g, b, alpha);
			    wdst += dstStride;
			    wsrc += srcStride;
			}			
		    }
		    
		}
	    }

	}
	
	currStride++; // additional one DWORD of color copy
    }

    // Copy Texture
    int ts;
    int texPos;
    boolean invalidTexCoord;

#ifdef TEXDEBUG
    printf("In copyVertexToVB TexSet Used %d\n", d3dCtx->texSetUsed);
#endif
    for (i=0; i < d3dCtx->texSetUsed; i++) {
	ts = d3dCtx->texStride[i];
	
	// TODO: skip when ts = 0
	if (ts == 0) {
	    continue;
	}
	texPos = strideData->texCoordPosition[i];

	invalidTexCoord = ((texPos != d3dCtx->pVB->texCoordPosition[i]) ||
	                   (texPos == TEX_OBJ_LINEAR));

#ifdef TEXDEBUG
	printf("%d texPos %d, invalidate Cached TexCoord %d, ts %d\n",i,  texPos, invalidTexCoord, ts);
#endif
	if ((cDirty & javax_media_j3d_GeometryArrayRetained_TEXTURE_CHANGED) || 
	    invalidTexCoord) {

	    if (texPos >= 0) {
		dst = *vbptr + currStride;
		src = strideData->textureCoordsPtr[i];
		endptr = dst + vcount*dstStride;
#ifdef TEXDEBUG
		printf("copy directly, ts %d\n", ts);
#endif
		if (ts == 2) {
		    dstStride--;
		    srcStride = strideData->textureCoordsStride[i] - 1;
		    while (dst < endptr) {
			*dst++ = *src++;  // tx
			*dst   = *src;    // ty
			dst += dstStride;
			src += srcStride;
		    }
		    dstStride++;
		} else if (ts == 3) { 
		    dstStride -= 2;
		    srcStride = strideData->textureCoordsStride[i] - 2;
		    while (dst < endptr) {
			*dst++ = *src++;  // tx
			*dst++ = *src++;  // ty
			*dst   = *src;    // tz
			dst += dstStride;
			src += srcStride;
		    }
		    dstStride += 2;
		} else {
		    // ts == 4
		    dstStride -= 3;
		    srcStride = strideData->textureCoordsStride[i] - 3;
		    while (dst < endptr) {
			*dst++ = *src++;  // tx
			*dst++ = *src++;  // ty
			*dst++ = *src++;  // tz
			*dst   = *src;    // tw
			dst += dstStride;
			src += srcStride;
		    }
		    dstStride += 3;
		}

	    } else {
		if (texPos == TEX_OBJ_LINEAR) {
		    // automatic texture generation for Object Linear
		    float *ps = d3dCtx->planeS[i];
		    float *pt = d3dCtx->planeT[i];
		    float *pr = d3dCtx->planeR[i];
		    float *pq = d3dCtx->planeQ[i];
#ifdef TEXDEBUG
		    printf("gen obj linear tex, ts %d\n", ts);
#endif
		    if (strideData->fpositionPtr) {
			float x, y, z;
			dst = *vbptr + currStride;
			endptr = dst + vcount*dstStride;
			src = strideData->fpositionPtr;
			srcStride = strideData->positionStride - 2;
			if (ts == 2) {
			    dstStride--;
			    if (xform == NULL) {
				while (dst < endptr) {
				    x = *src++;
				    y = *src++;
				    z = *src;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst   = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
				    dst += dstStride;
				    src += srcStride;
				}
			    } else {
				float tx, ty, tz, tw;
				while (dst < endptr) {
				    tx = *src++;
				    ty = *src++;
				    tz = *src;
				    tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
				    x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
				    y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
				    z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst   = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
				    dst += dstStride;
				    src += srcStride;	
				}			
			    }
			    dstStride++;
			} else if (ts == 3) {
			    dstStride -= 2;
			    if (xform == NULL) {
				while (dst < endptr) {
				    x = *src++;
				    y = *src++;
				    z = *src;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
				    *dst   = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];
				    dst += dstStride;
				    src += srcStride;
				}
			    } else {
				float tx, ty, tz, tw;
				while (dst < endptr) {
				    tx = *src++;
				    ty = *src++;
				    tz = *src;
				    tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
				    x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
				    y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
				    z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];
				    *dst   = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];	
				    dst += dstStride;
				    src += srcStride;	
				}			
			    }

			    dstStride += 2;
			} else {
			    // ts == 4 
			    dstStride -= 3;

			    if (!d3dCtx->texTransformSet[i]) {
				if (xform == NULL) {
				    while (dst < endptr) {
					x = *src++;
					y = *src++;
					z = *src;
					*dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					*dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
					*dst++ = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];
					*dst   = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					dst += dstStride;
					src += srcStride;
				    }
				} else {
				    float tx, ty, tz, tw;
				    while (dst < endptr) {
					tx = *src++;
					ty = *src++;
					tz = *src;
					tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
					x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
					y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
					z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
					*dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					*dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];
					*dst++ = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];	
					*dst   = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					dst += dstStride;
					src += srcStride;	
				    }			
				}
			    } else {
				// do texture transform manually
				D3DXMATRIX *m = &(d3dCtx->texTransform[i]);
				double tx, ty, tz, tw;
				if (xform == NULL) {
				    while (dst < endptr) {
					x = *src++;
					y = *src++;
					z = *src;
					tx = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					ty = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
					tz = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];
					tw = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					*dst++ = (*m)._11*tx + (*m)._21*ty + (*m)._31*tz + (*m)._41*tw;
					*dst++ = (*m)._12*tx + (*m)._22*ty + (*m)._32*tz + (*m)._42*tw;
					*dst++ = (*m)._13*tx + (*m)._23*ty + (*m)._33*tz + (*m)._43*tw;
					*dst =   (*m)._14*tx + (*m)._24*ty + (*m)._34*tz + (*m)._44*tw;
					dst += dstStride;
					src += srcStride;
				    }
				} else {
				    float tx, ty, tz, tw;
				    while (dst < endptr) {
					tx = *src++;
					ty = *src++;
					tz = *src;
					tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
					x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
					y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
					z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
					tx = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					ty = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];
					tz = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];	
					tw = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					*dst++ = (*m)._11*tx + (*m)._21*ty + (*m)._31*tz + (*m)._41*tw;
					*dst++ = (*m)._12*tx + (*m)._22*ty + (*m)._32*tz + (*m)._42*tw;
					*dst++ = (*m)._13*tx + (*m)._23*ty + (*m)._33*tz + (*m)._43*tw;
					*dst =   (*m)._14*tx + (*m)._24*ty + (*m)._34*tz + (*m)._44*tw;
					dst += dstStride;
					src += srcStride;	
				    }			
				}
			    }
			    dstStride += 3;
			}
		    } else {
			// double type position pointer
			double x, y, z;
			dst = *vbptr + currStride;
			endptr = dst + vcount*dstStride;
			dsrc = strideData->dpositionPtr;
			srcStride = strideData->positionStride - 2;
			if (ts == 2) {
			    dstStride--;
			    if (xform == NULL) {
				while (dst < endptr) {
				    x = *dsrc++;
				    y = *dsrc++;
				    z = *dsrc;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst   = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
				    dst += dstStride;
				    dsrc += srcStride;
				}
			    } else {
				double tx, ty, tz, tw;
				while (dst < endptr) {
				    tx = *src++;
				    ty = *src++;
				    tz = *src;
				    tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
				    x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
				    y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
				    z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst   = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
				    dst += dstStride;
				    src += srcStride;	
				}							
			    }
			    dstStride++;
			} else if (ts == 3) {
			    dstStride -= 2;
			    if (xform == NULL) {
				while (dst < endptr) {
				    x = *dsrc++;
				    y = *dsrc++;
				    z = *dsrc;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
				    *dst   = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];
				    dst += dstStride;
				    dsrc += srcStride;
				}
			    } else {
				double tx, ty, tz, tw;
				while (dst < endptr) {
				    tx = *src++;
				    ty = *src++;
				    tz = *src;
				    tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
				    x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
				    y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
				    z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
				    *dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
				    *dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];
				    *dst   = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];	
				    dst += dstStride;
				    src += srcStride;	
				}				
			    }
			    dstStride += 2;
			} else {
			    // ts == 4 
			    dstStride -= 3;
			    if (!d3dCtx->texTransformSet[i]) {
				if (xform == NULL) {
				    while (dst < endptr) {
					x = *dsrc++;
					y = *dsrc++;
					z = *dsrc;
					*dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					*dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
					*dst++ = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];
					*dst   = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					dst += dstStride;
					dsrc += srcStride;
				    }
				} else {
				    double tx, ty, tz, tw;
				    while (dst < endptr) {
					tx = *src++;
					ty = *src++;
					tz = *src;
					tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
					x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
					y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
					z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
					*dst++ = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					*dst++ = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];
					*dst++ = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];	
					*dst   = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					dst += dstStride;
					src += srcStride;	
				    }						
				}
			    } else {
// do texture transform manually
				D3DXMATRIX *m = &(d3dCtx->texTransform[i]);
				double tx, ty, tz, tw;
				if (xform == NULL) {
				    while (dst < endptr) {
					x = *src++;
					y = *src++;
					z = *src;
					tx = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					ty = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];	
					tz = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];
					tw = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					*dst++ = ((*m)._11*tx + (*m)._21*ty + (*m)._31*tz + (*m)._41*tw);
					*dst++ = ((*m)._12*tx + (*m)._22*ty + (*m)._32*tz + (*m)._42*tw);
					*dst++ = ((*m)._13*tx + (*m)._23*ty + (*m)._33*tz + (*m)._43*tw);
					*dst = (*m)._14*tx + (*m)._24*ty + (*m)._34*tz + (*m)._44*tw;
					dst += dstStride;
					src += srcStride;
				    }
				} else {
				    float tx, ty, tz, tw;
				    while (dst < endptr) {
					tx = *src++;
					ty = *src++;
					tz = *src;
					tw = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
					x = (xform[0]*tx + xform[1]*ty + xform[2]*tz + xform[3])*tw;
					y = (xform[4]*tx + xform[5]*ty + xform[6]*tz + xform[7])*tw;
					z  = (xform[8]*tx + xform[9]*ty + xform[10]*tz + xform[11])*tw;
					tx = ps[0]*x + ps[1]*y + ps[2]*z + ps[3];
					ty = pt[0]*x + pt[1]*y + pt[2]*z + pt[3];
					tz = pr[0]*x + pr[1]*y + pr[2]*z + pr[3];	
					tw = pq[0]*x + pq[1]*y + pq[2]*z + pq[3];
					*dst++ = ((*m)._11*tx + (*m)._21*ty + (*m)._31*tz + (*m)._41*tw);
					*dst++ = ((*m)._12*tx + (*m)._22*ty + (*m)._32*tz + (*m)._42*tw);
					*dst++ = ((*m)._13*tx + (*m)._23*ty + (*m)._33*tz + (*m)._43*tw);
					*dst = (*m)._14*tx + (*m)._24*ty + (*m)._34*tz + (*m)._44*tw;
					dst += dstStride;
					src += srcStride;	
				    }			
				}
			    }
			    dstStride += 3;
 			}
		    }
		} else if (texPos == TEX_GEN_INVALID) {
		    // application error, disable by setting texCoord to zero
#ifdef TEXDEBUG
		    printf("app error, ts %d\n", ts);
#endif
		    dst = *vbptr + currStride;
		    endptr = dst + vcount*dstStride;
		    if (ts == 2) {
			dstStride--;
			while (dst < endptr) {
			    *dst++ = 0;
			    *dst = 0;
			    dst += dstStride;
			}
			dstStride++;
		    } else if (ts == 3) {
			dstStride -= 2;
			while (dst < endptr) {
			    *dst++ = 0;
			    *dst++ = 0;
			    *dst = 0;
			    dst += dstStride;
			}
			dstStride += 2;			
		    } else {
			// ts == 4
			dstStride -= 3;
			while (dst < endptr) {
			    *dst++ = 0;
			    *dst++ = 0;
			    *dst++ = 0;
			    *dst = 0;
			    dst += dstStride;
			}
			dstStride += 3;						
		    }
		} else {
		    // Other automatic texture generation type handle
		    // by driver
		    //printf("TexStage %d, Tex gen by driver, texPos = %d\n", i, texPos);
		}
	    }
	}
	
	currStride += ts;
    }
        
    if (insertStrideToVB) {
	d3dCtx->pVB->addStride(vcount);
    }
    
    // Adjust VB pointer so that when this function is invoked
    // again, it append to the VB correctly.
    *vbptr += (vcount*dstStride);
}


void copyOneVertexToVB(D3dCtx *d3dCtx,
		       float **vbptr, 
		       D3DDRAWPRIMITIVESTRIDEDDATA* strideData,
		       DWORD idx, 
		       jint cDirty,
		       jdouble* xform,
		       jdouble* nxform)
{
    float *src;
    float *dst = *vbptr;
    DWORD vertexFormat = d3dCtx->pVB->vertexFormat;
    float posX, posY, posZ;

    // Copy Position

    //    if (cDirty & javax_media_j3d_GeometryArrayRetained_COORDINATE_CHANGED) 
    // Set the posX, posY, posZ anyway since TexGeneration will use it
    // if dirty.

    if (strideData->fpositionPtr != NULL) {
	src = strideData->fpositionPtr +
	    idx*strideData->positionStride;
	
	if (xform == NULL) {
	    posX = *src++;     // pos x
	    posY =  *src++;    // pos y
	    posZ = *src;       // pos z
	} else {
	    float x, y, z, w;
	    x = *src++;  
	    y = *src++; 
	    z = *src;    
	    w = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
	    posX =  (xform[0]*x + xform[1]*y + xform[2]*z + xform[3])*w;
	    posY =  (xform[4]*x + xform[5]*y + xform[6]*z + xform[7])*w;
	    posZ = (xform[8]*x + xform[9]*y + xform[10]*z + xform[11])*w;
	}
    } else { 
	// double is used for position coordinate in executeVA()
	double *dsrc = strideData->dpositionPtr + 
	    idx*strideData->positionStride;
	
	if (xform == NULL) {
	    posX = (float) *dsrc++;     // pos x
	    posY = (float) *dsrc++;    // pos y
	    posZ = (float) *dsrc;       // pos z
	} else {
	    double x, y, z, w;
	    x = *dsrc++;  
	    y = *dsrc++; 
	    z = *dsrc;    
	    w = 1/(xform[12]*x + xform[13]*y + xform[14]*z + xform[15]);
	    posX =  (float) (xform[0]*x + xform[1]*y + xform[2]*z + xform[3])*w;
	    posY =  (float) (xform[4]*x + xform[5]*y + xform[6]*z + xform[7])*w;
	    posZ = (float) (xform[8]*x + xform[9]*y + xform[10]*z + xform[11])*w;
	}
    }
    *dst++ = posX;
    *dst++ = posY;
    *dst++ = posZ;

    // Copy Normal
    if (vertexFormat & D3DFVF_NORMAL) { 
	if (cDirty & javax_media_j3d_GeometryArrayRetained_NORMAL_CHANGED) {
	    src = strideData->normalPtr +
		idx*strideData->normalStride;
	    if (nxform == NULL) {
		*dst++ = *src++;    // norm x
		*dst++ = *src++;    // norm y
		*dst++ = *src;      // norm z	    
	    } else {
		float nx, ny, nz, nw;
		nx = *src++;    // norm x
		ny = *src++;    // norm y
		nz = *src;      // norm z	    
		nw = 1/(nxform[12]*nx + nxform[13]*ny + nxform[14]*nz + nxform[15]);
		*dst++ = (nxform[0]*nx + nxform[1]*ny + nxform[2]*nz + nxform[3])*nw;
		*dst++ = (nxform[4]*nx + nxform[5]*ny + nxform[6]*nz + nxform[7])*nw;
		*dst   = (nxform[8]*nx + nxform[9]*ny + nxform[10]*nz + nxform[11])*nw;
	    }
	} 
    }


    // Copy Diffuse Color (DWORD & float are of the same size)
    if (vertexFormat & D3DFVF_DIFFUSE) {
	if (cDirty & javax_media_j3d_GeometryArrayRetained_COLOR_CHANGED) {
	    DWORD* wdst = (DWORD *) dst;
	    if (strideData->fdiffusePtr) {
		src = strideData->fdiffusePtr +
		    idx*strideData->diffuseStride;
		float r, g, b, a;
		if ((d3dCtx->currDisplayListID <= 0) || 
		    !strideData->modulateAlpha) {
		    // execute() or executeVA()
		    if (strideData->useAlpha) {
			r = *src++;
			g = *src++;
			b = *src++;
			a = *src;
		    } else {
			r = *src++;
			g = *src++;
			b = *src;
			a = 0;
		    }
		} else {  
		    // buildGA() & modeulateAlpha
		    if (strideData->useAlpha) {
			r = *src++;
			g = *src++;
			b = *src++;
			a = *src * strideData->alpha;
		    } else {
			r = *src++;
			g = *src++;
			b = *src;			    
			a = strideData->alpha;
		    }
		}
		*wdst = D3DCOLOR_COLORVALUE(r, g, b, a);
	    } else {  // byte color pointer
		jbyte* wsrc = strideData->bdiffusePtr +
		    idx*strideData->diffuseStride;
		jbyte r, g, b, a;
		if ((d3dCtx->currDisplayListID <= 0) || 
		    !strideData->modulateAlpha) {
		    // execute() or executeVA()
		    if (strideData->useAlpha) {
			r = *wsrc++;
			g = *wsrc++;
			b = *wsrc++;
			a = *wsrc;
		    } else {
			r = *wsrc++;
			g = *wsrc++;
			b = *wsrc;
			a = 0;
		    }
		} else {  
		    // buildGA() & modeulateAlpha
		    // Currently buildGA() will not use byte color
		    // so this code should never execute.
		    jbyte alpha = (jbyte) (255*strideData->alpha);
		    if (strideData->useAlpha) {
			r = *wsrc++;
			g = *wsrc++;
			b = *wsrc++;
			a = (jbyte)(((int)(*wsrc) & 0xff) * strideData->alpha);
		    } else {
			r = *wsrc++;
			g = *wsrc++;
			b = *wsrc;		
			a = alpha;

		    }
		}
		*wdst = D3DCOLOR_RGBA(r, g, b, a);
	    }
	}
	dst++; // additional one DWORD of color copy
    }


  // Copy Texture
    int ts;
    int texPos;
    boolean invalidTexCoord;

    for (int i=0; i < d3dCtx->texSetUsed; i++) {
	ts = d3dCtx->texStride[i];
	if (ts == 0) {
	    continue;
	}
	texPos = strideData->texCoordPosition[i];
	
	invalidTexCoord = ((texPos != d3dCtx->pVB->texCoordPosition[i]) ||
			   (texPos == TEX_OBJ_LINEAR));
	
	if ((cDirty & javax_media_j3d_GeometryArrayRetained_TEXTURE_CHANGED) || invalidTexCoord) {
	    if (texPos >= 0) {
		src = strideData->textureCoordsPtr[i] +
		    idx*strideData->textureCoordsStride[i];
		*dst++ = *src++;  // tx
		*dst++ = *src++;  // ty
		if (ts >= 3) { 
		    *dst++ = *src++;  // tx
		    if (ts >= 4) {
			*dst++ = *src;  // tx
		    }
		}
	    } else {
		// automatic texture generation
		if (texPos == TEX_OBJ_LINEAR) {
		    float *ps = d3dCtx->planeS[i];
		    float *pt = d3dCtx->planeT[i];
		    float *pr = d3dCtx->planeR[i];
		    float *pq = d3dCtx->planeQ[i];

		    if ((ts < 4) || (!d3dCtx->texTransformSet[i])) {
			*dst++ = ps[0]*posX + ps[1]*posY + ps[2]*posZ + ps[3];
			*dst++ = pt[0]*posX + pt[1]*posY + pt[2]*posZ + pt[3];	
			if (ts >= 3) {
			    *dst++  = pr[0]*posX + pr[1]*posY + pr[2]*posZ + pr[3];
			    if (ts >= 4) {
				*dst++ = pq[0]*posX + pq[1]*posY + pq[2]*posZ + pq[3];
			    }
			}
		    } else {
			float tx, ty, tz, tw;
			D3DXMATRIX *m = &(d3dCtx->texTransform[i]);
			tx = ps[0]*posX + ps[1]*posY + ps[2]*posZ + ps[3];
			ty = pt[0]*posX + pt[1]*posY + pt[2]*posZ + pt[3];
			tz = pr[0]*posX + pr[1]*posY + pr[2]*posZ + pr[3];				
			tw = pq[0]*posX + pq[1]*posY + pq[2]*posZ + pq[3];
			*dst++ = (*m)._11*tx + (*m)._21*ty + (*m)._31*tz + (*m)._41*tw;
			*dst++ = (*m)._12*tx + (*m)._22*ty + (*m)._32*tz + (*m)._42*tw;
			*dst++ = (*m)._13*tx + (*m)._23*ty + (*m)._33*tz + (*m)._43*tw;
			*dst++ = (*m)._14*tx + (*m)._24*ty + (*m)._34*tz + (*m)._44*tw;
		    }
		} else if (texPos == TEX_GEN_INVALID) {
		    // application error, disable by setting texCoord to zero
		    *dst++ = 0;
		    *dst++ = 0;
		    if (ts >= 3) {
			*dst++ = 0;
			if (ts >= 4) {
			    *dst++ = 0;
			}
		    }
		} else {
		    // should not happen
		    dst += ts;
		}
	    }
	} else {
	    dst += ts;
	}
    }

    *vbptr = dst;
}


float* allocateVB(D3dCtx *d3dCtx, 
		  LPDIRECT3DDEVICE8 device,
		  int vcount,
		  int maxVertexLimit,
		  jint *cdirty)
{
    LPD3DVERTEXBUFFER vb = d3dCtx->pVB->nextVB;
    HRESULT hr;
    float *ptr = NULL;


    if (vcount > maxVertexLimit) {
	vcount = maxVertexLimit;
    }
    
    if ((vb != NULL) && (vb->vcount < vcount)) {
	delete vb;
	d3dCtx->pVB->nextVB = NULL;
	vb = NULL;
    }

    if (vb == NULL) {
	vb = new D3dVertexBuffer();
	if (vb == NULL) {
	    D3dCtx::d3dWarning(OUTOFMEMORY);
	    return NULL;
	}

	vb->stride = d3dCtx->pVB->stride;
	vb->vertexFormat = d3dCtx->pVB->vertexFormat;
	// Don't set totalVertexCount
	vb->isIndexPrimitive = d3dCtx->pVB->isIndexPrimitive;
	vb->primitiveType = d3dCtx->pVB->primitiveType;
	vb->isPointFlagUsed = d3dCtx->pVB->isPointFlagUsed;
	vb->vcount = vcount;
	vb->maxVertexLimit = maxVertexLimit;

#ifdef VBDEBUG
	printf("Create secondary VertexBuffer of size %d, display list ID %d, pointFlag %d\n", 
	       vb->vcount, d3dCtx->currDisplayListID, vb->isPointFlagUsed);
#endif
	if (!vb->isPointFlagUsed) {
	    hr = device->CreateVertexBuffer(vb->stride*vcount,
					    D3DUSAGE_WRITEONLY,
					    vb->vertexFormat,
					    D3DPOOL_DEFAULT,
					    &vb->buffer);
	} else {
	    hr = device->CreateVertexBuffer(vb->stride*vcount,
					    D3DUSAGE_WRITEONLY|D3DUSAGE_POINTS,
					    vb->vertexFormat,
					    D3DPOOL_DEFAULT,
					    &vb->buffer);	    
	}
	if (FAILED(hr)) {
	    vb->buffer = NULL;
	    delete vb;
	    D3dCtx::d3dWarning(CREATEVBFAIL, hr);
	    return NULL;
	}
	d3dCtx->pVB->nextVB = vb;
	*cdirty = javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED;
    }

    hr = vb->buffer->Lock(0, 0, (BYTE**) &ptr,  0);

    if (FAILED(hr)) {
	D3dCtx::d3dWarning(LOCKVBFAIL, hr);
	delete vb;
	d3dCtx->pVB->nextVB = NULL;
	return NULL;
    }
	
    d3dCtx->pVB = vb;    

    vb->stripLen = 0;
    return ptr;
}



BOOL createCopyVBVertex(D3dCtx *d3dCtx,
			LPDIRECT3DDEVICE8 device,
			D3DDRAWPRIMITIVESTRIDEDDATA *strideData,
			int vcount, jint cDirty,
			jdouble* xform,
			jdouble* nxform)
{
    LPD3DVERTEXBUFFER vb = d3dCtx->pVB;   
    float *vbptr;


    if (vb->stripLen > 0) {
	// VertexBuffer already used, create a new one or used
	// the next VB in the list 
	// maxVertexLimit is already check before, so we can
	// pass vcount as maxVertexLimit
	vbptr = allocateVB(d3dCtx, device, vcount, vcount, &cDirty);
	if (vbptr == NULL) {
	    return FALSE;
	}

    } else {
	// use the same VB
	HRESULT hr;
	hr = vb->buffer->Lock(0, 0, (BYTE**)&vbptr, 0);

	if (FAILED(hr)) {
	    D3dCtx::d3dWarning(LOCKVBFAIL, hr);
	    return FALSE;
	}
	
    }

    copyVertexToVB(d3dCtx, strideData, vcount, &vbptr, cDirty, true,
		   xform, nxform);

    d3dCtx->pVB->buffer->Unlock();
    return TRUE;
}


/*
 * Draw Primitive with vertexCount > D3DMAXNUMVERTICES.
 * In this case we call the drawing routine multiple times.
 */
void splitVertexToMultipleVB(D3dCtx *d3dCtx,
			     LPD3DDRAWPRIMITIVESTRIDEDDATA strideData,
			     int vcount,
			     int maxVertexLimit,
			     jint cDirty,
			     jdouble* xform,
			     jdouble* nxform)
{
    int i, inc;
    int min = 0;
    int max = 0;
    jfloat *oldfPosition;
    double *olddPosition;
    jfloat *oldNormal;
    jfloat *oldfDiffuse;
    jbyte  *oldbDiffuse;
    float* oldTexCoords[D3DDP_MAXTEXCOORD];
    int vc;
    int texSetUsed = d3dCtx->texSetUsed;
    LPDIRECT3DDEVICE8 device = d3dCtx->pDevice;
    jfloat fr, fg, fb, fa;
    jbyte br, bg, bb, ba;
    boolean success;

    DWORD vertexFormat = d3dCtx->pVB->vertexFormat;

    // save stride pointers since strip set may have
    // multiple call to this procedure.
    oldfPosition = strideData->fpositionPtr;
    olddPosition = strideData->dpositionPtr;
    oldNormal    = strideData->normalPtr;
    oldfDiffuse  = strideData->fdiffusePtr;
    oldbDiffuse  = strideData->bdiffusePtr;    

    for (i=0; i < texSetUsed; i++) {
	oldTexCoords[i] = strideData->textureCoordsPtr[i];
    }



    switch (d3dCtx->pVB->primitiveType) {
        case D3DPT_TRIANGLEFAN:
	  {
	    // Copy the very first vertx and repeat the last vertex
	    jfloat fx, fy, fz, nx, ny, nz;
	    jdouble dx, dy, dz;
	    jfloat tx[D3DDP_MAXTEXCOORD];
	    jfloat ty[D3DDP_MAXTEXCOORD];
	    jfloat tz[D3DDP_MAXTEXCOORD];
	    jfloat tw[D3DDP_MAXTEXCOORD];
	    inc = maxVertexLimit - 2;

	    if (oldfPosition) {
		fx = *oldfPosition;
		fy = *(oldfPosition+1);
		fz = *(oldfPosition+2);	
	    } else {
		// must be double, since this routine will
		// not invoke when there is no position available
		dx = *olddPosition;
		dy = *(olddPosition+1);
		dz = *(olddPosition+2);	
	    }
    
	    if (oldNormal) {
		nx = *oldNormal;
		ny = *(oldNormal+1);
		nz = *(oldNormal+2);	    
	    }
	    if (oldfDiffuse) {
		fr =  *oldfDiffuse;
		fg =  *(oldfDiffuse+1);
		fb =  *(oldfDiffuse+2);
		if (strideData->useAlpha) {
		    fa = *(oldfDiffuse+3);
		}
	    } else if (oldbDiffuse) {
		br =  *oldbDiffuse;
		bg =  *(oldbDiffuse+1);
		bb =  *(oldbDiffuse+2);
		if (strideData->useAlpha) {
		    ba = *(oldbDiffuse+3);
		}		
	    }

	    for (i=0; i < texSetUsed; i++) {	
		tx[i] = *oldTexCoords[i];
		ty[i] = *(oldTexCoords[i]+1);
		if (d3dCtx->texStride[i] > 2) {
		    tz[i] = *(oldTexCoords[i]+2);
		    if (d3dCtx->texStride[i] > 3) {
			tw[i] = *(oldTexCoords[i]+3);
		    }
		}
	    }
	    while (true) {
		vc = (vcount >= maxVertexLimit ? maxVertexLimit : vcount);
		
		success = createCopyVBVertex(d3dCtx, device, strideData,
					     vc, cDirty, xform, nxform);
		// restore old values
		if (oldfPosition) {
		    *(strideData->fpositionPtr)   = fx;
		    *(strideData->fpositionPtr+1) = fy;
		    *(strideData->fpositionPtr+2) = fz;		
		} else {
		    *(strideData->dpositionPtr)   = dx;
		    *(strideData->dpositionPtr+1) = dy;
		    *(strideData->dpositionPtr+2) = dz;		
		}
		if (oldNormal) {
		    *(strideData->normalPtr)   = nx;
		    *(strideData->normalPtr+1) = ny;
		    *(strideData->normalPtr+2) = nz;
		}
		if (oldfDiffuse) {		
		    *(strideData->fdiffusePtr) = fr;
		    *(strideData->fdiffusePtr+1) = fg;
		    *(strideData->fdiffusePtr+2) = fb;
		    if (strideData->useAlpha) {
			*(strideData->fdiffusePtr+3) = fa;
		    }
		} else if (oldbDiffuse) {
		    *(strideData->bdiffusePtr) = br;
		    *(strideData->bdiffusePtr+1) = bg;
		    *(strideData->bdiffusePtr+2) = bb;
		    if (strideData->useAlpha) {
			*(strideData->bdiffusePtr+3) = ba;
		    }
		}
		for (i=0; i < texSetUsed; i++) {	    
		    *(strideData->textureCoordsPtr[i]) = tx[i];
		    *(strideData->textureCoordsPtr[i]+1) = ty[i];
		    if (d3dCtx->texStride[i] > 2) {
			*(strideData->textureCoordsPtr[i]+2) = tz[i];
			if (d3dCtx->texStride[i] > 3) {
			    *(strideData->textureCoordsPtr[i]+3) = tw[i];
			}
		    }
		}
		
		vcount -= inc;
		if (!success || (vcount <= 2)) {
		    break;
		}

		if (oldfPosition) {
		    strideData->fpositionPtr += strideData->positionStride*inc;
		    fx = *strideData->fpositionPtr;
		    *strideData->fpositionPtr = *oldfPosition;
		    fy = *(strideData->fpositionPtr+1);
		    *(strideData->fpositionPtr+1) = *(oldfPosition+1);		
		    fz = *(strideData->fpositionPtr+2);
		    *(strideData->fpositionPtr+2) = *(oldfPosition+2);		
		} else {
		    strideData->dpositionPtr += strideData->positionStride*inc;
		    dx = *strideData->dpositionPtr;
		    *strideData->dpositionPtr = *olddPosition;
		    dy = *(strideData->dpositionPtr+1);
		    *(strideData->dpositionPtr+1) = *(olddPosition+1);		
		    dz = *(strideData->dpositionPtr+2);
		    *(strideData->dpositionPtr+2) = *(olddPosition+2);		
		}


		if (oldNormal) {
		    strideData->normalPtr += strideData->normalStride*inc;
		    nx = *strideData->normalPtr;
		    *strideData->normalPtr = *oldNormal;
		    ny = *(strideData->normalPtr+1);
		    *(strideData->normalPtr+1) = *(oldNormal+1);		
		    nz = *(strideData->normalPtr+2);
		    *(strideData->normalPtr+2) = *(oldNormal+2);		
		}

		if (oldfDiffuse) {
		    strideData->fdiffusePtr += strideData->diffuseStride*inc;
		    fr =  *strideData->fdiffusePtr;
		    *strideData->fdiffusePtr = *oldfDiffuse;
		    fg =  *(strideData->fdiffusePtr+1);
		    *(strideData->fdiffusePtr+1) = *(oldfDiffuse+1);
		    fb =  *(strideData->fdiffusePtr+2);
		    *(strideData->fdiffusePtr+2) = *(oldfDiffuse+2);
		    if (strideData->useAlpha) {
			fa =  *(strideData->fdiffusePtr+3);
			*(strideData->fdiffusePtr+3) = *(oldfDiffuse+3);
		    }
		} else if (oldbDiffuse) {
		    strideData->bdiffusePtr += strideData->diffuseStride*inc;
		    br =  *strideData->bdiffusePtr;
		    *strideData->bdiffusePtr = *oldbDiffuse;
		    bg =  *(strideData->bdiffusePtr+1);
		    *(strideData->bdiffusePtr+1) = *(oldbDiffuse+1);
		    bb =  *(strideData->bdiffusePtr+2);
		    *(strideData->bdiffusePtr+2) = *(oldbDiffuse+2);
		    if (strideData->useAlpha) {
			ba =  *(strideData->bdiffusePtr+3);
			*(strideData->bdiffusePtr+3) = *(oldbDiffuse+3);
		    }
		}

		for (i=0; i < texSetUsed; i++) {
		    strideData->textureCoordsPtr[i] +=
			strideData->textureCoordsStride[i]*inc;

		    tx[i] = *strideData->textureCoordsPtr[i];
		    ty[i] = *(strideData->textureCoordsPtr[i]+1);
		    *(strideData->textureCoordsPtr[i]) = *oldTexCoords[i];
		    *(strideData->textureCoordsPtr[i]+1) = *(oldTexCoords[i]+1);
		    if (d3dCtx->texStride[i] > 2) {
			tz[i] =  *(strideData->textureCoordsPtr[i]+2);
			*(strideData->textureCoordsPtr[i]+2)
			    = *(oldTexCoords[i]+ 2);
			if (d3dCtx->texStride[i] > 3) {
			    tw[i] =  *(strideData->textureCoordsPtr[i]+3);
			    *(strideData->textureCoordsPtr[i]+3)
				= *(oldTexCoords[i]+ 3);
			}
			
		    }
		}

	    }
	    break;
	  }
    case D3DPT_POINTLIST:
	if (max == 0) {
	    max = maxVertexLimit;
	}
	// fall through
    case D3DPT_LINESTRIP:
	if (max == 0) {
	    max = maxVertexLimit;
	    min = 1; // repeat the last vertex;
	}
	// fall through	
    case D3DPT_TRIANGLELIST:
	if (max == 0) {
	    if (d3dCtx->pVB->isIndexPrimitive) {
		// QuadArray
		max = maxVertexLimit - (maxVertexLimit % 4);
	    } else {
		max = maxVertexLimit - (maxVertexLimit % 3);
	    }
	}
	// fall through
    case D3DPT_LINELIST:
	if (max == 0) {
	    max = maxVertexLimit - (maxVertexLimit % 2);
	}
	// fall through
    case D3DPT_TRIANGLESTRIP:
	if (max == 0) {
	    max = maxVertexLimit - (maxVertexLimit % 4);
	    min = 2;  // repeat the last two vertices
	}
	inc = max - min;

	while (true) {
	    vc = (vcount >= max ? max : vcount);

	    if (!createCopyVBVertex(d3dCtx, device, strideData, vc,
				    cDirty, xform, nxform)) {
		break;
	    } 

	    vcount -= inc;
	    if (vcount <= min) {
		break;
	    }
	    if (oldfPosition) {
		strideData->fpositionPtr += strideData->positionStride*inc;
	    } else {
		strideData->dpositionPtr += strideData->positionStride*inc;
	    }

	    if (oldNormal) {
		strideData->normalPtr += strideData->normalStride*inc;
	    }
	    if (oldfDiffuse) {
		strideData->fdiffusePtr += strideData->diffuseStride*inc;
	    } else if (oldbDiffuse) {
		strideData->bdiffusePtr += strideData->diffuseStride*inc;
	    }
	    for (i=0; i < texSetUsed; i++) {
		strideData->textureCoordsPtr[i] +=
		    strideData->textureCoordsStride[i]*inc;
	    }
	}
	break;
    }

    // Restore old pointers;
    strideData->fpositionPtr = oldfPosition;
    strideData->dpositionPtr = olddPosition;
    strideData->normalPtr    = oldNormal;
    strideData->fdiffusePtr  = oldfDiffuse;
    strideData->bdiffusePtr  = oldbDiffuse;

    for (i=0; i < texSetUsed; i++) {
	strideData->textureCoordsPtr[i] = oldTexCoords[i];
    }
}

		
BOOL reIndexifyIndexVertexToVBs(D3dCtx *d3dCtx, 
				D3DDRAWPRIMITIVESTRIDEDDATA* strideData, 
				DWORD indexCount,
				DWORD vcount,
				jint cDirty,
				BOOL expandQuadIndex,
				DWORD maxVertexLimit,
				jdouble* xform,
				jdouble* nxform) 
{
    LPD3DVERTEXBUFFER vb = d3dCtx->pVB;
    HRESULT hr;
    LPDIRECT3DDEVICE8 device = d3dCtx->pDevice;

    int vbSize;

    if (!expandQuadIndex) {
	vbSize = indexCount;
    } else {
	vbSize = (3*indexCount) >> 1;
    }    

    if (vb->stripLen > 0) {
	// VertexBuffer already used, create a new one or used
	// the next VB in the list 
	// maxVertexLimit is already check before, so we can
	// pass indexCount as maxVertexLimit.
	// The maximum vertex that can happens is equal
	// to indexCount so we can just set vcount = indexCount
	vb = vb->nextVB;
	if ((vb != NULL) && (vb->vcount < vbSize)) {
	    delete vb;
	    d3dCtx->pVB->nextVB = NULL;
	    vb = NULL;
	}
	
	if (vb == NULL) {
	     vb = new D3dVertexBuffer();
	     if (vb == NULL) {
		 D3dCtx::d3dWarning(OUTOFMEMORY);
		 return false;
	     }

	     vb->stride = d3dCtx->pVB->stride;
	     vb->vertexFormat = d3dCtx->pVB->vertexFormat;
	     // Don't set totalVertexCount 
	     vb->isIndexPrimitive = d3dCtx->pVB->isIndexPrimitive;
	     vb->primitiveType = d3dCtx->pVB->primitiveType;
	     vb->isPointFlagUsed = d3dCtx->pVB->isPointFlagUsed;
	     vb->vcount = vbSize;
	     vb->maxVertexLimit = maxVertexLimit;
	     
#ifdef VBDEBUG
	     printf("Create secondary VertexBuffer of size %d, display list ID %d, pointFlag %d\n", 
		    vbSize, d3dCtx->currDisplayListID, vb->isPointFlagUsed);
#endif
	     
	     if (!vb->isPointFlagUsed) {
		 hr = device->CreateVertexBuffer(vb->stride*vbSize,
						 D3DUSAGE_WRITEONLY,
						 vb->vertexFormat,
						 D3DPOOL_DEFAULT,
						 &vb->buffer);
	     } else {
		 hr = device->CreateVertexBuffer(vb->stride*vbSize,
						 D3DUSAGE_WRITEONLY|D3DUSAGE_POINTS,
						 vb->vertexFormat,
						 D3DPOOL_DEFAULT,
						 &vb->buffer);
		 vb->isPointFlagUsed = true;
	     }
	     
	     if (FAILED(hr)) {
		 vb->buffer = NULL;
		 vb->release();
		 D3dCtx::d3dWarning(CREATEVBFAIL, hr);
		 return false;
	     }
	     d3dCtx->pVB->nextVB = vb;
	     cDirty = javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED;
	}
    }

    if (vb->indexBuffer == NULL) {
	// No need to set totalIndexCount
	vb->indexCount = vbSize;

	if (indexCount <= 0xffff) {	
	    hr = device->CreateIndexBuffer(vbSize*sizeof(WORD),
					   D3DUSAGE_WRITEONLY,
					   D3DFMT_INDEX16,   
					   D3DPOOL_DEFAULT,
					   &vb->indexBuffer);
	} else {
	    hr = device->CreateIndexBuffer(vbSize*sizeof(UINT),
					   D3DUSAGE_WRITEONLY,
					   D3DFMT_INDEX32,   
					   D3DPOOL_DEFAULT,
					   &vb->indexBuffer);
	}
	
	if (FAILED(hr)) {
	    vb->indexBuffer = NULL;
	    vb->release();
	    D3dCtx::d3dWarning(CREATEINDEXVBFAIL, hr);
	    return false;
	}

	cDirty |= javax_media_j3d_GeometryArrayRetained_INDEX_CHANGED;
    }

    float *vbptr;
    // Note that DWORD (use for color) is of same size 
    // as float (use for vertex/normal)
    hr = vb->buffer->Lock(0, 0, (BYTE**)&vbptr,  0);
    if (FAILED(hr)) {
	D3dCtx::d3dWarning(LOCKVBFAIL, hr);
	// recreate it next time
	vb->release();
	return false;
    }

    d3dCtx->pVB = vb;

    // The current VB is not yet used. 
    vb->stripLen = 0;
    
   if (cDirty) {
       D3DINDEXBUFFER_DESC desc;
       BYTE *bptr;

       vb->indexBuffer->GetDesc(&desc);
       hr = vb->indexBuffer->Lock(0, 0, &bptr,  0);
       if (FAILED(hr)) {
	   D3dCtx::d3dWarning(LOCKINDEXVBFAIL, hr);
	   vb->buffer->Unlock();
	   return false;
       }

       if (d3dCtx->reIndexifyTable == NULL) {
	   // vcount will not change during renderIndexGeometry
	   // and splitIndexVertex so it is safe not to check
	   // size of reIndexifyTable and recreate a bigger
	   // one.
	   d3dCtx->reIndexifyTable = new DWORD[vcount];
	   if (d3dCtx->reIndexifyTable == NULL) {
	       D3dCtx::d3dWarning(OUTOFMEMORY, hr);
	       vb->release();
	       return false;	       
	   }

       }

       ZeroMemory(d3dCtx->reIndexifyTable, sizeof(DWORD)*vcount);

       DWORD i;
       jint *idxPtr = strideData->indexPtr + strideData->initialIndexIndex;
       USHORT firstEntry = *idxPtr;
       DWORD *table = d3dCtx->reIndexifyTable;

       if (desc.Format == D3DFMT_INDEX16) {
	   USHORT *dst = (USHORT *) bptr;
	   USHORT newIdx, prevIdx = -1, count = 0;
	   USHORT idx[3], vc = 0;
	   
	   for (i=0; i < indexCount; i++) {
	       newIdx = table[*idxPtr];
	       if ((newIdx == 0) && (*idxPtr != firstEntry)) {
		   newIdx = ++count;
		   table[*idxPtr] = newIdx;
	       } 
	       if (!expandQuadIndex) {
		   *dst++ = newIdx;
	       } else {
		   if (vc < 3) {
		       idx[vc++] = newIdx;
		   } else {
		       // vc = 3
		       *dst++ = idx[0];
		       *dst++ = idx[1];
		       *dst++ = idx[2];
		       *dst++ = idx[0];
		       *dst++ = idx[2];
		       *dst++ = newIdx;
		       vc = 0;
		   }
	       }
	       if (newIdx != prevIdx) {
		   copyOneVertexToVB(d3dCtx, &vbptr, strideData,
				     *idxPtr++, cDirty, xform, nxform);
		   prevIdx = newIdx;
	       } else {
		   idxPtr++;
	       }
	       
	   }
       } else {
	   DWORD *dst = (DWORD *) bptr;
	   DWORD newIdx, prevIdx = -1, count = 0;
	   DWORD idx[3], vc = 0;

	   for (i=0; i < indexCount; i++) {
	       newIdx = table[*idxPtr];
	       if ((newIdx == 0) && (*idxPtr != firstEntry)) {
		   newIdx = ++count;
		   table[*idxPtr] = newIdx;
	       } 
	       if (!expandQuadIndex) {
		   *dst++ = newIdx;
	       } else {
		   if (vc < 3) {
		       idx[vc++] = newIdx;
		   } else {
		       // vc = 3
		       *dst++ = idx[0];
		       *dst++ = idx[1];
		       *dst++ = idx[2];
		       *dst++ = idx[0];
		       *dst++ = idx[2];
		       *dst++ = newIdx;
		       vc = 0;
		   }
	       }
	       if (newIdx != prevIdx) {
		   copyOneVertexToVB(d3dCtx, &vbptr, strideData,
				     *idxPtr++, cDirty, xform, nxform);
		   prevIdx = newIdx;
	       } else {
		   idxPtr++;
	       }
	   }
       }
   }


   vb->addStride(vbSize);
   vb->indexBuffer->Unlock();
   vb->buffer->Unlock();
   return true;
}


void splitIndexVertexToMultipleVB(D3dCtx *d3dCtx,
				  LPD3DDRAWPRIMITIVESTRIDEDDATA strideData,
				  int indexCount,
				  int vertexCount,
				  int maxVertexLimit,
				  jint cDirty,
				  BOOL expandQuadIndex,
				  jdouble* xform,
				  jdouble* nxform) 
{
    int vc;
    BOOL success;
    int inc;
    int min = 0;
    int max = 0;
    int initialIdxIdx = strideData->initialIndexIndex;


    switch (d3dCtx->pVB->primitiveType) {
    case D3DPT_TRIANGLEFAN: 
        {
	    jint firstIdx = strideData->indexPtr[initialIdxIdx]; 
	    jint prevIdx = firstIdx;

	    inc = maxVertexLimit - 2;
	    
	    while (true) {
		vc = (indexCount >= maxVertexLimit ? maxVertexLimit : indexCount);
		success = reIndexifyIndexVertexToVBs(d3dCtx,
						     strideData,
						     vc,
						     vertexCount,
						     cDirty,
						     expandQuadIndex,
						     maxVertexLimit,
						     xform, nxform);
		// restore index 
		strideData->indexPtr[strideData->initialIndexIndex] = prevIdx;
		indexCount -= inc;
		
		if (!success || (indexCount <= 2)) {
		    break;
		}
		// repeat the last index
		strideData->initialIndexIndex += (vc - 2); 
		// replace by first index
		prevIdx = strideData->indexPtr[strideData->initialIndexIndex];
		strideData->indexPtr[strideData->initialIndexIndex] = firstIdx;
	    }
        }
	break;
    case D3DPT_POINTLIST:
	if (max == 0) {
	    max = maxVertexLimit;
	}
	// fall through
    case D3DPT_LINESTRIP:
	if (max == 0) {
	    max = maxVertexLimit;
	    min = 1; // repeat the last vertex;
	}
	// fall through	
    case D3DPT_TRIANGLELIST:
	if (max == 0) {
	    if (expandQuadIndex) {
		// QuadArray
		max = maxVertexLimit - (maxVertexLimit % 4);
	    } else {
		max = maxVertexLimit - (maxVertexLimit % 3);
	    }
	}
	// fall through
    case D3DPT_LINELIST:
	if (max == 0) {
	    max = maxVertexLimit - (maxVertexLimit % 2);
	}
	// fall through
    case D3DPT_TRIANGLESTRIP:
	if (max == 0) {
	    max = maxVertexLimit - (maxVertexLimit % 4);
	    min = 2;  // repeat the last two vertices
	}
	inc = max - min;

	while (true) {
	    vc = (indexCount >= max ? max : indexCount);

	    if (!reIndexifyIndexVertexToVBs(d3dCtx,
					    strideData,
					    vc,
					    vertexCount,
					    cDirty,
					    expandQuadIndex,
					    maxVertexLimit,
					    xform, nxform)) {
		break;
	    } 

	    indexCount -= inc;
	    if (indexCount <= min) {
		break;
	    }
	    strideData->initialIndexIndex += inc;
	}
    }
    strideData->initialIndexIndex = initialIdxIdx;
}

// This is used by quad polygon line mode
void DrawPolygonLine(D3dCtx *d3dCtx,
		     LPDIRECT3DDEVICE8 device,
		     DWORD vertexFormat,
		     D3DDRAWPRIMITIVESTRIDEDDATA *strideData)
{
    HRESULT hr;
    float *vbptr;

    hr = d3dCtx->pVB->buffer->Lock(0, 0, (BYTE**) &vbptr, 0 );
    if (FAILED(hr)) {
	D3dCtx::d3dWarning(LOCKVBFAIL, hr);
	return;
    }
    // DisplayList will not use in this case, so xform = nxform = NULL
    copyVertexToVB(d3dCtx, strideData, 4, &vbptr,
		   javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED, true,
		   NULL, NULL);
    d3dCtx->pVB->buffer->Unlock();
    device->SetStreamSource(0, d3dCtx->pVB->buffer, 
			    d3dCtx->pVB->stride); 
    device->SetIndices(d3dCtx->lineModeIndexBuffer, 0);
    device->SetVertexShader(vertexFormat);

    device->DrawIndexedPrimitive(D3DPT_LINESTRIP, 0, 4, 0, 4);
}


// This is used by indexed quad polygon line mode
void DrawIndexPolygonLine(D3dCtx *d3dCtx,
			  LPDIRECT3DDEVICE8 device,
			  DWORD vertexFormat,
			  D3DDRAWPRIMITIVESTRIDEDDATA *strideData,
			  jint idx0, jint idx1, jint idx2, jint idx3)
{
    HRESULT hr;
    float *vbptr;

    hr = d3dCtx->pVB->buffer->Lock(0, 0, (BYTE**) &vbptr, 0 );
    if (FAILED(hr)) {
	D3dCtx::d3dWarning(LOCKVBFAIL, hr);
	return;
    }

    copyOneVertexToVB(d3dCtx, &vbptr, strideData, idx0, 
		      javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED, 
		      NULL, NULL);
    copyOneVertexToVB(d3dCtx, &vbptr, strideData, idx1, 
		      javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED, 
		      NULL, NULL);
    copyOneVertexToVB(d3dCtx, &vbptr, strideData, idx2, 
		      javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED,
		      NULL, NULL);
    copyOneVertexToVB(d3dCtx, &vbptr, strideData, idx3, 
		      javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED,
		      NULL, NULL);

    d3dCtx->pVB->buffer->Unlock();
    device->SetStreamSource(0, d3dCtx->pVB->buffer, 
			    d3dCtx->pVB->stride); 
    device->SetVertexShader(vertexFormat);
    device->SetIndices(d3dCtx->lineModeIndexBuffer, 0);

    device->DrawIndexedPrimitive(D3DPT_LINESTRIP, 0, 4, 0, 4);
}


void renderGeometry(JNIEnv *env, 
		    D3dCtx *d3dCtx,
		    LPDIRECT3DDEVICE8 device,
		    jobject geo,
		    jint geo_type,
		    D3DDRAWPRIMITIVESTRIDEDDATA *strideData,
		    DWORD vertexFormat,
		    jint vcount,
		    jdouble* xform,
		    jdouble* nxform,
		    jint cDirty)
{
    D3DPRIMITIVETYPE d3dRenderType;
    BOOL renderTypeSet = false;
    int i, j, genMode;
    LPD3DVERTEXBUFFER vb = NULL;
    D3dVertexBufferVector *vbVector;
    float *vbptr;

#ifdef VBDEBUG
    BOOL createNew = false;
#endif

    if (vcount <= 0) {
	return;
    }

    jclass geoClass =  env->GetObjectClass(geo);
    DWORD maxVertexLimit =  d3dCtx->deviceInfo->maxVertexCount[geo_type];
    DWORD texSetUsed = d3dCtx->texSetUsed;
    HRESULT hr;
    BOOL needPointFlag = (geo_type == GEO_TYPE_POINT_SET) ||
	                 ((geo_type != GEO_TYPE_LINE_STRIP_SET) &&
			  (geo_type != GEO_TYPE_LINE_SET) &&
			  (d3dCtx->fillMode == D3DFILL_POINT));

    BOOL buildDL = (d3dCtx->currDisplayListID > 0);

    lockGeometry();

    if (!buildDL) {
	jfieldID fieldID =  env->GetFieldID(geoClass, "pVertexBuffers", "J");
	jobject cloneSource = NULL;

	vbVector = reinterpret_cast<D3dVertexBufferVector *>
	    (env->GetLongField(geo, fieldID));

	if (vbVector == NULL) {
	    // It is possible this is the mirrorGeometry 
	    // from cloneNonIndexGeometry()
	    jfieldID fieldID2 = env->GetFieldID(geoClass,
				      "cloneSourceArray",
				      "Ljavax/media/j3d/IndexedGeometryArrayRetained;");	
	    cloneSource = env->GetObjectField(geo, fieldID2);

	    if (cloneSource != NULL) {
		jclass cloneClass = env->GetObjectClass(cloneSource);
		fieldID =  env->GetFieldID(cloneClass, "pVertexBuffers", "J");

		vbVector = reinterpret_cast<D3dVertexBufferVector *>
		    (env->GetLongField(cloneSource, fieldID));
	    }

	}
	 

	// This is the first time rendering is invoked on the
	// first GeometryArray
	if (vbVector == NULL) {
	    vbVector = new D3dVertexBufferVector();
	    if (vbVector == NULL) {
		D3dCtx::d3dWarning(OUTOFMEMORY);
		unlockGeometry();
		return;
	    }
	    if (cloneSource == NULL) {
		env->SetLongField(geo, fieldID,
				  reinterpret_cast<long>(vbVector));
	    } else {
		env->SetLongField(cloneSource, fieldID,
				  reinterpret_cast<long>(vbVector));
	    }

	} else {
	    // Found the vb in the list of vbVector
	    for (LPD3DVERTEXBUFFER *s = vbVector->begin(); 
		 s != vbVector->end(); ++s) {
		if ((*s)->ctx == d3dCtx) {
		    vb = *s;
		    break;
		}
	    }
	}
    }

    if (vb == NULL) {
	// This is the first time rendering is invoked
	// using this ctx
	vb = new D3dVertexBuffer();

	if (vb == NULL) {
	    D3dCtx::d3dWarning(OUTOFMEMORY);
	    unlockGeometry();
	    return;
	}
	vb->ctx = d3dCtx;
	vb->maxVertexLimit = maxVertexLimit;

	if (!buildDL) {
	    vb->vbVector = vbVector;
	
	    // add it to the GeometryArray pVertexBuffers list
	    vbVector->push_back(vb);
	
	    // add it to the ctx lists
	    vb->next = 	d3dCtx->vertexBufferTable.next;
	    vb->previous = &(d3dCtx->vertexBufferTable);
	    d3dCtx->vertexBufferTable.next = vb;
	    if (vb->next != NULL) {
		vb->next->previous = vb;
	    }
	}
    }

    if ((vb->buffer != NULL) && 
	((vb->vertexFormat != vertexFormat) ||
	 (vb->totalVertexCount < vcount) ||
	 (cDirty &
	  javax_media_j3d_GeometryArrayRetained_STRIPCOUNT_CHANGED) ||
	 (!vb->isPointFlagUsed  && needPointFlag))) {
	// immediate release VB and reconstruct a new one
	vb->release();
    } 

    if (vb->buffer == NULL) {
	vb->stride = D3DXGetFVFVertexSize(vertexFormat);
	vb->vertexFormat = vertexFormat;
	vb->totalVertexCount = vcount;
	vb->vcount = (vcount >= maxVertexLimit ? maxVertexLimit : vcount); 
#ifdef VBDEBUG
	printf("Create primary VertexBuffer of size %d, display list ID %d, pointFlag %d\n", 
	       vb->vcount, d3dCtx->currDisplayListID, needPointFlag);
#endif
	if (!needPointFlag) {
	    hr = device->CreateVertexBuffer(vb->stride*vb->vcount,
					    D3DUSAGE_WRITEONLY,
					    vertexFormat,
					    D3DPOOL_DEFAULT,
					    &vb->buffer);
	} else {
	    hr = device->CreateVertexBuffer(vb->stride*vb->vcount,
					    D3DUSAGE_WRITEONLY|D3DUSAGE_POINTS,
					    vertexFormat,
					    D3DPOOL_DEFAULT,
					    &vb->buffer);
	    vb->isPointFlagUsed = true;
	}

	if (FAILED(hr)) {
	    vb->buffer = NULL;
	    D3dCtx::d3dWarning(CREATEVBFAIL, hr);
	    unlockGeometry();
	    return;
	}
#ifdef VBDEBUG
	createNew = true;
#endif
	cDirty = javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED;
    } 

    unlockGeometry();

    if (buildDL) { 
	// In display list mode, add it to the displayList ID table
	d3dCtx->displayListTable[d3dCtx->currDisplayListID]->add(vb);
    } else {

	if (vb->primitiveType == D3DPT_FORCE_DWORD) {
	    // This happens when previous frame use Quad Line
	    // so buffer not yet initialize
	    cDirty = javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED;
	}

	if (!cDirty &&
	    ((geo_type != GEO_TYPE_QUAD_SET) ||
	     (d3dCtx->fillMode != D3DFILL_WIREFRAME))) {
	    for (i=0; i < d3dCtx->texSetUsed; i++) {
		genMode = strideData->texCoordPosition[i];		
		if ((genMode == TEX_OBJ_LINEAR) ||
		    ((genMode != vb->texCoordPosition[i]) && 
		     (genMode != TEX_GEN_AUTO))) {
		    // For object linear mode user can set the plane
		    // equations so we need to change texture coordinate.
		    break;
		}
	    }
	    if (i == d3dCtx->texSetUsed) {
		vb->render(d3dCtx);
#ifdef TEXDEBUG
		printf("Skip VB Copy\n");
#endif
		return;
	    }
	}
    }
    
    // Note that DWORD (use for color) is of same size 
    // as float (use for vertex/normal)

    hr = vb->buffer->Lock(0, 0, (BYTE**)&vbptr,  0);
    if (FAILED(hr)) {
	D3dCtx::d3dWarning(LOCKVBFAIL, hr);
	// recreate it next time
	vb->release();
	return;
    }

    d3dCtx->pVB = vb;    
    // The current VB is not yet used. 
    vb->stripLen = 0;

    switch (geo_type) {
        case GEO_TYPE_TRI_STRIP_SET:
	    d3dRenderType = D3DPT_TRIANGLESTRIP;
	    renderTypeSet = true;
#ifdef VBDEBUG
	    if (createNew) {
		printf("Tri strip set %d\n", vcount);
	    }
#endif
	    // fall through
        case GEO_TYPE_TRI_FAN_SET:
	    if (renderTypeSet == false) {
#ifdef VBDEBUG
		if (createNew) {
		    printf("Tri fan set %d\n", vcount);
		}
#endif
		d3dRenderType = D3DPT_TRIANGLEFAN;
		renderTypeSet = true;
	    }
	    // fall through
        case GEO_TYPE_LINE_STRIP_SET:
	  {
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_LINESTRIP;
		renderTypeSet = true;
#ifdef VBDEBUG
		if (createNew) {
		    printf("Tri line set %d \n", vcount);
		}
#endif
	    }

	    jfieldID strip_field = env->GetFieldID(geoClass,
					  "stripVertexCounts", "[I");
	    jarray sarray = (jarray)env->GetObjectField(geo, strip_field);
	    jsize strip_len = (jsize)env->GetArrayLength(sarray);

            jint* strips = (jint *)env->GetPrimitiveArrayCritical(sarray, NULL);

	    int nlastStrip = 0;
	    int totalLen = 0;
	    int oldTotalLen = 0;
	    int vsum = 0;

	    vb->primitiveType = d3dRenderType;

	    if (vcount <= vb->vcount) {
		copyVertexToVB(d3dCtx, strideData, vcount,
			       &vbptr, cDirty, false, xform, nxform);
		vb->addStrides(strip_len, strips);
#ifdef VBDEBUG
	    if (createNew) {
		printf("Strip Length %d : ", strip_len);
		for (int k=0; k < strip_len; k++) {
		    printf("%d ", strips[k]);
		}
		printf("\n");
	    }
#endif
	    } else {
#ifdef VBDEBUG
	    if (createNew) {
		printf("Strip Length %d : ", strip_len);
	    }
#endif

		for (i = 0; i < strip_len; i++) {
		    if (strideData->fpositionPtr) {
			strideData->fpositionPtr +=
			    strideData->positionStride*nlastStrip;
		    } else {
			strideData->dpositionPtr +=
			    strideData->positionStride*nlastStrip;
		    }
		    
		    if (strideData->normalPtr) {
			strideData->normalPtr +=
			    strideData->normalStride*nlastStrip;
		    }
		    
		    if (strideData->fdiffusePtr) {
			strideData->fdiffusePtr  +=
			    strideData->diffuseStride*nlastStrip;
		    } else if (strideData->bdiffusePtr) {
			strideData->bdiffusePtr  +=
			    strideData->diffuseStride*nlastStrip;		    
		    }
		    
		    
		    if (strideData->textureCoordsPtr[0]) {
			for (j=0; j < texSetUsed; j++) {
			    strideData->textureCoordsPtr[j] += 
				strideData->textureCoordsStride[j]* nlastStrip;
			}
		    }
		    
		    
		    nlastStrip = strips[i];
		    oldTotalLen = totalLen;
		    totalLen += nlastStrip;
		    
		    if (totalLen > vcount) {
			// This should not happen since 
			// setValidVertexCount is disable
			// in v1.3. We should always have
			// (sum of strips[] < vcount)
			nlastStrip = (vcount - (totalLen - nlastStrip));
			totalLen = vcount;
		    }
		    
		    if (nlastStrip <= 0) {
			continue;
		    }
		    
		    
		    if (vbptr == NULL) {
			// This happen when the lastStrip copy
			// is greater than maxVertexLimit.
			// So we Unlock the last buffer
			vbptr = allocateVB(d3dCtx, device, 
					   vcount - oldTotalLen,
					   maxVertexLimit, &cDirty);
			vsum = 0;
			if (vbptr == NULL) {
			    break; // render whatever geometry the current VB have
			}
		    }
#ifdef VBDEBUG
		    if (createNew) {
			printf(" %d ", nlastStrip);
		    }
#endif
		    if ((vsum + nlastStrip) <= d3dCtx->pVB->vcount) {
			// There is space available to put in vertices
			vsum += nlastStrip;
			copyVertexToVB(d3dCtx, strideData, nlastStrip,
				       &vbptr, cDirty, true, xform, nxform);
		    } else {
			// Need to create a new VB
			if (nlastStrip <= maxVertexLimit) {
			    // No need to split strip in multiple VB
			    if (d3dCtx->pVB->stripLen > 0) {
				if (vbptr != NULL) {
				    d3dCtx->pVB->buffer->Unlock();
				}
				vbptr = allocateVB(d3dCtx, device, 
						   vcount - oldTotalLen,
						   maxVertexLimit, &cDirty);
				if (vbptr == NULL) {
				    break; 
				}
				vsum = 0;
			    }
			    vsum += nlastStrip;
			    copyVertexToVB(d3dCtx, strideData, nlastStrip,
					   &vbptr, cDirty, true,
					   xform, nxform);
			} else {
			    d3dCtx->pVB->buffer->Unlock();
			    vbptr = NULL;
			    vsum = 0;
			    // Multiple VBs for large vertex size
			    splitVertexToMultipleVB(d3dCtx, strideData,
						    nlastStrip,
						    maxVertexLimit,
						    cDirty, xform, nxform);
			    vbptr = NULL;
			}
		    }
		}
#ifdef VBDEBUG
		if (createNew) {
		    printf("\n");
		}
#endif
	  }
            env->ReleasePrimitiveArrayCritical(sarray, strips, NULL);
	  }
	    break;
        case GEO_TYPE_QUAD_SET:
#ifdef VBDEBUG
		if (createNew) {
		    printf("quad set %d\n", vcount);
		}
#endif

		if (buildDL ||
		    (d3dCtx->fillMode != D3DFILL_WIREFRAME)) {
		    /* 
		     * Note we can't just check
		     * if (d3dCtx->fillMode != D3DFILL_WIREFRAME)
		     * since the fillMode may set back to
		     * non-line mode AFTER build display list
		     * In fact it is gaurantee that when displaylist
		     * mode is used we are not in line mode
		     */

		    // break down solid into two triangles
		    if (createQuadIndices(d3dCtx, vcount)) {
                       // It happens when 
                       // vcount*3/2 != d3dCtx->quadIndexBufferSize
                       // to conform with index buffer Limitation in
                       // graphics card. So we adjust using a smaller
                       // maxVertexLimit when spliting into 
                       // multiple Vertex Buffers.
                       maxVertexLimit = 2*d3dCtx->quadIndexBufferSize/3;
                       vb->maxVertexLimit = maxVertexLimit;
                       vb->vcount = vb->maxVertexLimit;
		    }
		    d3dRenderType = D3DPT_TRIANGLELIST;
		    vb->isIndexPrimitive = true;
		    renderTypeSet = true;
		    // fall through
		} else { // line mode
		    // we don't want to see extra line appear in the
		    // diagonal of quads if it splits into two
		    // triangles. This is REALLY SLOW !!!
		    int len = vcount >> 2;
		    int offsetPos = 0;
		    int offsetNorm = 0;
		    int offsetColor = 0;
		    int  strideOffsetPos = strideData->positionStride << 2;
		    int  strideOffsetNorm = strideData->normalStride << 2;
		    int  strideOffsetColor = strideData->diffuseStride << 2;
		    jfloat *pdf = strideData->fpositionPtr;
		    jdouble *pdd = strideData->dpositionPtr;
		    jfloat *pn = strideData->normalPtr;
		    jfloat *pcf = strideData->fdiffusePtr;
		    jbyte  *pcb = strideData->bdiffusePtr;
		    jfloat* pt[D3DDP_MAXTEXCOORD];

		    pt[0] = NULL;

		    if (((vertexFormat & D3DFVF_DIFFUSE) == 0) && 
			(!d3dCtx->isLightEnable)) {
			d3dCtx->setAmbientLightMaterial();
		    }

		    vb->buffer->Unlock();		    
		    vbptr = NULL;		
#ifdef VBDEBUG
		    if (createNew) {
			printf("quad set polygon line %d\n", vcount);
		    }
#endif

		    for (i=0; i < texSetUsed; i++) {
			pt[i] = (FLOAT *) strideData->textureCoordsPtr[i];
		    }

		    jfloat *fptr;
		    jdouble *dptr;
		    jbyte *bptr;
		    jfloat *fspt;
		    jdouble *dspt;
		    int posStride = strideData->positionStride;
		    D3DVERTEX worldCoord[3];
		    D3DTLVERTEX screenCoord[3];

		    vb->primitiveType = D3DPT_FORCE_DWORD;

		    if (d3dCtx->lineModeIndexBuffer == NULL) {
			createLineModeIndexBuffer(d3dCtx);
		    }

		    for (i = 0; i < (vcount >> 2); i++) {
			if (pdf) {
			    fspt = fptr  = pdf + offsetPos;			
			    strideData->fpositionPtr = fptr;
			} else {
			    dspt = dptr  = pdd + offsetPos;			
			    strideData->dpositionPtr = dptr;
			}

			if (pn) {
			    fptr = pn + offsetNorm;
			    strideData->normalPtr = fptr;
			}

			if (pcf) {
			    fptr =  pcf + offsetColor;
			    strideData->fdiffusePtr = fptr;
			} else if (pcb) {
			    bptr = pcb + offsetColor;
			    strideData->bdiffusePtr = bptr;
			}

			if (pt[0]) {
			    for (j=0; j < texSetUsed; j++) {
				DWORD stride3 = 3*strideData->textureCoordsStride[j];
				fptr = pt[j] + i*(strideData->textureCoordsStride[j] << 2);
				strideData->textureCoordsPtr[j] = fptr;
			    }
			}
			if (d3dCtx->cullMode != D3DCULL_NONE) {
			// Do back face culling here
			    if (pdf) {
				worldCoord[0].x = fspt[0];
				worldCoord[0].y = fspt[1];
				worldCoord[0].z = fspt[2];
				fspt += posStride;
				worldCoord[1].x = fspt[0]; 
				worldCoord[1].y = fspt[1];
				worldCoord[1].z = fspt[2];
				fspt += posStride;
				worldCoord[2].x = fspt[0];
				worldCoord[2].y = fspt[1];
				worldCoord[2].z = fspt[2];
			    } else {
				worldCoord[0].x = dspt[0];
				worldCoord[0].y = dspt[1];
				worldCoord[0].z = dspt[2];
				dspt += posStride;
				worldCoord[1].x = dspt[0]; 
				worldCoord[1].y = dspt[1];
				worldCoord[1].z = dspt[2];
				dspt += posStride;
				worldCoord[2].x = dspt[0];
				worldCoord[2].y = dspt[1];
				worldCoord[2].z = dspt[2];
			    }
			    d3dCtx->transform(&worldCoord[0], &screenCoord[0]);
			    d3dCtx->transform(&worldCoord[1], &screenCoord[1]);
			    d3dCtx->transform(&worldCoord[2], &screenCoord[2]);
			    screenCoord[0].sx -= screenCoord[1].sx;  
			    screenCoord[0].sy -= screenCoord[1].sy;  
			    screenCoord[2].sx -= screenCoord[1].sx;  
			    screenCoord[2].sy -= screenCoord[1].sy;  
			    if (d3dCtx->cullMode == D3DCULL_CW) {
				// clip back face
				if ((screenCoord[0].sx*screenCoord[2].sy -
				     screenCoord[2].sx*screenCoord[0].sy) >= 0) {
				    DrawPolygonLine(d3dCtx,
						    device,
						    vertexFormat,
						    strideData);
				} 
			    } else { // Clip front face
				if ((screenCoord[0].sx*screenCoord[2].sy -
				     screenCoord[2].sx*screenCoord[0].sy) <= 0) {
				    DrawPolygonLine(d3dCtx,
						    device,
						    vertexFormat,
						    strideData);
				} 
			    }
			} else {
			    // cullMode == D3DCULL_NONE
			    DrawPolygonLine(d3dCtx,
					    device,
					    vertexFormat,
					    strideData);
			}
			offsetPos += strideOffsetPos;
			offsetNorm += strideOffsetNorm;
			offsetColor += strideOffsetColor;
		    }

		    if (((vertexFormat & D3DFVF_DIFFUSE) == 0) && 
			(!d3dCtx->isLightEnable)) {
			d3dCtx->restoreDefaultLightMaterial();
		    }
		    // Don't call vb->Renderer() at the end
		    return;
		}
	    // fallthrough
        case GEO_TYPE_TRI_SET:
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_TRIANGLELIST;
		renderTypeSet = true;
#ifdef VBDEBUG
		if (createNew) {
		    printf("tri set %d\n", vcount);
		}
#endif
	    }
	    // fallthrough
        case GEO_TYPE_LINE_SET:
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_LINELIST;
		renderTypeSet = true;
#ifdef VBDEBUG
		if (createNew) {
		    printf("line set %d\n", vcount);
		}
#endif
	    }
	    // fallthrough
        case GEO_TYPE_POINT_SET:
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_POINTLIST;
#ifdef VBDEBUG
		if (createNew) {
		    printf("point set %d\n", vcount);
		}
#endif
	    }
	    vb->primitiveType = d3dRenderType;

	    if (vcount <= vb->vcount) {
		copyVertexToVB(d3dCtx, strideData, vcount, &vbptr,
			       cDirty, true, xform, nxform);
	    } else {
		if (vbptr != NULL) {
		    vb->buffer->Unlock();
		    vbptr = NULL;
		}

		splitVertexToMultipleVB(d3dCtx, strideData, vcount,
					maxVertexLimit,
					cDirty, xform, nxform);
		vbptr = NULL;
	    }
	    break;
        default:
            printf("GeometryArrayRetained_execute:unknown geo_type %ld \n", geo_type);
    }

    if (vbptr != NULL) {
	// d3dCtx->pVB is the last reference in VB list
	d3dCtx->pVB->buffer->Unlock();
    }

    for (i=0; i < d3dCtx->texSetUsed; i++) {
	 d3dCtx->pVB->texCoordPosition[i] =
	     strideData->texCoordPosition[i];
    }

    if (!buildDL) { 
	// Not in displaylist mode, directly render VB
	// vb is the root reference in VB list
	vb->render(d3dCtx);
    }
}


void renderIndexGeometry(JNIEnv *env, 
			 D3dCtx *d3dCtx,
			 LPDIRECT3DDEVICE8 device,
			 jobject geo,
			 jint geo_type,
			 D3DDRAWPRIMITIVESTRIDEDDATA *strideData,
			 DWORD vertexFormat,
			 jint vcount,
			 jint indexCount,
			 jdouble* xform,
			 jdouble* nxform,
			 jint cDirty)
{
    D3DPRIMITIVETYPE d3dRenderType;
    BOOL renderTypeSet = false;
    BOOL expandQuadIndex = false;
    int i;
    LPD3DVERTEXBUFFER vb = NULL;
    D3dVertexBufferVector *vbVector;
    float *vbptr;

#ifdef VBDEBUG
    BOOL createNew = false;
#endif

    if (indexCount <= 0) {
	return;
    }

    jclass geoClass =  env->GetObjectClass(geo);
    DWORD maxVertexLimit =
	min(d3dCtx->deviceInfo->maxVertexCount[geo_type],
	    d3dCtx->deviceInfo->maxVertexIndex);
    DWORD texSetUsed = d3dCtx->texSetUsed;
    HRESULT hr;
    BOOL needPointFlag = (geo_type == GEO_TYPE_INDEXED_POINT_SET) ||
	                 ((geo_type != GEO_TYPE_INDEXED_LINE_STRIP_SET) &&
			  (geo_type != GEO_TYPE_INDEXED_LINE_SET) &&
			  (d3dCtx->fillMode == D3DFILL_POINT));

    BOOL buildDL = (d3dCtx->currDisplayListID > 0);

    if (geo_type == GEO_TYPE_INDEXED_QUAD_SET) {
	// Since the index we create with be 1.5 times the original index
	maxVertexLimit = 2*maxVertexLimit/3;
    }


    lockGeometry();

    if (!buildDL) {
	jfieldID fieldID =  env->GetFieldID(geoClass, "pVertexBuffers", "J");
	vbVector = reinterpret_cast<D3dVertexBufferVector *>
	    (env->GetLongField(geo, fieldID));
	
	if (vbVector == NULL) {
	    // This is the first time rendering is invoked on the
	    // first GeometryArray
	    vbVector = new D3dVertexBufferVector();
	    if (vbVector == NULL) {
		D3dCtx::d3dWarning(OUTOFMEMORY);
		unlockGeometry();
		return;
	    }
	    env->SetLongField(geo, fieldID, reinterpret_cast<long>(vbVector));	    
	} else {
	    // Found the vb in the list of vbVector
	    for (LPD3DVERTEXBUFFER *s = vbVector->begin(); 
		 s != vbVector->end(); ++s) {
		if ((*s)->ctx == d3dCtx) {
		    vb = *s;
		    break;
		}
	    }
	}
    }

    if (vb == NULL) {
	// This is the first time rendering is invoked
	// using this ctx
	vb = new D3dVertexBuffer();

	if (vb == NULL) {
	    D3dCtx::d3dWarning(OUTOFMEMORY);
	    unlockGeometry();
	    return;
	}
	vb->ctx = d3dCtx;
	vb->maxVertexLimit = maxVertexLimit;

	if (!buildDL) {
	    vb->vbVector = vbVector;
	
	    // add it to the GeometryArray pVertexBuffers list
	    vbVector->push_back(vb);
	
	    // add it to the ctx lists
	    vb->next = 	d3dCtx->vertexBufferTable.next;
	    vb->previous = &(d3dCtx->vertexBufferTable);
	    d3dCtx->vertexBufferTable.next = vb;
	    if (vb->next != NULL) {
		vb->next->previous = vb;
	    }
	}
    }

    if (((vb->indexBuffer != NULL) &&
	 (vb->totalIndexCount < indexCount)) || 
	((vb->buffer != NULL) && 
	((vb->vertexFormat != vertexFormat) ||
	 (vb->totalVertexCount < vcount) ||
	 (!vb->isPointFlagUsed  && needPointFlag)))) {
	// immediate release VB and reconstruct a new one
	vb->release();
    } 


    if (vb->buffer == NULL) {
	vb->stride = D3DXGetFVFVertexSize(vertexFormat);
	vb->vertexFormat = vertexFormat;
	vb->totalVertexCount = vcount;
	vb->isIndexPrimitive = true;
	vb->vcount = (vcount >= maxVertexLimit ? maxVertexLimit : vcount); 
#ifdef VBDEBUG
	printf("Create primary VertexBuffer of size %d, display list ID %d, pointFlag %d\n", 
	       vb->vcount, d3dCtx->currDisplayListID, needPointFlag);
#endif
	
	if (!needPointFlag) {
	    hr = device->CreateVertexBuffer(vb->stride*vb->vcount,
					    D3DUSAGE_WRITEONLY,
					    vertexFormat,
					    D3DPOOL_DEFAULT,
					    &vb->buffer);
	} else {
	    hr = device->CreateVertexBuffer(vb->stride*vb->vcount,
					    D3DUSAGE_WRITEONLY|D3DUSAGE_POINTS,
					    vertexFormat,
					    D3DPOOL_DEFAULT,
					    &vb->buffer);
	    vb->isPointFlagUsed = true;
	}

	if (FAILED(hr)) {
	    vb->buffer = NULL;
	    D3dCtx::d3dWarning(CREATEVBFAIL, hr);
	    unlockGeometry();
	    return;
	}
#ifdef VBDEBUG
	createNew = true;
#endif
	cDirty = javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED;
    }

    if (vb->indexBuffer == NULL) {

	vb->totalIndexCount = indexCount;
	vb->indexCount = (indexCount >= maxVertexLimit ? 
			  maxVertexLimit : indexCount); 	

	if (geo_type == GEO_TYPE_INDEXED_QUAD_SET) {
	    // Since we will construct another index with 
	    // 1.5 times of the original.
	    vb->indexCount = (3*vb->indexCount) >> 1;
	    vb->totalIndexCount = (3*indexCount) >> 1;
	}


	if (indexCount <= 0xffff) {
	    hr = device->CreateIndexBuffer(vb->indexCount*sizeof(WORD),
					   D3DUSAGE_WRITEONLY,
					   D3DFMT_INDEX16,
					   D3DPOOL_DEFAULT,
					   &vb->indexBuffer);
	} else {
	    hr = device->CreateIndexBuffer(vb->indexCount*sizeof(UINT),
					   D3DUSAGE_WRITEONLY,
					   D3DFMT_INDEX32,
					   D3DPOOL_DEFAULT,
					   &vb->indexBuffer);
	}
	
	if (FAILED(hr)) {
	    vb->indexBuffer = NULL;
	    D3dCtx::d3dWarning(CREATEINDEXVBFAIL, hr);
	    unlockGeometry();
	    return;
	}

	cDirty |= javax_media_j3d_GeometryArrayRetained_INDEX_CHANGED;
    }

    unlockGeometry();

    if (buildDL) { 
	// In display list mode, add it to the displayList ID table
	d3dCtx->displayListTable[d3dCtx->currDisplayListID]->add(vb);
    } else {

	if (vb->primitiveType == D3DPT_FORCE_DWORD) {
	    // This happens when previous frame use Quad Line
	    // so buffer not yet initialize
	    cDirty =
		javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED |
		javax_media_j3d_GeometryArrayRetained_INDEX_CHANGED;
	}

	if (!cDirty &&
	    ((geo_type != GEO_TYPE_INDEXED_QUAD_SET) ||
	     (d3dCtx->fillMode != D3DFILL_WIREFRAME))) {
	    for (i=0; i < d3dCtx->texSetUsed; i++) {
		if ((strideData->texCoordPosition[i] !=
		     vb->texCoordPosition[i]) 
		    &&
		    (strideData->texCoordPosition[i] != TEX_GEN_AUTO)) {
		    break;
		}
	    }
	    if (i == d3dCtx->texSetUsed) {
		vb->render(d3dCtx);
		return;
	    }
	}
    }

    // Note that DWORD (use for color) is of same size 
    // as float (use for vertex/normal)
    hr = vb->buffer->Lock(0, 0, (BYTE**)&vbptr,  0);
    if (FAILED(hr)) {
	D3dCtx::d3dWarning(LOCKVBFAIL, hr);
	// recreate it next time
	vb->release();
	return;
    }

    d3dCtx->pVB = vb;

    // The current VB is not yet used. 
    vb->stripLen = 0;

    switch (geo_type) {
        case GEO_TYPE_INDEXED_TRI_STRIP_SET:
	    d3dRenderType = D3DPT_TRIANGLESTRIP;
	    renderTypeSet = true;
#ifdef VBDEBUG
	    if (createNew) {
		printf("Tri strip set %d\n", vcount);
	    }
#endif
	    // fall through
        case GEO_TYPE_INDEXED_TRI_FAN_SET:
	    if (renderTypeSet == false) {
#ifdef VBDEBUG
		if (createNew) {
		    printf("Tri fan set %d\n", vcount);
		}
#endif
		d3dRenderType = D3DPT_TRIANGLEFAN;
		renderTypeSet = true;
	    }
	    // fall through
        case GEO_TYPE_INDEXED_LINE_STRIP_SET:
	  {
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_LINESTRIP;
		renderTypeSet = true;
#ifdef VBDEBUG
		if (createNew) {
		    printf("Tri line set %d \n", vcount);
		}
#endif
	    }

	    jfieldID strip_field = env->GetFieldID(geoClass,
					  "stripIndexCounts", "[I");
	    jarray sarray = (jarray)env->GetObjectField(geo, strip_field);
	    jsize strip_len = (jsize)env->GetArrayLength(sarray);

            jint* strips = (jint *)env->GetPrimitiveArrayCritical(sarray, NULL);
	    int nlastStrip = 0;

	    vb->primitiveType = d3dRenderType;
#ifdef VBDEBUG
	    if (createNew) {
		printf("Strip Length %d : ", strip_len);
	    }
#endif

	    if ((vb->totalIndexCount <= vb->indexCount) &&
		(vcount <= vb->vcount)) {
		copyIndexVertexToVB(d3dCtx, strideData,
				    indexCount, cDirty, false, false);
		copyVertexToVB(d3dCtx, strideData, vcount,
			       &vbptr, cDirty, false, xform, nxform);
		vb->addStrides(strip_len, strips);
	    } else {
		vb->buffer->Unlock();
		vbptr = NULL;		
		strideData->indexPtr += strideData->initialIndexIndex;
		strideData->initialIndexIndex = 0;
		for (i = 0; i < strip_len; i++) {
		    strideData->indexPtr += nlastStrip;

		    nlastStrip = strips[i];
		    
		    if (nlastStrip <= 0) {
			continue;
		    }
#ifdef VBDEBUG
		    if (createNew) {
			printf(" %d", nlastStrip);
		    }
#endif
		    if (nlastStrip <= vb->indexCount) {
			reIndexifyIndexVertexToVBs(d3dCtx, strideData, 
						   nlastStrip, vcount,
						   cDirty,
						   false,
						   maxVertexLimit, 
						   xform, nxform);
		    } else {
			// Multiple VBs for large vertex size
			splitIndexVertexToMultipleVB(d3dCtx,
						     strideData,
						     nlastStrip,
						     vcount,
						     maxVertexLimit,
						     cDirty,
						     false,
						     xform, nxform);
		    }
		    SafeDelete(d3dCtx->reIndexifyTable);
		}
#ifdef VBDEBUG
		if (createNew) {
		    printf("\n");
		}
#endif
	    }
	    env->ReleasePrimitiveArrayCritical(sarray, strips, NULL);
	  }

	    break;
        case GEO_TYPE_INDEXED_QUAD_SET:
#ifdef VBDEBUG
		if (createNew) {
		    printf("quad set %d\n", vcount);
		}
#endif
		if (buildDL ||
		    (d3dCtx->fillMode != D3DFILL_WIREFRAME)) {
		    d3dRenderType = D3DPT_TRIANGLELIST;
		    renderTypeSet = true;
		    expandQuadIndex = true;
		    // fall through
		} else { // polygon line mode
		    // we don't want to see extra line appear in the
		    // diagonal of quads if it splits into two
		    // triangles. This is REALLY SLOW !!!
		    int posStride = strideData->positionStride;
		    D3DVERTEX worldCoord[3];
		    D3DTLVERTEX screenCoord[3];
		    jint *idxPtr = strideData->indexPtr;
		    jfloat *fspt;
		    jdouble *dspt;
		    jint idx0, idx1, idx2, idx3;

		    if (((vertexFormat & D3DFVF_DIFFUSE) == 0) && 
			(!d3dCtx->isLightEnable)) {
			d3dCtx->setAmbientLightMaterial();
		    }  

		    vb->buffer->Unlock();		    
		    vbptr = NULL;		
#ifdef VBDEBUG
		    if (createNew) {
			printf("indexed quad set polygon line %d\n", vcount);
		    }
#endif
		    if (d3dCtx->lineModeIndexBuffer == NULL) {
			createLineModeIndexBuffer(d3dCtx);
		    }

		    vb->primitiveType = D3DPT_FORCE_DWORD;

		    for (i = 0; i < (indexCount >> 2); i++) {
			if (d3dCtx->cullMode != D3DCULL_NONE) {
			// Do back face culling here
			    idx0 = *idxPtr++;
			    idx1 = *idxPtr++;
			    idx2 = *idxPtr++;
			    idx3 = *idxPtr++;
			    if (strideData->fpositionPtr) {
				fspt = strideData->fpositionPtr + posStride*idx0;
				worldCoord[0].x = *fspt++;
				worldCoord[0].y = *fspt++;
				worldCoord[0].z = *fspt++;
				fspt = strideData->fpositionPtr + posStride*idx1;
				worldCoord[1].x = *fspt++;
				worldCoord[1].y = *fspt++;
				worldCoord[1].z = *fspt++;
				fspt = strideData->fpositionPtr + posStride*idx2;
				worldCoord[2].x = *fspt++;
				worldCoord[2].y = *fspt++;
				worldCoord[2].z = *fspt++;
			    } else {
				dspt = strideData->dpositionPtr + posStride*idx0;
				worldCoord[0].x = *dspt++;
				worldCoord[0].y = *dspt++;
				worldCoord[0].z = *dspt++;
				dspt = strideData->dpositionPtr + posStride*idx1;
				worldCoord[1].x = *dspt++;
				worldCoord[1].y = *dspt++;
				worldCoord[1].z = *dspt++;
				dspt = strideData->dpositionPtr + posStride*idx2;
				worldCoord[2].x = *dspt++;
				worldCoord[2].y = *dspt++;
				worldCoord[2].z = *dspt++;
			    }

			    d3dCtx->transform(&worldCoord[0], &screenCoord[0]);
			    d3dCtx->transform(&worldCoord[1], &screenCoord[1]);
			    d3dCtx->transform(&worldCoord[2], &screenCoord[2]);
			    screenCoord[0].sx -= screenCoord[1].sx;  
			    screenCoord[0].sy -= screenCoord[1].sy;  
			    screenCoord[2].sx -= screenCoord[1].sx;  
			    screenCoord[2].sy -= screenCoord[1].sy;  
			    if (d3dCtx->cullMode == D3DCULL_CW) {
				if ((screenCoord[0].sx*screenCoord[2].sy -
				     screenCoord[2].sx*screenCoord[0].sy) >= 0) {
				    DrawIndexPolygonLine(d3dCtx,
							 device,
							 vertexFormat,
							 strideData,
							 idx0, idx1,
							 idx2, idx3);
				} 
			    } else { // Clip front face
				if ((screenCoord[0].sx*screenCoord[2].sy -
				     screenCoord[2].sx*screenCoord[0].sy) <= 0) {
				    DrawIndexPolygonLine(d3dCtx,
							 device,
							 vertexFormat,
							 strideData,
							 idx0, idx1,
							 idx2, idx3);
				} 
			    }
			} else {
			    // cullMode == D3DCULL_NONE
			    DrawIndexPolygonLine(d3dCtx,
						 device,
						 vertexFormat,
						 strideData,
						 idx0, idx1,
						 idx2, idx3);
			}
		    }
		    if (((vertexFormat & D3DFVF_DIFFUSE) == 0) && 
			(!d3dCtx->isLightEnable)) {
			d3dCtx->restoreDefaultLightMaterial();	
		    }
		    // Don't call vb->Renderer() at the end
		    return;
		}
		// fall through
        case GEO_TYPE_INDEXED_TRI_SET:
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_TRIANGLELIST;
		renderTypeSet = true;
#ifdef VBDEBUG
		if (createNew) {
		    printf("tri set %d\n", vcount);
		}
#endif
	    }
	    // fallthrough
        case GEO_TYPE_INDEXED_LINE_SET:
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_LINELIST;
		renderTypeSet = true;
#ifdef VBDEBUG
		if (createNew) {
		    printf("line set %d\n", vcount);
		}
#endif
	    }
	    // fallthrough
        case GEO_TYPE_INDEXED_POINT_SET:
	    if (renderTypeSet == false) {
		d3dRenderType = D3DPT_POINTLIST;
#ifdef VBDEBUG
		if (createNew) {
		    printf("point set %d\n", vcount);
		}
#endif
	    }
	    vb->primitiveType = d3dRenderType;

	    if (vb->totalIndexCount <= vb->indexCount) {
		if (vcount <= vb->vcount) {
		    copyIndexVertexToVB(d3dCtx, strideData,  
					indexCount,
					cDirty, true, expandQuadIndex);
		    copyVertexToVB(d3dCtx, strideData, vcount, &vbptr,
				   cDirty, false, xform, nxform);
		} else {
		    vb->buffer->Unlock();
		    vbptr = NULL;
		    reIndexifyIndexVertexToVBs(d3dCtx, strideData, 
					       indexCount, vcount,
					       cDirty,
					       expandQuadIndex,
					       maxVertexLimit, 
					       xform, nxform);
		    SafeDelete(d3dCtx->reIndexifyTable);
		}
	    } else {
		vb->buffer->Unlock();
		vbptr = NULL;
		splitIndexVertexToMultipleVB(d3dCtx, 
					     strideData, 
					     indexCount,
					     vcount,
					     maxVertexLimit,
					     cDirty,
					     expandQuadIndex,
					     xform, nxform);
		SafeDelete(d3dCtx->reIndexifyTable);
	    }
	    break;
        default:
            printf("IndexedGeometryArrayRetained_execute:unknown geo_type %ld \n", geo_type);
    }

    if (vbptr != NULL) {
	// d3dCtx->pVB is the last reference in VB list
	d3dCtx->pVB->buffer->Unlock();
    }

    // Save new texture position to detect any change
    // in next round.
    for (i=0; i < d3dCtx->texSetUsed; i++) {
	 d3dCtx->pVB->texCoordPosition[i] =
	     strideData->texCoordPosition[i];
    }

    if (!buildDL) { 
	// Not in displaylist mode, directly render VB
	// vb is the root reference in VB list
	vb->render(d3dCtx);
    }
}


/*
 * Set the default texture coordinate pointers when automatically
 * texture generation is used or when there is application error
 */
inline void setDefaultTextureCoordPointers(D3dCtx *d3dCtx,
					   D3DDRAWPRIMITIVESTRIDEDDATA *strideData,
					   DWORD* vertexFormat,
					   jint ts,
					   int genMode,
					   int tus)
{
    strideData->textureCoordsPtr[tus] = &defaultTexCoord[0];
    strideData->textureCoordsStride[tus] = 0;
    strideData->texCoordPosition[tus] = genMode;
    d3dCtx->texStride[tus] = ts;
    *vertexFormat |= (TexFormatSizeTable[ts] << (tus*2 + 16));
}


/*
 * Set the textureCoordStride & textureCoordsPtr in strideData
 */
void setTextureCoordPointers(JNIEnv *env,
			     D3dCtx* d3dCtx,  
			     LPDIRECT3DDEVICE8 device, 
			     D3DDRAWPRIMITIVESTRIDEDDATA *strideData,
			     jint pass,
			     jint texoff,
			     jint texStride,
			     jint ts,
			     jboolean textureDefined,
			     jintArray tcoordsetmap,
			     jint texCoordMapLength, 
			     jintArray texUnitOffset,
			     jint numActiveTexUnit,
			     jintArray tunitstatemap,
			     DWORD* vertexFormat,
			     // Used by executeGeometryArray() & 
			     // executeIndexedGeometryArray() only
			     jfloat* verts, 
			     // Used by executeGeometryArrayVA() & 
			     // executeIndexedGeometryArrayVA() only
			     jfloat** texCoordPointer,
			     // Used by executeGeometryArrayVA() only 
			     jintArray texindices)
			     
{
    jint *texUnitStateMap = NULL;
    jint *texCoordSetMapOffset = NULL;
    jint *initialTexIndices = NULL;
    jint *texCoordSetMap = NULL;
    jint textureUnitIndex;
    int genMode;
    jint offsetOrTexset;
    BOOL nonVAGeom = (verts != NULL);
    int texSetInVB = 0;

    /*
     * In case of automatic texture generation, 
     * (vformat & GA_TEXTURE_COORDINATE) may equal to zero so we 
     * can't wrap around this whole block with the condition.
     */
    d3dCtx->texSetUsed = 0;

    // For GA buildGA(), numActiveTexUnit is 1 even though texture
    // is not used. This is only accurate for execute() immediate case.
    if (numActiveTexUnit <= 0) {
	return;
    }

    if (texCoordMapLength > 0) {
	if (nonVAGeom) {
	    // In executeGeometryArray() or executeIndexedGeometryArray()	    
	    texCoordSetMapOffset = (jint *) env->GetPrimitiveArrayCritical(texUnitOffset, NULL);
	} else {
	    // In executeGeometryArrayVA() or executeIndexedGeometryArrayVA()
	    texCoordSetMap = (jint *)
		env->GetPrimitiveArrayCritical(tcoordsetmap, NULL);
	}

    }

    if (texindices != NULL) {
	// In executeGeometryArrayVA()
	initialTexIndices = (jint *) env->GetPrimitiveArrayCritical(texindices, NULL);
    }

    if (pass >= 0) {
	/* 
	 * Single texture coordinate used or in multi-pass mode.
	 * In multi-pass mode, texture stage 0 is set so we 
	 * should not use
	 *     setTextureStage(d3dCtx, device, 0, pass);
	 */

	genMode = setTextureStage(d3dCtx, device, 0, 0);

#ifdef TEXDEBUG    
	printf("*** Single Pass *** %d, nonVAGeom %d, buildDL %d, numActiveTexUnit, texCoordMapLength %d, texDef %d, genMode %d \n", pass,  nonVAGeom, (d3dCtx->currDisplayListID > 0),  numActiveTexUnit, texCoordMapLength, textureDefined, genMode);
#endif

	if ((texCoordMapLength > 0) &&
	    (pass < texCoordMapLength)) {
	    offsetOrTexset = (nonVAGeom ? 
			      texCoordSetMapOffset[pass] : texCoordSetMap[pass]);
	} else {
	    // TexUnitState is not used or disable,
	    // so by default we use texUnitIndex 0   
	    offsetOrTexset = 0;
	}

	if (genMode != TEX_OBJ_LINEAR) {
	    // Only Object Linear Mode will not use DisplayList at
	    // all. That mean genMode must be correctly set before
	    // enter this Geometry execute() function/
	    // In non displaylist mode genMode may not set correctly
	    // when so we can't rely on it.
	    if (textureDefined) {
		if (offsetOrTexset != -1) {
		    if (nonVAGeom) {
			// In executeGeometryArray() or executeIndexedGeometryArray()	    
			strideData->textureCoordsPtr[0] = 
			    &verts[texoff + offsetOrTexset];
		    } else if (initialTexIndices != NULL) {
			//  executeGeometryArrayVA()
			strideData->textureCoordsPtr[0] = 
			    &(texCoordPointer[offsetOrTexset][initialTexIndices[offsetOrTexset]*texStride]);
		    } else { // executeIndexedGeometryArrayVA()
			strideData->textureCoordsPtr[0] = 
			    &(texCoordPointer[offsetOrTexset][0]);
		    }

		    strideData->textureCoordsStride[0] = texStride;
		    *vertexFormat |= (TexFormatSizeTable[ts] << 16);
		    d3dCtx->texSetUsed = 1;
		    strideData->texCoordPosition[0] = offsetOrTexset;
		    d3dCtx->texStride[0] = ts;
		    setTexTransformStageFlag(d3dCtx, device, 0, ts, genMode);
#ifdef TEXDEBUG    
		    printf("[pass 0] Non Object Linear, texDefined, ts=%d\n", ts);
#endif
		} 
	    } else {
		// may be automatic texture generation used
		// TexSetUsed remain unchange i.e. 0 since we will not
		// allocate VB space for texture coords.
		setTexTransformStageFlag(d3dCtx, device, 0, 
					 d3dCtx->texCoordFormat[0], genMode);
#ifdef TEXDEBUG    
		printf("[pass 0] Non Object Linear, No texDefined, ts=%d\n",
			   d3dCtx->texCoordFormat[0]);
#endif
	    }
	} else {
	    // Automatic texture generation Object Linear 
	    //  strideData->textureCoordsPtr[0] &
	    //  strideData->textureCoordsStride[0]
	    // are not use in VertexBuffer texture copy so
	    // it doesn't matter to set them using default.
	    setDefaultTextureCoordPointers(d3dCtx, strideData,
					   vertexFormat, 
					   d3dCtx->texCoordFormat[0],
					   genMode, 0);
	    setTexTransformStageFlag(d3dCtx, device, 0, 
				     d3dCtx->texCoordFormat[0], genMode);
	    d3dCtx->texSetUsed = 1;
#ifdef TEXDEBUG    
	    printf("[pass 0] Object Linear, ts=%d\n", d3dCtx->texCoordFormat[0]);
#endif
	} 
	texSetInVB = d3dCtx->texSetUsed;

    } else {
	// DisplayList is used for multiple texture single pass mode
	// Or when go through the VertexArray in OGL, pass = -1
	int tus;
#ifdef TEXDEBUG    
	printf("*** Multiple Pass *** %d, nonVAGeom %d, buildDL %d, numActiveTexUnit %d, texCoordMapLength %d, texDef %d\n", pass,
	   nonVAGeom, (d3dCtx->currDisplayListID > 0),
	   numActiveTexUnit, texCoordMapLength, textureDefined);
#endif

	if (tunitstatemap != NULL) {
	    texUnitStateMap = (jint *) env->GetPrimitiveArrayCritical(tunitstatemap, NULL);
	}
	for (textureUnitIndex = 0; textureUnitIndex <  numActiveTexUnit; 
	     textureUnitIndex++) {

	    tus = (texUnitStateMap != NULL ? 
		   texUnitStateMap[textureUnitIndex]: textureUnitIndex);

	    if (d3dCtx->currDisplayListID > 0) {
		genMode = setTextureStage(d3dCtx, device,
					  textureUnitIndex, tus);
	    } else {
		// This happen when we switch from displayList to
		// vertexArray mode. The displayList is already
		// built with 1-1 mapping so we can't use the 
		// textureUnitIndex Mapping
		genMode = setTextureStage(d3dCtx, device,
					  textureUnitIndex, 
					  textureUnitIndex); 
	    }
#ifdef TEXDEBUG
	    printf("[pass %d] genMode %d, tus %d\n", textureUnitIndex,
		   genMode, tus);
#endif
	    if (genMode != TEX_OBJ_LINEAR) {
		if (textureDefined) {
		    if (tus < texCoordMapLength) {
			offsetOrTexset = (nonVAGeom ?
					  texCoordSetMapOffset[tus]:texCoordSetMap[tus]);

			if (offsetOrTexset != -1) {
			    if (nonVAGeom) {
				strideData->textureCoordsPtr[textureUnitIndex]  =
				    &verts[texoff + offsetOrTexset];
			    } else if (initialTexIndices != NULL) {
				strideData->textureCoordsPtr[textureUnitIndex] = 
				    &(texCoordPointer[offsetOrTexset][initialTexIndices[offsetOrTexset]*texStride]);
			    } else {
				strideData->textureCoordsPtr[textureUnitIndex] = 
				    &(texCoordPointer[offsetOrTexset][0]);
			    }
			    strideData->textureCoordsStride[textureUnitIndex] = texStride;
			    strideData->texCoordPosition[textureUnitIndex]
				= offsetOrTexset;
			    *vertexFormat |= (TexFormatSizeTable[ts] << (textureUnitIndex*2 + 16));
			    d3dCtx->texStride[textureUnitIndex] = ts;
			    setTexTransformStageFlag(d3dCtx, device,
						     textureUnitIndex,
						     ts, genMode);
			    texSetInVB++;
#ifdef TEXDEBUG    
			    printf("[pass %d] Non Object Linear, texDefined, ts=%d, tus %d\n", textureUnitIndex, ts, tus);
#endif
			} else {
			    // This texture status is disable, this
			    // should not happen in D3D since
			    // TextureBin always compact unused state
			    // - unless when DisplayList is build and
			    // automatic texture generation
			    // used. Since if DL use
			    // updateAttributes() not yet invoke to
			    // set genMode correctly.
			    if (debug && (d3dCtx->currDisplayListID <= 0)) {
				printf("[Java3D] TextureBin not compact textureUnitState correctly, numActiveTex %d, disableUnit %d, current mapped Texture Unit %d\n", numActiveTexUnit, tus, textureUnitIndex);
			    }
			    setDefaultTextureCoordPointers(d3dCtx, strideData,
							   vertexFormat, ts,
							   genMode,
							   textureUnitIndex);
			    setTexTransformStageFlag(d3dCtx, device,
						     textureUnitIndex,
						     ts, genMode);
			    texSetInVB++;
#ifdef TEXDEBUG    
			    printf("[pass %d] Non Object Linear, texDefined, ts=%d\n", textureUnitIndex, ts);
#endif
			}
		    } else {
			// Internal error, should not happen.
			if (debug) {
			    printf("[Java3D] TextureCoordMapLength length %d, is smaller than texture unit %d, map texture unit %d\n", texCoordMapLength, tus, textureUnitIndex);
			}
			setDefaultTextureCoordPointers(d3dCtx, strideData,
						       vertexFormat, ts,
						       TEX_GEN_INVALID,
						       textureUnitIndex);
			setTexTransformStageFlag(d3dCtx, device,
						 textureUnitIndex, ts,
						 genMode);
						 
			texSetInVB++;
#ifdef TEXDEBUG    
			printf("[pass %d] Non Object Linear, texDefined,  offset/texset = -1, ts=%d\n", textureUnitIndex, ts);
#endif
		    }
		} else {
		    // May be in automatically texture coordinate
                    // generation mode.
		    // May have trouble if automatically texture
		    // coordinate not used. Note that we pass ts = 0 
		    // so that copyVertexToVB() will not inc. the
		    // stride for this unused tex stage.

		    // It is also the case in buildGA() case when
		    // numActiveTexUnit is 1 by default even though
		    // texture is not used.
		    /*
		    if ((d3dCtx->currDisplayListID <= 0) && 
			(genMode == TEX_GEN_NONE))  {
			// application error, use default TexCoord
			setDefaultTextureCoordPointers(d3dCtx, strideData,
						       vertexFormat, 
						       ts,
						       TEX_GEN_NONE,
						       textureUnitIndex);
			texSetInVB++;
                       }
		    */

		    setDefaultTextureCoordPointers(d3dCtx, strideData,
						   vertexFormat, 
						   0,
						   // This must be < 0
						   TEX_GEN_AUTO,
						   textureUnitIndex);
		    setTexTransformStageFlag(d3dCtx, device, textureUnitIndex, 
					     d3dCtx->texCoordFormat[textureUnitIndex], genMode);


#ifdef TEXDEBUG    
		    printf("[pass %d] Non Object Linear, No texDefined, ts=0\n", textureUnitIndex);
#endif
		}
	    } else {
		// Automatic Texture generation Object Linear is used
		setDefaultTextureCoordPointers(d3dCtx, strideData,
					       vertexFormat, 
					       d3dCtx->texCoordFormat[textureUnitIndex],
					       genMode,
					       textureUnitIndex);
		setTexTransformStageFlag(d3dCtx, device, textureUnitIndex, 
					 d3dCtx->texCoordFormat[textureUnitIndex], genMode);
		texSetInVB++;
#ifdef TEXDEBUG    
		printf("[pass %d] Object Linear, No texDefined, ts=%d\n", textureUnitIndex,  d3dCtx->texCoordFormat[textureUnitIndex]);
#endif
	    }
	}
	d3dCtx->texSetUsed = numActiveTexUnit;
#ifdef TEXDEBUG    
	printf("No of texSetInVB %d, numActiveTexUnit %d\n",
	       texSetInVB, numActiveTexUnit);
#endif
	if (texUnitStateMap != NULL) {
	    env->ReleasePrimitiveArrayCritical(tunitstatemap, texUnitStateMap, NULL);
	}
    }

    if (texCoordSetMapOffset != NULL) {
	env->ReleasePrimitiveArrayCritical(texUnitOffset,
					   texCoordSetMapOffset, NULL);
    }

    if (texCoordSetMap != NULL) {
	env->ReleasePrimitiveArrayCritical(tcoordsetmap,
					   texCoordSetMap, NULL);
    }

    if (initialTexIndices != NULL) {
	env->ReleasePrimitiveArrayCritical(texindices,
					   initialTexIndices, NULL);	
    }

    // texSetInVB <= d3dCtx->TexSetUsed
    *vertexFormat |= getVertexFormat(texSetInVB);
}



void executeGeometryArrayVA(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean modAlpha,
    float alpha,
    jboolean multiScreen,
    jboolean ignoreVertexColors,				   
    jint vcount,
    jint vformat,
    jint vdefined,
    jint initialCoordIndex,
    jfloat* fverts,
    jdouble* dverts,
    jint initialColorIndex,
    jfloat* fclrs,
    jbyte*  bclrs,
    jint initialNormalIndex,
    jfloat* norms,
    int pass, // or texUnitIndex
    int texCoordMapLength,
    jintArray 	tcoordsetmap,
    jint numActiveTexUnit,
    jintArray tunitstatemap,
    jintArray texindices,
    jint texStride,
    jfloat** texCoordPointer,
    jdoubleArray xform, 
    jdoubleArray nxform,
    jint cDirty)
{
    D3DDRAWPRIMITIVESTRIDEDDATA strideData;
    DWORD vertexFormat = 0;
    
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);
   
    GetDevice();

    ZeroMemory(&strideData, sizeof(D3DDRAWPRIMITIVESTRIDEDDATA));

    strideData.modulateAlpha = modAlpha;
    strideData.alpha = alpha;


    // setup coordinate pointers
    if (floatCoordDefined || doubleCoordDefined) {
	vertexFormat |= D3DFVF_XYZ;

	if (floatCoordDefined) {
	    strideData.fpositionPtr = &fverts[initialCoordIndex*3];
	} else if (doubleCoordDefined) {
	    strideData.dpositionPtr = &dverts[initialCoordIndex*3];
	}
	
	strideData.positionStride = 3;
	
    } else {
	// nothing worth doing if no coordinates define
	return;
    }

    // setup normal pointers
    if (normalsDefined) {
        vertexFormat |= D3DFVF_NORMAL;
        strideData.normalPtr = &norms[initialNormalIndex*3];
        strideData.normalStride = 3;
    }
    
    
    // setup color pointers
    if (!(floatColorsDefined || byteColorsDefined)
	|| ignoreVertexColors) {
	// Use Material color
	// Assume VertexBuffer will recreate when ignoreVertexColors
	// property changed. Otherwise we need to remove
	// the following one line
	vertexFormat &= ~D3DFVF_DIFFUSE;
    } else {
	if ((vformat & GA_WITH_ALPHA) != 0) {
	    strideData.diffuseStride = 4;
	    strideData.useAlpha = true;
	} else {
	    strideData.diffuseStride = 3;
	    strideData.useAlpha = false;
	}
	if (floatColorsDefined) {
	    strideData.fdiffusePtr = &fclrs[initialColorIndex*strideData.diffuseStride];
	} else {
	    strideData.bdiffusePtr = &bclrs[initialColorIndex*strideData.diffuseStride];
	} 

	vertexFormat |= D3DFVF_DIFFUSE;
    } 
    
    int ts = 2; // In case of automatic texture generation

    if ((vformat & GA_TEXTURE_COORDINATE_3) != 0) {
	ts = 3;
    } else if ((vformat & GA_TEXTURE_COORDINATE_4) != 0) {
	ts = 4;
    } 


    // setup texture pointer
    setTextureCoordPointers(env, d3dCtx, device,
			    &strideData,
			    pass, 0, texStride, ts,
			    textureDefined,
			    tcoordsetmap,
			    texCoordMapLength, 
			    NULL,
			    numActiveTexUnit,
			    tunitstatemap,
			    &vertexFormat,
			    NULL, texCoordPointer, 
			    texindices);

    

    jdouble* xform_ptr = NULL;
    jdouble* nxform_ptr = NULL;

    if (xform != NULL) {
        xform_ptr = (jdouble *) env->GetPrimitiveArrayCritical(xform, NULL);

    }

    if (nxform != NULL) {
        nxform_ptr = (jdouble *) env->GetPrimitiveArrayCritical(nxform, NULL);
    }

    // Construct/update VertexBuffer, render() if not in display list mode 
    renderGeometry(env, d3dCtx, device, geo, geo_type, &strideData,
		   vertexFormat, vcount, xform_ptr, nxform_ptr, cDirty);

    if (xform_ptr != NULL) {
	env->ReleasePrimitiveArrayCritical(xform, xform_ptr, 0);
    }
    if (nxform_ptr != NULL) {
	env->ReleasePrimitiveArrayCritical(nxform, nxform_ptr, 0);
    }

}




/* execute geometry array with java array format */
extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_executeVABuffer(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,    
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean multiScreen,
    jboolean ignoreVertexColors,
    jint vcount,
    jint vformat,
    jint vdefined,
    jint initialCoordIndex,
    jobject vcoords,
    jint initialColorIndex,
    jobject cdataBuffer,
    jfloatArray cfdata,
    jbyteArray  cbdata,    
    jint initialNormalIndex,
    jobject ndata,
    jint pass,  
    jint texCoordMapLength,
    jintArray 	tcoordsetmap,
    jint numActiveTexUnit,
    jintArray tunitstatemap,
    jintArray texindices,
    jint texStride,
    jobjectArray texCoords,
    jint cdirty)
{
    
    jfloat *fverts = NULL;
    jdouble *dverts = NULL ;
    jbyte *bclrs = NULL;
    jfloat *fclrs = NULL, *norms = NULL;
    jfloat* texCoordPointer[D3DDP_MAXTEXCOORD];
    jarray texobjs[D3DDP_MAXTEXCOORD];
    int i;
    
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);

    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    texobjs[i] = (jarray)env->GetObjectArrayElement(texCoords, i);
	}
    }

    /* get coordinate array */
    if (floatCoordDefined) {
	fverts = (jfloat *)env->GetDirectBufferAddress( vcoords );
    } else if (doubleCoordDefined) {
	dverts = (jdouble *)env->GetDirectBufferAddress( vcoords ); 
    }

    if(fverts == NULL && dverts == NULL)
	return; 

    /* get color array */
    if (floatColorsDefined) {
	if(cfdata != NULL) {
	    fclrs = (jfloat *) env->GetPrimitiveArrayCritical( cfdata, NULL);
	} else {
	    fclrs = (jfloat *) env->GetDirectBufferAddress (cdataBuffer);

	}
    }
    else if (byteColorsDefined) {
	if(cbdata != NULL) {
	    bclrs = (jbyte *) env->GetPrimitiveArrayCritical( cbdata, NULL);
	} else {
	    bclrs = (jbyte *) env->GetDirectBufferAddress(cdataBuffer);
	}
    }

    /* get normal array */
    if (normalsDefined) {
	norms = (jfloat *)env->GetDirectBufferAddress(ndata);
    }

    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texobjs[i] != NULL)
		texCoordPointer[i] = (jfloat*)env->GetDirectBufferAddress(texobjs[i]);
	    else
		texCoordPointer[i] = NULL;	
	    
	}	
    }

    executeGeometryArrayVA(env, obj, ctx, geo, geo_type,
			   isNonUniformScale, false, 0,
			   multiScreen, ignoreVertexColors,
			   vcount, vformat,  vdefined, initialCoordIndex,
			   fverts, dverts, initialColorIndex,
			   fclrs, bclrs, initialNormalIndex,
			   norms, pass, texCoordMapLength,
			   tcoordsetmap,numActiveTexUnit, tunitstatemap,
			   texindices,texStride,texCoordPointer, NULL,
			   NULL, cdirty);
    
    if(floatColorsDefined && cfdata != NULL)
	env->ReleasePrimitiveArrayCritical( cfdata, fclrs, 0);
    else if(byteColorsDefined && cbdata != NULL)
	env->ReleasePrimitiveArrayCritical(cbdata, bclrs, 0);
}


extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_executeVA(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean multiScreen,
    jboolean ignoreVertexColors,				   
    jint vcount,
    jint vformat,
    jint vdefined,
    jint initialCoordIndex,
    jfloatArray vfcoords,
    jdoubleArray vdcoords,
    jint initialColorIndex,
    jfloatArray cfdata,
    jbyteArray  cbdata,
    jint initialNormalIndex,
    jfloatArray ndata,
    jint pass, // or texUnitIndex
    jint texCoordMapLength,
    jintArray 	tcoordsetmap,
    jint numActiveTexUnit,
    jintArray tunitstatemap,
    jintArray texindices,
    jint texStride,
    jobjectArray texCoords,
    jint cDirty) 
   {
    
    jfloat *fverts = NULL;
    jdouble *dverts = NULL;
    jfloat *fclrs = NULL;
    jbyte *bclrs = NULL;    
    jfloat *norms = NULL;
    jfloat* texCoordPointer[D3DDP_MAXTEXCOORD];
    jarray texobjs[D3DDP_MAXTEXCOORD];
    int i;
    
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);

    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    texobjs[i] = (jarray)env->GetObjectArrayElement( texCoords, i);
	}
    }

    /* get coordinate array */
    if (floatCoordDefined) {
	fverts= (jfloat *) env->GetPrimitiveArrayCritical( vfcoords, NULL);
    } else if (doubleCoordDefined) {
	dverts= (jdouble *) env->GetPrimitiveArrayCritical( vdcoords, NULL);
    }

    if ((fverts == NULL) && (dverts == NULL)) {
	return; 
    }

    /* get color array */
    if (floatColorsDefined) {
	fclrs = (jfloat *) env->GetPrimitiveArrayCritical( cfdata, NULL);
    } else if (byteColorsDefined) {
	bclrs = (jbyte *)env->GetPrimitiveArrayCritical( cbdata, NULL);
    }

    /* get normal array */
    if (normalsDefined) {
	norms = (jfloat *) env->GetPrimitiveArrayCritical(ndata, NULL);
    }

    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texobjs[i] != NULL) {
		texCoordPointer[i] = (jfloat*)env->GetPrimitiveArrayCritical(texobjs[i], NULL);
	    } else {
		texCoordPointer[i] = NULL;	
	    }
	    
	}	
    }
    executeGeometryArrayVA(env, obj, ctx, geo, geo_type,
			   isNonUniformScale, false, 0,
			   multiScreen, ignoreVertexColors,
			   vcount, vformat,  vdefined, initialCoordIndex,
			   fverts, dverts, initialColorIndex,
			   fclrs, bclrs, initialNormalIndex,
			   norms, pass, texCoordMapLength,
			   tcoordsetmap,numActiveTexUnit, tunitstatemap,
			   texindices,texStride,texCoordPointer,
			   NULL, NULL, cDirty);
    
    if (floatCoordDefined) {
	env->ReleasePrimitiveArrayCritical( vfcoords, fverts, 0); 
    }
    else if (doubleCoordDefined) {
	env->ReleasePrimitiveArrayCritical( vdcoords, dverts, 0); 
    }

    if (floatColorsDefined) {
	env->ReleasePrimitiveArrayCritical( cfdata, fclrs, 0); 
    }
    else if (byteColorsDefined) {
	env->ReleasePrimitiveArrayCritical( cbdata, bclrs, 0);
    }

    if (normalsDefined) {
	env->ReleasePrimitiveArrayCritical( ndata, norms, 0);
    }
    
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texCoordPointer[i] != NULL) {
		env->ReleasePrimitiveArrayCritical(texobjs[i], texCoordPointer[i], 0);
	    }
	}
    }    
}

extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_setGlobalAlpha(
    JNIEnv *env,
    jobject obj,
    jlong ctx,
    jfloat alpha)
{
    // not use in D3D
}


extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_disableGlobalAlpha(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,
    jint vformat,
    jboolean useAlpha,
    jboolean ignoreVertexColors) 
{
    // not use in D3D
}

extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_setVertexFormat(
    JNIEnv *env,
    jobject obj,
    jint vformat,
    jboolean useAlpha,
    jboolean ignoreVertexColors,
    jlong ctx)
{
    // not use in D3D
}


extern "C" JNIEXPORT
jboolean JNICALL Java_javax_media_j3d_GeometryArrayRetained_globalAlphaSUN
    (JNIEnv *env, jobject obj, jlong ctx)
{
    return JNI_FALSE;
}



void executeGeometryArray(JNIEnv *env,
			  jobject obj, jlong ctx,
			  jobject geo, jint geo_type,
			  jboolean isNonUniformScale, 
			  jboolean modAlpha, // buildGA, should alpha be mode
			  jfloat alpha,
			  jboolean multiScreen,
			  jboolean ignoreVertexColors,
			  jint startVIndex,
			  jint vcount, jint vformat, jint texCoordSetCount,
			  jintArray texCoordSetMapArray,
			  jint texCoordMapLength, 
			  jintArray texUnitOffset,
			  jint numActiveTexUnit,
			  jintArray tunitstatemap,
			  jfloat* verts, jfloatArray carray, jint pass,
			  jdoubleArray xform, jdoubleArray nxform,
			  jint cDirty,
			  jboolean useAlpha) // Should alpha be sent down
{
    D3DDRAWPRIMITIVESTRIDEDDATA strideData;
    DWORD vertexFormat = 0;
    jint stride, coordoff, normoff, coloroff, texoff;
    int texStride, ts = 0;

    GetDevice();

    ZeroMemory(&strideData, sizeof(D3DDRAWPRIMITIVESTRIDEDDATA));

    strideData.modulateAlpha = modAlpha;
    strideData.alpha = alpha;

    /* This matches the code in GeometryArrayRetained.java */
    stride = coordoff = normoff = coloroff = texoff = 0;
    
    if ((vformat & GA_COORDINATES) != 0) {
        stride += 3;
        vertexFormat |= D3DFVF_XYZ;
    } else {
	// nothing worth doing if no coordinates define
	return;
    }

    if ((vformat & GA_NORMALS) != 0) {
        stride += 3;
        coordoff += 3;
        vertexFormat |= D3DFVF_NORMAL;
    }

    if ((vformat & GA_COLOR) != 0) {
	if ((vformat & GA_WITH_ALPHA) != 0 ) {
	    stride += 4;
	    normoff += 4;
	    coordoff += 4;
	} else { // Handle the case of executeInterleaved 3f
	    stride += 3;
	    normoff += 3;
	    coordoff += 3;
	}
	vertexFormat |= D3DFVF_DIFFUSE;
    }

    // In case of automatic texture generation
    ts = 2;
    
    if (vformat & GA_TEXTURE_COORDINATE) {
	if ((vformat & GA_TEXTURE_COORDINATE_2) != 0) {
	    texStride = texCoordSetCount << 1;
	} else if ((vformat & GA_TEXTURE_COORDINATE_3) != 0) {
	    ts = 3;
	    texStride = texCoordSetCount*3;
	} else { // GA_TEXTURE_COORDINATE_4
	    ts = 4;
	    texStride = texCoordSetCount << 2;
	}
        stride += texStride;
        normoff += texStride;
        coloroff += texStride;
        coordoff += texStride;
    }
    
    jfloat *cverts = NULL;

    texoff = startVIndex*stride;
    coordoff += texoff;
    normoff += texoff;

    if (carray != NULL) {
	// separate color array is used
	coloroff = startVIndex*4;
    } else {
	coloroff += texoff;
    }
    
    // setup coordinates pointer
    strideData.fpositionPtr = &verts[coordoff];
    strideData.positionStride = stride;

    // setup color pointer
    if (((vformat & GA_COLOR) == 0) || ignoreVertexColors) {
	// Use Material color
	// Assume VertexBuffer will recreate when ignoreVertexColors
	// property changed. Otherwise we need to remove
	// the following one line
	vertexFormat &= ~D3DFVF_DIFFUSE;
    } else {
	if (carray == NULL) {
	    strideData.fdiffusePtr = &verts[coloroff];
	    strideData.diffuseStride = stride;
	    strideData.useAlpha = (vformat & GA_WITH_ALPHA);
	} else {
	    cverts = (jfloat*) env->GetPrimitiveArrayCritical(carray, NULL);
	    strideData.fdiffusePtr = &cverts[coloroff];
	    strideData.diffuseStride = 4;
	    strideData.useAlpha = true;	    
	}
    }


    // setup normal pointer
    if ((vformat & GA_NORMALS) != 0) {
        strideData.normalPtr = &verts[normoff];
        strideData.normalStride = stride;
    } 

    // setup texture pointer
    setTextureCoordPointers(env, d3dCtx, device,
			    &strideData,
			    pass, texoff, stride, ts,
			    (vformat & GA_TEXTURE_COORDINATE),
			    NULL,
			    texCoordMapLength, 
			    texUnitOffset,
			    numActiveTexUnit,
			    tunitstatemap,
			    &vertexFormat,
			    verts, NULL, NULL);

    
    jdouble* xform_ptr = NULL;
    jdouble* nxform_ptr = NULL;

    if (xform != NULL) {
        xform_ptr = (jdouble *) env->GetPrimitiveArrayCritical(xform, NULL);

    }

    if (nxform != NULL) {
        nxform_ptr = (jdouble *) env->GetPrimitiveArrayCritical(nxform, NULL);
    }
		       
    renderGeometry(env, d3dCtx, device, geo, geo_type, &strideData,
	           vertexFormat, vcount, xform_ptr, nxform_ptr, cDirty);
    
    if (xform_ptr != NULL) {
	env->ReleasePrimitiveArrayCritical(xform, xform_ptr, 0);
    }
    if (nxform_ptr != NULL) {
	env->ReleasePrimitiveArrayCritical(nxform, nxform_ptr, 0);
    }


    /* env->ReleasePrimitiveArrayCritical(varray, verts, NULL); */

    if (cverts != NULL) {
	env->ReleasePrimitiveArrayCritical(carray, cverts, NULL);	
    }
}


extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_buildGA(JNIEnv *env, 
		jobject obj, jlong ctx, jobject geo, jint geo_type, 
                jboolean isNonUniformScale, jboolean updateAlpha, float alpha,
		jboolean ignoreVertexColors,
		jint startVIndex,
  	        jint vcount, jint vformat, 
		jint texCoordSetCount, 
                jintArray texCoordSetMapArray,
		jint texCoordMapLength,
		jintArray texUnitOffset, 
		jdoubleArray xform, jdoubleArray nxform,			
		jfloatArray varray)
{

    jfloat *verts = NULL;

    if (varray != NULL) {
	verts = (jfloat *) env->GetPrimitiveArrayCritical(varray, NULL);
    }

    if (verts == NULL) {
	return;
    }

    if (((vformat & GA_COLOR) != 0) &&
	((vformat & GA_BY_REFERENCE) == 0)) {
	// alpha component is added for buildGA
	vformat |= GA_WITH_ALPHA;
    }


    executeGeometryArray(env,
			 obj, ctx, geo,  geo_type, isNonUniformScale, 
			 updateAlpha, 
			 alpha,
			 false,
			 ignoreVertexColors,
			 startVIndex,
			 vcount,  
			 vformat,
			 texCoordSetCount,
			 texCoordSetMapArray,		
			 texCoordMapLength, 
			 texUnitOffset,
			 texCoordMapLength,
			 NULL,
			 verts, NULL, 
			 -1,
			 xform, nxform, 
			 javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED, 
			 false);

    env->ReleasePrimitiveArrayCritical( varray, verts, 0);
}



extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_execute(JNIEnv *env,
                jobject obj, jlong ctx,
		jobject geo, jint geo_type,
                jboolean isNonUniformScale, jboolean useAlpha,
                jboolean multiScreen,
                jboolean ignoreVertexColors,
                jint startVIndex,
                jint vcount, jint vformat, jint texCoordSetCount,
                jintArray texCoordSetMapArray,
                jint texCoordMapLength, jintArray texUnitOffset,
		jint numActiveTexUnit,
		jintArray tunitstatemap,
                jfloatArray varray, jfloatArray carray,
		jint texUnitIndex, jint cDirty)
{
    jfloat *verts = NULL;

    if (varray != NULL) {
	verts = (jfloat *) env->GetPrimitiveArrayCritical( varray, NULL);
    }

    if (verts == NULL) {
	return;
    }

    executeGeometryArray(env, obj, ctx, geo, geo_type, 
			 isNonUniformScale,
			 false,
			 0, multiScreen, 
			 ignoreVertexColors, startVIndex, 
			 vcount, vformat, texCoordSetCount,
			 texCoordSetMapArray,
			 texCoordMapLength, texUnitOffset, 
			 numActiveTexUnit, tunitstatemap,
			 verts, carray, texUnitIndex, NULL, NULL, cDirty,useAlpha);
    
    env->ReleasePrimitiveArrayCritical( varray, verts, 0);

}


/* interleaved data with nio buffer as data format */
extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_executeInterleavedBuffer(JNIEnv *env, 
		jobject obj, jlong ctx, jobject geo, jint geo_type, 
                jboolean isNonUniformScale, jboolean useAlpha,
		jboolean multiScreen,						
		jboolean ignoreVertexColors,
		jint startVIndex,
		jint vcount, jint vformat, 
		jint texCoordSetCount,
                jintArray texCoordSetMapArray, jint texCoordMapLength,
		jintArray texUnitOffset, 
		jint numActiveTexUnit,
		jintArray tunitstatemap,
		jobject varray, jfloatArray carray,
		jint texUnitIndex, jint cDirty) {
    
    jfloat *verts = NULL;
   
    /* get the direct buffer address */
    if (varray != NULL) {
	verts = (jfloat *) env->GetDirectBufferAddress(varray);
    }

    if (verts == NULL) {
	return;
    }

    /* call executeGeometryArray */
    executeGeometryArray(env, obj, ctx, geo, geo_type, 
			 isNonUniformScale,
			 false,
			 0, multiScreen, 
			 ignoreVertexColors, startVIndex, 
			 vcount, vformat, texCoordSetCount,
			 texCoordSetMapArray,
			 texCoordMapLength, texUnitOffset, 
			 numActiveTexUnit, tunitstatemap,
			 verts, carray, texUnitIndex, NULL, NULL, cDirty,useAlpha);
    
}


extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_freeD3DArray
    (JNIEnv *env, jobject geo, jboolean deleteVB)
{

    lockGeometry();

    jclass geoClass = (jclass) env->GetObjectClass(geo);
    // Free VertexBuffer associate with this GeometryArray
    jfieldID fieldID = env->GetFieldID(geoClass, "pVertexBuffers", "J");
    
    D3dVertexBufferVector *vbVector =
	reinterpret_cast<D3dVertexBufferVector*> (env->GetLongField(geo, fieldID));


    if (vbVector != NULL) {
	// clearLive() invoke this in Renderer thread
	for (LPD3DVERTEXBUFFER *s = vbVector->begin(); 
	     s != vbVector->end(); ++s) {
	    // This notify vb that parent vector is already free
	    // so there is no need  to remove itself from vbVector
	    (*s)->vbVector = NULL;
	    (*s)->ctx->freeVB(*s);
	}
	env->SetLongField(geo, fieldID, 0);
	vbVector->clear();
	delete vbVector;
    }

    unlockGeometry();
}



void executeIndexedGeometryArray(JNIEnv *env,
				 jobject obj, jlong ctx,
				 jobject geo, jint geo_type,
				 jboolean isNonUniformScale, 
				 jboolean modAlpha, // buildGA, should alpha be mode
				 jfloat alpha,
				 jboolean multiScreen,
				 jboolean ignoreVertexColors,
				 jint vcount,
				 jint vformat,
				 jint texCoordSetCount,
				 jintArray texCoordSetMapArray,
				 jint texCoordMapLength, 
				 jintArray texUnitOffset,
				 jint numActiveTexUnit,
				 jintArray tunitstatemap,
				 jfloat* verts, jfloatArray carray, jint pass,
				 jdoubleArray xform, jdoubleArray nxform,
				 jint cDirty,
				 jboolean useAlpha,
				 jint initialIndexIndex,
				 jint indexCount,
				 jintArray indexCoord) // Should alpha be sent down
{
    D3DDRAWPRIMITIVESTRIDEDDATA strideData;
    DWORD vertexFormat = 0;
    jint stride, coordoff, normoff, coloroff, texoff;
    int texStride, ts = 0;

    GetDevice();

    ZeroMemory(&strideData, sizeof(D3DDRAWPRIMITIVESTRIDEDDATA));

    strideData.modulateAlpha = modAlpha;
    strideData.alpha = alpha;

    /* This matches the code in GeometryArrayRetained.java */
    stride = coordoff = normoff = coloroff = texoff = 0;
    
    if ((vformat & GA_COORDINATES) != 0) {
        stride += 3;
        vertexFormat |= D3DFVF_XYZ;
    } else {
	// nothing worth doing if no coordinates define
	return;
    }

    if ((vformat & GA_NORMALS) != 0) {
        stride += 3;
        coordoff += 3;
        vertexFormat |= D3DFVF_NORMAL;
    }

    if ((vformat & GA_COLOR) != 0) {
	if ((vformat & GA_WITH_ALPHA) != 0 ) {
	    stride += 4;
	    normoff += 4;
	    coordoff += 4;
	} else { // Handle the case of executeInterleaved 3f
	    stride += 3;
	    normoff += 3;
	    coordoff += 3;
	}
	vertexFormat |= D3DFVF_DIFFUSE;
    }

    // In case of automatic texture generation
    ts = 2;
    
    if (vformat & GA_TEXTURE_COORDINATE) {
	if ((vformat & GA_TEXTURE_COORDINATE_2) != 0) {
	    texStride = texCoordSetCount << 1;
	} else if ((vformat & GA_TEXTURE_COORDINATE_3) != 0) {
	    ts = 3;
	    texStride = texCoordSetCount*3;
	} else { // GA_TEXTURE_COORDINATE_4
	    ts = 4;
	    texStride = texCoordSetCount << 2;
	}
        stride += texStride;
        normoff += texStride;
        coloroff += texStride;
        coordoff += texStride;
    }
    
    jfloat *cverts = NULL;

    if (carray != NULL) {
	// separate color array is used
	coloroff = 0;
    } else {
	coloroff += texoff;
    }

    // setup coordinates pointer
    strideData.fpositionPtr = &verts[coordoff];
    strideData.positionStride = stride;
    
    // setup color pointer
    if (((vformat & GA_COLOR) == 0) || ignoreVertexColors) {
	// Use Material color
	// Assume VertexBuffer will recreate when ignoreVertexColors
	// property changed. Otherwise we need to remove
	// the following one line
	vertexFormat &= ~D3DFVF_DIFFUSE;
    } else {
	if (carray == NULL) {
	    strideData.fdiffusePtr = &verts[coloroff];
	    strideData.diffuseStride = stride;
	    strideData.useAlpha = (vformat & GA_WITH_ALPHA);
	} else {
	    cverts = (jfloat*) env->GetPrimitiveArrayCritical(carray, NULL);
	    strideData.fdiffusePtr = &cverts[coloroff];
	    strideData.diffuseStride = 4;
	    strideData.useAlpha = true;	    
	}
    }


    // setup normal pointer
    if ((vformat & GA_NORMALS) != 0) {
        strideData.normalPtr = &verts[normoff];
        strideData.normalStride = stride;
    } 


    // setup texture pointer
    setTextureCoordPointers(env, d3dCtx, device,
			    &strideData,
			    pass, texoff, stride, ts,
			    (vformat & GA_TEXTURE_COORDINATE),
			    NULL,
			    texCoordMapLength, 
			    texUnitOffset,
			    numActiveTexUnit,
			    tunitstatemap,
			    &vertexFormat,
			    verts, NULL, NULL);

    // setup index pointer
    strideData.indexPtr =  (jint *) env->GetPrimitiveArrayCritical(indexCoord, NULL);
    strideData.initialIndexIndex = initialIndexIndex;


    jdouble* xform_ptr = NULL;
    jdouble* nxform_ptr = NULL;

    if (xform != NULL) {
        xform_ptr = (jdouble *) env->GetPrimitiveArrayCritical(xform, NULL);

    }

    if (nxform != NULL) {
        nxform_ptr = (jdouble *) env->GetPrimitiveArrayCritical(nxform, NULL);
    }

    renderIndexGeometry(env, d3dCtx, device, geo, geo_type, &strideData,
			vertexFormat, vcount, indexCount,
			xform_ptr, nxform_ptr, cDirty);



    if (xform_ptr != NULL) {
	env->ReleasePrimitiveArrayCritical(xform, xform_ptr, 0);
    }
    if (nxform_ptr != NULL) {
	env->ReleasePrimitiveArrayCritical(nxform, nxform_ptr, 0);
    }

    if (cverts != NULL) {
	env->ReleasePrimitiveArrayCritical(carray, cverts, NULL);	
    }

    env->ReleasePrimitiveArrayCritical(indexCoord,
				       strideData.indexPtr, NULL);
}


extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_IndexedGeometryArrayRetained_executeIndexedGeometry(
                JNIEnv *env,
	        jobject obj, jlong ctx,
		jobject geo, jint geo_type,
                jboolean isNonUniformScale, jboolean useAlpha,
                jboolean multiScreen,
                jboolean ignoreVertexColors,
                jint initialIndexIndex,
		jint indexCount,
		jint vcount,
                jint vformat, jint texCoordSetCount,
                jintArray texCoordSetMapArray,
                jint texCoordMapLength, jintArray texUnitOffset,
		jint numActiveTexUnit,
		jintArray tunitstatemap,
                jfloatArray varray, jfloatArray carray,
		jint texUnitIndex, jint cDirty,
		jintArray indexCoord)
{
    jfloat *verts = NULL;

    if (varray != NULL) {
	verts = (jfloat *) env->GetPrimitiveArrayCritical( varray, NULL);
    }

    if (verts == NULL) {
	return;
    }

    executeIndexedGeometryArray(env, obj, ctx, geo, geo_type, 
				isNonUniformScale,
				false, 0, multiScreen,
				ignoreVertexColors,
				vcount,
				vformat, texCoordSetCount,
				texCoordSetMapArray,
				texCoordMapLength, 
				texUnitOffset,
				numActiveTexUnit,
				tunitstatemap,
				verts, 
				carray,
				texUnitIndex,
				NULL, NULL,
				cDirty,
				useAlpha,
				initialIndexIndex,
				indexCount, 
				indexCoord);
    
    env->ReleasePrimitiveArrayCritical( varray, verts, 0);
}

extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_IndexedGeometryArrayRetained_executeIndexedGeometryBuffer(
                JNIEnv *env,
	        jobject obj, jlong ctx,
		jobject geo, jint geo_type,
                jboolean isNonUniformScale, jboolean useAlpha,
                jboolean multiScreen,
                jboolean ignoreVertexColors,
                jint initialIndexIndex,
		jint indexCount,
		jint vcount,
                jint vformat, jint texCoordSetCount,
                jintArray texCoordSetMapArray,
                jint texCoordMapLength, jintArray texUnitOffset,
		jint numActiveTexUnit,
		jintArray tunitstatemap,
                jobject varray, jfloatArray carray,
		jint texUnitIndex, jint cDirty,
		jintArray indexCoord)
{
    jfloat *verts = NULL;
    
    /* get the direct buffer address */
    if (varray != NULL) {
	verts = (jfloat *) env->GetDirectBufferAddress(varray );
    }

    if (verts == NULL)
	return;

    executeIndexedGeometryArray(env, obj, ctx, geo, geo_type, 
				isNonUniformScale,
				false, 0, multiScreen,
				ignoreVertexColors,
				vcount,
				vformat, texCoordSetCount,
				texCoordSetMapArray,
				texCoordMapLength, 
				texUnitOffset,
				numActiveTexUnit,
				tunitstatemap,
				verts, 
				carray,
				texUnitIndex,
				NULL, NULL,
				cDirty,
				useAlpha,
				initialIndexIndex,
				indexCount, 
				indexCoord);
}


extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_IndexedGeometryArrayRetained_buildIndexedGeometry(
                JNIEnv *env, 
		jobject obj, jlong ctx, jobject geo, 
		jint geo_type, 
                jboolean isNonUniformScale, jboolean updateAlpha, float alpha,
		jboolean ignoreVertexColors,
		jint initialIndexIndex,
  	        jint indexCount,
	        jint vertexCount,
	        jint vformat, 
		jint texCoordSetCount,
		jintArray texCoordSetMapArray,
		jint texCoordMapLength,
		jintArray texUnitOffset, 
		jdoubleArray xform, jdoubleArray nxform,
		jfloatArray varray, jintArray indexCoord)
{

    jfloat *verts = NULL;

    if (varray != NULL) {
	verts = (jfloat *) env->GetPrimitiveArrayCritical( varray, NULL);
    }

    if (verts == NULL) {
	return;
    }

    if ((vformat & GA_COLOR) != 0) {
	// alpha component is added for buildGA
	vformat |= GA_WITH_ALPHA;
    }

    executeIndexedGeometryArray(env, obj, ctx, geo, geo_type, 
				isNonUniformScale,
				updateAlpha, alpha,
				false,
				ignoreVertexColors,
				vertexCount,
				vformat, 
				texCoordSetCount,
				texCoordSetMapArray,
				texCoordMapLength, 
				texUnitOffset,
				texCoordMapLength, 
				NULL,
				verts, 
				NULL, -1,
				xform, nxform,
				javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED|
				javax_media_j3d_GeometryArrayRetained_INDEX_CHANGED,
				false,
				initialIndexIndex,
				indexCount, 
				indexCoord);
    
    env->ReleasePrimitiveArrayCritical( varray, verts, 0);

}



void executeIndexedGeometryArrayVA(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,    
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean multiScreen,
    jboolean ignoreVertexColors,
    jint initialIndexIndex,
    jint indexCount,
    jint vertexCount,
    jint vformat,
    jint vdefined,
    jfloat* fverts,
    jdouble* dverts,
    jfloat* fclrs,
    jbyte*  bclrs,
    jfloat* norms,
    jint pass,  
    jint texCoordMapLength,
    jintArray 	tcoordsetmap,
    jint numActiveTexUnit,
    jintArray tunitstatemap,
    jint texStride,
    jfloat** texCoordPointer,
    jint cDirty,
    jintArray indexCoord)
{
    D3DDRAWPRIMITIVESTRIDEDDATA strideData;
    DWORD vertexFormat = 0;
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);

    GetDevice();    

    ZeroMemory(&strideData, sizeof(D3DDRAWPRIMITIVESTRIDEDDATA));

    // setup coordinate pointers
    if (floatCoordDefined || doubleCoordDefined) {
	vertexFormat |= D3DFVF_XYZ;

	if (floatCoordDefined ) {
	    strideData.fpositionPtr = &fverts[0];
	} else if (doubleCoordDefined) {
	    strideData.dpositionPtr = &dverts[0];
	} 
	strideData.positionStride = 3;
	
    } else {
	// nothing worth doing if no coordinates define
	return;
    }

    // setup normal pointers
    if (normalsDefined) {
        vertexFormat |= D3DFVF_NORMAL;
        strideData.normalPtr = &norms[0];
        strideData.normalStride = 3;
    }
    
    // setup color pointers
    if (!(floatColorsDefined || byteColorsDefined)
	|| ignoreVertexColors) {
	// Use Material color
	// Assume VertexBuffer will recreate when ignoreVertexColors
	// property changed. Otherwise we need to remove
	// the following one line
	vertexFormat &= ~D3DFVF_DIFFUSE;
    } else {
	if ((vformat & GA_WITH_ALPHA) != 0) {
	    strideData.diffuseStride = 4;
	    strideData.useAlpha = true;
	} else {
	    strideData.diffuseStride = 3;
	    strideData.useAlpha = false;
	}
	if (floatColorsDefined) {
	    strideData.fdiffusePtr = &fclrs[0];
	} else {
	    strideData.bdiffusePtr = &bclrs[0];
	} 

	vertexFormat |= D3DFVF_DIFFUSE;
    } 
    

    int ts = 2; // In case of automatic texture generation
	
    if ((vformat & GA_TEXTURE_COORDINATE_3) != 0) {
	ts = 3;
    } else if ((vformat & GA_TEXTURE_COORDINATE_4) != 0) {
	ts = 4;
    }

    // setup texture pointer
    setTextureCoordPointers(env, d3dCtx, device,
			    &strideData,
			    pass, 0, 
			    texStride, ts,
			    textureDefined,
			    tcoordsetmap,
			    texCoordMapLength, 
			    NULL,
			    numActiveTexUnit,
			    tunitstatemap,
			    &vertexFormat,
			    NULL, texCoordPointer, 
			    NULL);

    // setup index pointer
    strideData.indexPtr =  (jint *) env->GetPrimitiveArrayCritical(indexCoord, NULL);
    strideData.initialIndexIndex = initialIndexIndex;

    // Construct/update VertexBuffer, render() if not in display list mode 
    renderIndexGeometry(env, d3dCtx, device, geo, geo_type, &strideData,
			vertexFormat, vertexCount,  indexCount,
			NULL, NULL, cDirty); 

    env->ReleasePrimitiveArrayCritical(indexCoord,
				       strideData.indexPtr, NULL);


}
extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_IndexedGeometryArrayRetained_executeIndexedGeometryVA(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,    
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean multiScreen,
    jboolean ignoreVertexColors,
    jint initialIndexIndex,
    jint indexCount,
    jint vertexCount,
    jint vformat,
    jint vdefined,
    jfloatArray vfcoords,
    jdoubleArray vdcoords,
    jfloatArray cfdata,
    jbyteArray  cbdata,
    jfloatArray ndata,
    jint pass,  
    jint texCoordMapLength,
    jintArray 	tcoordsetmap,
    jint numActiveTexUnit,
    jintArray tunitstatemap,
    jint texStride,
    jobjectArray texCoords,
    jint cDirty,
    jintArray indexCoord)
{
    jfloat *fverts = NULL;
    jdouble *dverts = NULL;
    jfloat *fclrs = NULL;
    jbyte *bclrs = NULL;    
    jfloat *norms = NULL;
    jfloat* texCoordPointer[D3DDP_MAXTEXCOORD];
    jarray texobjs[D3DDP_MAXTEXCOORD];
    int i;
    
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);

    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    texobjs[i] = (jarray)env->GetObjectArrayElement( texCoords, i);
	}
    }

    /* get coordinate array */
    if (floatCoordDefined) {
	fverts= (jfloat *) env->GetPrimitiveArrayCritical( vfcoords, NULL);
    } else if (doubleCoordDefined) {
	dverts= (jdouble *) env->GetPrimitiveArrayCritical( vdcoords, NULL);
    }

    if ((fverts == NULL) && (dverts == NULL)) {
	return; 
    }

    /* get color array */
    if (floatColorsDefined) {
	fclrs = (jfloat *) env->GetPrimitiveArrayCritical( cfdata, NULL);
    } else if (byteColorsDefined) {
	bclrs = (jbyte *)env->GetPrimitiveArrayCritical( cbdata, NULL);
    }

    /* get normal array */
    if (normalsDefined) {
	norms = (jfloat *) env->GetPrimitiveArrayCritical(ndata, NULL);
    }

    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texobjs[i] != NULL) {
		texCoordPointer[i] =
		    (jfloat*)env->GetPrimitiveArrayCritical(texobjs[i], NULL);
	    } else {
		texCoordPointer[i] = NULL;	
	    }
	    
	}	
    }

    
    executeIndexedGeometryArrayVA(env, 
				  obj,
				  ctx,    
				  geo,
				  geo_type, 
				  isNonUniformScale,
				  multiScreen,
				  ignoreVertexColors,
				  initialIndexIndex,
				  indexCount,
				  vertexCount,
				  vformat,
				  vdefined,
				  fverts,
				  dverts,
				  fclrs,
				  bclrs,
				  norms,
				  pass,  
				  texCoordMapLength,
				  tcoordsetmap,
				  numActiveTexUnit,
				  tunitstatemap,
				  texStride,
				  texCoordPointer,
				  cDirty,
				  indexCoord);
    
    // Free memory
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texCoordPointer[i] != NULL) {
		env->ReleasePrimitiveArrayCritical(texobjs[i], texCoordPointer[i], NULL);
	    }
	}
    }

    if (floatColorsDefined) {
	env->ReleasePrimitiveArrayCritical(cfdata, fclrs, 0); 
    } else if (byteColorsDefined) {
	env->ReleasePrimitiveArrayCritical(cbdata, bclrs, 0);
    }

    if (normalsDefined) {
	env->ReleasePrimitiveArrayCritical(ndata, norms, 0);
    }

    if (floatCoordDefined) {
	env->ReleasePrimitiveArrayCritical(vfcoords, fverts, 0); 
    } else if (doubleCoordDefined) {
	env->ReleasePrimitiveArrayCritical(vdcoords, dverts, 0); 
    }
}

extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_IndexedGeometryArrayRetained_executeIndexedGeometryVABuffer(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,    
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean multiScreen,
    jboolean ignoreVertexColors,
    jint initialIndexIndex,
    jint indexCount,
    jint vertexCount,
    jint vformat,
    jint vdefined,
    jobject vcoords,
    jobject cdataBuffer,
    jfloatArray cfdata,
    jbyteArray  cbdata,
    jobject ndata,
    jint pass,  
    jint texCoordMapLength,
    jintArray 	tcoordsetmap,
    jint numActiveTexUnit,
    jintArray tunitstatemap,
    jint texStride,
    jobjectArray texCoords,
    jint cDirty,
    jintArray indexCoord)
{
    jfloat *fverts = NULL;
    jdouble *dverts = NULL;
    jfloat *fclrs = NULL;
    jbyte *bclrs = NULL;    
    jfloat *norms = NULL;
    jfloat* texCoordPointer[D3DDP_MAXTEXCOORD];
    jarray texobjs[D3DDP_MAXTEXCOORD];
    int i;
    
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);

    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    texobjs[i] = (jarray)env->GetObjectArrayElement( texCoords, i);
	}
    }

    /* get coordinate array */
    if (floatCoordDefined) {
	fverts = (jfloat *)env->GetDirectBufferAddress( vcoords );
    } else if (doubleCoordDefined) {
	dverts = (jdouble *)env->GetDirectBufferAddress( vcoords ); 
    }

    if ((fverts == NULL) && (dverts == NULL)) {
	return; 
    }

    /* get color array */
    if (floatColorsDefined) {
	if(cfdata != NULL) {
	    fclrs = (jfloat *) env->GetPrimitiveArrayCritical( cfdata, NULL);
	} else {
	    fclrs = (jfloat *) env->GetDirectBufferAddress (cdataBuffer);
	}
    } else if (byteColorsDefined) {
	if (cbdata != NULL) {
	    bclrs = (jbyte *) env->GetPrimitiveArrayCritical( cbdata, NULL);
	} else {
	    bclrs = (jbyte *) env->GetDirectBufferAddress(cdataBuffer);
	}
    }

    /* get normal array */
    if (normalsDefined) {
	norms = (jfloat *)env->GetDirectBufferAddress(ndata);
    }
    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texobjs[i] != NULL)
		texCoordPointer[i] = (jfloat*)env->GetDirectBufferAddress(texobjs[i]);
	    else
		texCoordPointer[i] = NULL;	
	    
	}	
    }

    
    executeIndexedGeometryArrayVA(
				  env, 
				  obj,
				  ctx,    
				  geo,
				  geo_type, 
				  isNonUniformScale,
				  multiScreen,
				  ignoreVertexColors,
				  initialIndexIndex,
				  indexCount,
				  vertexCount,
				  vformat,
				  vdefined,
				  fverts,
				  dverts,
				  fclrs,
				  bclrs,
				  norms,
				  pass,  
				  texCoordMapLength,
				  tcoordsetmap,
				  numActiveTexUnit,
				  tunitstatemap,
				  texStride,
				  texCoordPointer,
				  cDirty,
				  indexCoord);
    
    if (floatColorsDefined && cfdata != NULL) {
	env->ReleasePrimitiveArrayCritical( cfdata, fclrs, 0);
    } else if (byteColorsDefined && cbdata != NULL) {
	env->ReleasePrimitiveArrayCritical(cbdata, bclrs, 0);
    }
}

extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_buildGAForBuffer(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,    
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean updateAlpha,
    jfloat alpha,
    jboolean ignoreVertexColors,
    jint vcount,
    jint vformat,
    jint vdefined,
    jint initialCoordIndex,
    jobject vcoords,
    jint initialColorIndex,
    jobject cdataBuffer,
    jint initialNormalIndex,
    jobject ndata,
    jint texCoordMapLength,
    jintArray 	tcoordsetmap,
    jintArray texindices,
    jint texStride,
    jobjectArray texCoords,
    jdoubleArray xform,
    jdoubleArray nxform)
{
    jfloat *fverts = NULL;
    jdouble *dverts = NULL ;
    jbyte *bclrs = NULL;
    jfloat *fclrs = NULL, *norms = NULL;
    jfloat* texCoordPointer[D3DDP_MAXTEXCOORD];
    jarray texobjs[D3DDP_MAXTEXCOORD];
    int i;
    
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);

    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    texobjs[i] = (jarray)env->GetObjectArrayElement(texCoords, i);
	}
    }

    /* get coordinate array */
    if (floatCoordDefined) {
	fverts = (jfloat *)env->GetDirectBufferAddress( vcoords );
    } else if (doubleCoordDefined) {
	dverts = (jdouble *)env->GetDirectBufferAddress( vcoords ); 
    }

    if ((fverts == NULL) && (dverts == NULL)) {
	return; 
    }

    /* get color array */
    if (floatColorsDefined) {
	fclrs = (jfloat *) env->GetDirectBufferAddress(cdataBuffer);
    } else if (byteColorsDefined) {
	bclrs = (jbyte *) env->GetDirectBufferAddress(cdataBuffer);
    }

    /* get normal array */
    if (normalsDefined) {
	norms = (jfloat *)env->GetDirectBufferAddress(ndata);
    }

    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texobjs[i] != NULL)
		texCoordPointer[i] = (jfloat*)env->GetDirectBufferAddress(texobjs[i]);
	    else
		texCoordPointer[i] = NULL;	
	    
	}	
    }

    executeGeometryArrayVA(env, obj, ctx, geo, geo_type,
			   isNonUniformScale, updateAlpha, alpha,
			   false, ignoreVertexColors,
			   vcount, vformat,  vdefined, initialCoordIndex,
			   fverts, dverts, initialColorIndex,
			   fclrs, bclrs, initialNormalIndex,
			   norms, -1, texCoordMapLength,
			   tcoordsetmap,texCoordMapLength, NULL,
			   texindices,texStride,texCoordPointer,
			   xform, nxform,
			   javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED);
}


extern "C" JNIEXPORT
void JNICALL Java_javax_media_j3d_GeometryArrayRetained_buildGAForByRef(
    JNIEnv *env, 
    jobject obj,
    jlong ctx,    
    jobject geo,
    jint geo_type, 
    jboolean isNonUniformScale,
    jboolean updateAlpha,
    jfloat alpha,
    jboolean ignoreVertexColors,
    jint vcount,
    jint vformat,
    jint vdefined,
    jint initialCoordIndex,
    jfloatArray vfcoords,
    jdoubleArray vdcoords,
    jint initialColorIndex,
    jfloatArray cfdata,
    jbyteArray  cbdata,
    jint initialNormalIndex,
    jfloatArray ndata,
    jint texCoordMapLength,
    jintArray 	tcoordsetmap,
    jintArray texindices,
    jint texStride,
    jobjectArray texCoords,
    jdoubleArray xform,
    jdoubleArray nxform)
{
    jfloat *fverts = NULL;
    jdouble *dverts = NULL;
    jfloat *fclrs = NULL;
    jbyte *bclrs = NULL;    
    jfloat *norms = NULL;
    jfloat* texCoordPointer[D3DDP_MAXTEXCOORD];
    jarray texobjs[D3DDP_MAXTEXCOORD];
    int i;
    
    jboolean floatCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_FLOAT) != 0);
    jboolean doubleCoordDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COORD_DOUBLE) != 0);
    jboolean floatColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_FLOAT) != 0);
    jboolean byteColorsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_COLOR_BYTE) != 0);
    jboolean normalsDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_NORMAL_FLOAT) != 0);
    jboolean textureDefined = ((vdefined & javax_media_j3d_GeometryArrayRetained_TEXCOORD_FLOAT) != 0);


    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    texobjs[i] = (jarray)env->GetObjectArrayElement( texCoords, i);
	}
    }

    /* get coordinate array */
    if (floatCoordDefined) {
	fverts= (jfloat *) env->GetPrimitiveArrayCritical( vfcoords, NULL);
    } else if (doubleCoordDefined) {
	dverts= (jdouble *) env->GetPrimitiveArrayCritical( vdcoords, NULL);
    }

    if ((fverts == NULL) && (dverts == NULL)) {
	return; 
    }

    /* get color array */
    if (floatColorsDefined) {
	fclrs = (jfloat *) env->GetPrimitiveArrayCritical( cfdata, NULL);
    } else if (byteColorsDefined) {
	bclrs = (jbyte *)env->GetPrimitiveArrayCritical( cbdata, NULL);
    }

    /* get normal array */
    if (normalsDefined) {
	norms = (jfloat *) env->GetPrimitiveArrayCritical(ndata, NULL);
    }

    /* get texture arrays */
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texobjs[i] != NULL) {
		texCoordPointer[i] = (jfloat*)env->GetPrimitiveArrayCritical(texobjs[i], NULL);
	    } else {
		texCoordPointer[i] = NULL;	
	    }
	    
	}	
    }


    executeGeometryArrayVA(env, obj, ctx, geo, geo_type,
			   isNonUniformScale,  updateAlpha, alpha,
			   false, ignoreVertexColors,
			   vcount, vformat,  vdefined, initialCoordIndex,
			   fverts, dverts, initialColorIndex,
			   fclrs, bclrs, initialNormalIndex,
			   norms, -1, texCoordMapLength,
			   tcoordsetmap,texCoordMapLength, NULL,
			   texindices,texStride,texCoordPointer,
			   xform, nxform,
			   javax_media_j3d_GeometryArrayRetained_VERTEX_CHANGED);
    
    if (floatCoordDefined) {
	env->ReleasePrimitiveArrayCritical( vfcoords, fverts, 0); 
    }
    else if (doubleCoordDefined) {
	env->ReleasePrimitiveArrayCritical( vdcoords, dverts, 0); 
    }

    if (floatColorsDefined) {
	env->ReleasePrimitiveArrayCritical( cfdata, fclrs, 0); 
    }
    else if (byteColorsDefined) {
	env->ReleasePrimitiveArrayCritical( cbdata, bclrs, 0);
    }

    if (normalsDefined) {
	env->ReleasePrimitiveArrayCritical( ndata, norms, 0);
    }
    
    if (textureDefined) {
	for (i = 0; i < texCoordMapLength; i++) {
	    if (texCoordPointer[i] != NULL) {
		env->ReleasePrimitiveArrayCritical(texobjs[i], texCoordPointer[i], 0);
	    }
	}
    }    
}