• Home
• com.massisframework.j3d
• java3d-core
• 1.6.0.1
• source code
• GeometryInfo.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.sun.j3d.utils.geometry.GeometryInfo Maven / Gradle / Ivy

/*
 * Copyright (c) 2007 Sun Microsystems, Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistribution of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
 * EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL
 * NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF
 * USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR
 * ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL,
 * CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND
 * REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR
 * INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or
 * intended for use in the design, construction, operation or
 * maintenance of any nuclear facility.
 *
 */

package com.sun.j3d.utils.geometry;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.util.HashMap;

import javax.media.j3d.GeometryArray;
import javax.media.j3d.IndexedGeometryArray;
import javax.media.j3d.IndexedQuadArray;
import javax.media.j3d.IndexedTriangleArray;
import javax.media.j3d.IndexedTriangleFanArray;
import javax.media.j3d.IndexedTriangleStripArray;
import javax.media.j3d.J3DBuffer;
import javax.media.j3d.QuadArray;
import javax.media.j3d.TriangleArray;
import javax.media.j3d.TriangleFanArray;
import javax.media.j3d.TriangleStripArray;
import javax.vecmath.Color3b;
import javax.vecmath.Color3f;
import javax.vecmath.Color4b;
import javax.vecmath.Color4f;
import javax.vecmath.Point2f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.TexCoord2f;
import javax.vecmath.TexCoord3f;
import javax.vecmath.TexCoord4f;
import javax.vecmath.Tuple2f;
import javax.vecmath.Tuple3f;
import javax.vecmath.Tuple4f;
import javax.vecmath.Vector3f;

import com.sun.j3d.internal.J3dUtilsI18N;

/**
 * The GeometryInfo object holds data for processing by the Java3D geometry
 * utility tools.

 *
 *         The NormalGenerator adds normals to geometry without normals.

 *
 *         The Stripifier combines adjacent triangles into triangle strips for
 *         more efficent rendering.

 *
 * Also, the GeometryCompressor can take a set of GeometryInfo objects in a
 * CompressionSteam and generate a CompressedGeometry object from the
 * geometry.

 *         Geometry is loaded into a GeometryInfo in a manner similar to the
 * 
 * GeometryArray methods.  The constructor for the GeometryInfo takes a flag
 * that specifies the kind of data being loaded.  The vertex data is
 * specified using methods that are similar to the GeometryArray methods, but
 * with fewer variations.

 *         The major difference between GeometryInfo and GeometryArray is
 * that the number of vertices, vertex format, and other data are specified
 * implictly, rather than as part of the constructor.  The number of verticies
 * comes from the number of coordinates passed to the setCoordinates()
 * method.  The format comes from the set of data components that are
 * specified.  For example, calling the setCoordinates(), setColors3() and
 * setTextureCoordinatesParames(1, 2) methods implies a
 * format of COORDINATES | COLOR_3
 * | TEXTURE_COORDINATE_2.  Indexed representation is specified by calling
 * the methods that specify the indices, for example
 * setCoordinateIndices().

 *         Stripped primitives are loaded using the TRIANGLE_FAN_ARRAY or
 * TRIANGLE_STRIP_ARRAY flags to the constructor.  The setStripCounts()
 * method specifies the length of each strip.

 *         A set of complex polygons is loaded using the POLYGON_ARRAY
 * flag to the constructor.  The setStripCounts() method specifies the length
 * of each contour of the polygons.  The setContourCounts() method specifies
 * the number of countours in each polygon. For example, a triangle with a
 * triangular hole would have strip counts [3, 3] (indicating two contours of
 * three points) and contour counts [2] (indicating a single polygon with two
 * contours).

 *         GeometryInfo itelf contains some simple utilities, such as
 * calculating indices for non-indexed data ("indexifying") and getting rid
 * of unused data in your indexed geometry ("compacting").

 *         The geometry utility tools modify the contents of the
 * GeometryInfo.  After processing, the resulting geometry can be extracted
 * from the GeometryInfo by calling getGeometryArray().  If multiple tools
 * are used, the order of processing should be: generate normals, then
 * stripify.  For example, to convert a general mesh of polygons without
 * normals into an optimized mesh call:
 * 

 *         GeometryInfo gi = new GeometryInfo(GeometryInfo.POLYGON_ARRAY);
 *         // initialize the geometry info here
 *         // generate normals
 *         NormalGenerator ng = new NormalGenerator();
 *         ng.generateNormals(gi);
 *         // stripify
 *         Stripifier st = new Stripifier();
 *         st.stripify(gi);
 *         GeometryArray result = gi.getGeometryArray();
 * 
 *
 * @see NormalGenerator
 * @see Stripifier
 * @see com.sun.j3d.utils.compression.CompressionStream
 * @see com.sun.j3d.utils.compression.GeometryCompressor
 * @see javax.media.j3d.GeometryArray
 */

