Enums¶

Details¶

class Cogl.AttributeType(value)¶

Bases: GObject.GEnum

Data types for the components of a vertex attribute.

New in version 1.0.

BYTE = 5120¶: Data is the same size of a byte

UNSIGNED_BYTE = 5121¶: Data is the same size of an unsigned byte

SHORT = 5122¶: Data is the same size of a short integer

UNSIGNED_SHORT = 5123¶: Data is the same size of an unsigned short integer

FLOAT = 5126¶: Data is the same size of a float

class Cogl.BitmapError(value)¶

Bases: GObject.GEnum

Error codes that can be thrown when performing bitmap operations. Note that gdk_pixbuf_new_from_file() can also throw errors directly from the underlying image loading library. For example, if GdkPixbuf is used then errors #GdkPixbufError s will be used directly.

New in version 1.4.

classmethod quark()¶

Return type:: int

FAILED = 0¶: Generic failure code, something went wrong.

UNKNOWN_TYPE = 1¶: Unknown image type.

CORRUPT_IMAGE = 2¶: An image file was broken somehow.

class Cogl.BlendStringError(value)¶

Bases: GObject.GEnum

Error enumeration for the blend strings parser

New in version 1.0.

classmethod quark()¶

Return type:: int

PARSE_ERROR = 0¶: Generic parse error

ARGUMENT_PARSE_ERROR = 1¶: Argument parse error

INVALID_ERROR = 2¶: Internal parser error

GPU_UNSUPPORTED_ERROR = 3¶: Blend string not supported by the GPU

class Cogl.DepthTestFunction(value)¶

Bases: GObject.GEnum

When using depth testing one of these functions is used to compare the depth of an incoming fragment against the depth value currently stored in the depth buffer. The function is changed using cogl_depth_state_set_test_function().

The test is only done when depth testing is explicitly enabled. (See cogl_depth_state_set_test_enabled())

NEVER = 512¶: Never passes.

LESS = 513¶: Passes if the fragment’s depth value is less than the value currently in the depth buffer.

EQUAL = 514¶: Passes if the fragment’s depth value is equal to the value currently in the depth buffer.

LEQUAL = 515¶: Passes if the fragment’s depth value is less or equal to the value currently in the depth buffer.

GREATER = 516¶: Passes if the fragment’s depth value is greater than the value currently in the depth buffer.

NOTEQUAL = 517¶: Passes if the fragment’s depth value is not equal to the value currently in the depth buffer.

GEQUAL = 518¶: Passes if the fragment’s depth value greater than or equal to the value currently in the depth buffer.

ALWAYS = 519¶: Always passes.

class Cogl.FilterReturn(value)¶

Bases: GObject.GEnum

Return values for the #CoglXlibFilterFunc and #CoglWin32FilterFunc functions.

CONTINUE = 0¶: The event was not handled, continues the processing

REMOVE = 1¶: Remove the event, stops the processing

class Cogl.FogMode(value)¶

Bases: GObject.GEnum

The fog mode determines the equation used to calculate the fogging blend factor while fogging is enabled. The simplest Cogl.FogMode.LINEAR mode determines f as:

f = end - eye_distance / end - start

Where eye_distance is the distance of the current fragment in eye coordinates from the origin.

New in version 1.0.

LINEAR = 0¶

Calculates the fog blend factor as:

f = end - eye_distance / end - start

EXPONENTIAL = 1¶

Calculates the fog blend factor as:

f = e ^ -(density * eye_distance)

EXPONENTIAL_SQUARED = 2¶

Calculates the fog blend factor as:

f = e ^ -(density * eye_distance)^2

class Cogl.IndicesType(value)¶

Bases: GObject.GEnum

You should aim to use the smallest data type that gives you enough range, since it reduces the size of your index array and can help reduce the demand on memory bandwidth.

Note that Cogl.IndicesType.INT is only supported if the %COGL_FEATURE_ID_UNSIGNED_INT_INDICES feature is available. This should always be available on OpenGL but on OpenGL ES it will only be available if the GL_OES_element_index_uint extension is advertized.

