geometrystriparrayretained.java

JAVA3D矩陈的相关类

                                 vertexData[tOffset] = ((TexCoord2f[])
					src.refTexCoords[k])[srcOffset].x;
                                 vertexData[tOffset+1] = ((TexCoord2f[])
					src.refTexCoords[k])[srcOffset].y;
                                 tOffset += texCoordStride;
                            }
			    vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		    break;
		case T3F: 
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = j+base;
			    for (k = 0, tOffset = vOffset;
				    k < texCoordSetCount; k++) {
                             	 srcOffset = 
				    src.indexTexCoord[k][index];
                                 vertexData[tOffset] = ((TexCoord3f[])
					src.refTexCoords[k])[srcOffset].x;
                                 vertexData[tOffset+1] = ((TexCoord3f[])
					src.refTexCoords[k])[srcOffset].y;
                                 vertexData[tOffset+2] = ((TexCoord3f[])
					src.refTexCoords[k])[srcOffset].z;
                                 tOffset += texCoordStride;
                            }
			    vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		    break;

		default:
		    break;
		}
	    }

            if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
		base = src.initialIndexIndex;
		vOffset = 0;
		switch (src.vertexType & VATTR_DEFINED) {
		case AF:
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = j+base;

                            for (k = 0; k < vertexAttrCount; k++) {
                                System.arraycopy(src.floatRefVertexAttrs[k],
                                        src.indexVertexAttr[k][index]*vertexAttrSizes[k],
                                        vertexData,
                                        vOffset + vertexAttrOffsets[k],
                                        vertexAttrSizes[k]);
                            }
                            vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		    break;
		}
	    }

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

    private void unIndexifyNIOBuffer(IndexedGeometryStripArrayRetained src) {
        int vOffset = 0, srcOffset, tOffset = 0;
        int base = src.initialIndexIndex;
	int i,j, k, index, colorStride = 0;
	
	
	// interleaved case 
	if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) {
	    if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
		colorStride = 4;
	    else if ((src.vertexFormat & GeometryArray.COLOR) != 0)
		colorStride = 3;

	    for (i=0; i < src.stripIndexCounts.length; i++) {
		for (j=0; j < src.stripIndexCounts[i]; j++) {
		    index = j + base;
		    if ((vertexFormat & GeometryArray.NORMALS) != 0){
			src.interleavedFloatBufferImpl.position(src.indexNormal[index]*src.stride + src.normalOffset);
			src.interleavedFloatBufferImpl.get(vertexData, vOffset + normalOffset, 3);
		    }
		    if (colorStride == 4) {
			src.interleavedFloatBufferImpl.position(src.indexColor[index]*src.stride + src.colorOffset);
			src.interleavedFloatBufferImpl.get(vertexData, vOffset + colorOffset, colorStride);
		    } else if (colorStride == 3) {
			src.interleavedFloatBufferImpl.position(src.indexColor[index]*src.stride + src.colorOffset);
			src.interleavedFloatBufferImpl.get(vertexData, vOffset + colorOffset, colorStride);			
			vertexData[vOffset + colorOffset + 3] = 1.0f;
		    }

                    if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
			for (k = 0; k < texCoordSetCount; k++) {
			    src.interleavedFloatBufferImpl.position((src.indexTexCoord[k][index])
					*src.stride + src.textureOffset +
					src.texCoordSetMapOffset[k]);
			    
			    src.interleavedFloatBufferImpl.get(vertexData,
							       vOffset + textureOffset + texCoordSetMapOffset[k], texCoordStride);
                        }
		    }

		    if ((vertexFormat & GeometryArray.COORDINATES) != 0){
			src.interleavedFloatBufferImpl.position(src.indexCoord[index]*src.stride + src.coordinateOffset);
			src.interleavedFloatBufferImpl.get( vertexData, vOffset + coordinateOffset, 3);
		    }
		    vOffset += stride;
		}
		base += src.stripIndexCounts[i];
	    }
	}
	else {
	    if ((vertexFormat & GeometryArray.NORMALS) != 0) {
		base = src.initialIndexIndex;
		vOffset = normalOffset;
		if((src.vertexType & NORMAL_DEFINED) != 0) {
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = j+base;
			    src.floatBufferRefNormals.position(src.indexNormal[index]*3);
			    src.floatBufferRefNormals.get(vertexData, vOffset, 3);
			    vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		}
	    }

            if ((vertexFormat & GeometryArray.COLOR) != 0) {
		base = src.initialIndexIndex;
		vOffset = colorOffset;
		int multiplier = 3;
		if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0)
		    multiplier = 4;
		
		switch ((src.vertexType & COLOR_DEFINED)) { 
		case CF:
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = j+base;

			    if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
				src.floatBufferRefColors.position(src.indexColor[index]*multiplier);
				src.floatBufferRefColors.get(vertexData, vOffset, 4);
	
			    }
			    else {
				src.floatBufferRefColors.position(src.indexColor[index]*multiplier);
				src.floatBufferRefColors.get(vertexData, vOffset, 3);
				
				vertexData[vOffset+3] = 1.0f;
			    }
			    vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		    break;
		case CUB: 
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = src.indexColor[j+base] * multiplier;
			    vertexData[vOffset] = (src.byteBufferRefColors.get(index) & 0xff) * ByteToFloatScale;
			    vertexData[vOffset+1] = (src.byteBufferRefColors.get(index+1) & 0xff) * ByteToFloatScale;;
			    vertexData[vOffset+2] = (src.byteBufferRefColors.get(index+2) & 0xff) * ByteToFloatScale;;
			    if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) {
				vertexData[vOffset+3] = (src.byteBufferRefColors.get(index+3) & 0xff) * ByteToFloatScale;
			    }
			    else {
				vertexData[vOffset+3] = 1.0f;
			    }
			    vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		    break;
		default:
		    break;
		}
	    }

            if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) {
		base = src.initialIndexIndex;
		vOffset = textureOffset;
		FloatBufferWrapper texBuffer;
		if((src.vertexType & TEXCOORD_DEFINED) != 0) {
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = j+base;

			    for (k = 0, tOffset = vOffset; 
					k < texCoordSetCount; k++) {
				texBuffer = (FloatBufferWrapper)(((J3DBuffer) (src.refTexCoordsBuffer[k])).getBufferImpl());
				texBuffer.position(src.indexTexCoord[k][index]*texCoordStride);
				texBuffer.get(vertexData, tOffset, texCoordStride);
				tOffset += texCoordStride;
                            }
                            vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		}
	    }

            if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) {
		base = src.initialIndexIndex;
		vOffset = 0;
		if((src.vertexType & VATTR_DEFINED) == AF) {
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = j+base;

			    for (k = 0; k < vertexAttrCount; k++) {
                                int vaOffset = vOffset + vertexAttrOffsets[k];
                                FloatBufferWrapper vaBuffer = src.floatBufferRefVertexAttrs[k];
				vaBuffer.position(src.indexVertexAttr[k][index]*vertexAttrSizes[k]);
				vaBuffer.get(vertexData, vaOffset, vertexAttrSizes[k]);
                            }
                            vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		}
	    }

	    if ((vertexFormat & GeometryArray.COORDINATES) != 0) {
		vOffset = coordinateOffset;
		base = src.initialIndexIndex;
		switch ((src.vertexType & VERTEX_DEFINED)) { 
		case PF:
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = j+base;
			    src.floatBufferRefCoords.position(src.indexCoord[index]*3);
			    src.floatBufferRefCoords.get(vertexData, vOffset, 3);

			    vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }			
		    break;
		case PD: 
		    for (i=0; i < src.stripIndexCounts.length; i++) {
			for (j=0; j < src.stripIndexCounts[i]; j++) {
			    index = src.indexCoord[j+base] * 3;
			    vertexData[vOffset] = (float)src.doubleBufferRefCoords.get(index);
			    vertexData[vOffset+1] = (float)src.doubleBufferRefCoords.get(index+1);
			    vertexData[vOffset+2] = (float)src.doubleBufferRefCoords.get(index+2);
			    vOffset += stride;
			}
			base += src.stripIndexCounts[i];
		    }
		    break;

		default:
		    break;
		}
	    }		
	}
    }


    /**
     * Get number of strips in the GeometryStripArray
     * @return numStrips number of strips
     */
    int getNumStrips(){
	return stripVertexCounts.length;
    }

    /**
     * Get a list of vertexCounts for each strip
     * @param stripVertexCounts an array that will receive vertexCounts
     */
    void getStripVertexCounts(int stripVertexCounts[]){

	int i, num = this.stripVertexCounts.length;

	for (i=0;i < num;i++)
	{
		stripVertexCounts[i] = this.stripVertexCounts[i];
	}

  }

    void getStripVertexCounts(int id, int counts[]) {
	int stripOffset = compileStripCountOffset[id];
	int stripLength = compileNumStrips[id];
	System.arraycopy(stripVertexCounts, stripOffset, counts, 0,stripLength);
    }


    int getNumStrips(int id) {
	return compileNumStrips[id];
    }

    // Called only for "by-copy" geometry
    void mergeGeometryArrays(ArrayList list) {
	int numMerge = list.size();
	int numStrips = 0;
	

	for (int i = 0; i < numMerge; i++) {
	    numStrips += 
		((GeometryStripArrayRetained)list.get(i)).stripVertexCounts.length;
	}
	stripVertexCounts = new int[numStrips];
	stripStartVertexIndices = new int[numStrips];
	stripStartOffsetIndices = new int[numStrips];
	int curStripOffset = 0;
	int curStripIndexOffset = 0,stripLength;
	int[] curStripVertexCounts;
	int[]  curStripStartIndices ;
	int[]  curStripOffsetIndices ;
	

	compileNumStrips = new int[numMerge];
	compileStripCountOffset = new int[numMerge];
	for (int i = 0; i < numMerge; i++) {
	    GeometryStripArrayRetained strip = 
				(GeometryStripArrayRetained)list.get(i);
	    curStripVertexCounts = strip.stripVertexCounts;
	    curStripStartIndices = strip.stripStartVertexIndices;
	    curStripOffsetIndices = strip.stripStartOffsetIndices;
	    stripLength = curStripVertexCounts.length;
	    compileNumStrips[i] = stripLength;
	    compileStripCountOffset[i] = curStripOffset;
	    System.arraycopy(curStripVertexCounts, 0, stripVertexCounts,
		curStripOffset, stripLength);
	    // Can't just copy StartIndices, have to update to reflect
	    // updated vertex position on the merged vertexData
	    for (int j = 0; j < stripLength; j++) {
		stripStartVertexIndices[j+curStripOffset] = curStripStartIndices[j] +
			curStripIndexOffset;
		stripStartOffsetIndices[j+curStripOffset] = curStripOffsetIndices[j] +
			curStripIndexOffset;
	    }
	    curStripOffset += stripLength;
	    curStripIndexOffset += strip.validVertexCount;
	 }
	// Assign the merged validVertexCount
	validVertexCount = curStripIndexOffset;
	
	// call the super to merge the vertex data
	super.mergeGeometryArrays(list);
    }
}