Provided by: erlang-manpages_22.0.7+dfsg-1build1_all bug

NAME

       glu -  A part of the standard OpenGL Utility api.

DESCRIPTION

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

       Booleans are represented by integers 0 and 1.

DATA TYPES

         enum() = non_neg_integer():

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

         matrix() = matrix12() | matrix16():

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

         matrix16() = {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-dimensional texture maps
              of decreasing resolutions called a mipmap. This is used  for  the  antialiasing  of
              texture mapped primitives.

              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-dimensional texture maps of
              decreasing resolutions called a mipmap.  This  is  used  for  the  antialiasing  of
              texture mapped primitives.

              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-dimensional texture maps
              of  decreasing  resolutions  called  a mipmap. This is used for the antialiasing of
              texture mapped primitives.

              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-dimensional texture  maps  of
              decreasing  resolutions  called  a  mipmap.  This  is  used for the antialiasing of
              texture-mapped primitives.

              See external documentation.

       build3DMipmapLevels(Target, InternalFormat, Width, Height,  Depth,  Format,  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-dimensional texture
              maps of decreasing resolutions called a mipmap. This is used for  the  antialiasing
              of texture mapped primitives.

              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-dimensional texture maps of
              decreasing  resolutions  called  a  mipmap.  This  is  used for the antialiasing of
              texture-mapped primitives.

              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.

              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.

              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 radius of Outer and
              contains a concentric circular hole with a radius 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).

              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:errorString(?GLU_OUT_OF_MEMORY) returns the
              string out of memory.

              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.

              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.

              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  region.  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 partial 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).

              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 coordinate 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.

              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 typically 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:renderMode/1  )  and
              rerender  the  scene. All primitives that would have been drawn near the cursor are
              identified and stored in the selection buffer.

              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
              failure.

              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 rendered with Quad . The
              legal values are as follows:

              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 follows:

              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 desired  for  quadrics
              rendered with Quad . The Orientation values are as follows:

              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 Texture is  ?GLU_TRUE,  then  texture
              coordinates  are generated, and if Texture is ?GLU_FALSE, they are not. The initial
              value is ?GLU_FALSE.

              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.

              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).

              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 indicates  success;  a  return  value  of  ?GLU_FALSE  indicates
              failure.

              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.8.8                                   glu(3erl)