GL Man Pages


glBegin

Name

  glBegin, glEnd - delimit the vertices	of a primitive or a group of like
  primitives

C Specification

  void glBegin(	GLenum mode )

Parameters

  mode	Specifies the primitive	or primitives that will	be created from
	vertices presented between glBegin and the subsequent glEnd.  Ten
	symbolic constants are accepted: GL_POINTS, GL_LINES, GL_LINE_STRIP,
	GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN,
	GL_QUADS, GL_QUAD_STRIP, and GL_POLYGON.

C Specification

  void glEnd( void )

Description

  glBegin and glEnd delimit the	vertices that define a primitive or a group
  of like primitives.  glBegin accepts a single	argument that specifies	which
  of ten ways the vertices are interpreted.  Taking n as an integer count
  starting at one, and N as the	total number of	vertices specified, the
  interpretations are as follows:

  GL_POINTS Treats each	vertex as a single point.  Vertex n defines point n.
	    N points are drawn.

  GL_LINES  Treates each pair of vertices as an	independent line segment.
	    Vertices 2n-1 and 2n define	line n.	 N/2 lines are drawn.

  GL_LINE_STRIP
	    Draws a connected group of line segments from the first vertex to
	    the	last.  Vertices	n and n+1 define line n.  N-1 lines are
	    drawn.

  GL_LINE_LOOP
	    Draws a connected group of line segments from the first vertex to
	    the	last, then back	to the first.  Vertices	n and n+1 define line
	    n.	The last line, however,	is defined by vertices N and 1.	 N
	    lines are drawn.

  GL_TRIANGLES
	    Treates each triplet of vertices as	an independent triangle.
	    Vertices 3n-2, 3n-1, and 3n	define triangle	n.  N/3	triangles are
	    drawn.

  GL_TRIANGLE_STRIP
	    Draws a connected group of triangles.  One triangle	is defined
	    for	each vertex presented after the	first two vertices.  For odd
	    n, vertices	n, n+1,	and n+2	define triangle	n.  For	even n,
	    vertices n+1, n, and n+2 define triangle n.	 N-2 triangles are
	    drawn.

  GL_TRIANGLE_FAN
	    Draws a connected group of triangles.  One triangle	is defined
	    for	each vertex presented after the	first two vertices.  Vertices
	    1, n+1, and	n+2 define triangle n.	N-2 triangles are drawn.

  GL_QUADS  Treats each	group of four vertices as an independent
	    quadrilateral.  Vertices 4n-3, 4n-2, 4n-1, and 4n define
	    quadrilateral n.  N/4 quadrilaterals are drawn.

  GL_QUAD_STRIP
	    Draws a connected group of quadrilaterals.	One quadrilateral is
	    defined for	each pair of vertices presented	after the first	pair.
	    Vertices 2n-1, 2n, 2n+2, and 2n+1 define quadrilateral n.  N/2-1
	    quadrilaterals are drawn.  Note that the order in which vertices
	    are	used to	construct a quadrilateral from strip data is
	    different from that	used with independent data.

  GL_POLYGON
	    Draws a single, convex polygon.  Vertices 1	through	N define this
	    polygon.

  Only a subset	of GL commands can be used between glBegin and glEnd.  The
  commands are glVertex, glColor, glIndex, glNormal, glTexCoord, glEvalCoord,
  glEvalPoint, glMaterial, and glEdgeFlag.  Also, it is	acceptable to use
  glCallList or	glCallLists to execute display lists that include only the
  preceding commands.  If any other GL command is executed between glBegin
  and glEnd, the error flag is set and the command is ignored.

  Regardless of	the value chosen for mode, there is no limit to	the number of
  vertices that	can be defined between glBegin and glEnd.  Lines, triangles,
  quadrilaterals, and polygons that are	incompletely specified are not drawn.
  Incomplete specification results when	either too few vertices	are provided
  to specify even a single primitive or	when an	incorrect multiple of
  vertices is specified. The incomplete	primitive is ignored; the rest are
  drawn.

  The minimum specification of vertices	for each primitive is as follows: 1
  for a	point, 2 for a line, 3 for a triangle, 4 for a quadrilateral, and 3
  for a	polygon.  Modes	that require a certain multiple	of vertices are
  GL_LINES (2),	GL_TRIANGLES (3), GL_QUADS (4),	and GL_QUAD_STRIP (2).


glCallList


Name

  glCallList - execute a display list

C Specification

  void glCallList( GLuint list )

Parameters

  list	Specifies the integer name of the display list to be executed.

Description

  glCallList causes the	named display list to be executed.  The	commands
  saved	in the display list are	executed in order, just	as if they were
  called without using a display list.	If list	has not	been defined as	a
  display list,	glCallList is ignored.

  glCallList can appear	inside a display list.	To avoid the possibility of
  infinite recursion resulting from display lists calling one another, a
  limit	is placed on the nesting level of display lists	during display-list
  execution.  This limit is at least 64, and it	depends	on the
  implementation.

  GL state is not saved	and restored across a call to glCallList.  Thus,
  changes made to GL state during the execution	of a display list remain
  after	execution of the display list is completed.  Use glPushMatrix, and              glPopMatrix to preserve GL state across glCallList calls.


glClearColor

Name

  glClearColor - specify clear values for the color buffers

C Specification

  void glClearColor( GLclampf red,
		     GLclampf green,
		     GLclampf blue,
		     GLclampf alpha )

Parameters

  red, green, blue, alpha
			Specify	the red, green,	blue, and alpha	values used
			when the color buffers are cleared.  The default
			values are all zero.

Description

  glClearColor specifies the red, green, blue, and alpha values	used by
  glClear to clear the color buffers.  Values specified	by glClearColor	are
  clamped to the range [0,1].

Errors

  GL_INVALID_OPERATION is generated if glClearColor is executed	between	the
  execution of glBegin and the corresponding execution of glEnd.

 


glClear

Name

  glClear - clear buffers to preset values

C Specification

  void glClear(	GLbitfield mask	)

Parameters

  mask	Bitwise	OR of masks that indicate the buffers to be cleared.  The
	four masks are GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT,
	GL_ACCUM_BUFFER_BIT, and GL_STENCIL_BUFFER_BIT.

