bionic (3) glu.3erl.gz

Provided by: erlang-manpages_20.2.2+dfsg-1ubuntu2_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.3                                           glu(3erl)