public class GeometryInfo {

  /**
   * Send to the constructor to inform that the data will be arranged so
   * that each set of three vertices form an independent triangle
   */
  public static final int TRIANGLE_ARRAY = 1;

  /**
   * Send to the constructor to inform that the data will be arranged so
   * that each set of four vertices form an independent quad
   */
  public static final int QUAD_ARRAY = 2;

  /**
   * Send to the constructor to inform that the data will be arranged so
   * that the stripCounts array indicates how many vertices to use
   * for each triangle fan.
   */
  public static final int TRIANGLE_FAN_ARRAY = 3;

  /**
   * Send to the constructor to inform that the data will be arranged so
   * that the stripCounts array indicates how many vertices to use
   * for each triangle strip.
   */
  public static final int TRIANGLE_STRIP_ARRAY = 4;

  /**
   * Send to the constructor to inform that the data is arranged as
   * possibly multi-contour, possible non-planar polygons.
   * The stripCounts array indicates how many vertices to use
   * for each contour, and the contourCounts array indicates how many
   * stripCounts entries to use for each polygon.  The first
   * contour is the bounding polygon, and subsequent contours are
   * "holes."  If contourCounts is left null, the default is
   * one contour per polygon.
   */
  public static final int POLYGON_ARRAY = 5;

  private int prim;

  // 1 Show indexification details
  private static final int DEBUG = 0;

  private Point3f coordinates[] = null;
  private Color3f colors3[] = null;
  private Color4f colors4[] = null;
  private Vector3f normals[] = null;
  private Object texCoordSets[][] = null;

  private int coordinateIndices[] = null;
  private int colorIndices[] = null;
  private int normalIndices[] = null;
  private int texCoordIndexSets[][] = null;

  private int[] texCoordSetMap = null;
  private int texCoordSetCount = 0;
  private int texCoordDim = 0;

  private int stripCounts[] = null;
  private int contourCounts[] = null;

  private Triangulator tr = null;
  private NormalGenerator ng = null;

  private int oldPrim = 0;
  private int oldStripCounts[] = null;

  private boolean coordOnly = false;



  /**
   * Constructor.
   * Creates an empty GeometryInfo object.
   * @param primitive Tells the GeometryInfo object the type of
   * primitive data to be stored
   * in it, so it will know the format of the data. It can be one of
   * TRIANGLE_ARRAY,
   * QUAD_ARRAY, TRIANGLE_FAN_ARRAY, TRIANGLE_STRIP_ARRAY, or POLYGON_ARRAY.
   */
  public GeometryInfo(int primitive)
  {
      if ((primitive >= TRIANGLE_ARRAY) && (primitive <= POLYGON_ARRAY)) {
	  prim = primitive;
      } else {
	  throw new IllegalArgumentException(
	      J3dUtilsI18N.getString("GeometryInfo0"));
      }
  } // End of GeometryInfo(int)