Description

  glClear sets the bitplane area of the	window to values previously selected
  by glClearColor, glClearIndex, glClearDepth, glClearStencil, and
  glClearAccum.	 Multiple color	buffers	can be cleared simultaneously by
  selecting more than one buffer at a time using glDrawBuffer.

  The pixel ownership test, the	scissor	test, dithering, and the buffer
  writemasks affect the	operation of glClear.  The scissor box bounds the
  cleared region.  Alpha function, blend function, logical operation,
  stenciling, texture mapping, and z-buffering are ignored by glClear.

  glClear takes	a single argument that is the bitwise OR of several values
  indicating which buffer is to	be cleared.

  The values are as follows:

  GL_COLOR_BUFFER_BIT	      Indicates	the buffers currently enabled for
			      color  writing.

  GL_DEPTH_BUFFER_BIT	      Indicates	the depth buffer.

  GL_ACCUM_BUFFER_BIT	      Indicates	the accumulation buffer.

  GL_STENCIL_BUFFER_BIT	      Indicates	the stencil buffer.

  The value to which each buffer is cleared depends on the setting of the
  clear	value for that buffer.

 


glClearDepth

Name

  glClearDepth - specify the clear value for the depth buffer

C Specification

  void glClearDepth( GLclampd depth )

Parameters

  depth	 Specifies the depth value used	when the depth buffer is cleared.

Description

  glClearDepth specifies the depth value used by glClear to clear the depth
  buffer.  Values specified by glClearDepth are	clamped	to the range [0,1].


glColor

Name

  glColor3b, glColor3d,	glColor3f, glColor3i, glColor3s, glColor3ub,
  glColor3ui, glColor3us, glColor4b, glColor4d,	glColor4f, glColor4i,
  glColor4s, glColor4ub, glColor4ui, glColor4us, glColor3bv, glColor3dv,
  glColor3fv, glColor3iv, glColor3sv, glColor3ubv, glColor3uiv,	glColor3usv,
  glColor4bv, glColor4dv, glColor4fv, glColor4iv, glColor4sv, glColor4ubv,
  glColor4uiv, glColor4usv - set the current color

C Specification

  void glColor3b( GLbyte red,
		  GLbyte green,
		  GLbyte blue )
  void glColor3d( GLdouble red,
		  GLdouble green,
		  GLdouble blue	)
  void glColor3f( GLfloat red,
		  GLfloat green,
		  GLfloat blue )
  void glColor3i( GLint	red,
		  GLint	green,
		  GLint	blue )
  void glColor3s( GLshort red,
		  GLshort green,
		  GLshort blue )
  void glColor3ub( GLubyte red,
		   GLubyte green,
		   GLubyte blue	)
  void glColor3ui( GLuint red,
		   GLuint green,
		   GLuint blue )
  void glColor3us( GLushort red,
		   GLushort green,
		   GLushort blue )
  void glColor4b( GLbyte red,
		  GLbyte green,
		  GLbyte blue,
		  GLbyte alpha )
  void glColor4d( GLdouble red,
		  GLdouble green,
		  GLdouble blue,
		  GLdouble alpha )
  void glColor4f( GLfloat red,
		  GLfloat green,
		  GLfloat blue,
		  GLfloat alpha	)
  void glColor4i( GLint	red,
		  GLint	green,
		  GLint	blue,
		  GLint	alpha )
  void glColor4s( GLshort red,
		  GLshort green,
		  GLshort blue,
		  GLshort alpha	)
  void glColor4ub( GLubyte red,
		   GLubyte green,
		   GLubyte blue,
		   GLubyte alpha )
  void glColor4ui( GLuint red,
		   GLuint green,
		   GLuint blue,
		   GLuint alpha	)
  void glColor4us( GLushort red,
		   GLushort green,
		   GLushort blue,
		   GLushort alpha )

Parameters

  red, green, blue
		  Specify new red, green, and blue values for the current
		  color.

  alpha		  Specifies a new alpha	value for the current color.
		  Included only	in the four-argument glColor4 command.

C Specification

  void glColor3bv( const GLbyte	*v )
  void glColor3dv( const GLdouble *v )
  void glColor3fv( const GLfloat *v )
  void glColor3iv( const GLint *v )
  void glColor3sv( const GLshort *v )
  void glColor3ubv( const GLubyte *v )
  void glColor3uiv( const GLuint *v )
  void glColor3usv( const GLushort *v )
  void glColor4bv( const GLbyte	*v )
  void glColor4dv( const GLdouble *v )
  void glColor4fv( const GLfloat *v )
  void glColor4iv( const GLint *v )
  void glColor4sv( const GLshort *v )
  void glColor4ubv( const GLubyte *v )
  void glColor4uiv( const GLuint *v )
  void glColor4usv( const GLushort *v )

Parameters

  v    Specifies a pointer to an array that contains red, green, blue, and
       (sometimes) alpha values.

Description

  The GL stores	both a current single-valued color index and a current four-
  valued RGBA color.  glColor sets a new four-valued RGBA color.  glColor has
  two major variants: glColor3 and glColor4.  glColor3 variants	specify	new
  red, green, and blue values explicitly, and set the current alpha value to
  1.0 implicitly.  glColor4 variants specify all four color components
  explicitly.

  glColor3b, glColor4b,	glColor3s, glColor4s, glColor3i, and glColor4i take
  three	or four	signed byte, short, or long integers as	arguments.  When v is
  appended to the name,	the color commands can take a pointer to an array of
  such values.

  Current color	values are stored in floating-point format, with unspecified
  mantissa and exponent	sizes.	Unsigned integer color components, when
  specified, are linearly mapped to floating-point values such that the
  largest representable	value maps to 1.0 (full	intensity), and	zero maps to
  0.0 (zero intensity).	 Signed	integer	color components, when specified, are
  linearly mapped to floating-point values such	that the most positive
  representable	value maps to 1.0, and the most	negative representable value
  maps to -1.0.	 Floating-point	values are mapped directly.


  Neither floating-point nor signed integer values are clamped to the range
  [0,1]	before updating	the current color.  However, color components are
  clamped to this range	before they are	interpolated or	written	into a color
  buffer.


glEnable

Name

  glEnable, glDisable -	enable or disable GL capabilities

C Specification

  void glEnable( GLenum	cap )