BYTE = 0¶: Your indices are unsigned bytes

SHORT = 1¶: Your indices are unsigned shorts

INT = 2¶: Your indices are unsigned ints

class Cogl.MaterialAlphaFunc(value)¶

Bases: GObject.GEnum

Alpha testing happens before blending primitives with the framebuffer and gives an opportunity to discard fragments based on a comparison with the incoming alpha value and a reference alpha value. The Cogl.MaterialAlphaFunc determines how the comparison is done.

NEVER = 512¶: Never let the fragment through.

LESS = 513¶: Let the fragment through if the incoming alpha value is less than the reference alpha value

EQUAL = 514¶: Let the fragment through if the incoming alpha value equals the reference alpha value

LEQUAL = 515¶: Let the fragment through if the incoming alpha value is less than or equal to the reference alpha value

GREATER = 516¶: Let the fragment through if the incoming alpha value is greater than the reference alpha value

NOTEQUAL = 517¶: Let the fragment through if the incoming alpha value does not equal the reference alpha value

GEQUAL = 518¶: Let the fragment through if the incoming alpha value is greater than or equal to the reference alpha value.

ALWAYS = 519¶: Always let the fragment through.

class Cogl.MaterialFilter(value)¶

Bases: GObject.GEnum

Texture filtering is used whenever the current pixel maps either to more than one texture element (texel) or less than one. These filter enums correspond to different strategies used to come up with a pixel color, by possibly referring to multiple neighbouring texels and taking a weighted average or simply using the nearest texel.

NEAREST = 9728¶: Measuring in manhatten distance from the, current pixel center, use the nearest texture texel

LINEAR = 9729¶: Use the weighted average of the 4 texels nearest the current pixel center

NEAREST_MIPMAP_NEAREST = 9984¶: Select the mimap level whose texel size most closely matches the current pixel, and use the Cogl.MaterialFilter.NEAREST criterion

LINEAR_MIPMAP_NEAREST = 9985¶: Select the mimap level whose texel size most closely matches the current pixel, and use the Cogl.MaterialFilter.LINEAR criterion

NEAREST_MIPMAP_LINEAR = 9986¶: Select the two mimap levels whose texel size most closely matches the current pixel, use the Cogl.MaterialFilter.NEAREST criterion on each one and take their weighted average

LINEAR_MIPMAP_LINEAR = 9987¶: Select the two mimap levels whose texel size most closely matches the current pixel, use the Cogl.MaterialFilter.LINEAR criterion on each one and take their weighted average

class Cogl.MaterialLayerType(value)¶

Bases: GObject.GEnum

Available types of layers for a Cogl.Material. This enumeration might be expanded in later versions.

New in version 1.0.

TEXTURE = 0¶

The layer represents a

‘texture [cogl-Textures]’

class Cogl.MaterialWrapMode(value)¶

Bases: GObject.GEnum

The wrap mode specifies what happens when texture coordinates outside the range 0→1 are used. Note that if the filter mode is anything but Cogl.MaterialFilter.NEAREST then texels outside the range 0→1 might be used even when the coordinate is exactly 0 or 1 because OpenGL will try to sample neighbouring pixels. For example if you are trying to render the full texture then you may get artifacts around the edges when the pixels from the other side are merged in if the wrap mode is set to repeat.

New in version 1.4.

REPEAT = 10497¶: The texture will be repeated. This is useful for example to draw a tiled background.

CLAMP_TO_EDGE = 33071¶: The coordinates outside the range 0→1 will sample copies of the edge pixels of the texture. This is useful to avoid artifacts if only one copy of the texture is being rendered.

AUTOMATIC = 519¶: Cogl will try to automatically decide which of the above two to use. For Cogl.rectangle(), it will use repeat mode if any of the texture coordinates are outside the range 0→1, otherwise it will use clamp to edge. For Cogl.polygon() it will always use repeat mode. For Cogl.vertex_buffer_draw() it will use repeat mode except for layers that have point sprite coordinate generation enabled. This is the default value.