  /**
   * Contructor.  Populates the GeometryInfo with the geometry from
   * the GeometryArray.

   * If the GeometryArray uses the Initial and
   * Valid GeometryArray methods (
   * setInitialVertexIndex() and setValidVertexCount()
   *  and their cousins) then only the needed geometry
   * is copied into the GeometryInfo.
   */
  public GeometryInfo(GeometryArray ga)
  {
    GeometryInfoGenerator.create(this, ga);
  } // End of GeometryInfo(GeometryArray)



  /**
   * Removes all data from the GeometryInfo and resets the primitive.
   * After a call to reset(), the GeometryInfo object will be just like
   * it was when it was newly constructed.
   * @param primitive Either TRIANGLE_ARRAY, QUAD_ARRAY,
   * TRIANGLE_FAN_ARRAY, TRIANGLE_STRIP_ARRAY, or POLYGON_ARRAY.
   * Tells the GeometryInfo object the type of primitive data to be stored
   * in it, so it will know the format of the data.
   */
  public void reset(int primitive)
  {
      if ((primitive >= TRIANGLE_ARRAY) && (primitive <= POLYGON_ARRAY)) {
	  prim = primitive;
      } else {
	  throw new IllegalArgumentException(
	      J3dUtilsI18N.getString("GeometryInfo0"));
      }

      coordinates = null;
      colors3 = null;
      colors4 = null;
      normals = null;

      coordinateIndices = null;
      colorIndices = null;
      normalIndices = null;

      stripCounts = null;
      contourCounts = null;

      oldPrim = 0;
      oldStripCounts = null;

      texCoordDim = 0;
      texCoordSetCount = 0;
      texCoordSets = null;
      texCoordIndexSets = null;
      texCoordSetMap = null;

      coordOnly = false;

  } // End of reset(int)



  /**
   * Removes all data from this GeometryInfo and populates it with
   * the geometry from the GeometryArray.
   */
  public void reset(GeometryArray ga)
  {
    GeometryInfoGenerator.create(this, ga);
  } // End of reset(GeometryArray)



  // This method takes an indexed quad array and expands it to
  // a list of indexed triangles.  It is used for the Coordinate
  // indices as well as the color and texture indices.
  private int[] expandQuad(int indices[])
  {
      int triangles[] = new int[indices.length / 4 * 6];

      for (int i = 0 ; i < indices.length / 4 ; i++ ) {
	  triangles[i * 6 + 0] = indices[i * 4];
	  triangles[i * 6 + 1] = indices[i * 4 + 1];
	  triangles[i * 6 + 2] = indices[i * 4 + 2];
	  triangles[i * 6 + 3] = indices[i * 4];
	  triangles[i * 6 + 4] = indices[i * 4 + 2];
	  triangles[i * 6 + 5] = indices[i * 4 + 3];
      }

      return triangles;
  } // End of expandQuad



  // This method takes an indexed triangle fan and expands it to
  // a list of indexed triangles.  It is used for the Coordinate
  // indices as well as the color and texture indices.
  private int[] expandTriFan(int numTris, int indices[])
  {
      int triangles[] = new int[numTris * 3];
      int p = 0;
      int base = 0;
      for (int f = 0 ; f < stripCounts.length ; f++) {
	  for (int t = 0 ; t < stripCounts[f] - 2 ; t++) {
	      triangles[p++] = indices[base];
	      triangles[p++] = indices[base + t + 1];
	      triangles[p++] = indices[base + t + 2];
	  }
	  base += stripCounts[f];
      }
      return triangles;
  } // End of expandTriFan