Parameters

  cap  Specifies a symbolic constant indicating	a GL capability.

C Specification

  void glDisable( GLenum cap )

Parameters

  cap  Specifies a symbolic constant indicating	a GL capability.

Description

  glEnable and glDisable enable	and disable various capabilities.  Use
  glIsEnabled or glGet to determine the	current	setting	of any capability.

  Both glEnable	and glDisable take a single argument, cap, which can assume
  one of the following values:


  GL_DEPTH_TEST		   If enabled, do depth	comparisons and	update the
			   depth buffer.

  GL_LIGHTi		   If enabled, include light i in the evaluation of
			   the lighting	equation.  See glLightModel and
			   glLight.

  GL_LIGHTING		   If enabled, use the current lighting	parameters to
			   compute the vertex color or index.  Otherwise,
			   simply associate the	current	color or index with
			   each	vertex.	 


glNewList

Name

  glNewList, glEndList - create	or replace a display list

C Specification

  void glNewList( GLuint list,
		  GLenum mode )

Parameters

  list	Specifies the display list name.

  mode	Specifies the compilation mode,	which can be GL_COMPILE	or
	GL_COMPILE_AND_EXECUTE.

C Specification

  void glEndList( void )

Description

  Display lists	are groups of GL commands that have been stored	for
  subsequent execution.	 The display lists are created with glNewList.	All
  subsequent commands are placed in the	display	list, in the order issued,
  until	glEndList is called.

  glNewList has	two arguments.	The first argument, list, is a positive
  integer that becomes the unique name for the display list.  Names can	be
  created and reserved with glGenLists and tested for uniqueness with
  glIsList.  The second	argument, mode,	is a symbolic constant that can
  assume one of	two values:

  GL_COMPILE	      Commands are merely compiled.

  GL_COMPILE_AND_EXECUTE
		      Commands are executed as they are	compiled into the
		      display list.

  Certain commands are not compiled into the display list, but are executed
  immediately, regardless of the display-list mode.  

  When glEndList is encountered, the display-list definition is	completed by
  associating the list with the	unique name list (specified in the glNewList
  command). If a display list with name	list already exists, it	is replaced
  only when glEndList is called.


glFlush

Name

  glFlush - force execution of GL commands in finite time

C Specification

  void glFlush(	void )

Description

  Different GL implementations buffer commands in several different
  locations, including network buffers and the graphics	accelerator itself.
  glFlush empties all of these buffers,	causing	all issued commands to be
  executed as quickly as they are accepted by the actual rendering engine.
  Though this execution	may not	be completed in	any particular time period,
  it does complete in finite time.

  Because any GL program might be executed over	a network, or on an
  accelerator that buffers commands, all programs should call glFlush
  whenever they	count on having	all of their previously	issued commands
  completed.  For example, call	glFlush	before waiting for user	input that
  depends on the generated image.

 


glFrustum

Name

  glFrustum - multiply the current matrix by a perspective matrix

C Specification

  void glFrustum( GLdouble left,
		  GLdouble right,
		  GLdouble bottom,
		  GLdouble top,
		  GLdouble near,
		  GLdouble far )

Parameters

  left,	right Specify the coordinates for the left and right vertical
	      clipping planes.

  bottom, top Specify the coordinates for the bottom and top horizontal
	      clipping planes.

  near,	far   Specify the distances to the near	and far	depth clipping
	      planes.  Both distances must be positive.

Description

  glFrustum describes a	perspective matrix that	produces a perspective
  projection.  (left, bottom, -near) and (right, top,  -near) specify the
  points on the	near clipping plane that are mapped to the lower left and
  upper	right corners of the window, respectively, assuming that the eye is
  located at (0, 0, 0).	 -far specifies	the location of	the far	clipping
  plane.  Both near and	far must be positive.  The corresponding matrix	is

		   |					   |
		   |    2·near  			   |
                   |  ----------                           |
		   |  right-left       0       A       0   |
		   |					   |
		   |	  0	    2·near     B       0   |
		   |              ----------               |
		   |		  top-bottom		   |
		   |	  0	       0       C       D   |
		   |					   |
		   |	  0	       0       -1      0   |

				    right+left
				A = ----------
				    right-left

				    top+bottom
				B = ----------
				    top-bottom

				      far+near
				C = - --------
				      far-near

				      2·far·near
				D = - ----------
				       far-near


  The current matrix is	multiplied by this matrix with the result replacing
  the current matrix.  That is,	if M is	the current matrix and F is the
  frustum perspective matrix, then M is	replaced with M·F.

  Use glPushMatrix and glPopMatrix to save and restore the current matrix
  stack.

 


glGet

Name

  glGetBooleanv, glGetDoublev, glGetFloatv, glGetIntegerv - return the value
  or values of a selected parameter

C Specification

  void glGetBooleanv( GLenum pname,
		      GLboolean	*params	)

C Specification

  void glGetDoublev( GLenum pname,
		     GLdouble *params )

C Specification

  void glGetFloatv( GLenum pname,
		    GLfloat *params )

C Specification

  void glGetIntegerv( GLenum pname,
		      GLint *params )

Parameters

  pname	  Specifies the	parameter value	to be returned.	 The symbolic
	  constants in the list	below are accepted.

  params  Returns the value or values of the specified parameter.

