Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
glu(3)			   Erlang Module Definition			glu(3)

NAME
       glu -  A	part of	the standard OpenGL Utility api.

DESCRIPTION
       A part of the standard OpenGL Utility api. See www.opengl.org

       Booleans	are represented	by integers 0 and 1.

DATA TYPES
	 enum()	= non_neg_integer():

	   See wx/include/gl.hrl or glu.hrl

	 matrix()  =  {float(),	 float(),  float(), float(), float(), float(),
	 float(),  float(),  float(),  float(),	 float(),  float(),   float(),
	 float(), float(), float()}:

	 mem() = binary() | tuple():

	   Memory block

	 vertex() = {float(), float(), float()}:

EXPORTS
       tesselate(Normal, Vs::[Vs]) -> {Triangles, VertexPos}

	      Types:

		 Normal	= vertex()
		 Vs = vertex()
		 Triangles = [integer()]
		 VertexPos = binary()

	      General purpose polygon triangulation. The first argument	is the
	      normal and the second a list of vertex positions.	Returned is  a
	      list  of	indecies  of  the  vertices and	a binary (64bit	native
	      float) containing	an array of vertex positions, it  starts  with
	      the vertices in Vs and may contain newly created vertices	in the
	      end.

       build1DMipmapLevels(Target, InternalFormat, Width, Format, Type,	Level,
       Base, Max, Data)	-> integer()

	      Types:

		 Target	= enum()
		 InternalFormat	= integer()
		 Width = integer()
		 Format	= enum()
		 Type =	enum()
		 Level = integer()
		 Base =	integer()
		 Max = integer()
		 Data =	binary()

	      Builds a subset of one-dimensional mipmap	levels

	      glu:build1DMipmapLevels  builds  a subset	of prefiltered one-di-
	      mensional	 texture  maps	of  decreasing	resolutions  called  a
	      mipmap.  This  is	 used  for  the	antialiasing of	texture	mapped
	      primitives.

	      A	return value of	zero indicates success,	otherwise a GLU	 error
	      code is returned (see glu:errorString/1 ).

	      A	 series	of mipmap levels from Base to Max is built by decimat-
	      ing Data in half until size 1A1 is reached. At each level,  each
	      texel  in	 the  halved  mipmap level is an average of the	corre-
	      sponding two texels in the larger	mipmap level.  gl:texImage1D/8
	      is  called to load these mipmap levels from Base to Max .	If Max
	      is larger	than the highest mipmap	level for the texture  of  the
	      specified	 size,	then a GLU error code is returned (see glu:er-
	      rorString/1 ) and	nothing	is loaded.

	      For example, if Level is 2 and Width is 16, the following	levels
	      are possible: 16A1, 8A1, 4A1, 2A1, 1A1. These correspond to lev-
	      els 2 through 6 respectively. If Base is 3 and Max  is  5,  then
	      only  mipmap levels 8A1, 4A1 and 2A1 are loaded. However,	if Max
	      is 7, then an error is returned and nothing is loaded since  Max
	      is  larger than the highest mipmap level which is, in this case,
	      6.

	      The highest mipmap level can be derived  from  the  formula  log
	      2(widthA2	level).

	      See  the gl:texImage1D/8 reference page for a description	of the
	      acceptable values	for Type parameter.  See  the  gl:drawPixels/5
	      reference	 page  for  a description of the acceptable values for
	      Level parameter.

	      See external documentation.

       build1DMipmaps(Target, InternalFormat, Width, Format,  Type,  Data)  ->
       integer()

	      Types:

		 Target	= enum()
		 InternalFormat	= integer()
		 Width = integer()
		 Format	= enum()
		 Type =	enum()
		 Data =	binary()

	      Builds a one-dimensional mipmap

	      glu:build1DMipmaps  builds  a  series  of	prefiltered one-dimen-
	      sional texture maps of decreasing	resolutions called  a  mipmap.
	      This is used for the antialiasing	of texture mapped primitives.

	      A	 return	value of zero indicates	success, otherwise a GLU error
	      code is returned (see glu:errorString/1 ).

	      Initially, the Width of Data is checked to see if	it is a	 power
	      of 2. If not, a copy of Data is scaled up	or down	to the nearest
	      power of 2. (If Width is exactly between powers of 2,  then  the
	      copy  of	Data  will  scale upwards.) This copy will be used for
	      subsequent mipmapping operations described below.	 For  example,
	      if  Width	 is 57,	then a copy of Data will scale up to 64	before
	      mipmapping takes place.

	      Then, proxy textures (see	gl:texImage1D/8	) are used  to	deter-
	      mine  if	the  implementation  can fit the requested texture. If
	      not, Width is continually	halved until it	fits.

	      Next, a series of	mipmap levels is built by decimating a copy of
	      Data  in	half  until  size  1A1 is reached. At each level, each
	      texel in the halved mipmap level is an  average  of  the	corre-
	      sponding two texels in the larger	mipmap level.

	      gl:texImage1D/8  is  called to load each of these	mipmap levels.
	      Level 0 is a copy	of Data	. The highest level is (log 2)(width).
	      For  example,  if	Width is 64 and	the implementation can store a
	      texture of this size, the	following  mipmap  levels  are	built:
	      64A1,  32A1,  16A1,  8A1,	4A1, 2A1, and 1A1. These correspond to
	      levels 0 through 6, respectively.

	      See the gl:texImage1D/8 reference	page for a description of  the
	      acceptable  values  for  the Type	parameter. See the gl:drawPix-
	      els/5 reference page for a description of	the acceptable	values
	      for the Data parameter.

	      See external documentation.

       build2DMipmapLevels(Target,   InternalFormat,  Width,  Height,  Format,
       Type, Level, Base, Max, Data) ->	integer()

	      Types:

		 Target	= enum()
		 InternalFormat	= integer()
		 Width = integer()
		 Height	= integer()
		 Format	= enum()
		 Type =	enum()
		 Level = integer()
		 Base =	integer()
		 Max = integer()
		 Data =	binary()

	      Builds a subset of two-dimensional mipmap	levels

	      glu:build2DMipmapLevels builds a subset of  prefiltered  two-di-
	      mensional	 texture  maps	of  decreasing	resolutions  called  a
	      mipmap. This is used for	the  antialiasing  of  texture	mapped
	      primitives.

	      A	 return	value of zero indicates	success, otherwise a GLU error
	      code is returned (see glu:errorString/1 ).

	      A	series of mipmap levels	from Base to Max is built by  decimat-
	      ing  Data	 in  half  along  both	dimensions  until  size	1A1 is
	      reached. At each level, each texel in the	halved mipmap level is
	      an average of the	corresponding four texels in the larger	mipmap
	      level. (In the case of rectangular images, the  decimation  will
	      ultimately  reach	 an NA1	or 1AN configuration. Here, two	texels
	      are averaged instead.) gl:texImage2D/9 is	called to  load	 these
	      mipmap levels from Base to Max . If Max is larger	than the high-
	      est mipmap level for the texture of the specified	size,  then  a
	      GLU  error code is returned (see glu:errorString/1 ) and nothing
	      is loaded.

	      For example, if Level is 2 and Width is 16 and Height is 8,  the
	      following	 levels	 are possible: 16A8, 8A4, 4A2, 2A1, 1A1. These
	      correspond to levels 2 through 6 respectively. If	Base is	3  and
	      Max  is 5, then only mipmap levels 8A4, 4A2, and 2A1 are loaded.
	      However, if Max is 7, then an error is returned and  nothing  is
	      loaded  since  Max is larger than	the highest mipmap level which
	      is, in this case,	6.

	      The highest mipmap level can be derived  from  the  formula  log
	      2(max(width height)A2 level).

	      See  the gl:texImage1D/8 reference page for a description	of the
	      acceptable values	for Format parameter. See the  gl:drawPixels/5
	      reference	 page  for  a description of the acceptable values for
	      Type parameter.

	      See external documentation.

       build2DMipmaps(Target, InternalFormat,  Width,  Height,	Format,	 Type,
       Data) ->	integer()

	      Types:

		 Target	= enum()
		 InternalFormat	= integer()
		 Width = integer()
		 Height	= integer()
		 Format	= enum()
		 Type =	enum()
		 Data =	binary()

	      Builds a two-dimensional mipmap

	      glu:build2DMipmaps  builds  a  series  of	prefiltered two-dimen-
	      sional texture maps of decreasing	resolutions called  a  mipmap.
	      This is used for the antialiasing	of texture-mapped primitives.

	      A	 return	value of zero indicates	success, otherwise a GLU error
	      code is returned (see glu:errorString/1 ).

	      Initially, the Width and Height of Data are checked  to  see  if
	      they  are	 a  power of 2.	If not,	a copy of Data (not Data ), is
	      scaled up	or down	to the nearest power of	2. This	copy  will  be
	      used  for	 subsequent mipmapping operations described below. (If
	      Width or Height is exactly between powers	of 2, then the copy of
	      Data will	scale upwards.)	For example, if	Width is 57 and	Height
	      is 23, then a copy of Data will scale up to 64 in	Width and down
	      to 16 in depth, before mipmapping	takes place.

	      Then,  proxy  textures (see gl:texImage2D/9 ) are	used to	deter-
	      mine if the implementation can fit  the  requested  texture.  If
	      not,  both  dimensions are continually halved until it fits. (If
	      the OpenGL version is (<=	1.0, both maximum  texture  dimensions
	      are  clamped  to the value returned by gl:getBooleanv/1 with the
	      argument ?GLU_MAX_TEXTURE_SIZE .)

	      Next, a series of	mipmap levels is built by decimating a copy of
	      Data in half along both dimensions until size 1A1	is reached. At
	      each level, each texel in	the halved mipmap level	is an  average
	      of the corresponding four	texels in the larger mipmap level. (In
	      the case of rectangular images, the decimation  will  ultimately
	      reach an NA1 or 1AN configuration. Here, two texels are averaged
	      instead.)

	      gl:texImage2D/9 is called	to load	each of	these  mipmap  levels.
	      Level  0	is  a  copy  of	 Data  .  The  highest	level  is (log
	      2)(max(width height)). For example, if Width is 64 and Height is
	      16  and the implementation can store a texture of	this size, the
	      following	mipmap levels are built: 64A16,	32A8, 16A4, 8A2,  4A1,
	      2A1,  and	 1A1  These  correspond	to levels 0 through 6, respec-
	      tively.

	      See the gl:texImage1D/8 reference	page for a description of  the
	      acceptable  values for Format parameter. See the gl:drawPixels/5
	      reference	page for a description of the  acceptable  values  for
	      Type parameter.

	      See external documentation.

       build3DMipmapLevels(Target,  InternalFormat, Width, Height, Depth, For-
       mat, Type, Level, Base, Max, Data) -> integer()

	      Types:

		 Target	= enum()
		 InternalFormat	= integer()
		 Width = integer()
		 Height	= integer()
		 Depth = integer()
		 Format	= enum()
		 Type =	enum()
		 Level = integer()
		 Base =	integer()
		 Max = integer()
		 Data =	binary()

	      Builds a subset of three-dimensional mipmap levels

	      glu:build3DMipmapLevels builds a subset of prefiltered three-di-
	      mensional	 texture  maps	of  decreasing	resolutions  called  a
	      mipmap. This is used for	the  antialiasing  of  texture	mapped
	      primitives.

	      A	 return	value of zero indicates	success, otherwise a GLU error
	      code is returned (see glu:errorString/1 ).

	      A	series of mipmap levels	from Base to Max is built by  decimat-
	      ing  Data	 in  half  along  both	dimensions until size 1A1A1 is
	      reached. At each level, each texel in the	halved mipmap level is
	      an  average  of  the  corresponding  eight  texels in the	larger
	      mipmap level. (If	exactly	one of the dimensions is 1, four  tex-
	      els  are	averaged.  If exactly two of the dimensions are	1, two
	      texels are averaged.) gl:texImage3D/10 is	called to  load	 these
	      mipmap levels from Base to Max . If Max is larger	than the high-
	      est mipmap level for the texture of the specified	size,  then  a
	      GLU  error code is returned (see glu:errorString/1 ) and nothing
	      is loaded.

	      For example, if Level is 2 and Width is  16,  Height  is	8  and
	      Depth  is	 4,  the following levels are possible:	16A8A4,	8A4A2,
	      4A2A1, 2A1A1, 1A1A1. These correspond to levels 2	through	6  re-
	      spectively.  If  Base is 3 and Max is 5, then only mipmap	levels
	      8A4A2, 4A2A1, and	2A1A1 are loaded. However, if Max is  7,  then
	      an  error	is returned and	nothing	is loaded, since Max is	larger
	      than the highest mipmap level which is, in this case, 6.

	      The highest mipmap level can be derived  from  the  formula  log
	      2(max(width height depth)A2 level).

	      See  the gl:texImage1D/8 reference page for a description	of the
	      acceptable values	for Format parameter. See the  gl:drawPixels/5
	      reference	 page  for  a description of the acceptable values for
	      Type parameter.

	      See external documentation.

       build3DMipmaps(Target, InternalFormat, Width,  Height,  Depth,  Format,
       Type, Data) -> integer()

	      Types:

		 Target	= enum()
		 InternalFormat	= integer()
		 Width = integer()
		 Height	= integer()
		 Depth = integer()
		 Format	= enum()
		 Type =	enum()
		 Data =	binary()

	      Builds a three-dimensional mipmap

	      glu:build3DMipmaps  builds  a series of prefiltered three-dimen-
	      sional texture maps of decreasing	resolutions called  a  mipmap.
	      This is used for the antialiasing	of texture-mapped primitives.

	      A	 return	value of zero indicates	success, otherwise a GLU error
	      code is returned (see glu:errorString/1 ).

	      Initially, the Width , Height and	Depth of Data are  checked  to
	      see if they are a	power of 2. If not, a copy of Data is made and
	      scaled up	or down	to the nearest power of	2. (If Width ,	Height
	      ,	or Depth is exactly between powers of 2, then the copy of Data
	      will scale upwards.) This	 copy  will  be	 used  for  subsequent
	      mipmapping  operations described below. For example, if Width is
	      57, Height is 23,	and Depth is 24, then  a  copy	of  Data  will
	      scale  up	 to 64 in width, down to 16 in height, and up to 32 in
	      depth before mipmapping takes place.

	      Then, proxy textures (see	gl:texImage3D/10 ) are used to	deter-
	      mine  if	the  implementation  can fit the requested texture. If
	      not, all three dimensions	are continually	halved until it	fits.

	      Next, a series of	mipmap levels is built by decimating a copy of
	      Data  in	half  along  all  three	dimensions until size 1A1A1 is
	      reached. At each level, each texel in the	halved mipmap level is
	      an  average  of  the  corresponding  eight  texels in the	larger
	      mipmap level. (If	exactly	one of the dimensions is 1, four  tex-
	      els  are	averaged.  If exactly two of the dimensions are	1, two
	      texels are averaged.)

	      gl:texImage3D/10 is called to load each of these mipmap  levels.
	      Level  0	is  a  copy  of	 Data  .  The  highest	level  is (log
	      2)(max(width height depth)). For example,	if Width is 64,	Height
	      is  16, and Depth	is 32, and the implementation can store	a tex-
	      ture of this  size,  the	following  mipmap  levels  are	built:
	      64A16A32,	32A8A16, 16A4A8, 8A2A4,	4A1A2, 2A1A1, and 1A1A1. These
	      correspond to levels 0 through 6,	respectively.

	      See the gl:texImage1D/8 reference	page for a description of  the
	      acceptable  values for Format parameter. See the gl:drawPixels/5
	      reference	page for a description of the  acceptable  values  for
	      Type parameter.

	      See external documentation.

       checkExtension(ExtName, ExtString) -> 0 | 1

	      Types:

		 ExtName = string()
		 ExtString = string()

	      Determines if an extension name is supported

	      glu:checkExtension  returns  ?GLU_TRUE  if  ExtName is supported
	      otherwise	?GLU_FALSE is returned.

	      This is used to check for	the presence for OpenGL, GLU,  or  GLX
	      extension	 names	by  passing  the extension strings returned by
	      gl:getString/1 , glu:getString/1 , see glXGetClientString	,  see
	      glXQueryExtensionsString,	 or  see glXQueryServerString, respec-
	      tively, as ExtString .

	      See external documentation.

       cylinder(Quad, Base, Top, Height, Slices, Stacks) -> ok

	      Types:

		 Quad =	integer()
		 Base =	float()
		 Top = float()
		 Height	= float()
		 Slices	= integer()
		 Stacks	= integer()

	      Draw a cylinder

	      glu:cylinder draws a cylinder oriented along  the	 z  axis.  The
	      base of the cylinder is placed at	z = 0 and the top at z=height.
	      Like a sphere, a cylinder	is subdivided around the z  axis  into
	      slices and along the z axis into stacks.

	      Note that	if Top is set to 0.0, this routine generates a cone.

	      If  the orientation is set to ?GLU_OUTSIDE (with glu:quadricOri-
	      entation/2 ), then any generated normals point away from	the  z
	      axis. Otherwise, they point toward the z axis.

	      If  texturing  is	 turned	 on (with glu:quadricTexture/2 ), then
	      texture coordinates are generated	so that	t ranges linearly from
	      0.0 at z = 0 to 1.0 at z = Height	, and s	ranges from 0.0	at the
	      +y axis, to 0.25 at the +x axis, to 0.5 at the -y	axis, to  0.75
	      at the -x	axis, and back to 1.0 at the +y	axis.

	      See external documentation.

       deleteQuadric(Quad) -> ok

	      Types:

		 Quad =	integer()

	      Destroy a	quadrics object

	      glu:deleteQuadric	 destroys  the	quadrics  object (created with
	      glu:newQuadric/0	)  and	frees  any  memory   it	  uses.	  Once
	      glu:deleteQuadric	has been called, Quad cannot be	used again.

	      See external documentation.

       disk(Quad, Inner, Outer,	Slices,	Loops) -> ok

	      Types:

		 Quad =	integer()
		 Inner = float()
		 Outer = float()
		 Slices	= integer()
		 Loops = integer()

	      Draw a disk

	      glu:disk	renders	 a disk	on the z = 0 plane. The	disk has a ra-
	      dius of Outer and	contains a concentric circular hole with a ra-
	      dius  of	Inner  . If Inner is 0,	then no	hole is	generated. The
	      disk is subdivided around	the z axis  into  slices  (like	 pizza
	      slices)  and  also  about	the z axis into	rings (as specified by
	      Slices and Loops , respectively).

	      With respect to orientation, the +z side of the disk is  consid-
	      ered  to	be outside (see	glu:quadricOrientation/2 ). This means
	      that if the orientation is set to	?GLU_OUTSIDE , then  any  nor-
	      mals  generated  point  along the	+z axis. Otherwise, they point
	      along the	-z axis.

	      If texturing has been turned on  (with  glu:quadricTexture/2  ),
	      texture  coordinates  are	 generated  linearly  such  that where
	      r=outer, the value at (r,	0, 0) is (1, 0.5), at (0, r, 0)	it  is
	      (0.5,  1), at (-r, 0, 0) it is (0, 0.5), and at (0, -r, 0) it is
	      (0.5, 0).

	      See external documentation.

       errorString(Error) -> string()

	      Types:

		 Error = enum()

	      Produce an error string from a GL	or GLU error code

	      glu:errorString produces an error	string from a GL or GLU	 error
	      code.  The string	is in ISO Latin	1 format. For example, glu:er-
	      rorString(?GLU_OUT_OF_MEMORY) returns the	string out of memory.

	      The standard GLU error  codes  are  ?GLU_INVALID_ENUM,  ?GLU_IN-
	      VALID_VALUE, and ?GLU_OUT_OF_MEMORY. Certain other GLU functions
	      can return specialized error codes through  callbacks.  See  the
	      gl:getError/0 reference page for the list	of GL error codes.

	      See external documentation.

       getString(Name) -> string()

	      Types:

		 Name =	enum()

	      Return a string describing the GLU version or GLU	extensions

	      glu:getString  returns  a	 pointer to a static string describing
	      the GLU version or the GLU extensions that are supported.

	      The version number is one	of the following forms:

	      major_number.minor_numbermajor_number.minor_number.release_num-
	      ber.

	      The version string is of the following form:

	      version number_lt;space_gt;vendor-specific information

	      Vendor-specific information is optional. Its format and contents
	      depend on	the implementation.

	      The standard GLU contains	a basic	set of features	and  capabili-
	      ties.  If	 a company or group of companies wish to support other
	      features,	these may be included as extensions  to	 the  GLU.  If
	      Name is ?GLU_EXTENSIONS, then glu:getString returns a space-sep-
	      arated list of names of  supported  GLU  extensions.  (Extension
	      names never contain spaces.)

	      All strings are null-terminated.

	      See external documentation.

       lookAt(EyeX,  EyeY,  EyeZ, CenterX, CenterY, CenterZ, UpX, UpY, UpZ) ->
       ok

	      Types:

		 EyeX =	float()
		 EyeY =	float()
		 EyeZ =	float()
		 CenterX = float()
		 CenterY = float()
		 CenterZ = float()
		 UpX = float()
		 UpY = float()
		 UpZ = float()

	      Define a viewing transformation

	      glu:lookAt 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. When	a typical projection matrix is
	      used, the	center of the scene therefore maps to  the  center  of
	      the  viewport. Similarly,	the direction described	by the UP vec-
	      tor 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 point  to
	      the reference point.

	      Let

	      F=(centerX-eyeX centerY-eyeY centerZ-eyeZ)

	      Let UP be	the vector (upX	upY upZ).

	      Then normalize as	follows: f=F/(||F||)

	      UP"=UP/(||UP||)

	      Finally, let s=fAUP", and	u=sAf.

	      M	 is then constructed as	follows: M=(s[0] s[1] s[2] 0 u[0] u[1]
	      u[2] 0-f[0]-f[1]-f[2] 0 0	0 0 1)

	      and  glu:lookAt  is  equivalent  to  glMultMatrixf(M);  glTrans-
	      lated(-eyex, -eyey, -eyez);

	      See external documentation.

       newQuadric() -> integer()

	      Create a quadrics	object

	      glu:newQuadric  creates  and returns a pointer to	a new quadrics
	      object. This object must be referred to  when  calling  quadrics
	      rendering	 and control functions.	A return value of 0 means that
	      there is not enough memory to allocate the object.

	      See external documentation.

       ortho2D(Left, Right, Bottom, Top) -> ok

	      Types:

		 Left =	float()
		 Right = float()
		 Bottom	= float()
		 Top = float()

	      Define a 2D orthographic projection matrix

	      glu:ortho2D sets up a two-dimensional orthographic  viewing  re-
	      gion.  This is equivalent	to calling gl:ortho/6 with near=-1 and
	      far=1.

	      See external documentation.

       partialDisk(Quad, Inner,	Outer, Slices, Loops, Start, Sweep) -> ok

	      Types:

		 Quad =	integer()
		 Inner = float()
		 Outer = float()
		 Slices	= integer()
		 Loops = integer()
		 Start = float()
		 Sweep = float()

	      Draw an arc of a disk

	      glu:partialDisk renders a	partial	disk on	the z=0	plane. A  par-
	      tial disk	is similar to a	full disk, except that only the	subset
	      of the disk from Start through Start + Sweep is included	(where
	      0	degrees	is along the +f2yf axis, 90 degrees along the +x axis,
	      180 degrees along	the -y axis, and  270  degrees	along  the  -x
	      axis).

	      The partial disk has a radius of Outer and contains a concentric
	      circular hole with a radius of Inner . If	Inner is  0,  then  no
	      hole  is	generated. The partial disk is subdivided around the z
	      axis into	slices (like pizza slices) and also about the  z  axis
	      into rings (as specified by Slices and Loops , respectively).

	      With  respect to orientation, the	+z side	of the partial disk is
	      considered to be outside (see glu:quadricOrientation/2  ).  This
	      means  that  if the orientation is set to	?GLU_OUTSIDE, then any
	      normals generated	point along the	+z axis. Otherwise, they point
	      along the	-z axis.

	      If  texturing is turned on (with glu:quadricTexture/2 ), texture
	      coordinates are generated	linearly such that where r=outer,  the
	      value at (r, 0, 0) is (1.0, 0.5),	at (0, r, 0) it	is (0.5, 1.0),
	      at (-r, 0, 0) it is (0.0,	0.5), and at (0, -r, 0)	 it  is	 (0.5,
	      0.0).

	      See external documentation.

       perspective(Fovy, Aspect, ZNear,	ZFar) -> ok

	      Types:

		 Fovy =	float()
		 Aspect	= float()
		 ZNear = float()
		 ZFar =	float()

	      Set up a perspective projection matrix

	      glu:perspective specifies	a viewing frustum into the world coor-
	      dinate system. In	general, the aspect ratio  in  glu:perspective
	      should  match  the  aspect ratio of the associated viewport. For
	      example, aspect=2.0 means	the viewer's angle of view is twice as
	      wide  in x as it is in y.	If the viewport	is twice as wide as it
	      is tall, it displays the image without distortion.

	      The matrix generated by glu:perspective is multipled by the cur-
	      rent  matrix,  just  as if gl:multMatrixd/1 were called with the
	      generated	matrix.	To load	the perspective	matrix onto  the  cur-
	      rent  matrix  stack instead, precede the call to glu:perspective
	      with a call to gl:loadIdentity/0 .

	      Given f defined as follows:

	      f=cotangent(fovy/2) The generated	matrix is

	      (f/aspect	0 0 0 0	f 0 0 0	 0(zFar+zNear)/(zNear-zFar)(2AzFarAzN-
	      ear)/(zNear-zFar)	0 0 -1 0)

	      See external documentation.

       pickMatrix(X, Y,	DelX, DelY, Viewport) -> ok

	      Types:

		 X = float()
		 Y = float()
		 DelX =	float()
		 DelY =	float()
		 Viewport = {integer(),	integer(), integer(), integer()}

	      Define a picking region

	      glu:pickMatrix  creates  a projection matrix that	can be used to
	      restrict drawing to a small region of the	viewport. This is typ-
	      ically useful to determine what objects are being	drawn near the
	      cursor. Use glu:pickMatrix to restrict drawing to	a small	region
	      around  the  cursor. Then, enter selection mode (with gl:render-
	      Mode/1 ) and rerender the	scene. All primitives that would  have
	      been  drawn near the cursor are identified and stored in the se-
	      lection buffer.

	      The matrix created by glu:pickMatrix is multiplied by  the  cur-
	      rent  matrix just	as if gl:multMatrixd/1 is called with the gen-
	      erated matrix. To	effectively use	the generated pick matrix  for
	      picking, first call gl:loadIdentity/0 to load an identity	matrix
	      onto the perspective matrix  stack.  Then	 call  glu:pickMatrix,
	      and,  finally,  call  a  command (such as	glu:perspective/4 ) to
	      multiply the perspective matrix by the pick matrix.

	      When using glu:pickMatrix	to pick	NURBS, be careful to turn  off
	      the  NURBS property ?GLU_AUTO_LOAD_MATRIX. If ?GLU_AUTO_LOAD_MA-
	      TRIX is not turned off, then any NURBS surface rendered is  sub-
	      divided  differently  with  the  pick matrix than	the way	it was
	      subdivided without the pick matrix.

	      See external documentation.

       project(ObjX,  ObjY,  ObjZ,   Model,   Proj,   View)   ->   {integer(),
       WinX::float(), WinY::float(), WinZ::float()}

	      Types:

		 ObjX =	float()
		 ObjY =	float()
		 ObjZ =	float()
		 Model = matrix()
		 Proj =	matrix()
		 View =	{integer(), integer(), integer(), integer()}

	      Map object coordinates to	window coordinates

	      glu:project  transforms  the  specified  object coordinates into
	      window coordinates using Model , Proj , and View . The result is
	      stored  in  WinX , WinY ,	and WinZ . A return value of ?GLU_TRUE
	      indicates	success, a return value	of ?GLU_FALSE indicates	 fail-
	      ure.

	      To  compute  the	coordinates, let v=(objX objY objZ 1.0)	repre-
	      sented as	a matrix with 4	rows and 1  column.  Then  glu:project
	      computes v" as follows:

	      v"=PAMAv

	      where  P is the current projection matrix	Proj and M is the cur-
	      rent modelview matrix Model (both	represented as 4A4 matrices in
	      column-major order).

	      The window coordinates are then computed as follows:

	      winX=view(0)+view(2)A(v"(0)+1)/2

	      winY=view(1)+view(3)A(v"(1)+1)/2

	      winZ=(v"(2)+1)/2

	      See external documentation.

       quadricDrawStyle(Quad, Draw) -> ok

	      Types:

		 Quad =	integer()
		 Draw =	enum()

	      Specify the draw style desired for quadrics

	      glu:quadricDrawStyle  specifies the draw style for quadrics ren-
	      dered with Quad .	The legal values are as	follows:

	      ?GLU_FILL: Quadrics are rendered with  polygon  primitives.  The
	      polygons are drawn in a counterclockwise fashion with respect to
	      their normals (as	defined	with glu:quadricOrientation/2 ).

	      ?GLU_LINE: Quadrics are rendered as a set	of lines.

	      ?GLU_SILHOUETTE: Quadrics	are rendered as	a set of lines,	except
	      that edges separating coplanar faces will	not be drawn.

	      ?GLU_POINT: Quadrics are rendered	as a set of points.

	      See external documentation.

       quadricNormals(Quad, Normal) -> ok

	      Types:

		 Quad =	integer()
		 Normal	= enum()

	      Specify what kind	of normals are desired for quadrics

	      glu:quadricNormals  specifies  what  kind	of normals are desired
	      for quadrics rendered with Quad .	The legal values are  as  fol-
	      lows:

	      ?GLU_NONE: No normals are	generated.

	      ?GLU_FLAT: One normal is generated for every facet of a quadric.

	      ?GLU_SMOOTH:  One	 normal	 is  generated	for  every vertex of a
	      quadric. This is the initial value.

	      See external documentation.

       quadricOrientation(Quad,	Orientation) ->	ok

	      Types:

		 Quad =	integer()
		 Orientation = enum()

	      Specify inside/outside orientation for quadrics

	      glu:quadricOrientation specifies what kind of orientation	is de-
	      sired  for  quadrics rendered with Quad .	The Orientation	values
	      are as follows:

	      ?GLU_OUTSIDE: Quadrics are drawn with normals  pointing  outward
	      (the initial value).

	      ?GLU_INSIDE: Quadrics are	drawn with normals pointing inward.

	      Note  that  the  interpretation of outward and inward depends on
	      the quadric being	drawn.

	      See external documentation.

       quadricTexture(Quad, Texture) ->	ok

	      Types:

		 Quad =	integer()
		 Texture = 0 | 1

	      Specify if texturing is desired for quadrics

	      glu:quadricTexture specifies if texture  coordinates  should  be
	      generated	for quadrics rendered with Quad	. If the value of Tex-
	      ture is ?GLU_TRUE, then texture coordinates are  generated,  and
	      if  Texture  is  ?GLU_FALSE,  they are not. The initial value is
	      ?GLU_FALSE.

	      The manner in which texture coordinates  are  generated  depends
	      upon the specific	quadric	rendered.

	      See external documentation.

       scaleImage(Format,  WIn,	 HIn,  TypeIn,	DataIn,	 WOut,	HOut, TypeOut,
       DataOut)	-> integer()

	      Types:

		 Format	= enum()
		 WIn = integer()
		 HIn = integer()
		 TypeIn	= enum()
		 DataIn	= binary()
		 WOut =	integer()
		 HOut =	integer()
		 TypeOut = enum()
		 DataOut = mem()

	      Scale an image to	an arbitrary size

	      glu:scaleImage scales a pixel image using	the appropriate	 pixel
	      store  modes  to unpack data from	the source image and pack data
	      into the destination image.

	      When shrinking an	image, glu:scaleImage uses  a  box  filter  to
	      sample  the  source  image and create pixels for the destination
	      image. When magnifying an	image, the pixels from the source  im-
	      age are linearly interpolated to create the destination image.

	      A	 return	value of zero indicates	success, otherwise a GLU error
	      code is returned (see glu:errorString/1 ).

	      See the gl:readPixels/7 reference	page for a description of  the
	      acceptable  values for the Format	, TypeIn , and TypeOut parame-
	      ters.

	      See external documentation.

       sphere(Quad, Radius, Slices, Stacks) -> ok

	      Types:

		 Quad =	integer()
		 Radius	= float()
		 Slices	= integer()
		 Stacks	= integer()

	      Draw a sphere

	      glu:sphere draws a sphere	of the given  radius  centered	around
	      the  origin.  The	 sphere	 is  subdivided	around the z axis into
	      slices and along the z axis into stacks  (similar	 to  lines  of
	      longitude	and latitude).

	      If  the orientation is set to ?GLU_OUTSIDE (with glu:quadricOri-
	      entation/2 ), then any normals generated	point  away  from  the
	      center of	the sphere. Otherwise, they point toward the center of
	      the sphere.

	      If texturing is turned on	 (with	glu:quadricTexture/2  ),  then
	      texture  coordinates  are	generated so that t ranges from	0.0 at
	      z=-radius	to 1.0 at z=radius (t increases	linearly along	longi-
	      tudinal lines), and s ranges from	0.0 at the +y axis, to 0.25 at
	      the +x axis, to 0.5 at the -y axis, to 0.75 at the -x axis,  and
	      back to 1.0 at the +y axis.

	      See external documentation.

       unProject(WinX,	 WinY,	 WinZ,	 Model,	 Proj,	View)  ->  {integer(),
       ObjX::float(), ObjY::float(), ObjZ::float()}

	      Types:

		 WinX =	float()
		 WinY =	float()
		 WinZ =	float()
		 Model = matrix()
		 Proj =	matrix()
		 View =	{integer(), integer(), integer(), integer()}

	      Map window coordinates to	object coordinates

	      glu:unProject maps the specified window coordinates into	object
	      coordinates using	Model ,	Proj , and View	. The result is	stored
	      in ObjX ,	ObjY , and ObjZ	. A return value  of  ?GLU_TRUE	 indi-
	      cates success; a return value of ?GLU_FALSE indicates failure.

	      To  compute the coordinates (objX	objY objZ), glu:unProject mul-
	      tiplies the normalized device  coordinates  by  the  inverse  of
	      Model * Proj as follows:

	      (objX	  objY	     objZ      W)=INV(P	     M)	     ((2(winX-
	      view[0]))/(view[2])-1(2(winY-view[1]))/(view[3])-1 2(winZ)-1  1)
	      INV  denotes matrix inversion. W is an unused variable, included
	      for consistent matrix notation.

	      See external documentation.

       unProject4(WinX,	WinY, WinZ, ClipW, Model, Proj,	View, NearVal, FarVal)
       ->    {integer(),    ObjX::float(),    ObjY::float(),	ObjZ::float(),
       ObjW::float()}

	      Types:

		 WinX =	float()
		 WinY =	float()
		 WinZ =	float()
		 ClipW = float()
		 Model = matrix()
		 Proj =	matrix()
		 View =	{integer(), integer(), integer(), integer()}
		 NearVal = float()
		 FarVal	= float()

	      See unProject/6

AUTHORS
       __

				   wx 1.3.3				glu(3)

NAME | DESCRIPTION | DATA TYPES | EXPORTS | AUTHORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=glu&sektion=3&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help