class Cogl.PixelFormat(value)¶

Bases: GObject.GEnum

Pixel formats used by Cogl. For the formats with a byte per component, the order of the components specify the order in increasing memory addresses. So for example Cogl.PixelFormat.RGB_888 would have the red component in the lowest address, green in the next address and blue after that regardless of the endianness of the system.

For the formats with non byte aligned components the component order specifies the order within a 16-bit or 32-bit number from most significant bit to least significant. So for Cogl.PixelFormat.RGB_565, the red component would be in bits 11-15, the green component would be in 6-11 and the blue component would be in 1-5. Therefore the order in memory depends on the endianness of the system.

When uploading a texture Cogl.PixelFormat.ANY can be used as the internal format. Cogl will try to pick the best format to use internally and convert the texture data if necessary.

New in version 0.8.

ANY = 0¶: Any format

ABGR_8888 = 115¶: ABGR, 32 bits

ABGR_2101010 = 125¶: ABGR, 32 bits, 10 bpc

RGBA_8888_PRE = 147¶: Premultiplied RGBA, 32 bits

RGBA_4444_PRE = 149¶: Premultiplied RGBA, 16 bits

RGBA_5551_PRE = 150¶: Premultiplied RGBA, 16 bits

RGBA_1010102_PRE = 157¶: Premultiplied RGBA, 32 bits, 10 bpc

A_8 = 17¶: 8 bits alpha mask

BGRA_8888_PRE = 179¶: Premultiplied BGRA, 32 bits

BGRA_1010102_PRE = 189¶: Premultiplied BGRA, 32 bits, 10 bpc

RGBA_8888 = 19¶: RGBA, 32 bits

RGB_888 = 2¶: RGB, 24 bits

RGBA_4444 = 21¶: RGBA, 16 bits

ARGB_8888_PRE = 211¶: Premultiplied ARGB, 32 bits

RGBA_5551 = 22¶: RGBA, 16 bits

ARGB_2101010_PRE = 221¶: Premultiplied ARGB, 32 bits, 10 bpc

ABGR_8888_PRE = 243¶: Premultiplied ABGR, 32 bits

ABGR_2101010_PRE = 253¶: Premultiplied ABGR, 32 bits, 10 bpc

DEPTH_32 = 259¶

DEPTH_16 = 265¶

RGBA_1010102 = 29¶: RGBA, 32 bits, 10 bpc

BGR_888 = 34¶: BGR, 24 bits

RGB_565 = 4¶: RGB, 16 bits

BGRA_8888 = 51¶: BGRA, 32 bits

BGRA_1010102 = 61¶: BGRA, 32 bits, 10 bpc

YUV = 7¶: Not currently supported

DEPTH_24_STENCIL_8 = 771¶

G_8 = 8¶: Single luminance component

ARGB_8888 = 83¶: ARGB, 32 bits

RG_88 = 9¶: RG, 16 bits. Note that red-green textures are only available if %COGL_FEATURE_ID_TEXTURE_RG is advertised. See Cogl.Texture.set_components() for details.

ARGB_2101010 = 93¶: ARGB, 32 bits, 10 bpc

class Cogl.RendererError(value)¶

Bases: GObject.GEnum

XLIB_DISPLAY_OPEN = 0¶

BAD_CONSTRAINT = 1¶

class Cogl.ShaderType(value)¶

Bases: GObject.GEnum

Types of shaders

New in version 1.0.

VERTEX = 0¶: A program for proccessing vertices

FRAGMENT = 1¶: A program for processing fragments

class Cogl.StereoMode(value)¶

Bases: GObject.GEnum

Represents how draw should affect the two buffers of a stereo framebuffer. See cogl_framebuffer_set_stereo_mode().

BOTH = 0¶: draw to both stereo buffers

LEFT = 1¶: draw only to the left stereo buffer

RIGHT = 2¶: draw only to the left stereo buffer

class Cogl.SystemError(value)¶

Bases: GObject.GEnum

Error enumeration for Cogl

