Create a new VAO. The only thing you can do with a VAO is bind it to the vertex array binding target (bindVAO) or delete it.

Assign the VAO to the vertex array binding target. The VAO already bound will be replaced, if any.

Delete a VAO.

Handle to a VAO.

Use this to create VBOs or element arrays from raw data. Choose the usage hint based on how often you expect to modify the VBO's contents.

Bind a VBO to the array buffer binding target. The buffer object bound there will be replaced, if any.

Assign an element array to the element array binding target. It will replace the buffer object already bound there, if any. The binding will be remembered in the currently bound VAO.

Modify the data in the currently bound VBO starting from the specified index in bytes.

Modify contents in the currently bound element array starting at the specified index in bytes.

Delete a buffer object.

Handle to a buffer object, such as a VBO or an element array.

Usage hint for allocation of buffer object storage.

Compile the code for a vertex shader and a fragment shader, then link them into a new program. If the compiler or linker fails it will throw a ProgramError.

Same as newProgram but does not throw exceptions.

Install a program into the rendering pipeline. Replaces the program already in use, if any.

Delete a program.

Handle to a shader program.

The error message emitted by the driver when shader compilation or linkage fails.

This configures the currently bound VAO. It calls glVertexAttribPointer and glEnableVertexAttribArray.

The name of a vertex input to a program combined with the component format and number of components for that attribute in the vertex data. Alternatively the size of an unused section of the data in bytes.

The size and interpretation of a vertex attribute component.

Handle to a texture object. It may be a Tex2D or a cubemap.

Create a new 2D texture from raw image data, its dimensions, and the assumed image format. The dimensions should be powers of 2.

Create a new cubemap texture from six raw data sources. Each side will have the same format.

Create an empty texture with the specified dimensions and format.

Create a cubemap texture where each of the six sides has the specified dimensions and format.

Delete a texture.

Set the active texture unit. The default is zero.

Bind a 2D texture to the 2D texture binding target and the currently active texture unit.

Bind a cubemap texture to the cubemap texture binding target and the currently active texture unit.

Set the filtering for the 2D texture currently bound to the 2D texture binding target.

Set the filtering for the cubemap texture currently bound to the cubemap texture binding target.

Set the wrapping mode for the 2D texture currently bound to the 2D texture binding target.

Set the wrapping mode for the cubemap texture currently bound to the cubemap texture binding target. Because no filtering occurs between cube faces you probably want ClampToEdge.

Six values, one on each side.

Texture filtering modes.

Texture wrapping modes.

Set the viewport. The default viewport simply covers the entire window.

Enable the scissor test. Graphics outside the scissor box will not be rendered.

Disable the scissor test.

Enable face culling. The argument specifies whether front faces, back faces, or both will be omitted from rendering. If both front and back faces are culled you can still render points and lines.

Disable face culling. Front and back faces will now be rendered.

A rectangular section of the window.

Face culling modes.

How indices are packed in an ElementArray buffer object.

Allow rendering commands to modify the color buffer of the current framebuffer.

Disable rendering to color buffer.

Clear the color buffer of the current framebuffer with the specified color. Has no effect if writing to the color buffer is disabled.

Enable the depth test. Attempting to render pixels with a depth value greater than the depth buffer at those pixels will have no effect. Otherwise the depth in the buffer will get updated to the new pixel's depth.

Disable the depth test and depth buffer updates.

Clear the depth buffer with the maximum depth value.

Enable the stencil test with a set of operating parameters.

Disable the stencil test and updates to the stencil buffer, if one exists.

Clear the stencil buffer with all zeros.

In this basic configuration of the stencil, anything rendered will create a silhouette of 1s in the stencil buffer. Attempting to render a second time into the silhouette will have no effect because the stencil test will fail (ref=1 isn't greater than buffer=1).

def { func = Greater
    , ref = 1
    , onBothPass = Replace }

Configuration of the stencil test and associated stencil buffer updating.

The stencil test passes under what condition.

Modification action for the stencil buffer.

Enable blending with the specified blending parameters.

Disable alpha blending.

This blending configuration is suitable for ordinary alpha blending transparency effects.

Blending
  { sFactor   = BlendSourceAlpha
  , dFactor   = BlendOneMinusSourceAlpha
  , blendFunc = FuncAdd }

Blending parameters.

Blending factors.

Blending functions.

A framebuffer object is an alternative rendering destination. Once an FBO is bound to framebuffer binding target, it is possible to attach images (textures or RBOs) for color, depth, or stencil rendering.

Create a new framebuffer object. Before the framebuffer can be used for rendering it must have a color image attachment.

Binds an FBO to the framebuffer binding target. Replaces the framebuffer already bound there.

Binds the default framebuffer to the framebuffer binding target.

Delete an FBO.

Attach a 2D texture to the FBO currently bound to the framebuffer binding target.

Attach one of the sides of a cube map texture to the FBO currently bound to the framebuffer binding target.

Attach an RBO to the FBO currently bound to the framebuffer binding target.

An RBO is a kind of image object used for rendering. The only thing you can do with an RBO is attach it to an FBO.

Create a new renderbuffer object with the specified dimensions and format.

Delete an RBO.

Detectable errors.

Check for a GL Error. This call has the semantics of a dequeue. If an error is returned, then calling getGLError again may return more errors that have "stacked up." When it returns Nothing then there are no more errors to report. An error indicates that a bug in your code caused incorrect ussage of the API or that the implementation has run out of memory.

It has been suggested that using this after every single GL command may adversely affect performance (not to mention be very tedious). Since there is no reasonable way to recover from a GL error, a good idea might be to check this once per frame or even less often, and respond with a core dump.

Throws an exception if getGLError returns non-Nothing.