geombuffer.java

JAVA3D矩陈的相关类

    int stripCounts[] = new int[currPrimCnt];
    for (i = 0; i < currPrimCnt; i++){
      stripCounts[i] = currPrimEndVertex[i] - currPrimStartVertex[i];
      totalVerts += stripCounts[i];
    }

    if (debug >= 1) System.out.println("totalVerts " + totalVerts);

    int tsaFlags = TriangleStripArray.COORDINATES;
    if ((flags & Primitive.GENERATE_NORMALS) != 0)
	tsaFlags |= TriangleStripArray.NORMALS;
    if ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)
	 tsaFlags |= TriangleStripArray.TEXTURE_COORDINATE_2;

    // Create GeometryArray to pass back
    obj = new TriangleStripArray(totalVerts, tsaFlags, 
			1, texCoordSetMap, stripCounts);

    // Allocate space to store new vertex info
    Point3f[] newpts = new Point3f[totalVerts];
    Vector3f[] newnormals = new Vector3f[totalVerts];
    TexCoord2f[] newtcoords = new TexCoord2f[totalVerts];
    int currVert = 0;
    
    // Repeat for each Quad Strip
    for (i = 0; i < currPrimCnt; i++){
      // Output order for these quad arrays same as java 3d triangle strips
      for (int j = currPrimStartVertex[i] ; j < currPrimEndVertex[i] ; j++){
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j);
      }

    }

    numVerts = currVert;
    numTris += totalVerts - currPrimCnt * 2;

    obj.setCoordinates(0, newpts);
    if ((flags & Primitive.GENERATE_NORMALS) != 0)
      obj.setNormals(0, newnormals);
    if ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)
      obj.setTextureCoordinates(0, 0, newtcoords);

    geometry = obj;
    return obj;
  }

  private GeometryArray processQuads()
  {
    GeometryArray obj = null;
    int i;
    int totalVerts = 0;

    for (i = 0; i < currPrimCnt; i++){
      totalVerts += currPrimEndVertex[i] - currPrimStartVertex[i];
    }

    if (debug >= 1) System.out.println("totalVerts " + totalVerts);

    if (((flags & Primitive.GENERATE_NORMALS) != 0) &&
	((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)){
      obj = new QuadArray(totalVerts,
			  QuadArray.COORDINATES | 
			  QuadArray.NORMALS |
			  QuadArray.TEXTURE_COORDINATE_2, 
			  1, texCoordSetMap);
    }
    else 
      if (((flags & Primitive.GENERATE_NORMALS) == 0) &&
	  ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)){
	obj = new QuadArray(totalVerts,
			    QuadArray.COORDINATES | 
			    QuadArray.TEXTURE_COORDINATE_2, 
			    1, texCoordSetMap);
      }
    else 
      if (((flags & Primitive.GENERATE_NORMALS) != 0) &&
	  ((flags & Primitive.GENERATE_TEXTURE_COORDS) == 0)){
	obj = new QuadArray(totalVerts,
			    QuadArray.COORDINATES | 
			    QuadArray.NORMALS);
      }
      else {
	obj = new QuadArray(totalVerts,
			    QuadArray.COORDINATES);
      }

    Point3f[] newpts = new Point3f[totalVerts];
    Vector3f[] newnormals = new Vector3f[totalVerts];
    TexCoord2f[] newtcoords = new TexCoord2f[totalVerts];
    int currVert = 0;

    if (debug > 1) System.out.println("total prims " + currPrimCnt);

    for (i = 0; i < currPrimCnt; i++){
      if (debug > 1) System.out.println("start " + currPrimStartVertex[i] + 
					" end " + currPrimEndVertex[i]);
      for (int j = currPrimStartVertex[i]; j < currPrimEndVertex[i] - 3;j+=4){
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j);
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j + 1);
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j + 2);
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j + 3);
	numTris += 2;
      }
    }
    numVerts = currVert;

    obj.setCoordinates(0, newpts);
    if ((flags & Primitive.GENERATE_NORMALS) != 0)
      obj.setNormals(0, newnormals);
    if ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)
      obj.setTextureCoordinates(0, 0, newtcoords);

    geometry = obj;
    return obj;
  }

  private GeometryArray processTriangles()
  {
    GeometryArray obj = null;
    int i;
    int totalVerts = 0;

    for (i = 0; i < currPrimCnt; i++){
      totalVerts += currPrimEndVertex[i] - currPrimStartVertex[i];
    }

    if (debug >= 1) System.out.println("totalVerts " + totalVerts);

    if (((flags & Primitive.GENERATE_NORMALS) != 0) &&
	((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)){
      obj = new TriangleArray(totalVerts,
			  TriangleArray.COORDINATES | 
			  TriangleArray.NORMALS |
			  TriangleArray.TEXTURE_COORDINATE_2,
			  1, texCoordSetMap);
    }
    else 
      if (((flags & Primitive.GENERATE_NORMALS) == 0) &&
	  ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)){
	obj = new TriangleArray(totalVerts,
			    TriangleArray.COORDINATES | 
			    TriangleArray.TEXTURE_COORDINATE_2,
			  1, texCoordSetMap);
      }
    else 
      if (((flags & Primitive.GENERATE_NORMALS) != 0) &&
	  ((flags & Primitive.GENERATE_TEXTURE_COORDS) == 0)){
	obj = new TriangleArray(totalVerts,
			    TriangleArray.COORDINATES | 
			    TriangleArray.NORMALS);
      }
      else {
	obj = new TriangleArray(totalVerts,
			    TriangleArray.COORDINATES);
      }

    Point3f[] newpts = new Point3f[totalVerts];
    Vector3f[] newnormals = new Vector3f[totalVerts];
    TexCoord2f[] newtcoords = new TexCoord2f[totalVerts];
    int currVert = 0;
    
    for (i = 0; i < currPrimCnt; i++){
      for (int j = currPrimStartVertex[i]; j < currPrimEndVertex[i] - 2;j+=3){
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j);
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j + 1);
	outVertex(newpts, newnormals, newtcoords, currVert++,
		  pts, normals, tcoords, j + 2);
	numTris += 1;
      }
    }
    numVerts = currVert;

    obj.setCoordinates(0, newpts);
    if ((flags & Primitive.GENERATE_NORMALS) != 0)
      obj.setNormals(0, newnormals);
    if ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0)
      obj.setTextureCoordinates(0, 0, newtcoords);

    geometry = obj;
    return obj;
  }


  private GeometryArray processTriangleFan() {
    if (debug > 0) System.out.println("processTriangleFan");

    GeometryArray obj = null;
    int i;
    int totalVerts = 0;

    int stripCounts[] = new int[currPrimCnt];

    // figure out how many vertices we need to hold the individual fans
    for (i = 0; i < currPrimCnt; i++) {
      stripCounts[i] = currPrimEndVertex[i] - currPrimStartVertex[i];
      totalVerts += stripCounts[i];
    }

    // figure out what flags we need
    int tfFlags = TriangleFanArray.COORDINATES;
    if ((flags & Primitive.GENERATE_NORMALS) != 0) {
      tfFlags |= TriangleFanArray.NORMALS;
    }
    if ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0) {
      tfFlags |= TriangleFanArray.TEXTURE_COORDINATE_2;
    }

    // create the TriangleFanArray
    obj = new TriangleFanArray(totalVerts, tfFlags, 1, texCoordSetMap,
			       stripCounts);

    // allocate space for vertex info
    Point3f[] newpts = new Point3f[totalVerts];
    Vector3f[] newnormals = new Vector3f[totalVerts];
    TexCoord2f[] newtcoords = new TexCoord2f[totalVerts];

    int currVert = 0;

    // repeat for each fan
    for (i = 0; i < currPrimCnt; i++) {
      for (int j = currPrimStartVertex[i]; j < currPrimEndVertex[i]; j++) {
	outVertex(newpts, newnormals, newtcoords, currVert++, pts, 
		  normals, tcoords, j);
      }
    }

    for (i = 0; i < newpts.length; i++) {
      if (debug > 1) System.out.println("i = " + i + " " + newpts[i]);
    }

    numVerts = currVert;
    numTris = totalVerts - currPrimCnt * 2;    

    // set the coordinates on the GeometryArray
    obj.setCoordinates(0, newpts);

    // set the normals and tex coords if necessary
    if ((flags & Primitive.GENERATE_NORMALS) != 0) {
      obj.setNormals(0, newnormals);
    }
    if ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0) {
      obj.setTextureCoordinates(0, 0, newtcoords);
    }
    geometry = obj;
    return obj;
  }



  void outVertex(Point3f[] dpts, Vector3f[] dnormals, TexCoord2f[] dtcoords,
		 int dloc,
		 Point3f[] spts, Vector3f[] snormals, TexCoord2f[] stcoords,
		 int sloc)
  {
    if (debug >= 1) System.out.println("v " + spts[sloc].x + " " +
				       spts[sloc].y + " " + 
				       spts[sloc].z);

    // PSP: Do we really need new points here?

    dpts[dloc] = new Point3f(spts[sloc]);

    if ((flags & Primitive.GENERATE_NORMALS) != 0){
      dnormals[dloc] = new Vector3f(snormals[sloc]);
    }
    if ((flags & Primitive.GENERATE_TEXTURE_COORDS) != 0){
      if (debug >= 2) System.out.println("final out tcoord");
      dtcoords[dloc] = new TexCoord2f(stcoords[sloc]);
    }
  }
}