  // This method takes an indexed triangle strip and expands it to
  // a list of indexed triangles.  It is used for the Coordinate
  // indices as well as the color and texture indices.
  private int[] expandTriStrip(int numTris, int indices[])
  {
      int triangles[] = new int[numTris * 3];

      int p = 0;
      int base = 0;
      for (int s = 0 ; s < stripCounts.length ; s++) {
	  for (int t = 0 ; t < stripCounts[s] - 2 ; t++) {

	      // Use a ping-ponging algorithm to reverse order on every other
	      // triangle to preserve winding
	      if (t % 2 == 0) {
		  triangles[p++] = indices[base + t + 0];
		  triangles[p++] = indices[base + t + 1];
		  triangles[p++] = indices[base + t + 2];
	      } else {
		  triangles[p++] = indices[base + t + 0];
		  triangles[p++] = indices[base + t + 2];
		  triangles[p++] = indices[base + t + 1];
	      }
	  }
	  base += stripCounts[s];
      }

      return triangles;
  } // End of expandTriStrip



  // Used by the NormalGenerator utility.  Informs the GeometryInfo object
  // to remember its current primitive and stripCounts arrays so that
  // they can be used to convert the object back to its original
  // primitive
  void rememberOldPrim()
  {
      oldPrim = prim;
      oldStripCounts = stripCounts;
  } // End of rememberOldPrim



  // The NormalGenerator needs to know the original primitive for
  // facet normal generation for quads
  int getOldPrim()
  {
      return oldPrim;
  } // End of getOldPrim



  // Used by the Utility libraries other than the NormalGenerator.
  // Informs the GeometryInfo object that the geometry need not
  // be converted back to the original primitive before returning.
  // For example, if a list of Fans is sent, converted to Triangles
  // for normal generation, and then stripified by the Stripifyer,
  // we want to make sure that GeometryInfo doesn't convert the
  // geometry *back* to fans before creating the output GeometryArray.
  void forgetOldPrim()
  {
      oldPrim = 0;
      oldStripCounts = null;
  } // End of forgetOldPrim



  // We have changed the user's data from their original primitive
  // type to TRIANGLE_ARRAY.  If this method is being called, it
  // means we need to change it back (to try and hide from the user
  // the fact that we've converted).  This usually happens when
  // the user has used GeometryInfo for generating normals, but
  // they are not Stripifying or Triangulating.  The function is
  // called from getGeometryArray before creating the output data.
  private void changeBackToOldPrim()
  {
      if (oldPrim != 0) {
	  convertToIndexedTriangles();
	  if (ng == null) ng = new NormalGenerator();
	  ng.convertBackToOldPrim(this, oldPrim, oldStripCounts);
	  oldPrim = 0;
	  oldStripCounts = null;
      }
  } // End of changeBackToOldPrim



  /**
   * Convert the GeometryInfo object to have primitive type TRIANGLE_ARRAY
   * and be indexed.
   * @throws IllegalArgumentException if coordinate data is missing,
   * if the index lists aren't all the
   * same length, if an index list is set and the corresponding data
   * list isn't set, if a data list is set and the corresponding
   * index list is unset (unless all index lists are unset or in
   * USE_COORD_INDEX_ONLY format),
   * if StripCounts or ContourCounts is inconsistent with the current
   * primitive, if the sum of the contourCounts array doesn't equal
   * the length of the StripCounts array, or if the number of vertices
   * isn't a multiple of three (for triangles) or four (for quads).
   */
  public void convertToIndexedTriangles()
  {
      int triangles = 0;

      // This calls checkForBadData
      indexify();

      if (prim == TRIANGLE_ARRAY) return;

      switch(prim) {

	  case QUAD_ARRAY:

	      coordinateIndices = expandQuad(coordinateIndices);
	      if (colorIndices != null) colorIndices = expandQuad(colorIndices);
	      if (normalIndices != null)
		  normalIndices = expandQuad(normalIndices);
	      for (int i = 0 ; i < texCoordSetCount ; i++)
		  texCoordIndexSets[i] = expandQuad(texCoordIndexSets[i]);
	      break;

	  case TRIANGLE_FAN_ARRAY:
	      // Count how many triangles are in the object
	      for (int i = 0 ; i < stripCounts.length ; i++) {
		  triangles += stripCounts[i] - 2;
	      }

	      coordinateIndices = expandTriFan(triangles, coordinateIndices);
	      if (colorIndices != null)
		  colorIndices = expandTriFan(triangles, colorIndices);
	      if (normalIndices != null)
		  normalIndices = expandTriFan(triangles, normalIndices);
	      for (int i = 0 ; i < texCoordSetCount ; i++)
		  texCoordIndexSets[i] = expandTriFan(triangles,
			      texCoordIndexSets[i]);
	      break;

	  case TRIANGLE_STRIP_ARRAY:
	      // Count how many triangles are in the object
	      for (int i = 0 ; i < stripCounts.length ; i++) {
		  triangles += stripCounts[i] - 2;
	      }

	      coordinateIndices = expandTriStrip(triangles, coordinateIndices);
	      if (colorIndices != null)
		  colorIndices = expandTriStrip(triangles, colorIndices);
	      if (normalIndices != null)
		  normalIndices = expandTriStrip(triangles, normalIndices);
	      for (int i = 0 ; i < texCoordSetCount ; i++)
		  texCoordIndexSets[i] = expandTriStrip(triangles,
			      texCoordIndexSets[i]);
	      break;

	  case POLYGON_ARRAY:
	      if (tr == null) tr = new Triangulator();
	      tr.triangulate(this);
	      break;
      }

      prim = TRIANGLE_ARRAY;
      stripCounts = null;
  } // End of convertToIndexedTriangles