Description

  These	four commands return values for	simple state variables in GL. pname
  is a symbolic	constant indicating the	state variable to be returned, and
  params is a pointer to an array of the indicated type	in which to place the
  returned data.

  Type conversion is performed if params has a different type than the state
  variable value being requested.  If glGetBooleanv is called, a floating-
  point	or integer value is converted to GL_FALSE if and only if it is zero.
  Otherwise, it	is converted to	GL_TRUE.  If glGetIntegerv is called, Boolean
  values are returned as GL_TRUE or GL_FALSE, and most floating-point values
  are rounded to the nearest integer value.  Floating-point colors and
  normals, however, are	returned with a	linear mapping that maps 1.0 to	the
  most positive	representable integer value, and -1.0 to the most negative
  representable	integer	value.	If glGetFloatv or glGetDoublev is called,
  Boolean values are returned as GL_TRUE or GL_FALSE, and integer values are
  converted to floating-point values.

  The following	symbolic constants are accepted	by pname:

  
  GL_DEPTH_CLEAR_VALUE	   params returns one value, the value that is used
			   to clear the	depth buffer.  Integer values, if
			   requested, are linearly mapped from the internal
			   floating-point representation such that 1.0
			   returns the most positive representable integer
			   value, and -1.0 returns the most negative
			   representable integer value.	

  GL_DEPTH_FUNC		   params returns one value, the symbolic constant
			   that	indicates the depth comparison function.  

  GL_DEPTH_TEST		   params returns a single Boolean value indicating
			   whether depth testing of fragments is enabled.
			
  GL_LIGHTi		   params returns a single Boolean value indicating
			   whether the specified light is enabled.  See
			   glLight.

  GL_LIGHTING		   params returns a single Boolean value indicating
			   whether lighting is enabled.	

  GL_MODELVIEW_MATRIX	   params returns sixteen values: the modelview
			   matrix on the top of	the modelview matrix stack.
			   See glPushMatrix.

  GL_MODELVIEW_STACK_DEPTH params returns one value, the number	of matrices
			   on the modelview matrix stack.  See glPushMatrix.

  GL_NAME_STACK_DEPTH	   params returns one value, the number	of names on
			   the selection name stack.  See glPushMatrix.

  GL_PROJECTION_MATRIX	   params returns sixteen values: the projection
			   matrix on the top of	the projection matrix stack.
			   See glPushMatrix.

  GL_PROJECTION_STACK_DEPTH
			   params returns one value, the number	of matrices
			   on the projection matrix stack.  See	glPushMatrix.

  GL_RENDER_MODE	   params returns one value, a symbolic	constant
			   indicating whether the GL is	in render, select, or
			   feedback mode.  See glRenderMode.

  GL_RGBA_MODE		   params returns a single Boolean value indicating
			   whether the GL is in	RGBA mode (true) or color
			   index mode (false).	See glColor.


glInitNames

Name

  glInitNames -	initialize the name stack

C Specification

  void glInitNames( void )

Description

  The name stack is used during	selection mode to allow	sets of	rendering
  commands to be uniquely identified.  It consists of an ordered set of
  unsigned integers.  glInitNames causes the name stack	to be initialized to
  its default empty state.

  The name stack is always empty while the render mode is not GL_SELECT.
  Calls	to glInitNames while the render	mode is	not GL_SELECT are ignored.

 


glLight

Name

  glLightf, glLighti, glLightfv, glLightiv - set light source parameters

C Specification

  void glLightf( GLenum	light,
		 GLenum	pname,
		 GLfloat param )
  void glLighti( GLenum	light,
		 GLenum	pname,
		 GLint param )

Parameters

  light	  Specifies a light.  The number of lights is depends on the
	  implementation, but at least eight lights are	supported.  They are
	  identified by	symbolic names of the form GL_LIGHTi where 0 <= i <
	  GL_MAX_LIGHTS.

  pname	  Specifies a single-valued light source parameter for light.
	  GL_SPOT_EXPONENT, GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION,
	  GL_LINEAR_ATTENUATION	, and GL_QUADRATIC_ATTENUATION are accepted.

  param	  Specifies the	value that parameter pname of light source light will
	  be set to.

C Specification

  void glLightfv( GLenum light,
		  GLenum pname,
		  const	GLfloat	*params	)
  void glLightiv( GLenum light,
		  GLenum pname,
		  const	GLint *params )

Parameters

  light
       Specifies a light.  The number of lights	depends	on the
       implementation, but at least eight lights are supported.	 They are
       identified by symbolic names of the form	GL_LIGHTi where	0 <= i <
       GL_MAX_LIGHTS.

  pname
       Specifies a light source	parameter for light.  GL_AMBIENT, GL_DIFFUSE,
       GL_SPECULAR, GL_POSITION, GL_SPOT_DIRECTION, GL_SPOT_EXPONENT,
       GL_SPOT_CUTOFF, GL_CONSTANT_ATTENUATION,	GL_LINEAR_ATTENUATION, and
       GL_QUADRATIC_ATTENUATION	are accepted.

  params
       Specifies a pointer to the value	or values that parameter pname of
       light source light will be set to.

Description

  glLight sets the values of individual	light source parameters.  light	names
  the light and	is a symbolic name of the form GL_LIGHTi, where	0 <= i <
  GL_MAX_LIGHTS.  pname	specifies one of ten light source parameters, again
  by symbolic name.  params is either a	single value or	a pointer to an	array
  that contains	the new	values.

  Lighting calculation is enabled and disabled using glEnable and glDisable
  with argument	GL_LIGHTING.  When lighting is enabled,	light sources that
  are enabled contribute to the	lighting calculation.  Light source i is
  enabled and disabled using glEnable and glDisable with argument GL_LIGHTi.

  The ten light	parameters are as follows:

  GL_AMBIENT	      params contains four integer or floating-point values
		      that specify the ambient RGBA intensity of the light.
		      Integer values are mapped	linearly such that the most
		      positive representable value maps	to 1.0,	and the	most
		      negative representable value maps	to -1.0.  Floating-
		      point values are mapped directly.	 Neither integer nor
		      floating-point values are	clamped.  The default ambient
		      light intensity is (0.0, 0.0, 0.0, 1.0).

  GL_DIFFUSE	      params contains four integer or floating-point values
		      that specify the diffuse RGBA intensity of the light.
		      Integer values are mapped	linearly such that the most
		      positive representable value maps	to 1.0,	and the	most
		      negative representable value maps	to -1.0.  Floating-
		      point values are mapped directly.	 Neither integer nor
		      floating-point values are	clamped.  The default diffuse
		      intensity	is (0.0, 0.0, 0.0, 1.0)	for all	lights other
		      than light zero.	The default diffuse intensity of
		      light zero is (1.0, 1.0, 1.0, 1.0).

  GL_SPECULAR	      params contains four integer or floating-point values
		      that specify the specular	RGBA intensity of the light.
		      Integer values are mapped	linearly such that the most
		      positive representable value maps	to 1.0,	and the	most
		      negative representable value maps	to -1.0.  Floating-
		      point values are mapped directly.	 Neither integer nor
		      floating-point values are	clamped.  The default
		      specular intensity is (0.0, 0.0, 0.0, 1.0) for all
		      lights other than	light zero.  The default specular
		      intensity	of light zero is (1.0, 1.0, 1.0, 1.0).

  GL_POSITION	      params contains four integer or floating-point values
		      that specify the position	of the light in	homogeneous
		      object coordinates.  Both	integer	and floating-point
		      values are mapped	directly.  Neither integer nor
		      floating-point values are	clamped.

		      The position is transformed by the modelview matrix
		      when glLight is called (just as if it were a point),
		      and it is	stored in eye coordinates.  If the w
		      component	of the position	is 0.0,	the light is treated
		      as a directional source.	Diffuse	and specular lighting
		      calculations take	the light's direction, but not its
		      actual position, into account, and attenuation is
		      disabled.	 Otherwise, diffuse and	specular lighting
		      calculations are based on	the actual location of the
		      light in eye coordinates,	and attenuation	is enabled.
		      The default position is (0,0,1,0); thus, the default
		      light source is directional, parallel to,	and in the
		      direction	of the -z axis.


