The number 1 expressed as a #CoglFixed number.
Two times pi, expressed as a #CoglFixed number.
Evaluates to the number of bits used by the #CoglFixed type.
A very small number expressed as a #CoglFixed number.
The biggest number representable using #CoglFixed
The smallest number representable using #CoglFixed
The number pi, expressed as a #CoglFixed number.
Half pi, expressed as a #CoglFixed number.
pi / 4, expressed as #CoglFixed number.
Evaluates to the number of bits used for the non-integer part of the #CoglFixed type.
Evaluates to 180 / pi in fixed point notation.
Maximum argument that can be passed to cogl_sqrti() for which the resulting error is < 10%
Maximum argument that can be passed to cogl_sqrti() for which the resulting error is < 5%
Maximum argument that can be passed to cogl_sqrti() function.
We do not advise nor reliably support the interleaving of raw GL drawing and Cogl drawing functions, but if you insist, cogl_begin_gl() and cogl_end_gl() provide a simple mechanism that may at least give you a fighting chance of succeeding.
Note: this doesn't help you modify the behaviour of Cogl drawing functions through the modification of GL state; that will never be reliably supported, but if you are trying to do something like:
|[ {
You should surround blocks of drawing using raw GL with cogl_begin_gl()
and cogl_end_gl():
|[
{
cogl_begin_gl ();
- setup some OpenGL state.
- draw using OpenGL (e.g. glDrawArrays() )
- reset modified OpenGL state.
cogl_end_gl ();
- continue using Cogl to draw
}
Don't ever try and do:
|[ {
When the internals of Cogl evolves, this is very liable to break.
This function will flush all batched primitives, and subsequently flush
all internal Cogl state to OpenGL as if it were going to draw something
itself.
The result is that the OpenGL modelview matrix will be setup; the state
corresponding to the current source material will be set up and other world
state such as backface culling, depth and fogging enabledness will be sent
to OpenGL.
<note>No special material state is flushed, so if you want Cogl to setup a
simplified material state it is your responsibility to set a simple source
material before calling cogl_begin_gl(). E.g. by calling
cogl_set_source_color4ub().</note>
<note>It is your responsibility to restore any OpenGL state that you modify
to how it was after calling cogl_begin_gl() if you don't do this then the
result of further Cogl calls is undefined.</note>
<note>You can not nest begin/end blocks.</note>
Again we would like to stress, we do not advise the use of this API and if
possible we would prefer to improve Cogl than have developers require raw
OpenGL.
Ensures that the current clipping region has been set in GL. This will automatically be called before any Cogl primitives but it maybe be neccessary to call if you are using raw GL calls with clipping.
Reverts the clipping region to the state before the last call to cogl_clip_push().
Specifies a rectangular clipping area for all subsequent drawing operations. Any drawing commands that extend outside the rectangle will be clipped so that only the portion inside the rectangle will be displayed. The rectangle dimensions are transformed by the current model-view matrix.
The rectangle is intersected with the current clip region. To undo the effect of this function, call cogl_clip_pop().
left edge of the clip rectangle
top edge of the clip rectangle
width of the clip rectangle
height of the clip rectangle
Specifies a rectangular clipping area for all subsequent drawing operations. Any drawing commands that extend outside the rectangle will be clipped so that only the portion inside the rectangle will be displayed. The rectangle dimensions are transformed by the current model-view matrix.
The rectangle is intersected with the current clip region. To undo the effect of this function, call cogl_clip_pop().
x coordinate for top left corner of the clip rectangle
y coordinate for top left corner of the clip rectangle
x coordinate for bottom right corner of the clip rectangle
y coordinate for bottom right corner of the clip rectangle
Specifies a rectangular clipping area for all subsequent drawing operations. Any drawing commands that extend outside the rectangle will be clipped so that only the portion inside the rectangle will be displayed. The rectangle dimensions are not transformed by the current model-view matrix.
The rectangle is intersected with the current clip region. To undo the effect of this function, call cogl_clip_pop().
left edge of the clip rectangle in window coordinates
top edge of the clip rectangle in window coordinates
width of the clip rectangle
height of the clip rectangle
Specifies a rectangular clipping area for all subsequent drawing operations. Any drawing commands that extend outside the rectangle will be clipped so that only the portion inside the rectangle will be displayed. The rectangle dimensions are not transformed by the current model-view matrix.
The rectangle is intersected with the current clip region. To undo the effect of this function, call cogl_clip_pop().
left edge of the clip rectangle in window coordinates
top edge of the clip rectangle in window coordinates
width of the clip rectangle
height of the clip rectangle
Restore the state of the clipping stack that was previously saved by cogl_clip_stack_save().
Save the entire state of the clipping stack and then clear all clipping. The previous state can be returned to with cogl_clip_stack_restore(). Each call to cogl_clip_push() after this must be matched by a call to cogl_clip_pop() before calling cogl_clip_stack_restore().
Create a new shader handle, use cogl_shader_source() to set the source code to be used on it.
COGL_SHADER_TYPE_VERTEX or COGL_SHADER_TYPE_FRAGMENT.
This function disables fogging, so primitives drawn afterwards will not be blended with any previously set fog color.
This is the counterpart to cogl_begin_gl() used to delimit blocks of drawing code using raw OpenGL. Please refer to cogl_begin_gl() for full details.
Checks whether the given COGL features are available. Multiple features can be checked for by or-ing them together with the '|' operator. %TRUE is only returned if all of the requested features are available.
A bitmask of features to check for
This function should only need to be called in exceptional circumstances.
As an optimization Cogl drawing functions may batch up primitives internally, so if you are trying to use raw GL outside of Cogl you stand a better chance of being successful if you ask Cogl to flush any batched geometry before making your state changes.
It only ensure that the underlying driver is issued all the commands necessary to draw the batched primitives. It provides no guarantees about when the driver will complete the rendering.
This provides no guarantees about the GL state upon returning and to avoid confusing Cogl you should aim to restore any changes you make before resuming use of Cogl.
If you are making state changes with the intention of affecting Cogl drawing primitives you are 100% on your own since you stand a good chance of conflicting with Cogl internals. For example clutter-gst which currently uses direct GL calls to bind ARBfp programs will very likely break when Cogl starts to use ARBfb programs itself for the material API.
Replaces the current projection matrix with a perspective matrix for a given viewing frustum defined by 4 side clip planes that all cross through the origin and 2 near and far clip planes.
X position of the left clipping plane where it intersects the near clipping plane
X position of the right clipping plane where it intersects the near clipping plane
Y position of the bottom clipping plane where it intersects the near clipping plane
Y position of the top clipping plane where it intersects the near clipping plane
The distance to the near clipping plane (Must be positive)
The distance to the far clipping plane (Must be positive)
Gets the number of bitplanes used for each of the color components in the color buffer. Pass %NULL for any of the arguments if the value is not required.
Returns all of the features supported by COGL.
Retrieves the #GOptionGroup used by Cogl to parse the command line options. Clutter uses this to handle the Cogl command line options during its initialization process.
Returns the current source material as previously set using cogl_set_source().
Stores the current viewport in v. v[0] and v[1] get the x and y
position of the viewport and v[2] and v[3] get the width and
height.
Drecreases the reference count of handle by 1; if the reference
count reaches 0, the resources allocated by handle will be freed
a #CoglHandle
Decrement the reference count for a #CoglMaterial.
a #CoglMaterial object.
Compares two matrices to see if they represent the same transformation. Although internally the matrices may have different annotations associated with them and may potentially have a cached inverse matrix these are not considered in the comparison.
A 4x4 transformation matrix
A 4x4 transformation matrix
Replaces the current projection matrix with an orthographic projection
matrix. See
The coordinate for the left clipping plane
The coordinate for the right clipping plane
The coordinate for the bottom clipping plane
The coordinate for the top clipping plane
The
The
Replaces the current projection matrix with a perspective matrix based on the provided values.
z_far / z_near
ratio since that will reduce the effectiveness of depth testing
since there wont be enough precision to identify the depth of
objects near to each other.
Vertical field of view angle in degrees.
The (width over height) aspect ratio for display
The distance to the near clipping plane (Must be positive)
The distance to the far clipping plane (Must be positive)
Draws a convex polygon using the current source material to fill / texture with according to the texture coordinates passed.
If use_color is %TRUE then the color will be changed for each vertex using
the value specified in the color member of #CoglTextureVertex. This can be
used for example to make the texture fade out by setting the alpha value of
the color.
All of the texture coordinates must be in the range [0,1] and repeating the texture is not supported.
Because of the way this function is implemented it will currently only work if either the texture is not sliced or the backend is not OpenGL ES and the minifying and magnifying functions are both set to COGL_MATERIAL_FILTER_NEAREST.
An array of #CoglTextureVertex structs
The length of the vertices array
%TRUE if the color member of #CoglTextureVertex should be used
Restore cogl_set_draw_buffer() state.
Restores the framebuffer that was previously at the top of the stack. All subsequent drawing will be redirected to this framebuffer.
Restores the current model-view matrix from the matrix stack.
Removes the material at the top of the source stack. The material at the top of this stack defines the GPU state used to process later primitives as defined by cogl_set_source().
Attaches a shader to a program object. A program can have multiple vertex or fragment shaders but only one of them may provide a main() function. It is allowed to use a program with only a vertex shader or only a fragment shader.
a #CoglHandle for a shdaer program.
a #CoglHandle for a vertex of fragment shader.
Retrieve the location (offset) of a uniform variable in a shader program, a uniform is a variable that is constant for all vertices/fragments for a shader object and is possible to modify as an external parameter.
a #CoglHandle for a shader program.
the name of a uniform.
Links a program making it ready for use. Note that calling this function is optional. If it is not called the program will automatically be linked the first time it is used.
a #CoglHandle for a shader program.
Changes the value of a floating point uniform for the given linked
program.
A #CoglHandle for a linked program
the uniform location retrieved from cogl_program_get_uniform_location().
the new value of the uniform.
Changes the value of an integer uniform for the given linked
program.
A #CoglHandle for a linked program
the uniform location retrieved from cogl_program_get_uniform_location().
the new value of the uniform.
Changes the value of a float vector uniform, or uniform array for
the given linked program.
A #CoglHandle for a linked program
the uniform location retrieved from cogl_program_get_uniform_location().
The number of components for the uniform. For example with glsl you'd use 3 for a vec3 or 4 for a vec4.
the new value of the uniform[s].
Changes the value of a int vector uniform, or uniform array for
the given linked program.
A #CoglHandle for a linked program
the uniform location retrieved from cogl_program_get_uniform_location().
The number of components for the uniform. For example with glsl you'd use 3 for a vec3 or 4 for a vec4.
the new value of the uniform[s].
Changes the value of a matrix uniform, or uniform array in the
given linked program.
A #CoglHandle for a linked program
the uniform location retrieved from cogl_program_get_uniform_location().
The dimensions of the matrix. So for for example pass 2 for a 2x2 matrix or 3 for 3x3.
Whether to transpose the matrix when setting the uniform.
the new value of the uniform.
Changes the value of a floating point uniform in the currently used (see cogl_program_use()) shader program.
the uniform to set.
the new value of the uniform.
Changes the value of an integer uniform in the currently used (see cogl_program_use()) shader program.
the uniform to set.
the new value of the uniform.
Changes the value of a float vector uniform, or uniform array in the currently used (see cogl_program_use()) shader program.
the uniform to set.
Size of float vector.
the new value of the uniform.
Changes the value of a int vector uniform, or uniform array in the currently used (see cogl_program_use()) shader program.
the uniform to set.
Size of int vector.
the new value of the uniform.
Changes the value of a matrix uniform, or uniform array in the
currently used (see cogl_program_use()) shader program. The size
parameter is used to determine the square size of the matrix.
the uniform to set.
Size of matrix.
Whether to transpose the matrix when setting the uniform.
the new value of the uniform.
Removes a reference to a program. If it was the last reference the program object will be destroyed.
A #CoglHandle to a program.
Activate a specific shader program replacing that part of the GL rendering pipeline, if passed in %COGL_INVALID_HANDLE the default behavior of GL is reinstated.
This function affects the global state of the current Cogl context. It is much more efficient to attach the shader to a specific material used for rendering instead by calling cogl_material_set_user_program().
a #CoglHandle for a shader program or %COGL_INVALID_HANDLE.
Save cogl_set_draw_buffer() state.
Stores the current model-view matrix on the matrix stack. The matrix can later be restored with cogl_pop_matrix().
Pushes the given material to the top of the source stack. The
material at the top of this stack defines the GPU state used to
process later primitives as defined by cogl_set_source().
A #CoglMaterial
This reads a rectangle of pixels from the current framebuffer where position (0, 0) is the top left. The pixel at (x, y) is the first read, and the data is returned with a rowstride of (width * 4).
Currently Cogl assumes that the framebuffer is in a premultiplied
format so if format is non-premultiplied it will convert it. To
read the pixel values without any conversion you should either
specify a format that doesn't use an alpha channel or use one of
the formats ending in PRE.
The window x position to start reading from
The window y position to start reading from
The width of the rectangle you want to read
The height of the rectangle you want to read
Identifies which auxillary buffer you want to read (only COGL_READ_PIXELS_COLOR_BUFFER supported currently)
The pixel format you want the result in (only COGL_PIXEL_FORMAT_RGBA_8888 supported currently)
The location to write the pixel data.
Fills a rectangle at the given coordinates with the current source material
X coordinate of the top-left corner
Y coordinate of the top-left corner
X coordinate of the bottom-right corner
Y coordinate of the bottom-right corner
This function draws a rectangle using the current source material to texture or fill with. As a material may contain multiple texture layers this interface lets you supply texture coordinates for each layer of the material.
The first pair of coordinates are for the first layer (with the smallest layer index) and if you supply less texture coordinates than there are layers in the current source material then default texture coordinates (0.0, 0.0, 1.0, 1.0) are generated.
x coordinate upper left on screen.
y coordinate upper left on screen.
x coordinate lower right on screen.
y coordinate lower right on screen.
An array containing groups of 4 float values: [tx1, ty1, tx2, ty2] that are interpreted as two texture coordinates; one for the upper left texel, and one for the lower right texel. Each value should be between 0.0 and 1.0, where the coordinate (0.0, 0.0) represents the top left of the texture, and (1.0, 1.0) the bottom right.
The length of the tex_coords array. (e.g. for one layer and one group of texture coordinates, this would be 4)
Draw a rectangle using the current material and supply texture coordinates
to be used for the first texture layer of the material. To draw the entire
texture pass in tx1=0.0 ty1=0.0 tx2=1.0 ty2=1.0.
x coordinate upper left on screen.
y coordinate upper left on screen.
x coordinate lower right on screen.
y coordinate lower right on screen.
x part of texture coordinate to use for upper left pixel
y part of texture coordinate to use for upper left pixel
x part of texture coordinate to use for lower right pixel
y part of texture coordinate to use for left pixel
Draws a series of rectangles in the same way that cogl_rectangle() does. In some situations it can give a significant performance boost to use this function rather than calling cogl_rectangle() separately for each rectangle.
verts should point to an array of #floats with
n_rects * 4 elements. Each group of 4 values corresponds to the
parameters x1, y1, x2, and y2, and have the same
meaning as in cogl_rectangle().
an array of vertices
number of rectangles to draw
Draws a series of rectangles in the same way that cogl_rectangle_with_texture_coords() does. In some situations it can give a significant performance boost to use this function rather than calling cogl_rectangle_with_texture_coords() separately for each rectangle.
verts should point to an array of #floats with
n_rects * 8 elements. Each group of 8 values corresponds to the
parameters x1, y1, x2, y2, tx1, ty1, tx2 and ty2 and have the same
meaning as in cogl_rectangle_with_texture_coords().
an array of vertices
number of rectangles to draw
Multiplies the current model-view matrix by one that rotates the
model around the vertex specified by x, y and z. The rotation
follows the right-hand thumb rule so for example rotating by 10
degrees about the vertex (0, 0, 1) causes a small counter-clockwise
rotation.
Angle in degrees to rotate.
X-component of vertex to rotate around.
Y-component of vertex to rotate around.
Z-component of vertex to rotate around.
Multiplies the current model-view matrix by one that scales the x, y and z axes by the given values.
Amount to scale along the x-axis
Amount to scale along the y-axis
Amount to scale along the z-axis
Sets whether textures positioned so that their backface is showing should be hidden. This can be used to efficiently draw two-sided textures or fully closed cubes without enabling depth testing. This only affects calls to the cogl_rectangle* family of functions and cogl_vertex_buffer_draw*. Backface culling is disabled by default.
%TRUE to enable backface culling or %FALSE to disable.
Sets whether depth testing is enabled. If it is disabled then the order that actors are layered on the screen depends solely on the order specified using clutter_actor_raise() and clutter_actor_lower(), otherwise it will also take into account the actor's depth. Depth testing is disabled by default.
%TRUE to enable depth testing or %FALSE to disable.
Redirects all subsequent drawing to the specified framebuffer. This can either be an offscreen buffer created with cogl_offscreen_new_to_texture () or you can revert to your original on screen window buffer.
A #CoglBufferTarget that specifies what kind of framebuffer you are setting as the render target.
If you are setting a framebuffer of type COGL_OFFSCREEN_BUFFER then this is a CoglHandle for the offscreen buffer.
Enables fogging. Fogging causes vertices that are further away from the eye
to be rendered with a different color. The color is determined according to
the chosen fog mode; at it's simplest the color is linearly interpolated so
that vertices at z_near are drawn fully with their original color and
vertices at z_far are drawn fully with fog_color. Fogging will remain
enabled until you call cogl_disable_fog().
The color of the fog
A #CoglFogMode that determines the equation used to calculate the fogging blend factor.
Used by %COGL_FOG_MODE_EXPONENTIAL and by %COGL_FOG_MODE_EXPONENTIAL_SQUARED equations.
Position along Z axis where no fogging should be applied
Position along Z axis where full fogging should be applied
This function changes the material at the top of the source stack. The material at the top of this stack defines the GPU state used to process subsequent primitives, such as rectangles drawn with cogl_rectangle() or vertices drawn using cogl_vertex_buffer_draw().
A #CoglMaterial
This is a convenience function for creating a solid fill source material from the given color. This color will be used for any subsequent drawing operation.
The color will be premultiplied by Cogl, so the color should be non-premultiplied. For example: use (1.0, 0.0, 0.0, 0.5) for semi-transparent red.
See also cogl_set_source_color4ub() and cogl_set_source_color4f() if you already have the color components.
This is a convenience function for creating a solid fill source material from the given color using normalized values for each component. This color will be used for any subsequent drawing operation.
The value for each component is a fixed point number in the range between 0 and %1.0. If the values passed in are outside that range, they will be clamped.
value of the red channel, between 0 and %1.0
value of the green channel, between 0 and %1.0
value of the blue channel, between 0 and %1.0
value of the alpha channel, between 0 and %1.0
This is a convenience function for creating a solid fill source material from the given color using unsigned bytes for each component. This color will be used for any subsequent drawing operation.
The value for each component is an unsigned byte in the range between 0 and 255.
value of the red channel, between 0 and 255
value of the green channel, between 0 and 255
value of the blue channel, between 0 and 255
value of the alpha channel, between 0 and 255
This is a convenience function for creating a material with the first
layer set to texture and setting that material as the source with
cogl_set_source.
Note: There is no interaction between calls to cogl_set_source_color
and cogl_set_source_texture. If you need to blend a texture with a color then
you can create a simple material like this:
Replaces the current viewport with the given values.
X offset of the viewport
Y offset of the viewport
Width of the viewport
Height of the viewport
Compiles the shader, no return value, but the shader is now ready for linking into a program. Note that calling this function is optional. If it is not called then the shader will be automatically compiled when it is linked.
#CoglHandle for a shader.
Retrieves the information log for a coglobject, can be used in conjunction with cogl_shader_get_parameteriv() to retrieve the compiler warnings/error messages that caused a shader to not compile correctly, mainly useful for debugging purposes.
#CoglHandle for a shader.
Retrieves the type of a shader #CoglHandle
#CoglHandle for a shader.
Replaces the current source associated with a shader with a new one.
Please see above for a description of the recommended format for the shader code.
#CoglHandle for a shader.
Shader source.
Removes a reference to a shader. If it was the last reference the shader object will be destroyed.
A #CoglHandle to a shader.
Very fast fixed point implementation of square root for integers.
This function is at least 6x faster than clib sqrt() on x86, and (this is not a typo!) about 500x faster on ARM without FPU. It's error is less than 5% for arguments smaller than %COGL_SQRTI_ARG_5_PERCENT and less than 10% for narguments smaller than %COGL_SQRTI_ARG_10_PERCENT. The maximum argument that can be passed to this function is %COGL_SQRTI_ARG_MAX.
integer value
Multiplies the current model-view matrix by one that translates the model along all three axes according to the given values.
Distance to translate along the x-axis
Distance to translate along the y-axis
Distance to translate along the z-axis
Adds an attribute to a buffer, or replaces a previously added attribute with the same name.
You either can use one of the built-in names such as "gl_Vertex", or "gl_MultiTexCoord0" to add standard attributes, like positions, colors and normals, or you can add custom attributes for use in shaders.
The number of vertices declared when calling cogl_vertex_buffer_new()
determines how many attribute values will be read from the supplied
pointer.
The data for your attribute isn't copied anywhere until you call cogl_vertex_buffer_submit(), or issue a draw call which automatically submits pending attribute changes. so the supplied pointer must remain valid until then. If you are updating an existing attribute (done by re-adding it) then you still need to re-call cogl_vertex_buffer_submit() to commit the changes to the GPU. Be carefull to minimize the number of calls to cogl_vertex_buffer_submit(), though.
A vertex buffer handle
The name of your attribute. It should be a valid GLSL variable name and standard attribute types must use one of following built-in names: (Note: they correspond to the built-in names of GLSL)
The number of components per attribute and must be 1, 2, 3 or 4
a #CoglAttributeType specifying the data type of each component.
If %TRUE, this specifies that values stored in an integer format should be mapped into the range [-1.0, 1.0] or [0.0, 1.0] for unsigned values. If %FALSE they are converted to floats directly.
This specifies the number of bytes from the start of one attribute value to the start of the next value (for the same attribute). So, for example, with a position interleved with color like this: XYRGBAXYRGBAXYRGBA, then if each letter represents a byte, the stride for both attributes is 6. The special value 0 means the values are stored sequentially in memory.
This addresses the first attribute in the vertex array. This must remain valid until you either call cogl_vertex_buffer_submit() or issue a draw call.
Deletes an attribute from a buffer. You will need to call cogl_vertex_buffer_submit() or issue a draw call to commit this change to the GPU.
A vertex buffer handle
The name of a previously added attribute
Disables a previosuly added attribute.
Since it can be costly to add and remove new attributes to buffers; to make individual buffers more reuseable it is possible to enable and disable attributes before using a buffer for drawing.
You don't need to call cogl_vertex_buffer_submit() after using this function.
A vertex buffer handle
The name of the attribute you want to disable
Allows you to draw geometry using all or a subset of the vertices in a vertex buffer.
Any un-submitted attribute changes are automatically submitted before drawing.
A vertex buffer handle
A #CoglVerticesMode specifying how the vertices should be interpreted.
Specifies the index of the first vertex you want to draw with
Specifies the number of vertices you want to draw.
This function lets you use an array of indices to specify the vertices within your vertex buffer that you want to draw. The indices themselves are created by calling cogl_vertex_buffer_indices_new ()
Any un-submitted attribute changes are automatically submitted before drawing.
A vertex buffer handle
A #CoglVerticesMode specifying how the vertices should be interpreted.
A CoglHandle for a set of indices allocated via cogl_vertex_buffer_indices_new ()
Specifies the minimum vertex index contained in indices
Specifies the maximum vertex index contained in indices
An offset into named indices. The offset marks the first index to use for drawing.
Specifies the number of vertices you want to draw.
Enables a previosuly disabled attribute.
Since it can be costly to add and remove new attributes to buffers; to make individual buffers more reuseable it is possible to enable and disable attributes before using a buffer for drawing.
You don't need to call cogl_vertex_buffer_submit() after using this function
A vertex buffer handle
The name of the attribute you want to enable
Retrieves the number of vertices that handle represents
A vertex buffer handle
Creates a vertex buffer containing the indices needed to draw pairs
of triangles from a list of vertices grouped as quads. There will
be at least n_indices entries in the buffer (but there may be
more).
The indices will follow this pattern:
0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7 ... etc
For example, if you submit vertices for a quad like like that shown
in
the number of indices in the vertex buffer.
Queries back the data type used for the given indices
An indices handle
Submits all the user added attributes to the GPU; once submitted, the attributes can be used for drawing.
You should aim to minimize calls to this function since it implies validating your data; it potentially incurs a transport cost (especially if you are using GLX indirect rendering) and potentially a format conversion cost if the GPU doesn't natively support any of the given attribute formats.
A vertex buffer handle
Decrement the reference count for a vertex buffer
a CoglHandle.
Replace the current viewport with the given values.
Width of the viewport
Height of the viewport
The number 0.5 expressed as a #CoglFixed number.