diff options
Diffstat (limited to 'src/javax/media/j3d/GeometryStripArrayRetained.java')
| -rw-r--r-- | src/javax/media/j3d/GeometryStripArrayRetained.java | 828 |
1 files changed, 828 insertions, 0 deletions
diff --git a/src/javax/media/j3d/GeometryStripArrayRetained.java b/src/javax/media/j3d/GeometryStripArrayRetained.java new file mode 100644 index 0000000..f08c9e9 --- /dev/null +++ b/src/javax/media/j3d/GeometryStripArrayRetained.java @@ -0,0 +1,828 @@ +/* + * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package javax.media.j3d; + +import java.nio.FloatBuffer; +import java.util.ArrayList; + +import javax.vecmath.TexCoord2f; +import javax.vecmath.TexCoord3f; + + +/** + * The GeometryStripArray object is an abstract class that is extended for + * a set of GeometryArray strip primitives. These include LINE_STRIP, + * TRIANGLE_STRIP, and TRIANGLE_FAN. + */ + +abstract class GeometryStripArrayRetained extends GeometryArrayRetained { + + // Array of per-strip vertex counts + int stripVertexCounts[]; + + // Array of per-strip starting index + int stripStartVertexIndices[]; // start of vertices for both by-copy + // and by-ref + int stripStartOffsetIndices[]; // Used in byRef non_interleaved + + // Following variables are only used in the compile mode + // isCompiled = true + int[] compileNumStrips; + int[] compileStripCountOffset; + + + /** + * Set stripVertexCount data into local array + */ + void setStripVertexCounts(int stripVertexCounts[]) { + boolean nullGeo = false; + + int i, num = stripVertexCounts.length, total = 0; + for (i=0; i < num; i++) { + total += stripVertexCounts[i]; + if (this instanceof LineStripArrayRetained) { + if (stripVertexCounts[i] < 2) { + throw new IllegalArgumentException(J3dI18N.getString("LineStripArrayRetained1")); + } + } + else if (this instanceof TriangleStripArrayRetained) { + if (stripVertexCounts[i] < 3) { + throw new IllegalArgumentException(J3dI18N.getString("TriangleStripArrayRetained1")); + } + } + else if (this instanceof TriangleFanArrayRetained) { + if (stripVertexCounts[i] < 3) { + throw new IllegalArgumentException(J3dI18N.getString("TriangleFanArrayRetained1")); + } + } + } + + if ((initialVertexIndex + total) > vertexCount) { + throw new IllegalArgumentException(J3dI18N.getString("GeometryStripArray3")); + } + if ((initialCoordIndex + total) > vertexCount) { + throw new IllegalArgumentException(J3dI18N.getString("GeometryStripArray7")); + } + if ((initialColorIndex + total) > vertexCount) { + throw new IllegalArgumentException(J3dI18N.getString("GeometryStripArray4")); + } + if ((initialNormalIndex + total) > vertexCount) { + throw new IllegalArgumentException(J3dI18N.getString("GeometryStripArray5")); + } + if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) { + if ((vertexFormat & (GeometryArray.BY_REFERENCE|vertexFormat &GeometryArray.INTERLEAVED)) == GeometryArray.BY_REFERENCE) { + for (i = 0; i < texCoordSetCount; i++) { + if ((initialTexCoordIndex[i] + total) > vertexCount) { + throw new IllegalArgumentException( + J3dI18N.getString("GeometryStripArray6")); + } + } + } + } + if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) { + if ((vertexFormat & (GeometryArray.BY_REFERENCE|vertexFormat &GeometryArray.INTERLEAVED)) == GeometryArray.BY_REFERENCE) { + for (i = 0; i < vertexAttrCount; i++) { + if ((initialVertexAttrIndex[i] + total) > vertexCount) { + throw new IllegalArgumentException( + J3dI18N.getString("GeometryStripArray8")); + } + } + } + } + boolean isLive = source!=null && source.isLive(); + if(isLive){ + geomLock.getLock(); + } + dirtyFlag |= STRIPCOUNT_CHANGED; + validVertexCount = total; + this.stripVertexCounts = new int[num]; + stripStartVertexIndices = new int[num]; + stripStartOffsetIndices = new int[num]; + stripStartOffsetIndices[0] = 0; + if ((vertexFormat & (GeometryArray.BY_REFERENCE|vertexFormat &GeometryArray.INTERLEAVED)) == GeometryArray.BY_REFERENCE) { + stripStartVertexIndices[0] = initialCoordIndex; + nullGeo = ((vertexType & GeometryArrayRetained.VERTEX_DEFINED) == 0); + } + else { + stripStartVertexIndices[0] = initialVertexIndex; + if ((vertexFormat & GeometryArray.INTERLEAVED) != 0) { + if (( vertexFormat & GeometryArray.USE_NIO_BUFFER) != 0) { + nullGeo = (interLeavedVertexData == null); + } + else { + nullGeo = (interleavedFloatBufferImpl == null); + } + } + } + + for (i=0; i<num-1; i++) { + this.stripVertexCounts[i] = stripVertexCounts[i]; + stripStartVertexIndices[i+1] = stripStartVertexIndices[i] + + stripVertexCounts[i]; + stripStartOffsetIndices[i+1] = stripStartOffsetIndices[i]+stripVertexCounts[i]; + } + this.stripVertexCounts[num-1] = stripVertexCounts[num-1]; + if(isLive) { + geomLock.unLock(); + } + if (!inUpdater && isLive) { + processCoordsChanged(nullGeo); + sendDataChangedMessage(true); + } + + } + void unIndexify(IndexedGeometryStripArrayRetained src) { + if ((src.vertexFormat & GeometryArray.USE_NIO_BUFFER) == 0) { + unIndexifyJavaArray(src); + } + else { + unIndexifyNIOBuffer(src); + } + } + + private void unIndexifyJavaArray(IndexedGeometryStripArrayRetained src) { + int vOffset = 0, srcOffset, tOffset = 0; + int base = src.initialIndexIndex; + int i,j, k, index, colorStride = 0; + float[] vdata = null; + + if (((src.vertexFormat & GeometryArray.BY_REFERENCE) == 0) || + ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0)) { + + if ((src.vertexFormat & GeometryArray.BY_REFERENCE) == 0) { + vdata = src.vertexData; + if ((src.vertexFormat & GeometryArray.COLOR) != 0) + colorStride = 4; + } + else if ((src.vertexFormat & GeometryArray.INTERLEAVED) != 0) { + vdata = src.interLeavedVertexData; + if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) + colorStride = 4; + else if ((src.vertexFormat & GeometryArray.COLOR) != 0) + colorStride = 3; + } + + for (i=0; i < src.stripIndexCounts.length; i++) { + for (j=0; j < src.stripIndexCounts[i]; j++) { + index = j + base; + if ((vertexFormat & GeometryArray.NORMALS) != 0){ + System.arraycopy(vdata, + src.indexNormal[index]*src.stride + src.normalOffset, + vertexData, vOffset + normalOffset, 3); + } + + if (colorStride == 4) { + /* + System.err.println("vdata.length = "+vdata.length); + System.err.println("vertexData.length = "+vertexData.length); + System.err.println("src.stride = "+src.stride); + System.err.println("src.colorOffset = "+src.colorOffset); + System.err.println("index = "+index+" src.indexColor.length = "+src.indexColor.length); + System.err.println("src.indexColor[index] = "+src.indexColor[index]); + System.err.println("base = "+base); + */ + System.arraycopy(vdata, + src.indexColor[index]*src.stride + src.colorOffset, + vertexData, vOffset + colorOffset, colorStride); + } else if (colorStride == 3) { + System.arraycopy(vdata, + src.indexColor[index]*src.stride + src.colorOffset, + vertexData, vOffset + colorOffset, colorStride); + vertexData[vOffset + colorOffset + 3] = 1.0f; + } + + if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) { + for (k = 0; k < texCoordSetCount; k++) { + System.arraycopy(vdata, + (src.indexTexCoord[k][index]) + * src.stride + src.textureOffset + + src.texCoordSetMapOffset[k], + vertexData, + vOffset + textureOffset + + texCoordSetMapOffset[k], + texCoordStride); + } + } + + if ((vertexFormat & GeometryArray.VERTEX_ATTRIBUTES) != 0) { + for (k = 0; k < vertexAttrCount; k++) { + System.arraycopy(vdata, + src.indexVertexAttr[k][index] * src.stride + src.vertexAttrOffsets[k], + vertexData, + vOffset + vertexAttrOffsets[k], + vertexAttrSizes[k]); + } + } + + if ((vertexFormat & GeometryArray.COORDINATES) != 0) { + System.arraycopy(vdata, + src.indexCoord[index]*src.stride + src.coordinateOffset, + vertexData, vOffset + coordinateOffset, 3); + } + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + } + else { + if ((vertexFormat & GeometryArray.NORMALS) != 0){ + base = src.initialIndexIndex; + vOffset = normalOffset; + switch ((src.vertexType & NORMAL_DEFINED)) { + case NF: + for (i=0; i < src.stripIndexCounts.length; i++) { + for (j=0; j < src.stripIndexCounts[i]; j++) { + index = j+base; + System.arraycopy(src.floatRefNormals, + src.indexNormal[index]*3, + vertexData, + vOffset, 3); + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + case N3F: + for (i=0; i < src.stripIndexCounts.length; i++) { + for (j=0; j < src.stripIndexCounts[i]; j++) { + index = src.indexNormal[j+base]; + vertexData[vOffset] = src.v3fRefNormals[index].x; + vertexData[vOffset+1] = src.v3fRefNormals[index].y; + vertexData[vOffset+2] = src.v3fRefNormals[index].z; + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + default: + break; + } + } + + 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) { + System.arraycopy(src.floatRefColors, + src.indexColor[index]*multiplier, + vertexData, + vOffset, 4); + } + else { + System.arraycopy(src.floatRefColors, + src.indexColor[index]*multiplier, + vertexData, + vOffset, 3); + vertexData[vOffset+3] = 1.0f; + } + vOffset += stride; + } + 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.byteRefColors[index] & 0xff) * ByteToFloatScale; + vertexData[vOffset+1] = (src.byteRefColors[index+1] & 0xff) * ByteToFloatScale;; + vertexData[vOffset+2] = (src.byteRefColors[index+2] & 0xff) * ByteToFloatScale;; + if ((src.vertexFormat & GeometryArray.WITH_ALPHA) != 0) { + vertexData[vOffset+3] = (src.byteRefColors[index+3] & 0xff) * ByteToFloatScale; + } + else { + vertexData[vOffset+3] = 1.0f; + } + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + case C3F: + for (i=0; i < src.stripIndexCounts.length; i++) { + for (j=0; j < src.stripIndexCounts[i]; j++) { + index = src.indexColor[j+base]; + vertexData[vOffset] = src.c3fRefColors[index].x; + vertexData[vOffset+1] = src.c3fRefColors[index].y; + vertexData[vOffset+2] = src.c3fRefColors[index].z; + vertexData[vOffset+3] = 1.0f; + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + case C4F: + for (i=0; i < src.stripIndexCounts.length; i++) { + for (j=0; j < src.stripIndexCounts[i]; j++) { + index = src.indexColor[j+base]; + vertexData[vOffset] = src.c4fRefColors[index].x; + vertexData[vOffset+1] = src.c4fRefColors[index].y; + vertexData[vOffset+2] = src.c4fRefColors[index].z; + vertexData[vOffset+3] = src.c4fRefColors[index].w; + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + case C3UB: + for (i=0; i < src.stripIndexCounts.length; i++) { + for (j=0; j < src.stripIndexCounts[i]; j++) { + index = src.indexColor[j+base]; + vertexData[vOffset] = (src.c3bRefColors[index].x & 0xff) * ByteToFloatScale; + vertexData[vOffset+1] = (src.c3bRefColors[index].y & 0xff) * ByteToFloatScale; + vertexData[vOffset+2] = (src.c3bRefColors[index].z & 0xff) * ByteToFloatScale; + vertexData[vOffset+3] = 1.0f; + + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + case C4UB: + for (i=0; i < src.stripIndexCounts.length; i++) { + for (j=0; j < src.stripIndexCounts[i]; j++) { + index = src.indexColor[j+base]; + vertexData[vOffset] = (src.c4bRefColors[index].x & 0xff) * ByteToFloatScale; + vertexData[vOffset+1] = (src.c4bRefColors[index].y & 0xff) * ByteToFloatScale; + vertexData[vOffset+2] = (src.c4bRefColors[index].z & 0xff) * ByteToFloatScale; + vertexData[vOffset+3] = (src.c4bRefColors[index].w & 0xff) * ByteToFloatScale; + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + default: + break; + } + } + + if ((vertexFormat & GeometryArray.TEXTURE_COORDINATE) != 0) { + base = src.initialIndexIndex; + vOffset = textureOffset; + switch ((src.vertexType & TEXCOORD_DEFINED)) { + case TF: + 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++) { + System.arraycopy(src.refTexCoords[k], + src.indexTexCoord[k][index] + *texCoordStride, + vertexData, tOffset, texCoordStride); + tOffset += texCoordStride; + } + vOffset += stride; + } + base += src.stripIndexCounts[i]; + } + break; + case T2F: + 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] = ((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; + 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++) { + FloatBuffer texBuffer = (FloatBuffer)src.refTexCoordsBuffer[k].getROBuffer(); + 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]; + FloatBuffer 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 + @Override + 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); + } +} |