glLineWidth


Name

  glLineWidth -	specify	the width of rasterized	lines

C Specification

  void glLineWidth( GLfloat width )

Parameters

  width	 Specifies the width of	rasterized lines.  The default is 1.0.

Description

  glLineWidth specifies	the rasterized width of	both aliased and antialiased
  lines.  Using	a line width other than	1.0 has	different effects, depending
  on whether line antialiasing is enabled.  Line antialiasing is controlled
  by calling glEnable and glDisable with argument GL_LINE_SMOOTH.

  If line antialiasing is disabled, the	actual width is	determined by
  rounding the supplied	width to the nearest integer.  (If the rounding
  results in the value 0, it is	as if the line width were 1.) If |dx| >= |dy|,
  i pixels are filled in each column that is rasterized, where i is the
  rounded value	of width.  Otherwise, i	pixels are filled in each row that is
  rasterized.

  If antialiasing is enabled, line rasterization produces a fragment for each
  pixel	square that intersects the region lying	within the rectangle having
  width	equal to the current line width, length	equal to the actual length of
  the line, and	centered on the	mathematical line segment.  The	coverage
  value	for each fragment is the window	coordinate area	of the intersection
  of the rectangular region with the corresponding pixel square.  This value
  is saved and used in the final rasterization step.

  Not all widths can be	supported when line antialiasing is enabled. If	an
  unsupported width is requested, the nearest supported	width is used.	Only
  width	1.0 is guaranteed to be	supported; others depend on the
  implementation.  The range of	supported widths and the size difference
  between supported widths within the range can	be queried by calling glGet
  with arguments GL_LINE_WIDTH_RANGE and GL_LINE_WIDTH_GRANULARITY.


glLoadIdentity

Name

  glLoadIdentity - replace the current matrix with the identity	matrix

C Specification

  void glLoadIdentity( void )

Description

  glLoadIdentity replaces the current matrix with the identity matrix.	It is
  semantically equivalent to calling glLoadMatrix with the identity matrix


			      |	1   0	0   0  |
			      |		       |
			      |	0   1	0   0  |
			      |	0   0	1   0  |
			      |		       |
			      |	0   0	0   1  |

  but in some cases it is more efficient.

 


glLoadName

Name

  glLoadName - load a name onto	the name stack

C Specification

  void glLoadName( GLuint name )

Parameters

  name	Specifies a name that will replace the top value on the	name stack.

Description

  The name stack is used during	selection mode to allow	sets of	rendering
  commands to be uniquely identified.  It consists of an ordered set of
  unsigned integers.  glLoadName causes	name to	replace	the value on the top
  of the name stack, which is initially	empty.

  The name stack is always empty while the render mode is not GL_SELECT.
  Calls	to glLoadName while the	render mode is not GL_SELECT are ignored.


glMatrixMode

Name

  glMatrixMode - specify which matrix is the current matrix

C Specification

  void glMatrixMode( GLenum mode )

Parameters

  mode	Specifies which	matrix stack is	the target for subsequent matrix
	operations.  Three values are accepted:	GL_MODELVIEW, GL_PROJECTION,
	and GL_TEXTURE.	 The default value is GL_MODELVIEW.

Description

  glMatrixMode sets the	current	matrix mode.  mode can assume one of three
  values:

  GL_MODELVIEW	      Applies subsequent matrix	operations to the modelview
		      matrix stack.

  GL_PROJECTION	      Applies subsequent matrix	operations to the projection
		      matrix stack.

 


glOrtho

Name

  glOrtho - multiply the current matrix	by an orthographic matrix

C Specification

  void glOrtho(	GLdouble left,
		GLdouble right,
		GLdouble bottom,
		GLdouble top,
		GLdouble near,
		GLdouble far )

Parameters

  left,	right Specify the coordinates for the left and right vertical
	      clipping planes.

  bottom, top Specify the coordinates for the bottom and top horizontal
	      clipping planes.

  near,	far   Specify the distances to the nearer and farther depth clipping
	      planes.  These distances are negative if the plane is to be
	      behind the viewer.

Description

  glOrtho describes a perspective matrix that produces a parallel projection.
  (left, bottom,  -near) and (right, top,  -near) specify the points on	the
  near clipping	plane that are mapped to the lower left	and upper right
  corners of the window, respectively, assuming	that the eye is	located	at
  (0, 0, 0).  -far specifies the location of the far clipping plane.  Both
  near and far can be either positive or negative.  The	corresponding matrix
  is

		    |     2	     		          |
		    |----------      0          0      t  |
		    |right-left				x |
		    |					  |
		    |		      2    		  |
		    |    0       ----------	0      t  |
		    |	  	 top-bottom	        y |
		    |                                     |
		    |					  |
		    |	 0	     0	        -2        |
		    |                        --------  t  |
		    |			     far-near	z |
		    |                                     |
		    |	 0	     0		0      1  |

  where
			              right+left
			       t  = - ----------
				x     right-left

				      top+bottom
			       t  = - ----------
				y     top-bottom

				       far+near
				t  = - --------
				 z     far-near

  The current matrix is	multiplied by this matrix with the result replacing
  the current matrix.  That is,	if M is	the current matrix and O is the	ortho
  matrix, then M is replaced with M · O.

  Use glPushMatrix and glPopMatrix to save and restore the current matrix
  stack.