The Cogl.SystemError.COGL_SYSTEM_ERROR_UNSUPPORTED error can be thrown for a variety of reasons. For example:

<itemizedlist> <listitem><para>You’ve tried to use a feature that is not advertised by cogl_has_feature(). This could happen if you create a 2d texture with a non-power-of-two size when %COGL_FEATURE_ID_TEXTURE_NPOT is not advertised.</para></listitem> <listitem><para>The GPU can not handle the configuration you have requested. An example might be if you try to use too many texture layers in a single #CoglPipeline</para></listitem> <listitem><para>The driver does not support some configuration.</para></listiem> </itemizedlist>

Currently this is only used by Cogl API marked as experimental so this enum should also be considered experimental.

New in version 1.4.

COGL_SYSTEM_ERROR_UNSUPPORTED = 0¶: You tried to use a feature or configuration not currently available.

COGL_SYSTEM_ERROR_NO_MEMORY = 1¶: You tried to allocate a resource such as a texture and there wasn’t enough memory.

class Cogl.TextureComponents(value)¶

Bases: GObject.GEnum

See Cogl.Texture.set_components().

New in version 1.18.

A = 1¶: Only the alpha component

RG = 2¶: Red and green components. Note that this can only be used if the %COGL_FEATURE_ID_TEXTURE_RG feature is advertised.

RGB = 3¶: Red, green and blue components

RGBA = 4¶: Red, green, blue and alpha components

DEPTH = 5¶: Only a depth component

class Cogl.TextureError(value)¶

Bases: GObject.GEnum

Error codes that can be thrown when allocating textures.

New in version 1.8.

classmethod quark()¶

Return type:: int

SIZE = 0¶: Unsupported size

FORMAT = 1¶: Unsupported format

BAD_PARAMETER = 2¶

TYPE = 3¶: A primitive texture type that is unsupported by the driver was used

class Cogl.TextureType(value)¶

Bases: GObject.GEnum

Constants representing the underlying hardware texture type of a Cogl.Texture.

New in version 1.10.

2D = 0¶

_2D = 0¶: A #CoglTexture2D

3D = 1¶

_3D = 1¶: A #CoglTexture3D

RECTANGLE = 2¶: A #CoglTextureRectangle

class Cogl.VerticesMode(value)¶

Bases: GObject.GEnum

Different ways of interpreting vertices when drawing.

New in version 1.0.

POINTS = 0¶

FIXME, equivalent to

GL_POINTS

LINES = 1¶: FIXME, equivalent to GL_LINES

LINE_LOOP = 2¶

FIXME, equivalent to

GL_LINE_LOOP

LINE_STRIP = 3¶

FIXME, equivalent to

GL_LINE_STRIP

TRIANGLES = 4¶

FIXME, equivalent to

GL_TRIANGLES

TRIANGLE_STRIP = 5¶

FIXME, equivalent to

GL_TRIANGLE_STRIP

TRIANGLE_FAN = 6¶: FIXME, equivalent to GL_TRIANGLE_FAN

class Cogl.Winding(value)¶

Bases: GObject.GEnum

Enum used to represent the two directions of rotation. This can be used to set the front face for culling by calling cogl_pipeline_set_front_face_winding().

CLOCKWISE = 0¶: Vertices are in a clockwise order

COUNTER_CLOCKWISE = 1¶: Vertices are in a counter-clockwise order

class Cogl.WinsysFeature(value)¶

Bases: GObject.GEnum

MULTIPLE_ONSCREEN = 0¶

SWAP_THROTTLE = 1¶

SYNC_AND_COMPLETE_EVENT = 10¶

N_FEATURES = 11¶

VBLANK_COUNTER = 2¶

VBLANK_WAIT = 3¶

TEXTURE_FROM_PIXMAP = 4¶

SWAP_BUFFERS_EVENT = 5¶

SWAP_REGION = 6¶

SWAP_REGION_THROTTLE = 7¶

SWAP_REGION_SYNCHRONIZED = 8¶

BUFFER_AGE = 9¶