  /**
   * Get the current primitive.  Some of the utilities may change the
   * primitive type of the data stored in the GeometryInfo object
   * (for example, the stripifyer will change it to TRIANGLE_STRIP_ARRAY).
   */
  public int getPrimitive()
  {
      return prim;
  } // End of getPrimitive()



  /**
   * Set the current primitive.  Some of the utilities may change the
   * primitive type of the data stored in the GeometryInfo object
   * (for example, the stripifyer will change it to TRIANGLE_STRIP_ARRAY).
   * But the user can't change the primitive type - it is set in the
   * constructor.  Therefore, this method has package scope.
   */
  void setPrimitive(int primitive)
  {
      if ((prim >= TRIANGLE_ARRAY) && (prim <= POLYGON_ARRAY)) {
	  prim = primitive;
      } else {
	  throw new IllegalArgumentException(
		  J3dUtilsI18N.getString("GeometryInfo0"));
      }
  } // End of setPrimitive()



  /**
   * Sets the coordinates array.
   * No data copying is done because a reference to user data is used.
   */
  public void setCoordinates(Point3f coordinates[])
  {
      this.coordinates = coordinates;
  } // End of setCoordinates



  /**
   * Sets the coordinates array.
   * The points are copied into the GeometryInfo object.
   */
  public void setCoordinates(Point3d coordinates[])
  {
      if (coordinates == null) this.coordinates = null;
      else {
	  this.coordinates = new Point3f[coordinates.length];
	  for (int i = 0 ; i < coordinates.length ; i++) {
	      this.coordinates[i] = new Point3f(
		      (float)(coordinates[i].x),
		      (float)(coordinates[i].y),
		      (float)(coordinates[i].z));
	  }
      }
  } // End of setCoordinates



  /**
   * Sets the coordinates array.
   * The points are copied into the GeometryInfo object.
   */
  public void setCoordinates(float coordinates[])
  {
      if (coordinates == null) this.coordinates = null;
      else {
	  this.coordinates = new Point3f[coordinates.length / 3];
	  for (int i = 0 ; i < this.coordinates.length ; i++) {
	      this.coordinates[i] = new Point3f(coordinates[i * 3],
		      				coordinates[i * 3 + 1],
		      				coordinates[i * 3 + 2]);
	  }
      }
  } // End of setCoordinates