glPointSize

 

Name

  glPointSize -	specify	the diameter of	rasterized points

C Specification

  void glPointSize( GLfloat size )

Parameters

  size	Specifies the diameter of rasterized points.  The default is 1.0.

Description

  glPointSize specifies	the rasterized diameter	of both	aliased	and
  antialiased points.  Using a point size other	than 1.0 has different
  effects, depending on	whether	point antialiasing is enabled.	Point
  antialiasing is controlled by	calling	glEnable and glDisable with argument
  GL_POINT_SMOOTH.

  If point antialiasing	is disabled, the actual	size is	determined by
  rounding the supplied	size to	the nearest integer.  (If the rounding
  results in the value 0, it is	as if the point	size were 1.) If the rounded
  size is odd, then the	center point (x, y) of the pixel fragment that
  represents the point is computed as

		    ( floor(x )+.5, floor(y )+.5 )
			     w	           w

  where	w subscripts indicate window coordinates.  All pixels that lie within
  the square grid of the rounded size centered at (x, y) make up the
  fragment.  If	the size is even, the center point is

		    ( floor(x +.5), floor(y +.5) )
			     w	           w

  and the rasterized fragment's	centers	are the	half-integer window
  coordinates within the square	of the rounded size centered at	(x, y).	 All
  pixel	fragments produced in rasterizing a nonantialiased point are assigned
  the same associated data, that of the	vertex corresponding to	the point.

  If antialiasing is enabled, then point rasterization produces	a fragment
  for each pixel square	that intersects	the region lying within	the circle
  having diameter equal	to the current point size and centered at the point's
  (x , y ).  The coverage value	for each fragment is the window	coordinate
    w   w
  area of the intersection of the circular region with the corresponding
  pixel	square.	 This value is saved and used in the final rasterization
  step.	The data associated with each fragment is the data associated with
  the point being rasterized.

  Not all sizes	are supported when point antialiasing is enabled. If an
  unsupported size is requested, the nearest supported size is used.  Only
  size 1.0 is guaranteed to be supported; others depend	on the
  implementation.  The range of	supported sizes	and the	size difference
  between supported sizes within the range can be queried by  calling glGet
  with arguments GL_POINT_SIZE_RANGE and GL_POINT_SIZE_GRANULARITY.


glPushMatrix

Name

  glPushMatrix,	glPopMatrix - push and pop the current matrix stack

C Specification

  void glPushMatrix( void )

C Specification

  void glPopMatrix( void )

Description

  There	is a stack of matrices for each	of the matrix modes.  In GL_MODELVIEW
  mode,	the stack depth	is at least 32.	 In the	other two modes,
  GL_PROJECTION	and GL_TEXTURE,	the depth is at	least 2.  The current matrix
  in any mode is the matrix on the top of the stack for	that mode.

  glPushMatrix pushes the current matrix stack down by one, duplicating	the
  current matrix.  That	is, after a glPushMatrix call, the matrix on the top
  of the stack is identical to the one below it.

  glPopMatrix pops the current matrix stack, replacing the current matrix
  with the one below it	on the stack.

  Initially, each of the stacks	contains one matrix, an	identity matrix.

  It is	an error to push a full	matrix stack, or to pop	a matrix stack that
  contains only	a single matrix.  In either case, the error flag is set	and
  no other change is made to GL	state.


glPushName

Name

  glPushName, glPopName	- push and pop the name	stack

C Specification

  void glPushName( GLuint name )

Parameters

  name	Specifies a name that will be pushed onto the name stack.

C Specification

  void glPopName( void )

Description

  The name stack is used during	selection mode to allow	sets of	rendering
  commands to be uniquely identified.  It consists of an ordered set of
  unsigned integers.  glPushName causes	name to	be pushed onto the name
  stack, which is initially empty.  glPopName pops one name off	the top	of
  the stack.

  It is	an error to push a name	onto a full stack, or to pop a name off	an
  empty	stack.	It is also an error to manipulate the name stack between the
  execution of glBegin and the corresponding execution of glEnd.  In any of
  these	cases, the error flag is set and no other change is made to GL state.

  The name stack is always empty while the render mode is not GL_SELECT.
  Calls	to glPushName or glPopName while the render mode is not	GL_SELECT are
  ignored.

 


glRenderMode

Name

  glRenderMode - set rasterization mode

C Specification

  GLint	glRenderMode( GLenum mode )

Parameters

  mode	Specifies the rasterization mode.  Three values	are accepted:
	GL_RENDER, GL_SELECT, and GL_FEEDBACK.	The default value is
	GL_RENDER.

Description

  glRenderMode sets the	rasterization mode.  It	takes one argument, mode,
  which	can assume one of three	predefined values:

  GL_RENDER	  Render mode. Primitives are rasterized, producing pixel
		  fragments, which are written into the	frame buffer.  This
		  is the normal	mode and also the default mode.

  GL_SELECT	  Selection mode.  No pixel fragments are produced, and	no
		  change to the	frame buffer contents is made.	Instead, a
		  record of the	names of primitives that would have been
		  drawn	if the render mode was GL_RENDER is returned in	a
		  select buffer, which must be created (see glSelectBuffer)
		  before selection mode	is entered.

  The return value of glRenderMode is determined by the	render mode at the
  time glRenderMode is called, rather than by mode.  The values	returned for
  the three render modes are as	follows:

  GL_RENDER	  Zero.

  GL_SELECT	  The number of	hit records transferred	to the select buffer.

  Refer	to the glSelectBuffer and glFeedbackBuffer reference pages for more
  details concerning selection and feedback operation.


glRotate

Name

  glRotated, glRotatef - multiply the current matrix by	a rotation matrix

C Specification

  void glRotated( GLdouble angle,
		  GLdouble x,
		  GLdouble y,
		  GLdouble z )
  void glRotatef( GLfloat angle,
		  GLfloat x,
		  GLfloat y,
		  GLfloat z )

Parameters

  angle	 Specifies the angle of	rotation, in degrees.

  x, y,	z
	 Specify the x,	y, and z coordinates of	a vector, respectively.

