glVertexPointerEXT(3G)	       OpenGL Reference		glVertexPointerEXT(3G)



NAME
     glVertexPointerEXT	- define an array of vertex data


C SPECIFICATION
     void glVertexPointerEXT( GLint size,
			      GLenum type,
			      GLsizei stride,
			      GLsizei count,
			      const GLvoid *pointer )


PARAMETERS
     size     Specifies	the number of coordinates per vertex, must be 2,3, or
	      4.

     type     Specifies	the data type of each coordinate in the	array.
	      Symbolic constants GL_SHORT, GL_INT, GL_FLOAT, or	GL_DOUBLE_EXT
	      are accepted.

     stride   Specifies	the byte offset	between	consecutive vertexes. If
	      stride is	0 the vertexes are understood to be tightly packed in
	      the array.

     count    Specifies	the number of vertexes,	counting from the first, that
	      are static.

     pointer  Specifies	a pointer to the first coordinate of the first vertex
	      in the array.

DESCRIPTION
     glVertexPointerEXT	specifies the location and data	format of an array of
     vertex coordinates	to use when rendering using the	vertex array
     extension.	 size specifies	the number of coordinates per vertex and type
     the data type of the coordinates. stride gives the	byte stride from one
     vertex to the next	allowing vertexes and attributes to be packed into a
     single array or stored in separate	arrays.	 (Single-array storage may be
     more efficient on some implementations.)  count indicates the number of
     array elements (counting from the first) that are static. Static elements
     may be modified by	the application, but once they are modified, the
     application must explicitly respecify the array before using it for any
     rendering.	When a vertex array is specified, size,	type, stride, count,
     and pointer are saved as client-side state, and static array elements may
     be	cached by the implementation.

     The vertex	array is enabled and disabled using glEnable and glDisable
     with the argument GL_VERTEX_ARRAY_EXT. If enabled,	the vertex array is
     used when glDrawArraysEXT or glArrayElementEXT is called.

     Use glDrawArraysEXT to define a sequence of primitives (all of the	same
     type) from	pre-specified vertex and vertex	attribute arrays.  Use
     glArrayElementEXT to specify primitives by	indexing vertexes and vertex



									Page 1






glVertexPointerEXT(3G)	       OpenGL Reference		glVertexPointerEXT(3G)



     attributes.

NOTES
     Non-static	array elements are not accessed	until glArrayElementEXT	or
     glDrawArraysEXT is	executed.

     By	default	the vertex array is disabled and it won't be accessed when
     glArrayElementEXT or glDrawArraysEXT is called.


     Although it is not	an error to call glVertexPointerEXT between the
     execution of glBegin and the corresponding	execution of glEnd, the
     results are undefined.


     glVertexPointerEXT	will typically be implemented on the client side with
     no	protocol.


     Since the vertex array parameters are client side state, they are not
     saved or restored by glPushAttrib and glPopAttrib.


     glVertexPointerEXT	commands are not entered into display lists.


     glVertexPointerEXT	is part	of the EXT_vertex_array	extension, not part of
     the core GL command set. If GL_EXT_vertex_array is	included in the	string
     returned by glGetString, when called with argument	GL_EXTENSIONS,
     extension EXT_vertex_array	is supported.


ERRORS
     GL_INVALID_VALUE is generated if size is not 2, 3,	or 4.

     GL_INVALID_ENUM is	generated if type is is	not an accepted	value.

     GL_INVALID_VALUE is generated if stride or	count is negative.

ASSOCIATED GETS
     glIsEnabled with argument GL_VERTEX_ARRAY_EXT
     glGet with	argument GL_VERTEX_ARRAY_SIZE_EXT
     glGet with	argument GL_VERTEX_ARRAY_TYPE_EXT
     glGet with	argument GL_VERTEX_ARRAY_STRIDE_EXT
     glGet with	argument GL_VERTEX_ARRAY_COUNT_EXT
     glGetPointervEXT with argument GL_VERTEX_ARRAY_POINTER_EXT


MACHINE	DEPENDENCIES
     On	RealityEngine, RealityEngine2, and VTX systems,	do not enable or
     disable GL_VERTEX_ARRAY_EXT, GL_NORMAL_ARRAY_EXT, GL_COLOR_ARRAY_EXT,
     GL_INDEX_ARRAY_EXT, GL_TEXTURE_COORD_ARRAY_EXT, or	GL_EDGE_FLAG_ARRAY_EXT



									Page 2






glVertexPointerEXT(3G)	       OpenGL Reference		glVertexPointerEXT(3G)



     between a call to glNewList and the corresponding call to glEndList.
     Instead, enable or	disable	before the call	to glNewList.

     On	InfiniteReality	systems	it is particularly important to	minimize the
     amount of data transferred	from the application to	the graphics pipe,
     since the host-to-pipe bandwidth limit can	cause a	performance
     bottleneck.  One way to reduce the	amount of data transferred per vertex
     is	to use properly-aligned	byte and short data types whenever possible.
     Accordingly, the EXT_vertex_array extension on InfiniteReality systems
     has been optimized	for vertex information packed into the following data
     structures.  (Note: v represents vertex coordinates, c represents color
     components, n represents normal coordinates, and t	represents texture
     coordinates.  Normals must	have unit length.)

	  struct {GLfloat v[3];}
	  struct {GLubyte c[4];	GLfloat	v[3];}
	  struct {GLshort n[3];	GLfloat	v[3];}
	  struct {GLubyte c[4];	GLshort	n[3]; GLfloat v[3];}
	  struct {GLshort t[2];	GLfloat	v[3];}
	  struct {GLshort t[2];	GLubyte	c[4]; GLfloat v[3];}
	  struct {GLshort t[2];	GLshort	n[3]; GLfloat v[3];}
	  struct {GLshort t[2];	GLubyte	c[4]; GLshort n[3]; GLfloat v[3];}
	  struct {GLfloat t[2];	GLfloat	v[3];}
	  struct {GLfloat t[2];	GLubyte	c[4]; GLfloat v[3];}
	  struct {GLfloat t[2];	GLshort	n[3]; GLfloat v[3];}
	  struct {GLfloat t[2];	GLubyte	c[4]; GLshort n[3]; GLfloat v[3];}

     Application-specific fields may be	added to these structures, provided
     that all the fields described above retain	their relative order and word
     alignment.

     Using these structures on InfiniteReality systems can improve performance
     considerably, compared to structures in which all values are single-
     precision floating	point.

     Note that there is	a bug on InfiniteReality systems that prevents using
     the current normal	for all	the primitives defined by a vertex array.
     This should be a very rare	case, but will be fixed	in a future release.


SEE ALSO
     glArrayElementEXT,	glColorPointerEXT, glDrawArraysEXT,
     glEdgeFlagPointerEXT, glEnable, glGetPointervEXT, glIndexPointerEXT,
     glNormalPointerEXT, glTexCoordPointerEXT











									Page 3