  /**
   * Sets the coordinates array.
   * The points are copied into the GeometryInfo object.
   */
  public void setCoordinates(double coordinates[])
  {
      if (coordinates == null) this.coordinates = null;
      else {
	  this.coordinates = new Point3f[coordinates.length / 3];
	  for (int i = 0 ; i < coordinates.length / 3 ; i++) {
	      this.coordinates[i] = new Point3f((float)coordinates[i * 3],
					        (float)coordinates[i * 3 + 1],
					        (float)coordinates[i * 3 + 2]);
	  }
      }
  } // End of setCoordinates



  /**
   * Retrieves a reference to the coordinate array.
   */
  public Point3f[] getCoordinates()
  {
      return coordinates;
  } // End of getCoordinates



  /**
   * Sets the colors array.
   * No data copying is done because a reference to
   * user data is used.
   */
  public void setColors(Color3f colors[])
  {
      colors3 = colors;
      colors4 = null;
  } // End of setColors



  /**
   * Sets the colors array.
   * No data copying is done because a reference to
   * user data is used.
   */
  public void setColors(Color4f colors[])
  {
      colors3 = null;
      colors4 = colors;
  } // End of setColors



  /**
   * Sets the colors array.
   * The points are copied into the GeometryInfo object.
   */
  public void setColors(Color3b colors[])
  {
      if (colors == null) {
	  colors3 = null;
	  colors4 = null;
      } else {
	  colors3 = new Color3f[colors.length];
	  colors4 = null;
	  for (int i = 0 ; i < colors.length ; i++) {
	      colors3[i] = new Color3f((float) (colors[i].x & 0xff) / 255.0f,
		      		       (float) (colors[i].y & 0xff) / 255.0f,
		      		       (float) (colors[i].z & 0xff) / 255.0f);
	  }
      }
  } // End of setColors



  /**
   * Sets the colors array.
   * The points are copied into the GeometryInfo object.
   */
  public void setColors(Color4b colors[])
  {
      if (colors == null) {
	  colors3 = null;
	  colors4 = null;
      } else {
	  colors3 = null;
	  colors4 = new Color4f[colors.length];
	  for (int i = 0 ; i < colors.length ; i++) {
	      colors4[i] = new Color4f((float) (colors[i].x & 0xff) / 255.0f,
		      		       (float) (colors[i].y & 0xff) / 255.0f,
		      		       (float) (colors[i].z & 0xff) / 255.0f,
		      		       (float) (colors[i].w & 0xff) / 255.0f);
	  }
      }
  } // End of setColors



  /**
   * Sets the colors array.
   * The points are copied into the GeometryInfo object, assuming
   * 3 components (R, G, and B) per vertex.
   */
  public void setColors3(float colors[])
  {
      if (colors == null) {
	  colors3 = null;
	  colors4 = null;
      } else {
	  colors3 = new Color3f[colors.length / 3];
	  colors4 = null;
	  for (int i = 0 ; i < colors.length / 3 ; i++) {
	      colors3[i] = new Color3f(colors[i * 3],
				       colors[i * 3 + 1],
				       colors[i * 3 + 2]);
	  }
      }
  } // End of setColors3



  /**
   * Sets the colors array.
   * The points are copied into the GeometryInfo object, assuming
   * 4 components (R, G, B, and A) per vertex.
   */
  public void setColors4(float colors[])
  {
      if (colors == null) {
	  colors3 = null;
	  colors4 = null;
      } else {
	  colors3 = null;
	  colors4 = new Color4f[colors.length / 4];
	  for (int i = 0 ; i < colors.length / 4 ; i++) {
	      colors4[i] = new Color4f(colors[i * 4],
		      		       colors[i * 4 + 1],
		      		       colors[i * 4 + 2],
		      		       colors[i * 4 + 3]);
	  }
      }
  } // End of setColors4