Description

  glRotate computes a matrix that performs a counterclockwise rotation of
  angle	degrees	about the vector from the origin through the point (x, y, z).

  The current matrix (see glMatrixMode)	is multiplied by this rotation
  matrix, with the product replacing the current matrix.  That is, if M	is
  the current matrix and R is the translation matrix, then M is	replaced with
  M · R.

  If the matrix	mode is	either GL_MODELVIEW or GL_PROJECTION, all objects
  drawn	after glRotate is called are rotated.  Use glPushMatrix	and
  glPopMatrix to save and restore the unrotated	coordinate system.


glScale

Name

  glScaled, glScalef - multiply	the current matrix by a	general	scaling
  matrix

C Specification

  void glScaled( GLdouble x,
		 GLdouble y,
		 GLdouble z )
  void glScalef( GLfloat x,
		 GLfloat y,
		 GLfloat z )

Parameters

  x, y,	z
	 Specify scale factors along the x, y, and z axes, respectively.

Description

  glScale produces a general scaling along the x, y, and z axes.  The three
  arguments indicate the desired scale factors along each of the three axes.
  The resulting	matrix is

			      |	 x   0	 0   0	|
			      |			|
			      |	 0   y	 0   0	|
			      |			|
			      |	 0   0	 z   0	|
			      |			|
			      |	 0   0	 0   1	|

  The current matrix (see glMatrixMode)	is multiplied by this scale matrix,
  with the product replacing the current matrix.  That is, if M	is the
  current matrix and S is the scale matrix, then M is replaced with M ·	S.

  If the matrix	mode is	either GL_MODELVIEW or GL_PROJECTION, all objects
  drawn	after glScale is called	are scaled.  Use glPushMatrix and glPopMatrix
  to save and restore the unscaled coordinate system.


glSelectBuffer

Name

  glSelectBuffer - establish a buffer for selection mode values

C Specification

  void glSelectBuffer( GLsizei size,
		       GLuint *buffer )

Parameters

  size	  Specifies the	size of	buffer.

  buffer  Returns the selection	data.

Description

  glSelectBuffer has two arguments: buffer is a	pointer	to an array of
  unsigned integers, and size indicates	the size of the	array.	buffer
  returns values from the name stack (see glInitNames, glLoadName,
  glPushName) when the rendering mode is GL_SELECT (see	glRenderMode).
  glSelectBuffer must be issued	before selection mode is enabled, and it must
  not be issued	while the rendering mode is GL_SELECT.

  Selection is used by a programmer to determine which primitives are drawn
  into some region of a	window.	 The region is defined by the current
  modelview and	perspective matrices.

  In selection mode, no	pixel fragments	are produced from rasterization.
  Instead, if a	primitive intersects the clipping volume defined by the
  viewing frustum and the user-defined clipping	planes,	this primitive causes
  a selection hit.  (With polygons, no hit occurs if the polygon is culled.)
  When a change	is made	to the name stack, or when glRenderMode	is called, a
  hit record is	copied to buffer if any	hits have occurred since the last
  such event (name stack change	or glRenderMode	call).	The hit	record
  consists of the number of names in the name stack at the time	of the event,
  followed by the minimum and maximum depth values of all vertices that	hit
  since	the previous event, followed by	the name stack contents, bottom	name
  first.

  Returned depth values	are mapped such	that the largest unsigned integer
  value	corresponds to window coordinate depth 1.0, and	zero corresponds to
  window coordinate depth 0.0.

  An internal index into buffer	is reset to zero whenever selection mode is
  entered.  Each time a	hit record is copied into buffer, the index is
  incremented to point to the cell just	past the end of	the block of names -
  that is, to the next available cell.	If the hit record is larger than the
  number of remaining locations	in buffer, as much data	as can fit is copied,
  and the overflow flag	is set.	 If the	name stack is empty when a hit record
  is copied, that record consists of zero followed by the minimum and maximum
  depth	values.

  Selection mode is exited by calling glRenderMode with	an argument other
  than GL_SELECT.  Whenever glRenderMode is called while the render mode is
  GL_SELECT, it	returns	the number of hit records copied to buffer, resets
  the overflow flag and	the selection buffer pointer, and initializes the
  name stack to	be empty.  If the overflow bit was set when glRenderMode was
  called, a negative hit record	count is returned.

 


glTranslate

Name

  glTranslated,	glTranslatef - multiply	the current matrix by a	translation
  matrix

C Specification

  void glTranslated( GLdouble x,
		     GLdouble y,
		     GLdouble z	)
  void glTranslatef( GLfloat x,
		     GLfloat y,
		     GLfloat z )

Parameters

  x, y,	z
	 Specify the x,	y, and z coordinates of	a translation vector.

Description

  glTranslate moves the	coordinate system origin to the	point specified	by
  (x,y,z).  The translation vector is used to compute a	4x4 translation
  matrix:

			    | 1	   0	0    x	 |
			    |			 |
			    | 0	   1	0    y	 |
			    |			 |
			    | 0	   0	1    z	 |
			    |			 |
			    | 0	   0	0    1	 |

  The current matrix (see glMatrixMode)	is multiplied by this translation
  matrix, with the product replacing the current matrix.  That is, if M	is
  the current matrix and T is the translation matrix, then M is	replaced with
  M · T.

  If the matrix	mode is	either GL_MODELVIEW or GL_PROJECTION, all objects
  drawn	after glTranslate is called are	translated.  Use glPushMatrix and
  glPopMatrix to save and restore the untranslated coordinate system.

 


glVertex

Name

  glVertex2d, glVertex2f, glVertex2i, glVertex2s, glVertex3d, glVertex3f,
  glVertex3i, glVertex3s, glVertex4d, glVertex4f, glVertex4i, glVertex4s,
  glVertex2dv, glVertex2fv, glVertex2iv, glVertex2sv, glVertex3dv,
  glVertex3fv, glVertex3iv, glVertex3sv, glVertex4dv, glVertex4fv,
  glVertex4iv, glVertex4sv - specify a vertex

C Specification

  void glVertex2d( GLdouble x,
		   GLdouble y )
  void glVertex2f( GLfloat x,
		   GLfloat y )
  void glVertex2i( GLint x,
		   GLint y )
  void glVertex2s( GLshort x,
		   GLshort y )
  void glVertex3d( GLdouble x,
		   GLdouble y,
		   GLdouble z )
  void glVertex3f( GLfloat x,
		   GLfloat y,
		   GLfloat z )
  void glVertex3i( GLint x,
		   GLint y,
		   GLint z )
  void glVertex3s( GLshort x,
		   GLshort y,
		   GLshort z )
  void glVertex4d( GLdouble x,
		   GLdouble y,
		   GLdouble z,
		   GLdouble w )
  void glVertex4f( GLfloat x,
		   GLfloat y,
		   GLfloat z,
		   GLfloat w )
  void glVertex4i( GLint x,
		   GLint y,
		   GLint z,
		   GLint w )
  void glVertex4s( GLshort x,
		   GLshort y,
		   GLshort z,
		   GLshort w )

Parameters

  x, y,	z, w
	   Specify x, y, z, and	w coordinates of a vertex.  Not	all
	   parameters are present in all forms of the command.

C Specification

  void glVertex2dv( const GLdouble *v )
  void glVertex2fv( const GLfloat *v )
  void glVertex2iv( const GLint	*v )
  void glVertex2sv( const GLshort *v )
  void glVertex3dv( const GLdouble *v )
  void glVertex3fv( const GLfloat *v )
  void glVertex3iv( const GLint	*v )
  void glVertex3sv( const GLshort *v )
  void glVertex4dv( const GLdouble *v )
  void glVertex4fv( const GLfloat *v )
  void glVertex4iv( const GLint	*v )
  void glVertex4sv( const GLshort *v )

Parameters

  v    Specifies a pointer to an array of two, three, or four elements.	 The
       elements	of a two-element array are x and y; of a three-element array,
       x, y, and z; and	of a four-element array, x, y, z, and w.

Description

  glVertex commands are	used within glBegin/glEnd pairs	to specify point,
  line,	and polygon vertices.  The current color, normal, and texture
  coordinates are associated with the vertex when glVertex is called.

  When only x and y are	specified, z defaults to 0.0 and w defaults to 1.0.
  When x, y, and z are specified, w defaults to	1.0.


glViewport

Name

  glViewport - set the viewport

C Specification

  void glViewport( GLint x,
		   GLint y,
		   GLsizei width,
		   GLsizei height )

Parameters

  x, y Specify the lower left corner of	the viewport rectangle,	in pixels.
       The default is (0,0).

  width, height
       Specify the width and height, respectively, of the viewport.  When a
       GL context is first attached to a window, width and height are set to
       the dimensions of that window.

Description

  glViewport specifies the affine transformation of x and y from normalized
  device coordinates to	window coordinates.  Let (x  , y  ) be normalized
                                                   nd   nd
  device coordinates.  Then the	window coordinates x , y ) are computed as
  follows:					    w	w

                                        width
			    x  = (x  +1)----- + x
			     w	   nd	  2  

                                        height
			    y  = (y  +1)------ + y
			     w	   nd	   2  

  Viewport width and height are	silently clamped to a range that depends on
  the implementation.  This range is queried by	calling	glGet with argument
  GL_MAX_VIEWPORT_DIMS.


gluLookAt

Name

  gluLookAt - define a viewing transformation

C Specification

  void gluLookAt( GLdouble eyex,
		  GLdouble eyey,
		  GLdouble eyez,
		  GLdouble centerx,
		  GLdouble centery,
		  GLdouble centerz,
		  GLdouble upx,
		  GLdouble upy,
		  GLdouble upz )

Parameters

  eyex,	eyey, eyez
		  Specifies the	position of the	eye point.

  centerx, centery, centerz
		  Specifies the	position of the	reference point.

  upx, upy, upz	  Specifies the	direction of the up vector.

Description

  gluLookAt creates a viewing matrix derived from an eye point,	a reference
  point	indicating the center of the scene, and	an up vector.  The matrix
  maps the reference point to the negative z axis and the eye point to the
  origin, so that, when	a typical projection matrix is used, the center	of
  the scene maps to the	center of the viewport.	 Similarly, the	direction
  described by the up vector projected onto the	viewing	plane is mapped	to
  the positive y axis so that it points	upward in the viewport.	 The up
  vector must not be parallel to the line of sight from	the eye	to the
  reference point.

  The matrix generated by gluLookAt postmultiplies the current matrix.


gluPickMatrix

Name

  gluPickMatrix	- define a picking region

C Specification

  void gluPickMatrix( GLdouble x,
		      GLdouble y,
		      GLdouble width,
		      GLdouble height,
		      GLint viewport[4]	)

Parameters

  x, y Specify the center of a picking region in window	coordinates.

  width, height
       Specify the width and height, respectively, of the picking region in
       window coordinates.

  viewport
       Specifies the current viewport (as from a glGetIntegerv call).

Description

  gluPickMatrix	creates	a projection matrix that can be	used to	restrict
  drawing to a small region of the viewport.  This is typically	useful to
  determine what objects are being drawn near the cursor.  Use gluPickMatrix
  to restrict drawing to a small region	around the cursor.  Then, enter
  selection mode (with glRenderMode and	rerender the scene.  All primitives
  that would have been drawn near the cursor are identified and	stored in the
  selection buffer.

  The matrix created by	gluPickMatrix is multiplied by the current matrix
  just as if glMultMatrix is called with the generated matrix.	To
  effectively use the generated	pick matrix for	picking, first call
  glLoadIdentity to load an identity matrix onto the perspective matrix
  stack.  Then call gluPickMatrix, and finally,	call a command (such as
  glOrtho) to multiply the perspective matrix by the pick matrix.

  When using gluPickMatrix to pick NURBS, be careful to	turn off the NURBS
  property GLU_AUTO_LOAD_MATRIX.  If GLU_AUTO_LOAD_MATRIX is not turned	off,
  then any NURBS surface rendered is subdivided	differently with the pick
  matrix than the way it was subdivided	without	the pick matrix.

Example

  When rendering a scene as follows:

  glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(...);
  glMatrixMode(GL_MODELVIEW); /* Draw the scene	*/

  a portion of the viewport can	be selected as a pick region like this:

  glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPickMatrix(x, y, width,
  height, viewport); glOrtho(...); glMatrixMode(GL_MODELVIEW); /* Draw
  the scene */