  /**
   * Sets the colors array.
   * The points are copied into the GeometryInfo object, assuming
   * 3 components (R, G, and B) per vertex.
   */
  public void setColors3(byte colors[])
  {
      if (colors == null) {
	  colors3 = null;
	  colors4 = null;
      } else {
	  colors3 = new Color3f[colors.length / 3];
	  colors4 = null;
	  for (int i = 0 ; i < colors.length / 3 ; i++) {
	      colors3[i] =
		  new Color3f((float)(colors[i * 3] & 0xff) / 255.0f,
		      	      (float)(colors[i * 3 + 1] & 0xff) / 255.0f,
			      (float)(colors[i * 3 + 2] & 0xff) / 255.0f);
	  }
      }
  } // End of setColors3



  /**
   * Sets the colors array.
   * The points are copied into the GeometryInfo object, assuming
   * 4 components (R, G, B, and A) per vertex.
   */
  public void setColors4(byte colors[])
  {
      if (colors == null) {
	  colors3 = null;
	  colors4 = null;
      } else {
	  colors3 = null;
	  colors4 = new Color4f[colors.length / 4];
	  for (int i = 0 ; i < colors.length / 4 ; i++) {
	      colors4[i] =
		  new Color4f((float)(colors[i * 4] & 0xff) / 255.0f,
			      (float)(colors[i * 4 + 1] & 0xff) / 255.0f,
			      (float)(colors[i * 4 + 2] & 0xff) / 255.0f,
			      (float)(colors[i * 4 + 3] & 0xff) / 255.0f);
	  }
      }
  } // End of setColors4



  /**
   * Retrieves a reference to the colors array.  Will be either
   * Color3f[] or Color4f[] depending on
   * the type of the input data.  Call
   * getNumColorComponents() to find out which version is returned.
   */
  public Object[] getColors()
  {
      if (colors3 != null) return colors3;
      else return colors4;
  } // End of getColors



  /**
   * Returns the number of color data components stored per vertex
   * in the current GeometryInfo object (3 for RGB or 4 for RGBA).
   * If no colors are currently defined, 0 is returned.
   */
  public int getNumColorComponents()
  {
      if (colors3 != null) return 3;
      else if (colors4 != null) return 4;
      else return 0;
  } // End of getNumColorComponents



  /**
   * Sets the normals array.
   * No data copying is done because a reference to
   * user data is used.
   */
  public void setNormals(Vector3f normals[])
  {
      this.normals = normals;
  } // End of setNormals



  /**
   * Sets the normals array.
   * The points are copied into the GeometryInfo object.
   */
  public void setNormals(float normals[])
  {
      if (normals == null) this.normals = null;
      else {
	  this.normals = new Vector3f[normals.length / 3];
	  for (int i = 0 ; i < this.normals.length ; i++) {
	      this.normals[i] = new Vector3f(normals[i * 3],
		      			     normals[i * 3 + 1],
		      			     normals[i * 3 + 2]);
	  }
      }
  } // End of setNormals(float[])



  /**
   * Retrieves a reference to the normal array.
   */
  public Vector3f[] getNormals()
  {
      return normals;
  } // End of getNormals



  /**
   * This method is used to specify the number of texture coordinate sets
   * and the dimensionality of the texture coordinates.
   * The number of texture coordinate sets must be specified to the GeometryInfo
   * class before any of the sets are specified. The dimensionality of the
   * texture coordinates may be 2, 3, or 4, corresponding to 2D, 3D, or 4D
   * texture coordinates respectively.(All sets must have the same
   * dimensionality.) The default is zero, 2D texture coordinate sets.
   * This method should be called before any texture coordinate sets are
   * specified because calling this method will delete all previously
   * specified texture coordinate and texture coordinate index arrays
   * associated with this GeometryInfo.  For example:
   * 
   *	geomInfo.setTextureCoordinateParams(2, 3);
   *	geomInfo.setTextureCoordinates(0, tex0);
   *	geomInfo.setTextureCoordinates(1, tex1);
   *	geomInfo.setTextureCoordinateParams(1, 2);
   *	geomInfo.getTexCoordSetCount();
   *