Functions for managing textures in Cogl's global set of texture atlases A texture atlas is a texture that contains many smaller images that an application is interested in. These are packed together as a way of optimizing drawing with those images by avoiding the costs of repeatedly telling the hardware to change what texture it should sample from. This can enable more geometry to be batched together into few draw calls. Each #CoglContext has an shared, pool of texture atlases that are are managed by Cogl. This api lets applications upload texture data into one of Cogl's shared texture atlases using a high-level #CoglAtlasTexture which represents a sub-region of one of these atlases. A #CoglAtlasTexture is a high-level meta texture which has some limitations to be aware of. Creates a new #CoglAtlasTexture texture based on data residing in a @bmp. A #CoglAtlasTexture represents a sub-region within one of Cogl's shared texture atlases. The storage for the texture is not allocated before this function returns. You can call cogl_texture_allocate() to explicitly allocate the underlying storage or preferably let Cogl automatically allocate storage lazily when it may know more about how the texture is being used and can optimize how it is allocated. The texture is still configurable until it has been allocated so for example you can influence the internal format of the texture using cogl_texture_set_components() and cogl_texture_set_premultiplied(). Allocate call can fail if Cogl considers the internal format to be incompatible with the format of its internal atlases. The returned #CoglAtlasTexture is a high-level meta-texture with some limitations. A new #CoglAtlasTexture object. A #CoglBitmap Creates a #CoglAtlasTexture with a given @width and @height. A #CoglAtlasTexture represents a sub-region within one of Cogl's shared texture atlases. The storage for the texture is not allocated before this function returns. You can call cogl_texture_allocate() to explicitly allocate the underlying storage or let Cogl automatically allocate storage lazily. The texture is still configurable until it has been allocated so for example you can influence the internal format of the texture using cogl_texture_set_components() and cogl_texture_set_premultiplied(). Allocate call can fail if Cogl considers the internal format to be incompatible with the format of its internal atlases. The returned #CoglAtlasTexture is a high-level meta-texture with some limitations. A new #CoglAtlasTexture object. A #CoglContext The width of your atlased texture. The height of your atlased texture. Describes the layout for a list of vertex attribute values (For example, a list of texture coordinates or colors). The @name is used to access the attribute inside a GLSL vertex shader and there are some special names you should use if they are applicable: - "cogl_position_in" (used for vertex positions) - "cogl_color_in" (used for vertex colors) - "cogl_tex_coord0_in", "cogl_tex_coord1", ... (used for vertex texture coordinates) - "cogl_normal_in" (used for vertex normals) - "cogl_point_size_in" (used to set the size of points per-vertex. Note this can only be used if %COGL_FEATURE_ID_POINT_SIZE_ATTRIBUTE is advertised and cogl_pipeline_set_per_vertex_point_size() is called on the pipeline. The attribute values corresponding to different vertices can either be tightly packed or interleaved with other attribute values. For example it's common to define a structure for a single vertex like: ```c typedef struct { float x, y, z; /<!-- -->* position attribute *<!-- -->/ float s, t; /<!-- -->* texture coordinate attribute *<!-- -->/ } MyVertex; ``` And then create an array of vertex data something like: ```c MyVertex vertices[100] = { .... } ``` In this case, to describe either the position or texture coordinate attribute you have to move `sizeof (MyVertex)` bytes to move from one vertex to the next. This is called the attribute @stride. If you weren't interleving attributes and you instead had a packed array of float x, y pairs then the attribute stride would be `(2 * sizeof (float))`. So the @stride is the number of bytes to move to find the attribute value of the next vertex. Normally a list of attributes starts at the beginning of an array. So for the `MyVertex` example above the @offset is the offset inside the `MyVertex` structure to the first component of the attribute. For the texture coordinate attribute the offset would be `offsetof (MyVertex, s)` or instead of using the offsetof macro you could use `sizeof (float) * 3`. If you've divided your @array into blocks of non-interleved attributes then you will need to calculate the @offset as the number of bytes in blocks preceding the attribute you're describing. An attribute often has more than one component. For example a color is often comprised of 4 red, green, blue and alpha @components, and a position may be comprised of 2 x and y @components. You should aim to keep the number of components to a minimum as more components means more data needs to be mapped into the GPU which can be a bottleneck when dealing with a large number of vertices. Finally you need to specify the component data type. Here you should aim to use the smallest type that meets your precision requirements. Again the larger the type then more data needs to be mapped into the GPU which can be a bottleneck when dealing with a large number of vertices. A newly allocated #CoglAttribute describing the layout for a list of attribute values stored in @array. The #CoglAttributeBuffer containing the actual attribute data The name of the attribute (used to reference it from GLSL) The number of bytes to jump to get to the next attribute value for the next vertex. (Usually `sizeof (MyVertex)`) The byte offset from the start of @attribute_buffer for the first attribute value. (Usually `offsetof (MyVertex, component0)` The number of components (e.g. 4 for an rgba color or 3 for and (x,y,z) position) FIXME the #CoglAttributeBuffer that was set with cogl_attribute_new(). A #CoglAttribute Sets whether fixed point attribute types are mapped to the range 0→1. For example when this property is TRUE and a %COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE type is used then the value 255 will be mapped to 1.0. The default value of this property depends on the name of the attribute. For the builtin properties cogl_color_in and cogl_normal_in it will default to TRUE and for all other names it will default to FALSE. A #CoglAttribute The new value for the normalized property. Functions for creating and manipulating attribute buffers Describes a new #CoglAttributeBuffer of @size bytes to contain arrays of vertex attribute data and also uploads @size bytes read from @data to the new buffer. You should never pass a %NULL data pointer. This function does not report out-of-memory errors back to the caller by returning %NULL and so you can assume this function always succeeds. In the unlikely case that there is an out of memory problem then Cogl will abort the application with a message. If your application needs to gracefully handle out-of-memory errors then you can use cogl_attribute_buffer_new_with_size() and then explicitly catch errors with cogl_buffer_set_data() or cogl_buffer_map(). A newly allocated #CoglAttributeBuffer (never %NULL) A #CoglContext The number of bytes to allocate for vertex attribute data. An optional pointer to vertex data to upload immediately. Describes a new #CoglAttributeBuffer of @size bytes to contain arrays of vertex attribute data. Afterwards data can be set using cogl_buffer_set_data() or by mapping it into the application's address space using cogl_buffer_map(). The underlying storage of this buffer isn't allocated by this function so that you have an opportunity to use the cogl_buffer_set_update_hint() functions which may influence how the storage is allocated. The storage will be allocated once you upload data to the buffer. Note: You can assume this function always succeeds and won't return %NULL A newly allocated #CoglAttributeBuffer. Never %NULL. A #CoglContext The number of bytes to allocate for vertex attribute data. Data types for the components of a vertex attribute. Data is the same size of a byte Data is the same size of an unsigned byte Data is the same size of a short integer Data is the same size of an unsigned short integer Data is the same size of a float Functions for loading images Cogl allows loading image data into memory as CoglBitmaps without loading them immediately into GPU textures. Creates a bitmap using some existing data. The data is not copied so the application must keep the buffer alive for the lifetime of the #CoglBitmap. This can be used for example with [method@Cogl.Framebuffer.read_pixels_into_bitmap] to read data directly into an application buffer with the specified rowstride. A new #CoglBitmap. A #CoglContext The width of the bitmap. The height of the bitmap. The format of the pixel data. The rowstride of the bitmap (the number of bytes from the start of one row of the bitmap to the next). A pointer to the data. The bitmap will take ownership of this data. Wraps some image data that has been uploaded into a #CoglBuffer as a #CoglBitmap. The data is not copied in this process. a #CoglBitmap encapsulating the given @buffer. A #CoglBuffer containing image data The #CoglPixelFormat defining the format of the image data in the given @buffer. The width of the image data in the given @buffer. The height of the image data in the given @buffer. The rowstride in bytes of the image data in the given @buffer. The offset into the given @buffer to the first pixel that should be considered part of the #CoglBitmap. Creates a new #CoglBitmap with the given width, height and format. The initial contents of the bitmap are undefined. The data for the bitmap will be stored in a newly created #CoglPixelBuffer. You can get a pointer to the pixel buffer using [method@Cogl.Bitmap.get_buffer]. The #CoglBuffer API can then be used to fill the bitmap with data. Cogl will try its best to provide a hardware array you can map, write into and effectively do a zero copy upload when creating a texture from it with cogl_texture_new_from_bitmap(). For various reasons, such arrays are likely to have a stride larger than width * bytes_per_pixel. The user must take the stride into account when writing into it. The stride can be retrieved with [method@Cogl.Bitmap.get_rowstride]. a #CoglPixelBuffer representing the newly created array or %NULL on failure A #CoglContext width of the bitmap in pixels height of the bitmap in pixels the format of the pixels the array will store the #CoglPixelBuffer that this buffer uses for storage. A #CoglBitmap the #CoglPixelFormat that the data for the bitmap is in. A #CoglBitmap the height of the bitmap A #CoglBitmap the rowstride of the bitmap. This is the number of bytes between the address of start of one row to the address of the next row in the image. A #CoglBitmap the width of the bitmap A #CoglBitmap Common buffer functions, including data upload APIs The CoglBuffer API provides a common interface to manipulate buffers that have been allocated either via `cogl_pixel_buffer_new()` or `cogl_attribute_buffer_new()`. The API allows you to upload data to these buffers and define usage hints that help Cogl manage your buffer optimally. Data can either be uploaded by supplying a pointer and size so Cogl can copy your data, or you can mmap() a CoglBuffer and then you can copy data to the buffer directly. One of the most common uses for CoglBuffers is to upload texture data asynchronously since the ability to mmap the buffers into the CPU makes it possible for another thread to handle the IO of loading an image file and unpacking it into the mapped buffer without blocking other Cogl operations. Retrieves the size of buffer the size of the buffer in bytes a buffer object Retrieves the update hints set using [method@Cogl.Buffer.set_update_hint] the #CoglBufferUpdateHint currently used by the buffer a buffer object Maps the buffer into the application address space for direct access. This is equivalent to calling [method@Cogl.Buffer.map_range] with zero as the offset and the size of the entire buffer as the size. It is strongly recommended that you pass %COGL_BUFFER_MAP_HINT_DISCARD as a hint if you are going to replace all the buffer's data. This way if the buffer is currently being used by the GPU then the driver won't have to stall the CPU and wait for the hardware to finish because it can instead allocate a new buffer to map. The behaviour is undefined if you access the buffer in a way conflicting with the @access mask you pass. It is also an error to release your last reference while the buffer is mapped. A pointer to the mapped memory or %NULL is the call fails a buffer object how the mapped buffer will be used by the application A mask of `CoglBufferMapHint`s that tell Cogl how the data will be modified once mapped. Maps a sub-region of the buffer into the application's address space for direct access. It is strongly recommended that you pass %COGL_BUFFER_MAP_HINT_DISCARD as a hint if you are going to replace all the buffer's data. This way if the buffer is currently being used by the GPU then the driver won't have to stall the CPU and wait for the hardware to finish because it can instead allocate a new buffer to map. You can pass %COGL_BUFFER_MAP_HINT_DISCARD_RANGE instead if you want the regions outside of the mapping to be retained. The behaviour is undefined if you access the buffer in a way conflicting with the @access mask you pass. It is also an error to release your last reference while the buffer is mapped. A pointer to the mapped memory or %NULL is the call fails a buffer object Offset within the buffer to start the mapping The size of data to map how the mapped buffer will be used by the application A mask of `CoglBufferMapHint`s that tell Cogl how the data will be modified once mapped. Updates part of the buffer with new data from @data. Where to put this new data is controlled by @offset and @offset + @data should be less than the buffer size. %TRUE is the operation succeeded, %FALSE otherwise a buffer object destination offset (in bytes) in the buffer a pointer to the data to be copied into the buffer number of bytes to copy Sets the update hint on a buffer. See #CoglBufferUpdateHint for a description of the available hints. a buffer object the new hint Unmaps a buffer previously mapped by [method@Cogl.Buffer.map]. a buffer object The access hints for [method@Cogl.Buffer.set_update_hint] the buffer will be read the buffer will written to the buffer will be used for both reading and writing Types of auxiliary buffers Selects the primary color buffer Selects the depth buffer Selects the stencil buffer Hints to Cogl about how you are planning to modify the data once it is mapped. Tells Cogl that you plan to replace all the buffer's contents. When this flag is used to map a buffer, the entire contents of the buffer become undefined, even if only a subregion of the buffer is mapped. Tells Cogl that you plan to replace all the contents of the mapped region. The contents of the region specified are undefined after this flag is used to map a buffer. The update hint on a buffer allows the user to give some detail on how often the buffer data is going to be updated. the buffer will not change over time the buffer will change from time to time the buffer will be used once or a couple of times A macro that initializes a #CoglColor, to be used when declaring it. A generic color definition #CoglColor is a simple structure holding the definition of a color such that it can be efficiently used by GL Creates a copy of @color a newly-allocated #CoglColor. Use cogl_color_free() to free the allocate resources the color to copy Compares two `CoglColor`s and checks if they are the same. This function can be passed to g_hash_table_new() as the @key_equal_func parameter, when using `CoglColor`s as keys in a #GHashTable. %TRUE if the two colors are the same. a #CoglColor a #CoglColor Frees the resources allocated by cogl_color_new() and cogl_color_copy() the color to free Retrieves the alpha channel of @color as a fixed point value between 0 and 1.0. the alpha channel of the passed color a #CoglColor Retrieves the blue channel of @color as a fixed point value between 0 and 1.0. the blue channel of the passed color a #CoglColor Retrieves the green channel of @color as a fixed point value between 0 and 1.0. the green channel of the passed color a #CoglColor Retrieves the red channel of @color as a fixed point value between 0 and 1.0. the red channel of the passed color a #CoglColor Converts a #CoglColor to a hash value. This function can be passed to g_hash_table_new() as the @hash_func parameter, when using `CoglColor`s as keys in a #GHashTable. a hash value corresponding to the color a #CoglColor Sets the values of the passed channels into a #CoglColor A pointer to a #CoglColor to initialize 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 Converts a non-premultiplied color to a pre-multiplied color. For example, semi-transparent red is (1.0, 0, 0, 0.5) when non-premultiplied and (0.5, 0, 0, 0.5) when premultiplied. the color to premultiply Converts @color to the HLS format. The @hue value is in the 0 .. 360 range. The @luminance and @saturation values are in the 0 .. 1 range. a #CoglColor return location for the hue value or %NULL return location for the saturation value or %NULL return location for the luminance value or %NULL Returns a textual specification of @color in the hexadecimal form `&num;rrggbbaa`, where `r`, `g`, `b` and `a` are hexadecimal digits representing the red, green, blue and alpha components respectively. a newly-allocated text string a #CoglColor Parses a string definition of a color, filling the #CoglColor.red, #CoglColor.green, #CoglColor.blue and #CoglColor.alpha fields of @color. The @color is not allocated. The format of @str can be either one of: - an hexadecimal value in the form: `#rgb`, `#rrggbb`, `#rgba`, or `#rrggbbaa` - a RGB color in the form: `rgb(r, g, b)` - a RGB color in the form: `rgba(r, g, b, a)` - a HSL color in the form: `hsl(h, s, l)` -a HSL color in the form: `hsla(h, s, l, a)` where 'r', 'g', 'b' and 'a' are (respectively) the red, green, blue color intensities and the opacity. The 'h', 's' and 'l' are (respectively) the hue, saturation and luminance values. In the rgb() and rgba() formats, the 'r', 'g', and 'b' values are either integers between 0 and 255, or percentage values in the range between 0% and 100%; the percentages require the '%' character. The 'a' value, if specified, can only be a floating point value between 0.0 and 1.0. In the hls() and hlsa() formats, the 'h' value (hue) is an angle between 0 and 360.0 degrees; the 'l' and 's' values (luminance and saturation) are percentage values in the range between 0% and 100%. The 'a' value, if specified, can only be a floating point value between 0.0 and 1.0. Whitespace inside the definitions is ignored; no leading whitespace is allowed. If the alpha component is not specified then it is assumed to be set to be fully opaque. %TRUE if parsing succeeded, and %FALSE otherwise return location for a #CoglColor a string specifying a color Converts a color expressed in HLS (hue, luminance and saturation) values into a #CoglColor. return location for a #CoglColor hue value, in the 0 .. 360 range saturation value, in the 0 .. 1 range luminance value, in the 0 .. 1 range The top level application context. A #CoglContext is the top most sandbox of Cogl state for an application or toolkit. Its main purpose is to act as a sandbox for the memory management of state objects. Normally an application will only create a single context since there is no way to share resources between contexts. For those familiar with OpenGL or perhaps Cairo it should be understood that unlike these APIs a Cogl context isn't a rendering context as such. In other words Cogl doesn't aim to provide a state machine style model for configuring rendering parameters. Most rendering state in Cogl is directly associated with user managed objects called pipelines and geometry is drawn with a specific pipeline object to a framebuffer object and those 3 things fully define the state for drawing. This is an important part of Cogl's design since it helps you write orthogonal rendering components that can all access the same GPU without having to worry about what state other components have left you with. Cogl does not maintain internal references to the context for resources that depend on the context so applications. This is to help applications control the lifetime a context without us needing to introduce special api to handle the breakup of internal circular references due to internal resources and caches associated with the context. One a context has been destroyed then all directly or indirectly dependent resources will be in an inconsistent state and should not be manipulated or queried in any way. For applications that rely on the operating system to clean up resources this policy shouldn't affect them, but for applications that need to carefully destroy and re-create Cogl contexts multiple times throughout their lifetime (such as Android applications) they should be careful to destroy all context dependent resources, such as framebuffers or textures etc before unrefing and destroying the context. Creates a new #CoglContext which acts as an application sandbox for any state objects that are allocated. A newly allocated #CoglContext A #CoglDisplay pointer 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 pipeline API. A #CoglContext a #CoglContext pointer a #CoglTimestampQuery Retrieves the #CoglDisplay that is internally associated with the given @context. This will return the same #CoglDisplay that was passed to cogl_context_new() or if %NULL was passed to cogl_context_new() then this function returns a pointer to the display that was automatically setup internally. The #CoglDisplay associated with the given @context. A #CoglContext pointer This function should only be called if the COGL_FEATURE_ID_TIMESTAMP_QUERY feature is advertised. Current GPU time in nanoseconds a #CoglContext pointer Returns the graphics reset status as reported by GetGraphicsResetStatusARB defined in the ARB_robustness extension. Note that Cogl doesn't normally enable the ARB_robustness extension in which case this will only ever return #COGL_GRAPHICS_RESET_STATUS_NO_ERROR. a #CoglGraphicsResetStatus a #CoglContext pointer This function is used to get support for waiting on previous GPU work through sync fds. It will return a sync fd which will signal when the previous work has completed. sync fd for latest GPU submission if available, returns -1 if not. a #CoglContext pointer The #CoglPipeline associated with the given @context and @key, or %NULL if no such #CoglPipeline was found. a #CoglContext pointer a #CoglPipelineKey pointer a #CoglIndices Retrieves the #CoglRenderer that is internally associated with the given @context. This will return the same #CoglRenderer that was passed to cogl_display_new() or if %NULL was passed to cogl_display_new() or cogl_context_new() then this function returns a pointer to the renderer that was automatically connected internally. The #CoglRenderer associated with the given @context. A #CoglContext pointer Checks if a given @feature is currently available Cogl does not aim to be a lowest common denominator API, it aims to expose all the interesting features of GPUs to application which means applications have some responsibility to explicitly check that certain features are available before depending on them. %TRUE if the @feature is currently supported or %FALSE if not. A #CoglContext pointer A #CoglFeatureID %TRUE if the @context is hardware accelerated, or %FALSE if not. a #CoglContext pointer Associate a #CoglPipeline with a @context and @key. This will not take a new reference to the @pipeline, but will unref all associated pipelines when the @context gets destroyed. Similarly, if a pipeline gets overwritten, it will get unreffed as well. a #CoglContext pointer a #CoglPipelineKey pointer a #CoglPipeline to associate with the @context and @key Functions for describing the depth testing state of your GPU. Initializes the members of @state to their default values. You should never pass an un initialized #CoglDepthState structure to cogl_pipeline_set_depth_state(). A #CoglDepthState struct Sets the range to map depth values in normalized device coordinates to before writing out to a depth buffer. After your geometry has be transformed, clipped and had perspective division applied placing it in normalized device coordinates all depth values between the near and far z clipping planes are in the range -1 to 1. Before writing any depth value to the depth buffer though the value is mapped into the range [0, 1]. With this function you can change the range which depth values are mapped too although the range must still lye within the range [0, 1]. By default normalized device coordinate depth values are mapped to the full range of depth buffer values, [0, 1]. NB: this won't directly affect the state of the GPU. You have to then set the state on a #CoglPipeline using cogl_pipeline_set_depth_state(). A #CoglDepthState object The near component of the desired depth range which will be clamped to the range [0, 1] The far component of the desired depth range which will be clamped to the range [0, 1] Enables or disables depth testing according to the value of @enable. If depth testing is enable then the #CoglDepthTestFunction set using cogl_depth_state_set_test_function() us used to evaluate the depth value of incoming fragments against the corresponding value stored in the current depth buffer, and if the test passes then the fragments depth value is used to update the depth buffer. (unless you have disabled depth writing via cogl_depth_state_set_write_enabled()) By default depth testing is disabled. NB: this won't directly affect the state of the GPU. You have to then set the state on a #CoglPipeline using cogl_pipeline_set_depth_state() A #CoglDepthState struct The enable state you want Sets the #CoglDepthTestFunction used to compare the depth value of an incoming fragment against the corresponding value in the current depth buffer. By default the depth test function is %COGL_DEPTH_TEST_FUNCTION_LESS NB: this won't directly affect the state of the GPU. You have to then set the state on a #CoglPipeline using cogl_pipeline_set_depth_state() A #CoglDepthState struct The #CoglDepthTestFunction to set Enables or disables depth buffer writing according to the value of @enable. Normally when depth testing is enabled and the comparison between a fragment's depth value and the corresponding depth buffer value passes then the fragment's depth is written to the depth buffer unless writing is disabled here. By default depth writing is enabled NB: this won't directly affect the state of the GPU. You have to then set the state on a #CoglPipeline using cogl_pipeline_set_depth_state() A #CoglDepthState struct The enable state you want 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 passes. Passes if the fragment's depth value is less than the value currently in the depth buffer. Passes if the fragment's depth value is equal to the value currently in the depth buffer. Passes if the fragment's depth value is less or equal to the value currently in the depth buffer. Passes if the fragment's depth value is greater than the value currently in the depth buffer. Passes if the fragment's depth value is not equal to the value currently in the depth buffer. Passes if the fragment's depth value greater than or equal to the value currently in the depth buffer. Always passes. Common aspects of a display pipeline The basic intention for this object is to let the application configure common display preferences before creating a context, and there are a few different aspects to this... Firstly there are options directly relating to the physical display pipeline that is currently being used including the digital to analogue conversion hardware and the screens the user sees. Another aspect is that display options may constrain or affect how onscreen framebuffers should later be configured. The original rationale for the display object in fact was to let us handle GLX and EGLs requirements that framebuffers must be "compatible" with the config associated with the current context meaning we have to force the user to describe how they would like to create their onscreen windows before we can choose a suitable fbconfig and create a GLContext. Explicitly allocates a new #CoglDisplay object to encapsulate the common state of the display pipeline that applies to the whole application. A @display can only be made for a specific choice of renderer which is why this takes the @renderer argument. When a display is first allocated via cogl_display_new() it is in a mutable configuration mode. It's designed this way so we can extend the apis available for configuring a display without requiring huge numbers of constructor arguments. When you have finished configuring a display object you can optionally call cogl_display_setup() to explicitly apply the configuration and check for errors. Alternaitvely you can pass the display to cogl_context_new() and Cogl will implicitly apply your configuration but if there are errors then the application will abort with a message. For simple applications with no fallback options then relying on the implicit setup can be fine. A newly allocated #CoglDisplay object in a mutable configuration mode. A #CoglRenderer Queries the #CoglRenderer associated with the given @display. The associated #CoglRenderer a #CoglDisplay Explicitly sets up the given @display object. Use of this api is optional since Cogl will internally setup the display if not done explicitly. When a display is first allocated via cogl_display_new() it is in a mutable configuration mode. This allows us to extend the apis available for configuring a display without requiring huge numbers of constructor arguments. Its possible to request a configuration that might not be supportable on the current system and so this api provides a means to apply the configuration explicitly but if it fails then an exception will be returned so you can handle the error gracefully and perhaps fall back to an alternative configuration. If you instead rely on Cogl implicitly calling cogl_display_setup() for you then if there is an error with the configuration you won't get an opportunity to handle that and the application may abort with a message. For simple applications that don't have any fallback options this behaviour may be fine. Returns %TRUE if there was no error, else it returns %FALSE and returns an exception via @error. a #CoglDisplay An opaque type that tracks the lifetime of a DMA buffer fd. Release with cogl_dma_buf_handle_free(). Releases @dmabuf_handle; it is a programming error to release an already released handle. a #CoglDmaBufHandle Retrieves the file descriptor of @dmabuf_handle. a valid file descriptor Retrieves the #CoglFramebuffer, backed by an exported DMABuf buffer, of @dmabuf_handle. a #CoglFramebuffer Identifiers for underlying hardware drivers that may be used by Cogl for rendering. Implies no preference for which driver is used A No-Op driver. An OpenGL driver using the core GL 3.1 profile An OpenGL ES 2.0 driver. All the capabilities that can vary between different GPUs supported by Cogl. Applications that depend on any of these features should explicitly check for them using [method@Cogl.Context.has_feature]. Set if %COGL_INDICES_TYPE_UNSIGNED_INT is supported in cogl_indices_new(). Whether cogl_buffer_map() is supported with CoglBufferAccess including read support. Whether cogl_buffer_map() is supported with CoglBufferAccess including write support. Support for %COGL_TEXTURE_COMPONENTS_RG as the internal components of a texture. Support for 10bpc RGBA formats Support for half float formats Support for 16bpc formats Available if the age of #CoglOnscreen back buffers are tracked and so cogl_onscreen_get_buffer_age() can be expected to return age values other than 0. Whether blitting using [method@Cogl.Framebuffer.blit] is supported. @COGL_FEATURE_ID_SYNC_FD cogl_context_get_latest_sync_fd() is supported. Return values for the #CoglXlibFilterFunc and #CoglWin32FilterFunc functions. The event was not handled, continues the processing Remove the event, stops the processing Is a callback that can be registered via cogl_onscreen_add_frame_callback() to be called when a frame progresses in some notable way. Please see the documentation for #CoglFrameEvent and cogl_onscreen_add_frame_callback() for more details about what events can be notified. The onscreen that the frame is associated with A #CoglFrameEvent notifying how the frame has progressed The meta information, such as timing information, about the frame that has progressed. The user pointer passed to cogl_onscreen_add_frame_callback() An opaque type that tracks a #CoglFrameCallback and associated user data. A #CoglFrameClosure pointer will be returned from cogl_onscreen_add_frame_callback() and it allows you to remove a callback later using cogl_onscreen_remove_frame_callback(). Identifiers that are passed to #CoglFrameCallback functions (registered using cogl_onscreen_add_frame_callback()) that mark the progression of a frame in some way which usually means that new information will have been accumulated in the frame's corresponding #CoglFrameInfo object. The last event that will be sent for a frame will be a @COGL_FRAME_EVENT_COMPLETE event and so these are a good opportunity to collect statistics about a frame since the #CoglFrameInfo should hold the most data at this point. A frame may not be completed before the next frame can start so applications should avoid needing to collect all statistics for a particular frame before they can start a new frame. Notifies that the system compositor has acknowledged a frame and is ready for a new frame to be created. Notifies that a frame has ended. This is a good time for applications to collect statistics about the frame since the #CoglFrameInfo should hold the most data at this point. No other events should be expected after a @COGL_FRAME_EVENT_COMPLETE event. Frame information. Gets the frame counter for the #CoglOnscreen that corresponds to this frame. The frame counter value a #CoglFrameInfo object Gets the presentation time for the frame. This is the time at which the frame became visible to the user. The presentation time measured in microseconds, is based on CLOCK_MONOTONIC. Some buggy Mesa drivers up to 9.0.1 may incorrectly report non-monotonic timestamps. the presentation time for the frame a #CoglFrameInfo object Gets the refresh rate in Hertz for the output that the frame was on at the time the frame was presented. Some platforms can't associate a #CoglOutput with a #CoglFrameInfo object but are able to report a refresh rate via this api. Therefore if you need this information then this api is more reliable than using cogl_frame_info_get_output() followed by cogl_output_get_refresh_rate(). the refresh rate in Hertz a #CoglFrameInfo object Gets the target presentation time for the frame. This is the time at which the frame was expected to became visible to the user. The target presentation time measured in microseconds, is based on CLOCK_MONOTONIC. the presentation time for the frame if available, or 0 a #CoglFrameInfo object Explicitly allocates a configured #CoglFramebuffer allowing developers to check and handle any errors that might arise from an unsupported configuration so that fallback configurations may be tried. Many applications don't support any fallback options at least when they are initially developed and in that case the don't need to use this API since Cogl will automatically allocate a framebuffer when it first gets used. The disadvantage of relying on automatic allocation is that the program will abort with an error message if there is an error during automatic allocation. %TRUE if there were no error allocating the framebuffer, else %FALSE. A #CoglFramebuffer Explicitly allocates a configured #CoglFramebuffer allowing developers to check and handle any errors that might arise from an unsupported configuration so that fallback configurations may be tried. Many applications don't support any fallback options at least when they are initially developed and in that case the don't need to use this API since Cogl will automatically allocate a framebuffer when it first gets used. The disadvantage of relying on automatic allocation is that the program will abort with an error message if there is an error during automatic allocation. %TRUE if there were no error allocating the framebuffer, else %FALSE. A #CoglFramebuffer @return FALSE for an immediately detected error, TRUE otherwise. This blits a region of the color buffer of the source buffer to the destination buffer. This function should only be called if the COGL_FEATURE_ID_BLIT_FRAMEBUFFER feature is advertised. The source and destination rectangles are defined in offscreen framebuffer orientation. When copying between an offscreen and onscreen framebuffers, the image is y-flipped accordingly. The two buffers must have the same value types (e.g. floating-point, unsigned int, signed int, or fixed-point), but color formats do not need to match. This limitation comes from OpenGL ES 3.0 definition of glBlitFramebuffer. Note that this function differs a lot from the glBlitFramebuffer function provided by the GL_EXT_framebuffer_blit extension. Notably it doesn't support having different sizes for the source and destination rectangle. This doesn't seem like a particularly useful feature. If the application wanted to scale the results it may make more sense to draw a primitive instead. The GL function is documented to be affected by the scissor. This function therefore ensure that an empty clip stack is flushed before performing the blit which means the scissor is effectively ignored. The function also doesn't support specifying the buffers to copy and instead only the color buffer is copied. When copying the depth or stencil buffers the extension on GLES2.0 only supports copying the full buffer which would be awkward to document with this API. If we wanted to support that feature it may be better to have a separate function to copy the entire buffer for a given mask. The @c error argument is optional, it can be NULL. If it is not NULL and this function returns FALSE, an error object with a code from COGL_SYSTEM_ERROR will be created. The source #CoglFramebuffer The destination #CoglFramebuffer Source x position Source y position Destination x position Destination y position Width of region to copy Height of region to copy Clears all the auxiliary buffers identified in the @buffers mask, and if that includes the color buffer then the specified @color is used. A #CoglFramebuffer A mask of `CoglBufferBit`s identifying which auxiliary buffers to clear The color to clear the color buffer too if specified in @buffers. Clears all the auxiliary buffers identified in the @buffers mask, and if that includes the color buffer then the specified @color is used. A #CoglFramebuffer A mask of `CoglBufferBit`s identifying which auxiliary buffers to clear The red component of color to clear the color buffer too if specified in @buffers. The green component of color to clear the color buffer too if specified in @buffers. The blue component of color to clear the color buffer too if specified in @buffers. The alpha component of color to clear the color buffer too if specified in @buffers. Creates a query for the GPU timestamp that will complete upon completion of all previously submitted GL commands related to this framebuffer. E.g. when the rendering is finished on this framebuffer. This function should only be called if the COGL_FEATURE_ID_TIMESTAMP_QUERY feature is advertised. Declares that the specified @buffers no longer need to be referenced by any further rendering commands. This can be an important optimization to avoid subsequent frames of rendering depending on the results of a previous frame. For example; some tile-based rendering GPUs are able to avoid allocating and accessing system memory for the depth and stencil buffer so long as these buffers are not required as input for subsequent frames and that can save a significant amount of memory bandwidth used to save and restore their contents to system memory between frames. It is currently considered an error to try and explicitly discard the color buffer by passing %COGL_BUFFER_BIT_COLOR. This is because the color buffer is already implicitly discard when you finish rendering to a #CoglOnscreen framebuffer, and it's not meaningful to try and discard the color buffer of a #CoglOffscreen framebuffer since they are single-buffered. A #CoglFramebuffer A #CoglBufferBit mask of which ancillary buffers you want to discard. Draws a textured rectangle to @framebuffer with the given @pipeline state with the top left corner positioned at (@x_1, @y_1) and the bottom right corner positioned at (@x_2, @y_2). As a pipeline may contain multiple texture layers this interface lets you supply texture coordinates for each layer of the pipeline. The position is the position before the rectangle has been transformed by the model-view matrix and the projection matrix. This is a high level drawing api that can handle any kind of #CoglTexture texture for the first layer such as #CoglTexture2DSliced textures which may internally be comprised of multiple low-level textures. This is unlike low-level drawing apis such as cogl_primitive_draw() which only support low level texture types that are directly supported by GPUs such as #CoglTexture2D. This api can not currently handle multiple high-level meta texture layers. The first layer may be a high level meta texture such as #CoglTexture2DSliced but all other layers much be low level textures such as #CoglTexture2D. The top left texture coordinate for layer 0 of any pipeline will be (tex_coords[0], tex_coords[1]) and the bottom right coordinate will be (tex_coords[2], tex_coords[3]). The coordinates for layer 1 would be (tex_coords[4], tex_coords[5]) (tex_coords[6], tex_coords[7]) and so on... The given texture coordinates should always be normalized such that (0, 0) corresponds to the top left and (1, 1) corresponds to the bottom right. To map an entire texture across the rectangle pass in tex_coords[0]=0, tex_coords[1]=0, tex_coords[2]=1, tex_coords[3]=1. 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 pipeline then default texture coordinates (0.0, 0.0, 1.0, 1.0) are generated. A destination #CoglFramebuffer A #CoglPipeline state object 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: [s_1, t_1, s_2, t_2] that are interpreted as two texture coordinates; one for the top left texel, and one for the bottom 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. (For one layer and one group of texture coordinates, this would be 4) Draws a rectangle to @framebuffer with the given @pipeline state and with the top left corner positioned at (@x_1, @y_1) and the bottom right corner positioned at (@x_2, @y_2). The position is the position before the rectangle has been transformed by the model-view matrix and the projection matrix. If you want to describe a rectangle with a texture mapped on it then you can use cogl_framebuffer_draw_textured_rectangle(). A destination #CoglFramebuffer A #CoglPipeline state object 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 Draws a series of rectangles to @framebuffer with the given @pipeline state in the same way that cogl_framebuffer_draw_rectangle() does. The top left corner of the first rectangle is positioned at (coordinates[0], coordinates[1]) and the bottom right corner is positioned at (coordinates[2], coordinates[3]). The positions for the second rectangle are (coordinates[4], coordinates[5]) and (coordinates[6], coordinates[7]) and so on... The position is the position before the rectangle has been transformed by the model-view matrix and the projection matrix. As a general rule for better performance its recommended to use this this API instead of calling cogl_framebuffer_draw_textured_rectangle() separately for multiple rectangles if all of the rectangles will be drawn together with the same @pipeline state. A destination #CoglFramebuffer A #CoglPipeline state object an array of coordinates containing groups of 4 float values: [x_1, y_1, x_2, y_2] that are interpreted as two position coordinates; one for the top left of the rectangle (x1, y1), and one for the bottom right of the rectangle (x2, y2). number of rectangles defined in @coordinates. Draws a textured rectangle to @framebuffer using the given @pipeline state with the top left corner positioned at (@x_1, @y_1) and the bottom right corner positioned at (@x_2, @y_2). The top left corner will have texture coordinates of (@s_1, @t_1) and the bottom right corner will have texture coordinates of (@s_2, @t_2). The position is the position before the rectangle has been transformed by the model-view matrix and the projection matrix. This is a high level drawing api that can handle any kind of #CoglTexture texture such as #CoglTexture2DSliced textures which may internally be comprised of multiple low-level textures. This is unlike low-level drawing apis such as cogl_primitive_draw() which only support low level texture types that are directly supported by GPUs such as #CoglTexture2D. The given texture coordinates will only be used for the first texture layer of the pipeline and if your pipeline has more than one layer then all other layers will have default texture coordinates of @s_1=0.0 @t_1=0.0 @s_2=1.0 @t_2=1.0 The given texture coordinates should always be normalized such that (0, 0) corresponds to the top left and (1, 1) corresponds to the bottom right. To map an entire texture across the rectangle pass in @s_1=0, @t_1=0, @s_2=1, @t_2=1. A destination #CoglFramebuffer A #CoglPipeline state object x coordinate upper left on screen. y coordinate upper left on screen. x coordinate lower right on screen. y coordinate lower right on screen. S texture coordinate of the top-left coorner T texture coordinate of the top-left coorner S texture coordinate of the bottom-right coorner T texture coordinate of the bottom-right coorner Draws a series of rectangles to @framebuffer with the given @pipeline state in the same way that cogl_framebuffer_draw_textured_rectangle() does. The position is the position before the rectangle has been transformed by the model-view matrix and the projection matrix. This is a high level drawing api that can handle any kind of #CoglTexture texture such as #CoglTexture2DSliced textures which may internally be comprised of multiple low-level textures. This is unlike low-level drawing apis such as cogl_primitive_draw() which only support low level texture types that are directly supported by GPUs such as #CoglTexture2D. The top left corner of the first rectangle is positioned at (coordinates[0], coordinates[1]) and the bottom right corner is positioned at (coordinates[2], coordinates[3]). The top left texture coordinate is (coordinates[4], coordinates[5]) and the bottom right texture coordinate is (coordinates[6], coordinates[7]). The coordinates for subsequent rectangles are defined similarly by the subsequent coordinates. As a general rule for better performance its recommended to use this this API instead of calling cogl_framebuffer_draw_textured_rectangle() separately for multiple rectangles if all of the rectangles will be drawn together with the same @pipeline state. The given texture coordinates should always be normalized such that (0, 0) corresponds to the top left and (1, 1) corresponds to the bottom right. To map an entire texture across the rectangle pass in tex_coords[0]=0, tex_coords[1]=0, tex_coords[2]=1, tex_coords[3]=1. A destination #CoglFramebuffer A #CoglPipeline state object an array containing groups of 8 float values: [x_1, y_1, x_2, y_2, s_1, t_1, s_2, t_2] that have the same meaning as the arguments for cogl_framebuffer_draw_textured_rectangle(). number of rectangles to @coordinates to draw This blocks the CPU until all pending rendering associated with the specified framebuffer has completed. It's very rare that developers should ever need this level of synchronization with the GPU and should never be used unless you clearly understand why you need to explicitly force synchronization. One example might be for benchmarking purposes to be sure timing measurements reflect the time that the GPU is busy for not just the time it takes to queue rendering commands. A #CoglFramebuffer pointer Flushes @framebuffer to ensure the current batch of commands is submitted to the GPU. Unlike cogl_framebuffer_finish(), this does not block the CPU. A #CoglFramebuffer pointer 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. A #CoglFramebuffer pointer 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) Retrieves the number of alpha bits of @framebuffer the number of bits a pointer to a #CoglFramebuffer Retrieves the number of blue bits of @framebuffer the number of bits a pointer to a #CoglFramebuffer Can be used to query the #CoglContext a given @framebuffer was instantiated within. This is the #CoglContext that was passed to cogl_onscreen_new() for example. The #CoglContext that the given @framebuffer was instantiated within. A #CoglFramebuffer Queries whether depth buffer writing is enabled for @framebuffer. This can be controlled via cogl_framebuffer_set_depth_write_enabled(). %TRUE if depth writing is enabled or %FALSE if not. a pointer to a #CoglFramebuffer Returns whether dithering has been requested for the given @framebuffer. See cogl_framebuffer_set_dither_enabled() for more details about dithering. This may return %TRUE even when the underlying @framebuffer display pipeline does not support dithering. This value only represents the user's request for dithering. %TRUE if dithering has been requested or %FALSE if not. a pointer to a #CoglFramebuffer Retrieves the number of green bits of @framebuffer the number of bits a pointer to a #CoglFramebuffer Queries the current height of the given @framebuffer. The height of @framebuffer. A #CoglFramebuffer Returns the pixel format used internally by the framebuffer. Stores the current model-view matrix in @matrix. A #CoglFramebuffer pointer return location for the model-view matrix Stores the current projection matrix in @matrix. A #CoglFramebuffer pointer return location for the projection matrix Retrieves the number of red bits of @framebuffer the number of bits a pointer to a #CoglFramebuffer Queries the x, y, width and height components of the current viewport as set using cogl_framebuffer_set_viewport() or the default values which are 0, 0, framebuffer_width and framebuffer_height. The values are written into the given @viewport array. A #CoglFramebuffer A pointer to an array of 4 floats to receive the (x, y, width, height) components of the current viewport. Queries the height of the viewport as set using cogl_framebuffer_set_viewport() or the default value which is the height of the framebuffer. The height of the viewport. A #CoglFramebuffer Queries the width of the viewport as set using cogl_framebuffer_set_viewport() or the default value which is the width of the framebuffer. The width of the viewport. A #CoglFramebuffer Queries the x coordinate of the viewport origin as set using cogl_framebuffer_set_viewport() or the default value which is 0. The x coordinate of the viewport origin. A #CoglFramebuffer Queries the y coordinate of the viewport origin as set using cogl_framebuffer_set_viewport() or the default value which is 0. The y coordinate of the viewport origin. A #CoglFramebuffer Queries the current width of the given @framebuffer. The width of @framebuffer. A #CoglFramebuffer Replaces the current projection matrix with an orthographic projection matrix. A #CoglFramebuffer pointer The x coordinate for the first vertical clipping plane The y coordinate for the first horizontal clipping plane The x coordinate for the second vertical clipping plane The y coordinate for the second horizontal clipping plane The *distance* to the near clipping plane (will be *negative* if the plane is behind the viewer) The *distance* to the far clipping plane (will be *negative* if the plane is behind the viewer) Replaces the current projection matrix with a perspective matrix based on the provided values. You should be careful not to have to great a @z_far / @z_near ratio since that will reduce the effectiveness of depth testing since there won't be enough precision to identify the depth of objects near to each other. A #CoglFramebuffer pointer 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, and must not be 0) The distance to the far clipping plane (Must be positive) Reverts the clipping region to the state before the last call to cogl_framebuffer_push_rectangle_clip() A #CoglFramebuffer pointer Restores the model-view matrix on the top of the matrix stack. A #CoglFramebuffer pointer Copies the current model-view matrix onto the matrix stack. The matrix can later be restored with cogl_framebuffer_pop_matrix(). A #CoglFramebuffer pointer Specifies a modelview transformed 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_framebuffer_pop_clip(). A #CoglFramebuffer pointer 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 This is a convenience wrapper around cogl_framebuffer_read_pixels_into_bitmap() which allocates a temporary #CoglBitmap to read pixel data directly into the given buffer. The rowstride of the buffer is assumed to be the width of the region times the bytes per pixel of the format. The source for the data is always taken from the color buffer. If you want to use any other rowstride or source, please use the cogl_framebuffer_read_pixels_into_bitmap() function directly. The implementation of the function looks like this: ```c bitmap = cogl_bitmap_new_for_data (context, width, height, format, /<!-- -->* rowstride *<!-- -->/ bpp * width, pixels); cogl_framebuffer_read_pixels_into_bitmap (framebuffer, x, y, COGL_READ_PIXELS_COLOR_BUFFER, bitmap); g_object_unref (bitmap); ``` %TRUE if the read succeeded or %FALSE otherwise. A #CoglFramebuffer The x position to read from The y position to read from The width of the region of rectangles to read The height of the region of rectangles to read The pixel format to store the data in The address of the buffer to store the data in This reads a rectangle of pixels from the given framebuffer where position (0, 0) is the top left. The pixel at (x, y) is the first read, and a rectangle of pixels with the same size as the bitmap is read right and downwards from that point. Currently Cogl assumes that the framebuffer is in a premultiplied format so if the format of @bitmap 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. %TRUE if the read succeeded or %FALSE otherwise. The function is only likely to fail if the bitmap points to a pixel buffer and it could not be mapped. A #CoglFramebuffer The x position to read from The y position to read from Identifies which auxiliary buffer you want to read (only COGL_READ_PIXELS_COLOR_BUFFER supported currently) The bitmap to store the results in. Multiplies the current model-view matrix by one that rotates the model around the axis-vector specified by @x, @y and @z. The rotation follows the right-hand thumb rule so for example rotating by 10 degrees about the axis-vector (0, 0, 1) causes a small counter-clockwise rotation. A #CoglFramebuffer pointer 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. A #CoglFramebuffer pointer Amount to scale along the x-axis Amount to scale along the y-axis Amount to scale along the z-axis Enables or disables depth buffer writing when rendering to @framebuffer. If depth writing is enabled for both the framebuffer and the rendering pipeline, and the framebuffer has an associated depth buffer, depth information will be written to this buffer during rendering. Depth buffer writing is enabled by default. a pointer to a #CoglFramebuffer %TRUE to enable depth writing or %FALSE to disable Enables or disabled dithering if supported by the hardware. Dithering is a hardware dependent technique to increase the visible color resolution beyond what the underlying hardware supports by playing tricks with the colors placed into the framebuffer to give the illusion of other colors. (For example this can be compared to half-toning used by some news papers to show varying levels of grey even though their may only be black and white are available). If the current display pipeline for @framebuffer does not support dithering then this has no affect. Dithering is enabled by default. a pointer to a #CoglFramebuffer %TRUE to enable dithering or %FALSE to disable Sets @matrix as the new model-view matrix. A #CoglFramebuffer pointer the new model-view matrix Sets @matrix as the new projection matrix. A #CoglFramebuffer pointer the new projection matrix Defines a scale and offset for everything rendered relative to the top-left of the destination framebuffer. By default the viewport has an origin of (0,0) and width and height that match the framebuffer's size. Assuming a default projection and modelview matrix then you could translate the contents of a window down and right by leaving the viewport size unchanged by moving the offset to (10,10). The viewport coordinates are measured in pixels. If you left the x and y origin as (0,0) you could scale the windows contents down by specify and width and height that's half the real size of the framebuffer. Although the function takes floating point arguments, existing drivers only allow the use of integer values. In the future floating point values will be exposed via a checkable feature. A #CoglFramebuffer The top-left x coordinate of the viewport origin (only integers supported currently) The top-left y coordinate of the viewport origin (only integers supported currently) The width of the viewport (only integers supported currently) The height of the viewport (only integers supported currently) Multiplies the current model-view matrix by the given matrix. A #CoglFramebuffer pointer the matrix to multiply with the current model-view Multiplies the current model-view matrix by one that translates the model along all three axes according to the given values. A #CoglFramebuffer pointer Distance to translate along the x-axis Distance to translate along the y-axis Distance to translate along the z-axis %TRUE if there were no error allocating the framebuffer, else %FALSE. A #CoglFramebuffer All the error values that might be returned by cogl_context_get_graphics_reset_status(). Each value's meaning corresponds to the similarly named value defined in the ARB_robustness and NV_robustness_video_memory_purge extensions. Functions for creating and manipulating vertex indices. Declares a new #CoglIndexBuffer of @size bytes to contain vertex indices. Once declared, data can be set using cogl_buffer_set_data() or by mapping it into the application's address space using cogl_buffer_map(). A newly allocated #CoglIndexBuffer A #CoglContext The number of bytes to allocate for vertex attribute data. Describe vertex indices stored in a #CoglIndexBuffer. Indices allow you to avoid duplicating vertices in your vertex data by virtualizing your data and instead providing a sequence of index values that tell the GPU which data should be used for each vertex. If the GPU is given a sequence of indices it doesn't simply walk through each vertex of your data in order it will instead walk through the indices which can provide random access to the underlying data. Since it's very common to have duplicate vertices when describing a shape as a list of triangles it can often be a significant space saving to describe geometry using indices. Reducing the size of your models can make it cheaper to map them into the GPU by reducing the demand on memory bandwidth and may help to make better use of your GPUs internal vertex caching. For example, to describe a quadrilateral as 2 triangles for the GPU you could either provide data with 6 vertices or instead with indices you can provide vertex data for just 4 vertices and an index buffer that specifies the 6 vertices by indexing the shared vertices multiple times. ```c CoglVertexP2 quad_vertices[] = { {x0, y0}, //0 = top left {x1, y1}, //1 = bottom left {x2, y2}, //2 = bottom right {x3, y3}, //3 = top right }; //tell the gpu how to interpret the quad as 2 triangles... unsigned char indices[] = {0, 1, 2, 0, 2, 3}; ``` Even in the above illustration we see a saving of 10bytes for one quad compared to having data for 6 vertices and no indices but if you need to draw 100s or 1000s of quads then its really quite significant. Something else to consider is that often indices can be defined once and remain static while the vertex data may change for animations perhaps. That means you may be able to ignore the negligible cost of mapping your indices into the GPU if they don't ever change. The above illustration is actually a good example of static indices because it's really common that developers have quad mesh data that they need to display and we know exactly what that indices array needs to look like depending on the number of quads that need to be drawn. It doesn't matter how the quads might be animated and changed the indices will remain the same. Cogl even has a utility ([method@Cogl.Context.get_rectangle_indices]) to get access to re-useable indices for drawing quads as above. a #CoglIndexBuffer 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_INDICES_TYPE_UNSIGNED_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. Your indices are unsigned bytes Your indices are unsigned shorts Your indices are unsigned ints Represents a single immutable transformation that was retrieved from a #CoglMatrixStack using cogl_matrix_stack_get_entry(). Internally a #CoglMatrixEntry represents a single matrix operation (such as "rotate", "scale", "translate") which is applied to the transform of a single parent entry. Using the #CoglMatrixStack api effectively builds up a graph of these immutable #CoglMatrixEntry structures whereby operations that can be shared between multiple transformations will result in shared #CoglMatrixEntry nodes in the graph. When a #CoglMatrixStack is first created it references one #CoglMatrixEntry that represents a single "load identity" operation. This serves as the root entry and all operations that are then applied to the stack will extend the graph starting from this root "load identity" entry. Given the typical usage model for a #CoglMatrixStack and the way the entries are built up while traversing a scenegraph then in most cases where an application is interested in comparing two transformations for equality then it is enough to simply compare two #CoglMatrixEntry pointers directly. Technically this can lead to false negatives that could be identified with a deeper comparison but often these false negatives are unlikely and don't matter anyway so this enables extremely cheap comparisons. `CoglMatrixEntry`s are reference counted using cogl_matrix_entry_ref() and cogl_matrix_entry_unref() not with g_object_ref() and g_object_unref(). Determines if the only difference between two transforms is a translation and if so returns what the @x, @y, and @z components of the translation are. If the difference between the two translations involves anything other than a translation then the function returns %FALSE. %TRUE if the only difference between the transform of @entry0 and the transform of @entry1 is a translation, otherwise %FALSE. The first reference transform A second reference transform The destination for the x-component of the translation The destination for the y-component of the translation The destination for the z-component of the translation Resolves the current @entry transform into a #graphene_matrix_t by combining the sequence of operations that have been applied to build up the current transform. There are two possible ways that this function may return its result depending on whether it's possible to directly point to an internal #graphene_matrix_t or whether the result needs to be composed of multiple operations. If an internal matrix contains the required result then this function will directly return a pointer to that matrix, otherwise if the function returns %NULL then @matrix will be initialized to match the transform of @entry. @matrix will be left untouched if a direct pointer is returned. A direct pointer to a #graphene_matrix_t transform or %NULL and in that case @matrix will be initialized with the effective transform represented by @entry. A #CoglMatrixEntry The potential destination for the transform as a matrix Determines whether @entry is known to represent an identity transform. If this returns %TRUE then the entry is definitely the identity matrix. If it returns %FALSE it may or may not be the identity matrix but no expensive comparison is performed to verify it. %TRUE if @entry is definitely an identity transform, otherwise %FALSE. A #CoglMatrixEntry Takes a reference on the given @entry to ensure the @entry stays alive and remains valid. When you are finished with the @entry then you should call cogl_matrix_entry_unref(). A #CoglMatrixEntry Releases a reference on @entry either taken by calling cogl_matrix_entry_unref() or to release the reference given when calling cogl_matrix_stack_get_entry(). A #CoglMatrixEntry Efficiently tracking many related transformations. Tracks your current position within a hierarchy and lets you build up a graph of transformations as you traverse through a hierarchy such as a scenegraph. A #CoglMatrixStack always maintains a reference to a single transformation at any point in time, representing the transformation at the current position in the hierarchy. You can get a reference to the current transformation by calling cogl_matrix_stack_get_entry(). When a #CoglMatrixStack is first created with cogl_matrix_stack_new() then it is conceptually positioned at the root of your hierarchy and the current transformation simply represents an identity transformation. As you traverse your object hierarchy (your scenegraph) then you should call cogl_matrix_stack_push() whenever you move down one level and call cogl_matrix_stack_pop() whenever you move back up one level towards the root. At any time you can apply a set of operations, such as "rotate", "scale", "translate" on top of the current transformation of a #CoglMatrixStack using functions such as cogl_matrix_stack_rotate(), cogl_matrix_stack_scale() and cogl_matrix_stack_translate(). These operations will derive a new current transformation and will never affect a transformation that you have referenced using cogl_matrix_stack_get_entry(). Internally applying operations to a #CoglMatrixStack builds up a graph of #CoglMatrixEntry structures which each represent a single immutable transform. Allocates a new #CoglMatrixStack that can be used to build up transformations relating to objects in a scenegraph like hierarchy. (See the description of #CoglMatrixStack and #CoglMatrixEntry for more details of what a matrix stack is best suited for) When a #CoglMatrixStack is first allocated it is conceptually positioned at the root of your scenegraph hierarchy. As you traverse your scenegraph then you should call cogl_matrix_stack_push() whenever you move down a level and cogl_matrix_stack_pop() whenever you move back up a level towards the root. Once you have allocated a #CoglMatrixStack you can get a reference to the current transformation for the current position in the hierarchy by calling cogl_matrix_stack_get_entry(). Once you have allocated a #CoglMatrixStack you can apply operations such as rotate, scale and translate to modify the current transform for the current position in the hierarchy by calling cogl_matrix_stack_rotate(), cogl_matrix_stack_scale() and cogl_matrix_stack_translate(). A newly allocated #CoglMatrixStack A #CoglContext Replaces the current 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. A #CoglMatrixStack 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) Resolves the current @stack transform into a #graphene_matrix_t by combining the operations that have been applied to build up the current transform. There are two possible ways that this function may return its result depending on whether the stack is able to directly point to an internal #graphene_matrix_t or whether the result needs to be composed of multiple operations. If an internal matrix contains the required result then this function will directly return a pointer to that matrix, otherwise if the function returns %NULL then @matrix will be initialized to match the current transform of @stack. @matrix will be left untouched if a direct pointer is returned. A direct pointer to the current transform or %NULL and in that case @matrix will be initialized with the value of the current transform. A #CoglMatrixStack The potential destination for the current matrix Gets a reference to the current transform represented by a #CoglMatrixEntry pointer. The transform represented by a #CoglMatrixEntry is immutable. `CoglMatrixEntry`s are reference counted using cogl_matrix_entry_ref() and cogl_matrix_entry_unref() and you should call cogl_matrix_entry_unref() when you are finished with and entry you get via cogl_matrix_stack_get_entry(). A pointer to the #CoglMatrixEntry representing the current matrix stack transform. A #CoglMatrixStack Resets the current matrix to the identity matrix. A #CoglMatrixStack Multiplies the current matrix by the given matrix. A #CoglMatrixStack the matrix to multiply with the current model-view Restores the previous transform that was last saved by calling cogl_matrix_stack_push(). This is usually called while traversing a scenegraph whenever you return up one level in the graph towards the root node. A #CoglMatrixStack Saves the current transform and starts a new transform that derives from the current transform. This is usually called while traversing a scenegraph whenever you traverse one level deeper. cogl_matrix_stack_pop() can then be called when going back up one layer to restore the previous transform of an ancestor. A #CoglMatrixStack Multiplies the current matrix by one that rotates the around the axis-vector specified by @x, @y and @z. The rotation follows the right-hand thumb rule so for example rotating by 10 degrees about the axis-vector (0, 0, 1) causes a small counter-clockwise rotation. A #CoglMatrixStack 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 matrix by one that rotates according to the rotation described by @euler. A #CoglMatrixStack A #graphene_euler_t Multiplies the current matrix by one that scales the x, y and z axes by the given values. A #CoglMatrixStack Amount to scale along the x-axis Amount to scale along the y-axis Amount to scale along the z-axis Replaces the current @stack matrix value with the value of @matrix. This effectively discards any other operations that were applied since the last time cogl_matrix_stack_push() was called or since the stack was initialized. A #CoglMatrixStack A #graphene_matrix_t replace the current matrix value with Multiplies the current matrix by one that translates along all three axes according to the given values. A #CoglMatrixStack Distance to translate along the x-axis Distance to translate along the y-axis Distance to translate along the z-axis Functions for creating and manipulating offscreen framebuffers. This creates an offscreen framebuffer object using the given @texture as the primary color buffer. It doesn't just initialize the contents of the offscreen buffer with the @texture; they are tightly bound so that drawing to the offscreen buffer effectively updates the contents of the given texture. You don't need to destroy the offscreen buffer before you can use the @texture again. This api only works with low-level #CoglTexture types such as #CoglTexture2D and not with meta-texture types such as #CoglTexture2DSliced. The storage for the framebuffer is actually allocated lazily so this function will never return %NULL to indicate a runtime error. This means it is still possible to configure the framebuffer before it is really allocated. Simple applications without full error handling can simply rely on Cogl to lazily allocate the storage of framebuffers but you should be aware that if Cogl encounters an error (such as running out of GPU memory) then your application will simply abort with an error message. If you need to be able to catch such exceptions at runtime then you can explicitly allocate your framebuffer when you have finished configuring it by calling cogl_framebuffer_allocate() and passing in a #GError argument to catch any exceptions. a newly instantiated #CoglOffscreen framebuffer. A #CoglTexture pointer a #CoglTexture Gets the current age of the buffer contents. This function allows applications to query the age of the current back buffer contents for a #CoglOnscreen as the number of frames elapsed since the contents were most recently defined. These age values exposes enough information to applications about how Cogl internally manages back buffers to allow applications to re-use the contents of old frames and minimize how much must be redrawn for the next frame. The back buffer contents can either be reported as invalid (has an age of 0) or it may be reported to be the same contents as from n frames prior to the current frame. The queried value remains valid until the next buffer swap. One caveat is that under X11 the buffer age does not reflect changes to buffer contents caused by the window systems. X11 applications must track Expose events to determine what buffer regions need to additionally be repaired each frame. The recommended way to take advantage of this buffer age api is to build up a circular buffer of length 3 for tracking damage regions over the last 3 frames and when starting a new frame look at the age of the buffer and combine the damage regions for the current frame with the damage regions of previous @age frames so you know everything that must be redrawn to update the old contents for the new frame. If the system doesn't not support being able to track the age of back buffers then this function will always return 0 which implies that the contents are undefined. The %COGL_FEATURE_ID_BUFFER_AGE feature can optionally be explicitly checked to determine if Cogl is currently tracking the age of #CoglOnscreen back buffer contents. If this feature is missing then this function will always return 0. The age of the buffer contents or 0 when the buffer contents are undefined. A #CoglOnscreen framebuffer Implementation for https://www.khronos.org/registry/EGL/extensions/KHR/EGL_KHR_partial_update.txt This immediately queues state to OpenGL that will be used for the next swap. This needs to be called every frame. The expected values are independent of any viewport transforms applied to the framebuffer. A #CoglOnscreen framebuffer A region representing damage Swaps the current back buffer being rendered too, to the front for display and provides information to any system compositor about what regions of the buffer have changed (damage) with respect to the last swapped buffer. This function has the same semantics as cogl_framebuffer_swap_buffers() except that it additionally allows applications to pass a damage region which may be used to minimize how much of the screen is redrawn. For example if your application is only animating a small object in the corner of the screen and everything else is remaining static then it can help the compositor to know that only the bottom right corner of your newly swapped buffer has really changed with respect to your previously swapped front buffer. If @region is NULL then the whole buffer will implicitly be reported as damaged as if cogl_onscreen_swap_buffers() had been called. This function also implicitly discards the contents of the color, depth and stencil buffers as if cogl_framebuffer_discard_buffers() were used. The significance of the discard is that you should not expect to be able to start a new frame that incrementally builds on the contents of the previous frame. If you want to perform incremental updates to older back buffers then please refer to the cogl_onscreen_get_buffer_age() api. Whenever possible it is recommended that applications use this function instead of cogl_onscreen_swap_buffers() to improve performance when running under a compositor. It is highly recommended to use this API in conjunction with the cogl_onscreen_get_buffer_age() api so that your application can perform incremental rendering based on old back buffers. A #CoglOnscreen framebuffer A region representing damage Swaps a region of the back buffer being rendered too, to the front for display. This function also implicitly discards the contents of the color, depth and stencil buffers as if cogl_framebuffer_discard_buffers() were used. The significance of the discard is that you should not expect to be able to start a new frame that incrementally builds on the contents of the previous frame. A #CoglOnscreen framebuffer A region Installs a @callback function that will be called for significant events relating to the given @onscreen framebuffer. The @callback will be used to notify when the system compositor is ready for this application to render a new frame. In this case %COGL_FRAME_EVENT_SYNC will be passed as the event argument to the given @callback in addition to the #CoglFrameInfo corresponding to the frame being acknowledged by the compositor. The @callback will also be called to notify when the frame has ended. In this case %COGL_FRAME_EVENT_COMPLETE will be passed as the event argument to the given @callback in addition to the #CoglFrameInfo corresponding to the newly presented frame. The meaning of "ended" here simply means that no more timing information will be collected within the corresponding #CoglFrameInfo and so this is a good opportunity to analyse the given info. It does not necessarily mean that the GPU has finished rendering the corresponding frame. We highly recommend throttling your application according to %COGL_FRAME_EVENT_SYNC events so that your application can avoid wasting resources, drawing more frames than your system compositor can display. a #CoglFrameClosure pointer that can be used to remove the callback and associated @user_data later. A #CoglOnscreen framebuffer A callback function to call for frame events A private pointer to be passed to @callback An optional callback to destroy @user_data when the @callback is removed or @onscreen is freed. A #CoglOnscreen framebuffer A #CoglFrameInfo Gets the current age of the buffer contents. This function allows applications to query the age of the current back buffer contents for a #CoglOnscreen as the number of frames elapsed since the contents were most recently defined. These age values exposes enough information to applications about how Cogl internally manages back buffers to allow applications to re-use the contents of old frames and minimize how much must be redrawn for the next frame. The back buffer contents can either be reported as invalid (has an age of 0) or it may be reported to be the same contents as from n frames prior to the current frame. The queried value remains valid until the next buffer swap. One caveat is that under X11 the buffer age does not reflect changes to buffer contents caused by the window systems. X11 applications must track Expose events to determine what buffer regions need to additionally be repaired each frame. The recommended way to take advantage of this buffer age api is to build up a circular buffer of length 3 for tracking damage regions over the last 3 frames and when starting a new frame look at the age of the buffer and combine the damage regions for the current frame with the damage regions of previous @age frames so you know everything that must be redrawn to update the old contents for the new frame. If the system doesn't not support being able to track the age of back buffers then this function will always return 0 which implies that the contents are undefined. The %COGL_FEATURE_ID_BUFFER_AGE feature can optionally be explicitly checked to determine if Cogl is currently tracking the age of #CoglOnscreen back buffer contents. If this feature is missing then this function will always return 0. The age of the buffer contents or 0 when the buffer contents are undefined. A #CoglOnscreen framebuffer Gets the value of the framebuffers frame counter. This is a counter that increases by one each time cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() is called. the current frame counter value Implementation for https://www.khronos.org/registry/EGL/extensions/KHR/EGL_KHR_partial_update.txt This immediately queues state to OpenGL that will be used for the next swap. This needs to be called every frame. The expected values are independent of any viewport transforms applied to the framebuffer. A #CoglOnscreen framebuffer A region representing damage Removes a callback and associated user data that were previously registered using cogl_onscreen_add_frame_callback(). If a destroy callback was passed to cogl_onscreen_add_frame_callback() to destroy the user data then this will get called. A #CoglOnscreen A #CoglFrameClosure returned from cogl_onscreen_add_frame_callback() Swaps the current back buffer being rendered too, to the front for display. This function also implicitly discards the contents of the color, depth and stencil buffers as if cogl_framebuffer_discard_buffers() were used. The significance of the discard is that you should not expect to be able to start a new frame that incrementally builds on the contents of the previous frame. It is highly recommended that applications use cogl_onscreen_swap_buffers_with_damage() instead whenever possible and also use the cogl_onscreen_get_buffer_age() api so they can perform incremental updates to older buffers instead of having to render a full buffer for every frame. A #CoglOnscreen framebuffer Swaps the current back buffer being rendered too, to the front for display and provides information to any system compositor about what regions of the buffer have changed (damage) with respect to the last swapped buffer. This function has the same semantics as cogl_framebuffer_swap_buffers() except that it additionally allows applications to pass a damage region which may be used to minimize how much of the screen is redrawn. For example if your application is only animating a small object in the corner of the screen and everything else is remaining static then it can help the compositor to know that only the bottom right corner of your newly swapped buffer has really changed with respect to your previously swapped front buffer. If @region is NULL then the whole buffer will implicitly be reported as damaged as if cogl_onscreen_swap_buffers() had been called. This function also implicitly discards the contents of the color, depth and stencil buffers as if cogl_framebuffer_discard_buffers() were used. The significance of the discard is that you should not expect to be able to start a new frame that incrementally builds on the contents of the previous frame. If you want to perform incremental updates to older back buffers then please refer to the cogl_onscreen_get_buffer_age() api. Whenever possible it is recommended that applications use this function instead of cogl_onscreen_swap_buffers() to improve performance when running under a compositor. It is highly recommended to use this API in conjunction with the cogl_onscreen_get_buffer_age() api so that your application can perform incremental rendering based on old back buffers. A #CoglOnscreen framebuffer A region representing damage Swaps a region of the back buffer being rendered too, to the front for display. This function also implicitly discards the contents of the color, depth and stencil buffers as if cogl_framebuffer_discard_buffers() were used. The significance of the discard is that you should not expect to be able to start a new frame that incrementally builds on the contents of the previous frame. A #CoglOnscreen framebuffer A region A #CoglOnscreen framebuffer A region representing damage A #CoglOnscreen framebuffer A region A #CoglOnscreen framebuffer A region representing damage The age of the buffer contents or 0 when the buffer contents are undefined. A #CoglOnscreen framebuffer The maximum number of planes of a pixel format (see also cogl_pixel_format_get_planes()). A #GParamSpec subclass for defining properties holding a #CoglColor. default color value Functions for creating and manipulating the GPU pipeline Cogl allows creating and manipulating objects representing the full configuration of the GPU pipeline. In simplified terms the GPU pipeline takes primitive geometry as the input, it first performs vertex processing, allowing you to deform your geometry, then rasterizes that (turning it from pure geometry into fragments) then performs fragment processing including depth testing and texture mapping. Finally it blends the result with the framebuffer. Allocates and initializes a default simple pipeline that will color a primitive white. a pointer to a new #CoglPipeline a #CoglContext Adds a shader snippet that will hook on to the given layer of the pipeline. The exact part of the pipeline that the snippet wraps around depends on the hook that is given to cogl_snippet_new(). Note that some hooks can't be used with a layer and need to be added with cogl_pipeline_add_snippet() instead. A #CoglPipeline The layer to hook the snippet to A #CoglSnippet Adds a shader snippet to @pipeline. The snippet will wrap around or replace some part of the pipeline as defined by the hook point in @snippet. Note that some hook points are specific to a layer and must be added with cogl_pipeline_add_layer_snippet() instead. A #CoglPipeline The #CoglSnippet to add to the vertex processing hook Creates a new pipeline with the configuration copied from the source pipeline. We would strongly advise developers to always aim to use cogl_pipeline_copy() instead of cogl_pipeline_new() whenever there will be any similarity between two pipelines. Copying a pipeline helps Cogl keep track of a pipelines ancestry which we may use to help minimize GPU state changes. a pointer to the newly allocated #CoglPipeline a #CoglPipeline object to copy Iterates all the layer indices of the given @pipeline. A #CoglPipeline object A #CoglPipelineLayerCallback to be called for each layer index Private data that will be passed to the callback The alpha test function of @pipeline. A #CoglPipeline object The alpha test reference value of @pipeline. A #CoglPipeline object Retrieves the current pipeline color. A #CoglPipeline object The location to store the color the cull face mode that was previously set with cogl_pipeline_set_cull_face_mode(). Retrieves the current depth state configuration for the given @pipeline as previously set using cogl_pipeline_set_depth_state(). A #CoglPipeline object A destination #CoglDepthState struct The order of the vertices within a primitive specifies whether it is considered to be front or back facing. This function specifies which order is considered to be the front faces. %COGL_WINDING_COUNTER_CLOCKWISE sets the front faces to primitives with vertices in a counter-clockwise order and %COGL_WINDING_CLOCKWISE sets them to be clockwise. The default is %COGL_WINDING_COUNTER_CLOCKWISE. The @pipeline front face winding a #CoglPipeline Returns the decimation and interpolation filters used when a texture is drawn at other scales than 100%. A #CoglPipeline object the layer number to change. Return location for the filter used when scaling a texture down. Return location for the filter used when magnifying a texture. Gets whether point sprite coordinate generation is enabled for this texture layer. whether the texture coordinates will be replaced with point sprite coordinates. A #CoglPipeline object the layer number to check. the texture that was set for the given layer of the pipeline or %NULL if no texture was set. A #CoglPipeline object the index of the layer Returns the wrap mode for the 's' coordinate of texture lookups on this layer. the wrap mode for the 's' coordinate of texture lookups on this layer. A #CoglPipeline object the layer number to change. Returns the wrap mode for the 't' coordinate of texture lookups on this layer. the wrap mode for the 't' coordinate of texture lookups on this layer. A #CoglPipeline object the layer number to change. Retrieves the number of layers defined for the given @pipeline the number of layers A #CoglPipeline object The pipeline name, or %NULL A #CoglPipeline object %TRUE if the pipeline has per-vertex point size enabled or %FALSE otherwise. The per-vertex point size can be enabled with cogl_pipeline_set_per_vertex_point_size(). a #CoglPipeline pointer Get the size of points drawn when %COGL_VERTICES_MODE_POINTS is used with the vertex buffer API. the point size of the @pipeline. a #CoglPipeline pointer This is used to get an integer representing the uniform with the name @uniform_name. The integer can be passed to functions such as cogl_pipeline_set_uniform_1f() to set the value of a uniform. This function will always return a valid integer. Ie, unlike OpenGL, it does not return -1 if the uniform is not available in this pipeline so it can not be used to test whether uniforms are present. It is not necessary to set the program on the pipeline before calling this function. A integer representing the location of the given uniform. A #CoglPipeline object The name of a uniform Queries what user program has been associated with the given @pipeline using cogl_pipeline_set_user_program(). The current user program or %NULL. a #CoglPipeline object. This function removes a layer from your pipeline A #CoglPipeline object Specifies the layer you want to remove Before a primitive is blended with the framebuffer, it goes through an alpha test stage which lets you discard fragments based on the current alpha value. This function lets you change the function used to evaluate the alpha channel, and thus determine which fragments are discarded and which continue on to the blending stage. The default is %COGL_PIPELINE_ALPHA_FUNC_ALWAYS A #CoglPipeline object A @CoglPipelineAlphaFunc constant A reference point that the chosen alpha function uses to compare incoming fragments to. Blending occurs after the alpha test function, and combines fragments with the framebuffer. Currently the only blend function Cogl exposes is ADD(). So any valid blend statements will be of the form: ``` &lt;channel-mask&gt;=ADD(SRC_COLOR*(&lt;factor&gt;), DST_COLOR*(&lt;factor&gt;)) ``` This is the list of source-names usable as blend factors: - `SRC_COLOR`: The color of the incoming fragment - `DST_COLOR`: The color of the framebuffer - `CONSTANT`: The constant set via cogl_pipeline_set_blend_constant() These can also be used as factors: - `0`: (0, 0, 0, 0) - `1`: (1, 1, 1, 1) - `SRC_ALPHA_SATURATE_FACTOR`: (f,f,f,1) where `f = MIN(SRC_COLOR[A],1-DST_COLOR[A])` Remember; all color components are normalized to the range [0, 1] before computing the result of blending. - Blend Strings/1: Blend a non-premultiplied source over a destination with premultiplied alpha: ``` "RGB = ADD(SRC_COLOR*(SRC_COLOR[A]), DST_COLOR*(1-SRC_COLOR[A]))" "A = ADD(SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))" ``` Blend Strings/2: Blend a premultiplied source over a destination with premultiplied alpha ``` "RGBA = ADD(SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))" ``` The default blend string is: ``` RGBA = ADD (SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A])) ``` That gives normal alpha-blending when the calculated color for the pipeline is in premultiplied form. %TRUE if the blend string was successfully parsed, and the described blending is supported by the underlying driver/hardware. If there was an error, %FALSE is returned and @error is set accordingly (if present). A #CoglPipeline object A Cogl blend string describing the desired blend function. When blending is setup to reference a CONSTANT blend factor then blending will depend on the constant set with this function. A #CoglPipeline object The constant color you want Sets the basic color of the pipeline, used when no lighting is enabled. Note that if you don't add any layers to the pipeline then the color will be blended unmodified with the destination; the default blend expects premultiplied colors: for example, use (0.5, 0.0, 0.0, 0.5) for semi-transparent red. See cogl_color_premultiply(). The default value is (1.0, 1.0, 1.0, 1.0) A #CoglPipeline object The components of the color Sets which faces will be culled when drawing. Face culling can be used to increase efficiency by avoiding drawing faces that would get overridden. For example, if a model has gaps so that it is impossible to see the inside then faces which are facing away from the screen will never be seen so there is no point in drawing them. This can be achieved by setting the cull face mode to %COGL_PIPELINE_CULL_FACE_MODE_BACK. Face culling relies on the primitives being drawn with a specific order to represent which faces are facing inside and outside the model. This order can be specified by calling cogl_pipeline_set_front_face_winding(). A #CoglPipeline The new mode to set This commits all the depth state configured in @state struct to the given @pipeline. The configuration values are copied into the pipeline so there is no requirement to keep the #CoglDepthState struct around if you don't need it any more. Note: Since some platforms do not support the depth range feature it is possible for this function to fail and report an @error. %TRUE if the GPU supports all the given @state else %FALSE and returns an @error. A #CoglPipeline object A #CoglDepthState struct The order of the vertices within a primitive specifies whether it is considered to be front or back facing. This function specifies which order is considered to be the front faces. %COGL_WINDING_COUNTER_CLOCKWISE sets the front faces to primitives with vertices in a counter-clockwise order and %COGL_WINDING_CLOCKWISE sets them to be clockwise. The default is %COGL_WINDING_COUNTER_CLOCKWISE. a #CoglPipeline the winding order These are all the functions available for texture combining: - `REPLACE(arg0) = arg0` - `MODULATE(arg0, arg1) = arg0 x arg1` - `ADD(arg0, arg1) = arg0 + arg1` - `ADD_SIGNED(arg0, arg1) = arg0 + arg1 - 0.5` - `INTERPOLATE(arg0, arg1, arg2) = arg0 x arg2 + arg1 x (1 - arg2)` - `SUBTRACT(arg0, arg1) = arg0 - arg1` - ``` DOT3_RGB(arg0, arg1) = 4 x ((arg0[R] - 0.5)) * (arg1[R] - 0.5) + (arg0[G] - 0.5)) * (arg1[G] - 0.5) + (arg0[B] - 0.5)) * (arg1[B] - 0.5)) ``` - ``` DOT3_RGBA(arg0, arg1) = 4 x ((arg0[R] - 0.5)) * (arg1[R] - 0.5) + (arg0[G] - 0.5)) * (arg1[G] - 0.5) + (arg0[B] - 0.5)) * (arg1[B] - 0.5)) ``` The valid source names for texture combining are: - `TEXTURE`: Use the color from the current texture layer - `TEXTURE_0, TEXTURE_1, etc`: Use the color from the specified texture layer - `CONSTANT`: Use the color from the constant given with [method@Cogl.Pipeline.set_layer_combine_constant] - `PRIMARY`: Use the color of the pipeline as set with [method@Cogl.Pipeline.set_color] - `PREVIOUS`: Either use the texture color from the previous layer, or if this is layer 0, use the color of the pipeline as set with [method@Cogl.Pipeline.set_color] Layer Combine Examples: This is effectively what the default blending is: ``` RGBA = MODULATE (PREVIOUS, TEXTURE) ``` This could be used to cross-fade between two images, using the alpha component of a constant as the interpolator. The constant color is given by calling [method@Cogl.Pipeline.set_layer_combine_constant]. ``` RGBA = INTERPOLATE (PREVIOUS, TEXTURE, CONSTANT[A]) ``` You can't give a multiplication factor for arguments as you can with blending. %TRUE if the blend string was successfully parsed, and the described texture combining is supported by the underlying driver and or hardware. On failure, %FALSE is returned and @error is set A #CoglPipeline object Specifies the layer you want define a combine function for A Cogl blend string describing the desired texture combine function. When you are using the 'CONSTANT' color source in a layer combine description then you can use this function to define its value. A #CoglPipeline object Specifies the layer you want to specify a constant used for texture combining The constant color you want Changes the decimation and interpolation filters used when a texture is drawn at other scales than 100%. It is an error to pass anything other than %COGL_PIPELINE_FILTER_NEAREST or %COGL_PIPELINE_FILTER_LINEAR as magnification filters since magnification doesn't ever need to reference values stored in the mipmap chain. A #CoglPipeline object the layer number to change. the filter used when scaling a texture down. the filter used when magnifying a texture. This function lets you set a matrix that can be used to e.g. translate and rotate a single layer of a pipeline used to fill your geometry. A #CoglPipeline object the index for the layer inside @pipeline the transformation matrix for the layer Sets the texture for this layer to be the default texture for the given type. The default texture is a 1x1 pixel white texture. This function is mostly useful if you want to create a base pipeline that you want to create multiple copies from using cogl_pipeline_copy(). In that case this function can be used to specify the texture type so that any pipeline copies can share the internal texture type state for efficiency. A #CoglPipeline The layer number to modify When rendering points, if @enable is %TRUE then the texture coordinates for this layer will be replaced with coordinates that vary from 0.0 to 1.0 across the primitive. The top left of the point will have the coordinates 0.0,0.0 and the bottom right will have 1.0,1.0. If @enable is %FALSE then the coordinates will be fixed for the entire point. %TRUE if the function succeeds, %FALSE otherwise. A #CoglPipeline object the layer number to change. whether to enable point sprite coord generation. Sets the wrap mode for all three coordinates of texture lookups on this layer. This is equivalent to calling cogl_pipeline_set_layer_wrap_mode_s() and cogl_pipeline_set_layer_wrap_mode_t() separately. A #CoglPipeline object the layer number to change. the new wrap mode Sets the wrap mode for the 's' coordinate of texture lookups on this layer. A #CoglPipeline object the layer number to change. the new wrap mode Sets the wrap mode for the 't' coordinate of texture lookups on this layer. A #CoglPipeline object the layer number to change. the new wrap mode Sets whether to use a per-vertex point size or to use the value set by cogl_pipeline_set_point_size(). If per-vertex point size is enabled then the point size can be set for an individual point either by drawing with a #CoglAttribute with the name ‘cogl_point_size_in’ or by writing to the GLSL builtin ‘cogl_point_size_out’ from a vertex shader snippet. If per-vertex point size is enabled and this attribute is not used and cogl_point_size_out is not written to then the results are undefined. %TRUE if the change succeeded or %FALSE otherwise a #CoglPipeline pointer whether to enable per-vertex point size Changes the size of points drawn when %COGL_VERTICES_MODE_POINTS is used with the attribute buffer API. Note that typically the GPU will only support a limited minimum and maximum range of point sizes. If the chosen point size is outside that range then the nearest value within that range will be used instead. The size of a point is in screen space so it will be the same regardless of any transformations. If the point size is set to 0.0 then drawing points with the pipeline will have undefined results. This is the default value so if an application wants to draw points it must make sure to use a pipeline that has an explicit point size set on it. a #CoglPipeline pointer the new point size. Set a pipeline name. It may be used for debugging or logging purposes. The string must be a static string, and string. It will not be copied. A #CoglPipeline object A descriptive name Sets a new value for the uniform at @uniform_location. If this pipeline has a user program attached and is later used as a source for drawing, the given value will be assigned to the uniform which can be accessed from the shader's source. The value for @uniform_location should be retrieved from the string name of the uniform by calling cogl_pipeline_get_uniform_location(). This function should be used to set uniforms that are of type float. It can also be used to set a single member of a float array uniform. A #CoglPipeline object The uniform's location identifier The new value for the uniform Sets a new value for the uniform at @uniform_location. If this pipeline has a user program attached and is later used as a source for drawing, the given value will be assigned to the uniform which can be accessed from the shader's source. The value for @uniform_location should be retrieved from the string name of the uniform by calling cogl_pipeline_get_uniform_location(). This function should be used to set uniforms that are of type int. It can also be used to set a single member of a int array uniform or a sampler uniform. A #CoglPipeline object The uniform's location identifier The new value for the uniform Sets new values for the uniform at @uniform_location. If this pipeline has a user program attached and is later used as a source for drawing, the given values will be assigned to the uniform which can be accessed from the shader's source. The value for @uniform_location should be retrieved from the string name of the uniform by calling cogl_pipeline_get_uniform_location(). This function can be used to set any floating point type uniform, including float arrays and float vectors. For example, to set a single vec4 uniform you would use 4 for @n_components and 1 for @count. To set an array of 8 float values, you could use 1 for @n_components and 8 for @count. A #CoglPipeline object The uniform's location identifier The number of components in the corresponding uniform's type The number of values to set The array of float to set @uniform Sets new values for the uniform at @uniform_location. If this pipeline has a user program attached and is later used as a source for drawing, the given values will be assigned to the uniform which can be accessed from the shader's source. The value for @uniform_location should be retrieved from the string name of the uniform by calling cogl_pipeline_get_uniform_location(). This function can be used to set any integer type uniform, including int arrays and int vectors. For example, to set a single ivec4 uniform you would use 4 for @n_components and 1 for @count. To set an array of 8 int values, you could use 1 for @n_components and 8 for @count. A #CoglPipeline object The uniform's location identifier The number of components in the corresponding uniform's type The number of values to set The array of int to set @uniform Sets new values for the uniform at @uniform_location. If this pipeline has a user program attached and is later used as a source for drawing, the given values will be assigned to the uniform which can be accessed from the shader's source. The value for @uniform_location should be retrieved from the string name of the uniform by calling cogl_pipeline_get_uniform_location(). This function can be used to set any matrix type uniform, including matrix arrays. For example, to set a single mat4 uniform you would use 4 for @dimensions and 1 for @count. To set an array of 8 mat3 values, you could use 3 for @dimensions and 8 for @count. If @transpose is %FALSE then the matrix is expected to be in column-major order or if it is %TRUE then the matrix is in row-major order. You can pass a #graphene_matrix_t by calling by passing the result of graphene_matrix_to_float() in @value and setting @transpose to %FALSE. A #CoglPipeline object The uniform's location identifier The size of the matrix The number of values to set Whether to transpose the matrix The array of float to set @uniform Associates a linked CoglProgram with the given pipeline so that the program can take full control of vertex and/or fragment processing. This is an example of how it can be used to associate an ARBfp program with a #CoglPipeline: ```c CoglShader *shader; CoglProgram *program; CoglPipeline *pipeline; shader = cogl_shader_new (COGL_SHADER_TYPE_FRAGMENT); cogl_shader_source (shader, "!!ARBfp1.0\n" "MOV result.color,fragment.color;\n" "END\n"); program = cogl_program_new (); cogl_program_attach_shader (program, shader); cogl_program_link (program); pipeline = cogl_pipeline_new (); cogl_pipeline_set_user_program (pipeline, program); cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff); cogl_rectangle (0, 0, 100, 100); ``` It is possibly worth keeping in mind that this API is not part of the long term design for how we want to expose shaders to Cogl developers (We are planning on deprecating the cogl_program and cogl_shader APIs in favour of a "snippet" framework) but in the meantime we hope this will handle most practical GLSL and ARBfp requirements. a #CoglPipeline object. A linked CoglProgram 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 #CoglPipelineAlphaFunc determines how the comparison is done. Never let the fragment through. Let the fragment through if the incoming alpha value is less than the reference alpha value Let the fragment through if the incoming alpha value equals the reference alpha value Let the fragment through if the incoming alpha value is less than or equal to the reference alpha value Let the fragment through if the incoming alpha value is greater than the reference alpha value Let the fragment through if the incoming alpha value does not equal the reference alpha value Let the fragment through if the incoming alpha value is greater than or equal to the reference alpha value. Always let the fragment through. Specifies which faces should be culled. This can be set on a pipeline using cogl_pipeline_set_cull_face_mode(). Neither face will be culled. This is the default. Front faces will be culled. Back faces will be culled. All faces will be culled. 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. Measuring in manhatten distance from the, current pixel center, use the nearest texture texel Use the weighted average of the 4 texels nearest the current pixel center Select the mimap level whose texel size most closely matches the current pixel, and use the %COGL_PIPELINE_FILTER_NEAREST criterion Select the mimap level whose texel size most closely matches the current pixel, and use the %COGL_PIPELINE_FILTER_LINEAR criterion Select the two mimap levels whose texel size most closely matches the current pixel, use the %COGL_PIPELINE_FILTER_NEAREST criterion on each one and take their weighted average Select the two mimap levels whose texel size most closely matches the current pixel, use the %COGL_PIPELINE_FILTER_LINEAR criterion on each one and take their weighted average The callback prototype used with cogl_pipeline_foreach_layer() for iterating all the layers of a @pipeline. The #CoglPipeline whose layers are being iterated The current layer index The private data passed to cogl_pipeline_foreach_layer() 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_PIPELINE_FILTER_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. The texture will be repeated. This is useful for example to draw a tiled background. 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. 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. Declares a new #CoglPixelBuffer of @size bytes to contain arrays of pixels. Once declared, data can be set using cogl_buffer_set_data() or by mapping it into the application's address space using cogl_buffer_map(). If @data isn't %NULL then @size bytes will be read from @data and immediately copied into the new buffer. a newly allocated #CoglPixelBuffer A #CoglContext The number of bytes to allocate for the pixel data. An optional pointer to vertex data to upload immediately 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_PIXEL_FORMAT_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_PIXEL_FORMAT_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_PIXEL_FORMAT_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. Any format 8 bits alpha mask RGB, 16 bits RGBA, 16 bits RGBA, 16 bits Not currently supported Single luminance component 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. RGB, 24 bits BGR, 24 bits RGBX, 32 bits RGBA, 32 bits BGRX, 32 bits BGRA, 32 bits XRGB, 32 bits ARGB, 32 bits XBGR, 32 bits ABGR, 32 bits Premultiplied RGBA, 32 bits Premultiplied BGRA, 32 bits Premultiplied ARGB, 32 bits Premultiplied ABGR, 32 bits Premultiplied RGBA, 16 bits Premultiplied RGBA, 16 bits RGBA, 32 bits, 10 bpc BGRA, 32 bits, 10 bpc XRGB, 32 bits, 10 bpc ARGB, 32 bits, 10 bpc XBGR, 32 bits, 10 bpc ABGR, 32 bits, 10 bpc Premultiplied RGBA, 32 bits, 10 bpc Premultiplied BGRA, 32 bits, 10 bpc Premultiplied ARGB, 32 bits, 10 bpc Premultiplied ABGR, 32 bits, 10 bpc RGBX half floating point, 64 bit RGBA half floating point, 64 bit BGRX half floating point, 64 bit BGRA half floating point, 64 bit ARGB half floating point, 64 bit ABGR half floating point, 64 bit Premultiplied RGBA half floating point, 64 bit Premultiplied BGRA half floating point, 64 bit Premultiplied ARGB half floating point, 64 bit Premultiplied ABGR half floating point, 64 bit RGBA floating point, 128 bit Premultiplied RGBA floating point, 128 bit Single luminance component, 16 bits RG, 32 bits RGBA, 64 bits, 16bpc Queries the number of bytes per pixel for a given format in the given plane. The number of bytes per pixel in the given format's given plane. The pixel format The index of the plane (should not be more than the number of planes in the given format). Returns the number of planes the given CoglPixelFormat specifies. The no. of planes of @format (at most %COGL_PIXEL_FORMAT_MAX_PLANES) The format for which to get the number of planes Returns a string representation of @format, useful for debugging purposes. A string representation of @format. a #CoglPixelFormat Functions for creating, manipulating and drawing primitives Combines a set of `CoglAttribute`s with a specific draw @mode and defines a vertex count so a #CoglPrimitive object can be retained and drawn later with no addition information required. The value passed as @n_vertices will simply update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to read when drawing. A newly allocated #CoglPrimitive object A #CoglVerticesMode defining how to draw the vertices The number of vertices to process when drawing A %NULL terminated list of attributes Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary #CoglAttributeBuffer storage, describe the position attribute with a #CoglAttribute and upload your data. For example to draw a convex polygon you can do: ```c CoglVertexP2 triangle[] = { { 0, 300 }, { 150, 0, }, { 300, 300 } }; prim = cogl_primitive_new_p2 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); ``` The value passed as @n_vertices is initially used to determine how much can be read from @data but it will also be used to update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to read when drawing. The primitive API doesn't support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). If your hardware doesn't support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don't have to be square) A newly allocated #CoglPrimitive with a reference of 1. This can be freed using g_object_unref(). A #CoglContext A #CoglVerticesMode defining how to draw the vertices The number of vertices to read from @data and also the number of vertices to read when later drawing. An array of #CoglVertexP2 vertices Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary #CoglAttributeBuffer storage, describe the position and color attributes with `CoglAttribute`s and upload your data. For example to draw a convex polygon with a linear gradient you can do: ```c CoglVertexP2C4 triangle[] = { { 0, 300, 0xff, 0x00, 0x00, 0xff }, { 150, 0, 0x00, 0xff, 0x00, 0xff }, { 300, 300, 0xff, 0x00, 0x00, 0xff } }; prim = cogl_primitive_new_p2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); ``` The value passed as @n_vertices is initially used to determine how much can be read from @data but it will also be used to update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to read when drawing. The primitive API doesn't support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). If your hardware doesn't support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don't have to be square) A newly allocated #CoglPrimitive with a reference of 1. This can be freed using g_object_unref(). A #CoglContext A #CoglVerticesMode defining how to draw the vertices The number of vertices to read from @data and also the number of vertices to read when later drawing. An array of #CoglVertexP2C4 vertices Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary #CoglAttributeBuffer storage, describe the position and texture coordinate attributes with `CoglAttribute`s and upload your data. For example to draw a convex polygon with texture mapping you can do: ```c CoglVertexP2T2 triangle[] = { { 0, 300, 0.0, 1.0}, { 150, 0, 0.5, 0.0}, { 300, 300, 1.0, 1.0} }; prim = cogl_primitive_new_p2t2 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); ``` The value passed as @n_vertices is initially used to determine how much can be read from @data but it will also be used to update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to read when drawing. The primitive API doesn't support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). If your hardware doesn't support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don't have to be square) A newly allocated #CoglPrimitive with a reference of 1. This can be freed using g_object_unref(). A #CoglContext A #CoglVerticesMode defining how to draw the vertices The number of vertices to read from @data and also the number of vertices to read when later drawing. An array of #CoglVertexP2T2 vertices Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary #CoglAttributeBuffer storage, describe the position attribute with a #CoglAttribute and upload your data. For example to draw a convex polygon you can do: ```c CoglVertexP3 triangle[] = { { 0, 300, 0 }, { 150, 0, 0 }, { 300, 300, 0 } }; prim = cogl_primitive_new_p3 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); ``` The value passed as @n_vertices is initially used to determine how much can be read from @data but it will also be used to update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to read when drawing. The primitive API doesn't support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). If your hardware doesn't support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don't have to be square) A newly allocated #CoglPrimitive with a reference of 1. This can be freed using g_object_unref(). A #CoglContext A #CoglVerticesMode defining how to draw the vertices The number of vertices to read from @data and also the number of vertices to read when later drawing. An array of #CoglVertexP3 vertices Provides a convenient way to describe a primitive, such as a single triangle strip or a triangle fan, that will internally allocate the necessary #CoglAttributeBuffer storage, describe the position and texture coordinate attributes with `CoglAttribute`s and upload your data. For example to draw a convex polygon with texture mapping you can do: ```c CoglVertexP3T2 triangle[] = { { 0, 300, 0, 0.0, 1.0}, { 150, 0, 0, 0.5, 0.0}, { 300, 300, 0, 1.0, 1.0} }; prim = cogl_primitive_new_p3t2 (COGL_VERTICES_MODE_TRIANGLE_FAN, 3, triangle); cogl_primitive_draw (prim); ``` The value passed as @n_vertices is initially used to determine how much can be read from @data but it will also be used to update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to read when drawing. The primitive API doesn't support drawing with sliced textures (since switching between slices implies changing state and so that implies multiple primitives need to be submitted). If your hardware doesn't support non-power of two textures (For example you are using GLES 1.1) then you will need to make sure your assets are resized to a power-of-two size (though they don't have to be square) A newly allocated #CoglPrimitive with a reference of 1. This can be freed using g_object_unref(). A #CoglContext A #CoglVerticesMode defining how to draw the vertices The number of vertices to read from @data and also the number of vertices to read when later drawing. An array of #CoglVertexP3T2 vertices Combines a set of `CoglAttribute`s with a specific draw @mode and defines a vertex count so a #CoglPrimitive object can be retained and drawn later with no addition information required. The value passed as @n_vertices will simply update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to read when drawing. A newly allocated #CoglPrimitive object A #CoglVerticesMode defining how to draw the vertices The number of vertices to process when drawing An array of CoglAttribute The number of attributes Draws the given @primitive geometry to the specified destination @framebuffer using the graphics processing state described by @pipeline. This drawing api doesn't support high-level meta texture types such as #CoglTexture2DSliced so it is the user's responsibility to ensure that only low-level textures that can be directly sampled by a GPU such as #CoglTexture2D are associated with layers of the given @pipeline. A #CoglPrimitive geometry object A destination #CoglFramebuffer A #CoglPipeline state object Associates a sequence of #CoglIndices with the given @primitive. #CoglIndices provide a way to virtualize your real vertex data by providing a sequence of indices that index into your real vertex data. The GPU will walk though the index values to indirectly lookup the data for each vertex instead of sequentially walking through the data directly. This lets you save memory by indexing shared data multiple times instead of duplicating the data. The value passed as @n_indices will simply update the #CoglPrimitive `n_vertices` property as if cogl_primitive_set_n_vertices() were called. This property defines the number of vertices to draw or, put another way, how many indices should be read from @indices when drawing. The #CoglPrimitive `first_vertex` property also affects drawing with indices by defining the first entry of the indices to start drawing from. A #CoglPrimitive A #CoglIndices array The number of indices to reference when drawing Specifies how many vertices should be read when drawing the given @primitive. Usually this value is set implicitly when associating vertex data or indices with a #CoglPrimitive. To be clear; it doesn't refer to the number of vertices - in terms of data - associated with the primitive it's just the number of vertices to read and draw. A #CoglPrimitive object The number of vertices to read when drawing. Create a new cogl program object that can be used to replace parts of the GL rendering pipeline with custom code. Use #CoglSnippet api a new cogl program. 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. Use #CoglSnippet api a #CoglProgram for a shader program. a #CoglShader 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. Use #CoglSnippet api instead the offset of a uniform in a specified program. 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. Use #CoglSnippet api A shader program. Changes the value of a floating point uniform for the given linked @program. Use #CoglSnippet api instead A linked program the uniform location retrieved from [method@Program.get_uniform_location]. the new value of the uniform. Changes the value of an integer uniform for the given linked @program. Use #CoglSnippet api instead A linked program the uniform location retrieved from [method@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. Use #CoglSnippet api instead A linked program the uniform location retrieved from [method@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. For uniform arrays this is the array length otherwise just pass 1 the new value of the uniform[s]. Changes the value of a int vector uniform, or uniform array for the given linked @program. Use #CoglSnippet api instead A linked program the uniform location retrieved from [method@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. For uniform arrays this is the array length otherwise just pass 1 the new value of the uniform[s]. Changes the value of a matrix uniform, or uniform array in the given linked @program. Use #CoglSnippet api instead A linked program the uniform location retrieved from [method@Program.get_uniform_location]. The dimensions of the matrix. So for for example pass 2 for a 2x2 matrix or 3 for 3x3. For uniform arrays this is the array length otherwise just pass 1 Whether to transpose the matrix when setting the uniform. the new value of the uniform. Flags for cogl_framebuffer_read_pixels_into_bitmap() Read from the color buffer Choosing a means to render A #CoglRenderer represents a means to render. It encapsulates the selection of an underlying driver, such as OpenGL or OpenGL-ES and a selection of a window system binding API such as GLX or EGL. A #CoglRenderer has two states, "unconnected" and "connected". When a renderer is first instantiated using cogl_renderer_new() it is unconnected so that it can be configured and constraints can be specified for how the backend driver and window system should be chosen. After configuration a #CoglRenderer can (optionally) be explicitly connected using cogl_renderer_connect() which allows for the handling of connection errors so that fallback configurations can be tried if necessary. Applications that don't support any fallbacks though can skip using cogl_renderer_connect() and leave Cogl to automatically connect the renderer. Once you have a configured #CoglRenderer it can be used to create a #CoglDisplay object using cogl_display_new(). Instantiates a new (unconnected) #CoglRenderer object. A #CoglRenderer represents a means to render. It encapsulates the selection of an underlying driver, such as OpenGL or OpenGL-ES and a selection of a window system binding API such as GLX or EGL. There are also some platform specific configuration apis such as cogl_xlib_renderer_set_foreign_display() that may also be used while the renderer is unconnected. Once the renderer has been configured, then it may (optionally) be explicitly connected using cogl_renderer_connect() which allows errors to be handled gracefully and potentially fallback configurations can be tried out if there are initial failures. If a renderer is not explicitly connected then cogl_display_new() will automatically connect the renderer for you. If you don't have any code to deal with error/fallback situations then its fine to just let Cogl do the connection for you. Once you have setup your renderer then the next step is to create a #CoglDisplay using cogl_display_new(). A newly created #CoglRenderer. Connects the configured @renderer. Renderer connection isn't a very active process, it basically just means validating that any given constraint criteria can be satisfied and that a usable driver and window system backend can be found. %TRUE if there was no error while connecting the given @renderer. %FALSE if there was an error. An unconnected #CoglRenderer Creates a new #CoglFramebuffer with @width x @height, with pixel format @format, and exports the new framebuffer's DMA buffer handle. Passing an empty modifier array (passing a 0 n_modifiers) means implicit modifiers will be used. a #CoglDmaBufHandle. The return result must be released with cogl_dma_buf_handle_free() after use. A #CoglRenderer A #CoglPixelFormat array of DRM format modifiers length of modifiers array width of the new height of the new Queries what underlying driver is being used by Cogl. This may only be called on a connected #CoglRenderer. A connected #CoglRenderer Gets a pointer to a given GL or GL ES extension function. This acts as a wrapper around glXGetProcAddress() or whatever is the appropriate function for the current backend. This function should not be used to query core opengl API symbols since eglGetProcAddress for example doesn't allow this and and may return a junk pointer if you do. a pointer to the requested function or %NULL if the function is not available. A #CoglRenderer. the name of the function. Queries which window system backend Cogl has chosen to use. This may only be called on a connected #CoglRenderer. The #CoglWinsysID corresponding to the chosen window system backend. A #CoglRenderer Processes a single event. #CoglFilterReturn. %COGL_FILTER_REMOVE indicates that Cogl has internally handled the event and the caller should do no further processing. %COGL_FILTER_CONTINUE indicates that Cogl is either not interested in the event, or has used the event to update internal state without taking any exclusive action. a #CoglRenderer pointer to an event structure %TRUE if DMA buffers can be allocated A #CoglRenderer A #CoglRenderer The #CoglPixelFormat Requests that Cogl should try to use a specific underlying driver for rendering. If you select an unsupported driver then cogl_renderer_connect() will fail and report an error. Most applications should not explicitly select a driver and should rely on Cogl automatically choosing the driver. This may only be called on an un-connected #CoglRenderer. An unconnected #CoglRenderer a #CoglScanoutBuffer Scanout inhibited Functions for accessing the programmable GL pipeline Cogl allows accessing the GL programmable pipeline in order to create vertex and fragment shaders. When using GLSL Cogl provides replacement names for most of the builtin varyings and uniforms. It is recommended to use these names wherever possible to increase portability between OpenGL 2.0 and GLES 2.0. GLES 2.0 does not have most of the builtins under their original names so they will only work with the Cogl names. For use in all GLSL shaders, the Cogl builtins are as follows: - `uniform mat4 cogl_modelview_matrix` The current modelview matrix. This is equivalent to #gl_ModelViewMatrix. - `uniform mat4 cogl_projection_matrix` The current projection matrix. This is equivalent to #gl_ProjectionMatrix. - `uniform mat4 cogl_modelview_projection_matrix` The combined modelview and projection matrix. A vertex shader would typically use this to transform the incoming vertex position. The separate modelview and projection matrices are usually only needed for lighting calculations. This is equivalent to #gl_ModelViewProjectionMatrix. - `uniform mat4 cogl_texture_matrix[]` An array of matrices for transforming the texture coordinates. This is equivalent to #gl_TextureMatrix. In a vertex shader, the following are also available: - `attribute vec4 cogl_position_in` The incoming vertex position. This is equivalent to #gl_Vertex. - `attribute vec4 cogl_color_in` The incoming vertex color. This is equivalent to #gl_Color. - `attribute vec4 cogl_tex_coord_in` The texture coordinate for the first texture unit. This is equivalent to #gl_MultiTexCoord0. - `attribute vec4 cogl_tex_coord0_in` The texture coordinate for the first texture unit. This is equivalent to #gl_MultiTexCoord0. There is also #cogl_tex_coord1_in and so on. - `attribute vec3 cogl_normal_in` The normal of the vertex. This is equivalent to #gl_Normal. - `vec4 cogl_position_out` The calculated position of the vertex. This must be written to in all vertex shaders. This is equivalent to #gl_Position. - `float cogl_point_size_out` The calculated size of a point. This is equivalent to #gl_PointSize. - `varying vec4 cogl_color_out` The calculated color of a vertex. This is equivalent to #gl_FrontColor. - `varying vec4 cogl_tex_coord_out[]` An array of calculated texture coordinates for a vertex. This is equivalent to #gl_TexCoord. In a fragment shader, the following are also available: - `varying vec4 cogl_color_in` The calculated color of a vertex. This is equivalent to #gl_FrontColor. - `varying vec4 cogl_tex_coord_in[]` An array of calculated texture coordinates for a vertex. This is equivalent to #gl_TexCoord. - `vec4 cogl_color_out` The final calculated color of the fragment. All fragment shaders must write to this variable. This is equivalent to #gl_FrontColor. - `float cogl_depth_out` An optional output variable specifying the depth value to use for this fragment. This is equivalent to #gl_FragDepth. - `bool cogl_front_facing` A readonly variable that will be true if the current primitive is front facing. This can be used to implement two-sided coloring algorithms. This is equivalent to #gl_FrontFacing. It's worth nothing that this API isn't what Cogl would like to have in the long term and it may be removed in Cogl 2.0. The experimental #CoglShader API is the proposed replacement. Create a new shader handle, use cogl_shader_source() to set the source code to be used on it. Use #CoglSnippet api a new shader handle. COGL_SHADER_TYPE_VERTEX or COGL_SHADER_TYPE_FRAGMENT. Retrieves the type of a shader Use #CoglSnippet api %COGL_SHADER_TYPE_VERTEX if the shader is a vertex processor or %COGL_SHADER_TYPE_FRAGMENT if the shader is a fragment processor #CoglShader for a shader. Replaces the current source associated with a shader with a new one. Use #CoglSnippet api A shader. Shader source. Types of shaders A program for processing vertices A program for processing fragments Functions for creating and manipulating shader snippets `CoglSnippet`s are used to modify or replace parts of a #CoglPipeline using GLSL. GLSL is a programming language supported by OpenGL on programmable hardware to provide a more flexible description of what should be rendered. A description of GLSL itself is outside the scope of this documentation but any good OpenGL book should help to describe it. Unlike in OpenGL, when using GLSL with Cogl it is possible to write short snippets to replace small sections of the pipeline instead of having to replace the whole of either the vertex or fragment pipelines. Of course it is also possible to replace the whole of the pipeline if needed. Each snippet is a standalone chunk of code which would attach to the pipeline at a particular point. The code is split into four separate strings (all of which are optional): - `declarations` The code in this string will be inserted outside of any function in the global scope of the shader. This can be used to declare uniforms, attributes, varyings and functions to be used by the snippet. - `pre` The code in this string will be inserted before the hook point. - `post` The code in this string will be inserted after the hook point. This can be used to modify the results of the builtin generated code for that hook point. - `replace If present the code in this string will replace the generated code for the hook point. All of the strings apart from the declarations string of a pipeline are generated in a single function so they can share variables declared from one string in another. The scope of the code is limited to each snippet so local variables declared in the snippet will not collide with variables declared in another snippet. However, code in the 'declarations' string is global to the shader so it is the application's responsibility to ensure that variables declared here will not collide with those from other snippets. The snippets can be added to a pipeline with cogl_pipeline_add_snippet() or cogl_pipeline_add_layer_snippet(). Which function to use depends on which hook the snippet is targeting. The snippets are all generated in the order they are added to the pipeline. That is, the post strings are executed in the order they are added to the pipeline and the pre strings are executed in reverse order. If any replace strings are given for a snippet then any other snippets with the same hook added before that snippet will be ignored. The different hooks are documented under #CoglSnippetHook. For portability with GLES2, it is recommended not to use the GLSL builtin names such as gl_FragColor. Instead there are replacement names under the cogl_* namespace which can be used instead. These are: - `uniform mat4 cogl_modelview_matrix The current modelview matrix. This is equivalent to #gl_ModelViewMatrix. - `uniform mat4 cogl_projection_matrix The current projection matrix. This is equivalent to #gl_ProjectionMatrix. - `uniform mat4 cogl_modelview_projection_matrix The combined modelview and projection matrix. A vertex shader would typically use this to transform the incoming vertex position. The separate modelview and projection matrices are usually only needed for lighting calculations. This is equivalent to #gl_ModelViewProjectionMatrix. - `uniform mat4 cogl_texture_matrix[] An array of matrices for transforming the texture coordinates. This is equivalent to #gl_TextureMatrix. In a vertex shader, the following are also available: - `attribute vec4 cogl_position_in The incoming vertex position. This is equivalent to #gl_Vertex. - `attribute vec4 cogl_color_in` The incoming vertex color. This is equivalent to #gl_Color. - `attribute vec4 cogl_tex_coord_in` The texture coordinate for layer 0. This is an alternative name for #cogl_tex_coord0_in. - `attribute vec4 cogl_tex_coord0_in The texture coordinate for the layer 0. This is equivalent to #gl_MultiTexCoord0. There will also be #cogl_tex_coord1_in and so on if more layers are added to the pipeline. - `attribute vec3 cogl_normal_in` The normal of the vertex. This is equivalent to #gl_Normal. - `vec4 cogl_position_out The calculated position of the vertex. This must be written to in all vertex shaders. This is equivalent to #gl_Position. - `float cogl_point_size_in The incoming point size from the cogl_point_size_in attribute. This is only available if cogl_pipeline_set_per_vertex_point_size() is set on the pipeline. - `float cogl_point_size_out` The calculated size of a point. This is equivalent to #gl_PointSize. - `varying vec4 cogl_color_out` The calculated color of a vertex. This is equivalent to #gl_FrontColor. - `varying vec4 cogl_tex_coord0_out` The calculated texture coordinate for layer 0 of the pipeline. This is equivalent to #gl_TexCoord[0]. There will also be #cogl_tex_coord1_out and so on if more layers are added to the pipeline. In the fragment shader, this varying is called #cogl_tex_coord0_in. In a fragment shader, the following are also available: - `varying vec4 cogl_color_in` The calculated color of a vertex. This is equivalent to #gl_FrontColor. - `varying vec4 cogl_tex_coord0_in` The texture coordinate for layer 0. This is equivalent to #gl_TexCoord[0]. There will also be #cogl_tex_coord1_in and so on if more layers are added to the pipeline. - `vec4 cogl_color_out` The final calculated color of the fragment. All fragment shaders must write to this variable. This is equivalent to #gl_FrontColor. - `float cogl_depth_out` An optional output variable specifying the depth value to use for this fragment. This is equivalent to #gl_FragDepth. - `bool cogl_front_facing` A readonly variable that will be true if the current primitive is front facing. This can be used to implement two-sided coloring algorithms. This is equivalent to #gl_FrontFacing. - `vec2 cogl_point_coord` When rendering points, this will contain a vec2 which represents the position within the point of the current fragment. vec2(0.0,0.0) will be the topleft of the point and vec2(1.0,1.0) will be the bottom right. Note that there is currently a bug in Cogl where when rendering to an offscreen buffer these coordinates will be upside-down. The value is undefined when not rendering points. Here is an example of using a snippet to add a desaturate effect to the generated color on a pipeline. ```c CoglPipeline *pipeline = cogl_pipeline_new (); /<!-- -->* Set up the pipeline here, ie by adding a texture or other layers *<!-- -->/ /<!-- -->* Create the snippet. The first string is the declarations which we will use to add a uniform. The second is the 'post' string which will contain the code to perform the desaturation. *<!-- -->/ CoglSnippet *snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_FRAGMENT, "uniform float factor;", "float gray = dot (vec3 (0.299, 0.587, 0.114), " " cogl_color_out.rgb);" "cogl_color_out.rgb = mix (vec3 (gray)," " cogl_color_out.rgb," " factor);"); /<!-- -->* Add it to the pipeline *<!-- -->/ cogl_pipeline_add_snippet (pipeline, snippet); /<!-- -->* The pipeline keeps a reference to the snippet so we don't need to *<!-- -->/ g_object_unref (snippet); /<!-- -->* Update the custom uniform on the pipeline *<!-- -->/ int location = cogl_pipeline_get_uniform_location (pipeline, "factor"); cogl_pipeline_set_uniform_1f (pipeline, location, 0.5f); /<!-- -->* Now we can render with the snippet as usual *<!-- -->/ cogl_push_source (pipeline); cogl_rectangle (0, 0, 10, 10); cogl_pop_source (); ``` Allocates and initializes a new snippet with the given source strings. a pointer to a new #CoglSnippet The point in the pipeline that this snippet will wrap around or replace. The source code for the declarations for this snippet or %NULL. See cogl_snippet_set_declarations(). The source code to run after the hook point where this shader snippet is attached or %NULL. See cogl_snippet_set_post(). the source string that was set with cogl_snippet_set_declarations() or %NULL if none was set. A #CoglSnippet the hook that was set when cogl_snippet_new() was called. A #CoglSnippet the source string that was set with cogl_snippet_set_post() or %NULL if none was set. A #CoglSnippet the source string that was set with cogl_snippet_set_pre() or %NULL if none was set. A #CoglSnippet the source string that was set with cogl_snippet_set_replace() or %NULL if none was set. A #CoglSnippet Sets a source string that will be inserted in the global scope of the generated shader when this snippet is used on a pipeline. This string is typically used to declare uniforms, attributes or functions that will be used by the other parts of the snippets. This function should only be called before the snippet is attached to its first pipeline. After that the snippet should be considered immutable. A #CoglSnippet The new source string for the declarations section of this snippet. Sets a source string that will be inserted after the hook point in the generated shader for the pipeline that this snippet is attached to. Please see the documentation of each hook point in #CoglPipeline for a description of how this string should be used. This function should only be called before the snippet is attached to its first pipeline. After that the snippet should be considered immutable. A #CoglSnippet The new source string for the post section of this snippet. Sets a source string that will be inserted before the hook point in the generated shader for the pipeline that this snippet is attached to. Please see the documentation of each hook point in #CoglPipeline for a description of how this string should be used. This function should only be called before the snippet is attached to its first pipeline. After that the snippet should be considered immutable. A #CoglSnippet The new source string for the pre section of this snippet. Sets a source string that will be used instead of any generated source code or any previous snippets for this hook point. Please see the documentation of each hook point in #CoglPipeline for a description of how this string should be used. This function should only be called before the snippet is attached to its first pipeline. After that the snippet should be considered immutable. A #CoglSnippet The new source string for the replace section of this snippet. #CoglSnippetHook is used to specify a location within a #CoglPipeline where the code of the snippet should be used when it is attached to a pipeline. - `COGL_SNIPPET_HOOK_VERTEX_GLOBALS` Adds a shader snippet at the beginning of the global section of the shader for the vertex processing. Any declarations here can be shared with all other snippets that are attached to a vertex hook. Only the ‘declarations’ string is used and the other strings are ignored. - `COGL_SNIPPET_HOOK_FRAGMENT_GLOBALS` Adds a shader snippet at the beginning of the global section of the shader for the fragment processing. Any declarations here can be shared with all other snippets that are attached to a fragment hook. Only the ‘declarations’ string is used and the other strings are ignored. - `COGL_SNIPPET_HOOK_VERTEX` Adds a shader snippet that will hook on to the vertex processing stage of the pipeline. This gives a chance for the application to modify the vertex attributes generated by the shader. Typically the snippet will modify cogl_color_out or cogl_position_out builtins. The ‘declarations’ string in @snippet will be inserted in the global scope of the shader. Use this to declare any uniforms, attributes or functions that the snippet requires. The ‘pre’ string in @snippet will be inserted at the top of the main() function before any vertex processing is done. The ‘replace’ string in @snippet will be used instead of the generated vertex processing if it is present. This can be used if the application wants to provide a complete vertex shader and doesn't need the generated output from Cogl. The ‘post’ string in @snippet will be inserted after all of the standard vertex processing is done. This can be used to modify the outputs. - `COGL_SNIPPET_HOOK_VERTEX_TRANSFORM` Adds a shader snippet that will hook on to the vertex transform stage. Typically the snippet will use the cogl_modelview_matrix, cogl_projection_matrix and cogl_modelview_projection_matrix matrices and the cogl_position_in attribute. The hook must write to cogl_position_out. The default processing for this hook will multiply cogl_position_in by the combined modelview-projection matrix and store it on cogl_position_out. The ‘declarations’ string in @snippet will be inserted in the global scope of the shader. Use this to declare any uniforms, attributes or functions that the snippet requires. The ‘pre’ string in @snippet will be inserted at the top of the main() function before the vertex transform is done. The ‘replace’ string in @snippet will be used instead of the generated vertex transform if it is present. The ‘post’ string in @snippet will be inserted after all of the standard vertex transformation is done. This can be used to modify the cogl_position_out in addition to the default processing. - `COGL_SNIPPET_HOOK_POINT_SIZE` Adds a shader snippet that will hook on to the point size calculation step within the vertex shader stage. The snippet should write to the builtin cogl_point_size_out with the new point size. The snippet can either read cogl_point_size_in directly and write a new value or first read an existing value in cogl_point_size_out that would be set by a previous snippet. Note that this hook is only used if cogl_pipeline_set_per_vertex_point_size() is enabled on the pipeline. The ‘declarations’ string in @snippet will be inserted in the global scope of the shader. Use this to declare any uniforms, attributes or functions that the snippet requires. The ‘pre’ string in @snippet will be inserted just before calculating the point size. The ‘replace’ string in @snippet will be used instead of the generated point size calculation if it is present. The ‘post’ string in @snippet will be inserted after the standard point size calculation is done. This can be used to modify cogl_point_size_out in addition to the default processing. - `COGL_SNIPPET_HOOK_FRAGMENT` Adds a shader snippet that will hook on to the fragment processing stage of the pipeline. This gives a chance for the application to modify the fragment color generated by the shader. Typically the snippet will modify cogl_color_out. The ‘declarations’ string in @snippet will be inserted in the global scope of the shader. Use this to declare any uniforms, attributes or functions that the snippet requires. The ‘pre’ string in @snippet will be inserted at the top of the main() function before any fragment processing is done. The ‘replace’ string in @snippet will be used instead of the generated fragment processing if it is present. This can be used if the application wants to provide a complete fragment shader and doesn't need the generated output from Cogl. The ‘post’ string in @snippet will be inserted after all of the standard fragment processing is done. At this point the generated value for the rest of the pipeline state will already be in cogl_color_out so the application can modify the result by altering this variable. - `COGL_SNIPPET_HOOK_TEXTURE_COORD_TRANSFORM` Adds a shader snippet that will hook on to the texture coordinate transformation of a particular layer. This can be used to replace the processing for a layer or to modify the results. Within the snippet code for this hook there are two extra variables. The first is a mat4 called cogl_matrix which represents the user matrix for this layer. The second is called cogl_tex_coord and represents the incoming and outgoing texture coordinate. On entry to the hook, cogl_tex_coord contains the value of the corresponding texture coordinate attribute for this layer. The hook is expected to modify this variable. The output will be passed as a varying to the fragment processing stage. The default code will just multiply cogl_matrix by cogl_tex_coord and store the result in cogl_tex_coord. The ‘declarations’ string in @snippet will be inserted in the global scope of the shader. Use this to declare any uniforms, attributes or functions that the snippet requires. The ‘pre’ string in @snippet will be inserted just before the fragment processing for this layer. At this point cogl_tex_coord still contains the value of the texture coordinate attribute. If a ‘replace’ string is given then this will be used instead of the default fragment processing for this layer. The snippet can modify cogl_tex_coord or leave it as is to apply no transformation. The ‘post’ string in @snippet will be inserted just after the transformation. At this point cogl_tex_coord will contain the results of the transformation but it can be further modified by the snippet. - `COGL_SNIPPET_HOOK_LAYER_FRAGMENT` Adds a shader snippet that will hook on to the fragment processing of a particular layer. This can be used to replace the processing for a layer or to modify the results. Within the snippet code for this hook there is an extra vec4 variable called ‘cogl_layer’. This contains the resulting color that will be used for the layer. This can be modified in the ‘post’ section or it the default processing can be replaced entirely using the ‘replace’ section. The ‘declarations’ string in @snippet will be inserted in the global scope of the shader. Use this to declare any uniforms, attributes or functions that the snippet requires. The ‘pre’ string in @snippet will be inserted just before the fragment processing for this layer. If a ‘replace’ string is given then this will be used instead of the default fragment processing for this layer. The snippet must write to the ‘cogl_layer’ variable in that case. The ‘post’ string in @snippet will be inserted just after the fragment processing for the layer. The results can be modified by changing the value of the ‘cogl_layer’ variable. - `COGL_SNIPPET_HOOK_TEXTURE_LOOKUP` Adds a shader snippet that will hook on to the texture lookup part of a given layer. This gives a chance for the application to modify the coordinates that will be used for the texture lookup or to alter the returned texel. Within the snippet code for this hook there are three extra variables available. ‘cogl_sampler’ is a sampler object representing the sampler for the layer where the snippet is attached. ‘cogl_tex_coord’ is a vec4 which contains the texture coordinates that will be used for the texture lookup. This can be modified. ‘cogl_texel’ will contain the result of the texture lookup. This can also be modified. The ‘declarations’ string in @snippet will be inserted in the global scope of the shader. Use this to declare any uniforms, attributes or functions that the snippet requires. The ‘pre’ string in @snippet will be inserted at the top of the main() function before any fragment processing is done. This is a good place to modify the cogl_tex_coord variable. If a ‘replace’ string is given then this will be used instead of a the default texture lookup. The snippet would typically use its own sampler in this case. The ‘post’ string in @snippet will be inserted after texture lookup has been performed. Here the snippet can modify the cogl_texel variable to alter the returned texel. A hook for the entire vertex processing stage of the pipeline. A hook for the vertex transformation. A hook for declaring global data that can be shared with all other snippets that are on a vertex hook. A hook for manipulating the point size of a vertex. This is only used if cogl_pipeline_set_per_vertex_point_size() is enabled on the pipeline. A hook for the entire fragment processing stage of the pipeline. A hook for declaring global data wthat can be shared with all other snippets that are on a fragment hook. A hook for applying the layer matrix to a texture coordinate for a layer. A hook for the fragment processing of a particular layer. A hook for the texture lookup stage of a given layer in a pipeline. Functions for creating and manipulating sub-textures. These functions allow high-level textures to be created that represent a sub-region of another texture. For example these can be used to implement custom texture atlasing schemes. Creates a high-level #CoglSubTexture representing a sub-region of any other #CoglTexture. The sub-region must strictly lye within the bounds of the @parent_texture. The returned texture implements the #CoglTexture interface because it's not a low level texture that hardware can understand natively. Remember: Unless you are using high level drawing APIs such as cogl_rectangle() or other APIs documented to understand the #CoglTexture interface then you need to use the #CoglTexture interface to resolve a #CoglSubTexture into a low-level texture before drawing. A newly allocated #CoglSubTexture representing a sub-region of @parent_texture. A #CoglContext pointer The full texture containing a sub-region you want to make a #CoglSubTexture from. The top-left x coordinate of the parent region to make a texture from. The top-left y coordinate of the parent region to make a texture from. The width of the parent region to make a texture from. The height of the parent region to make a texture from. Error enumeration for Cogl The @COGL_SYSTEM_ERROR_UNSUPPORTED error can be thrown for a variety of reasons. For example: - You've tried to use a feature that is not advertised by [method@Cogl.Context.has_feature]. - 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 - The driver does not support some configuration. Currently this is only used by Cogl API marked as experimental so this enum should also be considered experimental. You tried to use a feature or configuration not currently available. You tried to allocate a resource such as a texture and there wasn't enough memory. Functions for creating and manipulating textures Cogl allows creating and manipulating textures using a uniform API that tries to hide all the various complexities of creating, loading and manipulating textures. Explicitly allocates the storage for the given @texture which allows you to be sure that there is enough memory for the texture and if not then the error can be handled gracefully. Normally applications don't need to use this api directly since the texture will be implicitly allocated when data is set on the texture, or if the texture is attached to a #CoglOffscreen framebuffer and rendered too. %TRUE if the texture was successfully allocated, otherwise %FALSE and @error will be updated if it wasn't %NULL. A #CoglTexture Allows you to manually iterate the low-level textures that define a given region of a high-level #CoglTexture. For example cogl_texture_2d_sliced_new_with_size() can be used to create a meta texture that may slice a large image into multiple, smaller power-of-two sized textures. These high level textures are not directly understood by a GPU and so this API must be used to manually resolve the underlying textures for drawing. All high level textures (#CoglAtlasTexture, #CoglSubTexture, #CoglTexturePixmapX11, and #CoglTexture2DSliced) can be handled consistently using this interface which greately simplifies implementing primitives that support all texture types. For example if you use the cogl_rectangle() API then Cogl will internally use this API to resolve the low level textures of any meta textures you have associated with CoglPipeline layers. The low level drawing APIs such as cogl_primitive_draw() don't understand the #CoglTexture interface and so it is your responsibility to use this API to resolve all CoglPipeline textures into low-level textures before drawing. For each low-level texture that makes up part of the given region of the @meta_texture, @callback is called specifying how the low-level texture maps to the original region. An object implementing the #CoglTexture interface. The top-left x coordinate of the region to iterate The top-left y coordinate of the region to iterate The bottom-right x coordinate of the region to iterate The bottom-right y coordinate of the region to iterate The wrap mode for the x-axis The wrap mode for the y-axis A #CoglTextureForeachCallback pointer to be called for each low-level texture within the specified region. A private pointer that is passed to @callback. Queries what components the given @texture stores internally as set via cogl_texture_set_components(). For textures created by the ‘_with_size’ constructors the default is %COGL_TEXTURE_COMPONENTS_RGBA. The other constructors which take a %CoglBitmap or a data pointer default to the same components as the pixel format of the data. a #CoglTexture pointer. The associated %CoglContext Copies the pixel data from a cogl texture to system memory. Don't pass the value of cogl_texture_get_rowstride() as the @rowstride argument, the rowstride should be the rowstride you want for the destination @data buffer not the rowstride of the source texture the size of the texture data in bytes a #CoglTexture pointer. the #CoglPixelFormat to store the texture as. the rowstride of @data in bytes or pass 0 to calculate from the bytes-per-pixel of @format multiplied by the @texture width. memory location to write the @texture's contents, or %NULL to only query the data size through the return value. Queries the GL handles for a GPU side texture through its #CoglTexture. If the texture is spliced the data for the first sub texture will be queried. %TRUE if the handle was successfully retrieved, %FALSE if the handle was invalid a #CoglTexture pointer. pointer to return location for the textures GL handle, or %NULL. pointer to return location for the GL target type, or %NULL. Queries the height of a cogl texture. the height of the GPU side texture in pixels a #CoglTexture pointer. Queries the pre-multiplied alpha status for internally stored red, green and blue components for the given @texture as set by cogl_texture_set_premultiplied(). By default the pre-multiplied state is @TRUE. %TRUE if red, green and blue components are internally stored pre-multiplied by the alpha value or %FALSE if not. a #CoglTexture pointer. Queries the width of a cogl texture. the width of the GPU side texture in pixels a #CoglTexture pointer. Queries if a texture is sliced (stored as multiple GPU side tecture objects). %TRUE if the texture is sliced, %FALSE if the texture is stored as a single GPU texture a #CoglTexture pointer. Affects the internal storage format for this texture by specifying what components will be required for sampling later. This api affects how data is uploaded to the GPU since unused components can potentially be discarded from source data. For textures created by the ‘_with_size’ constructors the default is %COGL_TEXTURE_COMPONENTS_RGBA. The other constructors which take a %CoglBitmap or a data pointer default to the same components as the pixel format of the data. Note that the %COGL_TEXTURE_COMPONENTS_RG format is not available on all drivers. The availability can be determined by checking for the %COGL_FEATURE_ID_TEXTURE_RG feature. If this format is used on a driver where it is not available then %COGL_TEXTURE_ERROR_FORMAT will be raised when the texture is allocated. Even if the feature is not available then %COGL_PIXEL_FORMAT_RG_88 can still be used as an image format as long as %COGL_TEXTURE_COMPONENTS_RG isn't used as the texture's components. a #CoglTexture pointer. @texture a #CoglTexture. Sets all the pixels for a given mipmap @level by copying the pixel data pointed to by the @data argument into the given @texture. @data should point to the first pixel to copy corresponding to the top left of the mipmap @level being set. If @rowstride equals 0 then it will be automatically calculated from the width of the mipmap level and the bytes-per-pixel for the given @format. A mipmap @level of 0 corresponds to the largest, base image of a texture and @level 1 is half the width and height of level 0. If dividing any dimension of the previous level by two results in a fraction then round the number down (floor()), but clamp to 1 something like this: ``` next_width = MAX (1, floor (prev_width)); ``` You can determine the number of mipmap levels for a given texture like this: ``` n_levels = 1 + floor (log2 (max_dimension)); ``` Where %max_dimension is the larger of cogl_texture_get_width() and cogl_texture_get_height(). It is an error to pass a @level number >= the number of levels that @texture can have according to the above calculation. Since the storage for a #CoglTexture is allocated lazily then if the given @texture has not previously been allocated then this api can return %FALSE and throw an exceptional @error if there is not enough memory to allocate storage for @texture. %TRUE if the data upload was successful, and %FALSE otherwise the #CoglPixelFormat used in the source @data buffer. rowstride of the source @data buffer (computed from the texture width and @format if it equals 0) the source data, pointing to the first top-left pixel to set The mipmap level to update (Normally 0 for the largest, base texture) Affects the internal storage format for this texture by specifying whether red, green and blue color components should be stored as pre-multiplied alpha values. This api affects how data is uploaded to the GPU since Cogl will convert source data to have premultiplied or unpremultiplied components according to this state. For example if you create a texture via cogl_texture_2d_new_with_size() and then upload data via cogl_texture_set_data() passing a source format of %COGL_PIXEL_FORMAT_RGBA_8888 then Cogl will internally multiply the red, green and blue components of the source data by the alpha component, for each pixel so that the internally stored data has pre-multiplied alpha components. If you instead upload data that already has pre-multiplied components by passing %COGL_PIXEL_FORMAT_RGBA_8888_PRE as the source format to cogl_texture_set_data() then the data can be uploaded without being converted. By default the @premultipled state is @TRUE. a #CoglTexture pointer. Whether any internally stored red, green or blue components are pre-multiplied by an alpha component. Sets the pixels in a rectangular subregion of @texture from an in-memory buffer containing pixel data. The region set can't be larger than the source @data %TRUE if the subregion upload was successful, and %FALSE otherwise a #CoglTexture. upper left coordinate to use from source data. upper left coordinate to use from source data. upper left destination horizontal coordinate. upper left destination vertical coordinate. width of destination region to write. (Must be less than or equal to @width) height of destination region to write. (Must be less than or equal to @height) width of source data buffer. height of source data buffer. the #CoglPixelFormat used in the source buffer. rowstride of source buffer (computed from width if none specified) the actual pixel data. Copies a specified source region from @bitmap to the position (@src_x, @src_y) of the given destination texture @handle. The region updated can't be larger than the source bitmap %TRUE if the subregion upload was successful, and %FALSE otherwise a #CoglTexture pointer upper left coordinate to use from the source bitmap. upper left coordinate to use from the source bitmap upper left destination horizontal coordinate. upper left destination vertical coordinate. width of destination region to write. (Must be less than or equal to the bitmap width) height of destination region to write. (Must be less than or equal to the bitmap height) The source bitmap to read from Functions for creating and manipulating 2D textures These functions allow low-level 2D textures to be allocated. These differ from sliced textures for example which may internally be made up of multiple 2D textures, or atlas textures where Cogl must internally modify user texture coordinates before they can be used by the GPU. Creates a low-level #CoglTexture2D texture based on data residing in a #CoglBitmap. The storage for the texture is not allocated before this function returns. You can call cogl_texture_allocate() to explicitly allocate the underlying storage or preferably let Cogl automatically allocate storage lazily when it may know more about how the texture is being used and can optimize how it is allocated. The texture is still configurable until it has been allocated so for example you can influence the internal format of the texture using cogl_texture_set_components() and cogl_texture_set_premultiplied(). A newly allocated #CoglTexture2D A #CoglBitmap Creates a low-level #CoglTexture2D texture based on data residing in memory. This api will always immediately allocate GPU memory for the texture and upload the given data so that the @data pointer does not need to remain valid once this function returns. This means it is not possible to configure the texture before it is allocated. If you do need to configure the texture before allocation (to specify constraints on the internal format for example) then you can instead create a #CoglBitmap for your data and use cogl_texture_2d_new_from_bitmap() or use cogl_texture_2d_new_with_size() and then upload data using cogl_texture_set_data() A newly allocated #CoglTexture2D, or if the size is not supported (because it is too large or a non-power-of-two size that the hardware doesn't support) it will return %NULL and set @error. A #CoglContext width of texture in pixels height of texture in pixels the #CoglPixelFormat the buffer is stored in in RAM the memory offset in bytes between the starts of scanlines in @data. A value of 0 will make Cogl automatically calculate @rowstride from @width and @format. pointer the memory region where the source buffer resides Creates a low-level #CoglTexture2D texture with a given @width and @height that your GPU can texture from directly. The storage for the texture is not allocated before this function returns. You can call cogl_texture_allocate() to explicitly allocate the underlying storage or preferably let Cogl automatically allocate storage lazily when it may know more about how the texture is being used and can optimize how it is allocated. The texture is still configurable until it has been allocated so for example you can influence the internal format of the texture using cogl_texture_set_components() and cogl_texture_set_premultiplied(). A new #CoglTexture2D object with no storage yet allocated. A #CoglContext Width of the texture to allocate Height of the texture to allocate format of the texture to allocate Creates a low-level #CoglTexture2D texture with a given @width and @height that your GPU can texture from directly. The storage for the texture is not allocated before this function returns. You can call cogl_texture_allocate() to explicitly allocate the underlying storage or preferably let Cogl automatically allocate storage lazily when it may know more about how the texture is being used and can optimize how it is allocated. The texture is still configurable until it has been allocated so for example you can influence the internal format of the texture using cogl_texture_set_components() and cogl_texture_set_premultiplied(). A new #CoglTexture2D object with no storage yet allocated. A #CoglContext Width of the texture to allocate Height of the texture to allocate Sets whether the texture will automatically update the smaller mipmap levels after any part of level 0 is updated. The update will only occur whenever the texture is used for drawing with a texture filter that requires the lower mipmap levels. An application should disable this if it wants to upload its own data for the other levels. By default auto mipmapping is enabled. A #CoglTexture2D The new value for whether to auto mipmap Functions for creating and manipulating 2D meta textures that may internally be comprised of multiple 2D textures with power-of-two sizes. These functions allow high-level meta textures to be allocated that may internally be comprised of multiple 2D texture "slices" with power-of-two sizes. This API can be useful when working with GPUs that don't have native support for non-power-of-two textures or if you want to load a texture that is larger than the GPUs maximum texture size limits. The algorithm for slicing works by first trying to map a virtual size to the next larger power-of-two size and then seeing how many wasted pixels that would result in. For example if you have a virtual texture that's 259 texels wide, the next pot size = 512 and the amount of waste would be 253 texels. If the amount of waste is above a max-waste threshold then we would next slice that texture into one that's 256 texels and then looking at how many more texels remain unallocated after that we choose the next power-of-two size. For the example of a 259 texel image that would mean having a 256 texel wide texture, leaving 3 texels unallocated so we'd then create a 4 texel wide texture - now there is only one texel of waste. The algorithm continues to slice the right most textures until the amount of waste is less than or equal to a specified max-waste threshold. The same logic for slicing from left to right is also applied from top to bottom. Creates a new #CoglTexture2DSliced texture based on data residing in a bitmap. A #CoglTexture2DSliced may internally be comprised of 1 or more #CoglTexture2D textures depending on GPU limitations. For example if the GPU only supports power-of-two sized textures then a sliced texture will turn a non-power-of-two size into a combination of smaller power-of-two sized textures. If the requested texture size is larger than is supported by the hardware then the texture will be sliced into smaller textures that can be accessed by the hardware. @max_waste is used as a threshold for recursively slicing the right-most or bottom-most slices into smaller sizes until the wasted padding at the bottom and right of the textures is less than specified. A negative @max_waste will disable slicing. The storage for the texture is not allocated before this function returns. You can call cogl_texture_allocate() to explicitly allocate the underlying storage or let Cogl automatically allocate storage lazily. It's possible for the allocation of a sliced texture to fail later due to impossible slicing constraints if a negative @max_waste value is given. If the given virtual texture size is larger than is supported by the hardware but slicing is disabled the texture size would be too large to handle. A newly created #CoglTexture2DSliced or %NULL on failure and @error will be updated. A #CoglBitmap The threshold of how wide a strip of wasted texels are allowed along the right and bottom textures before they must be sliced to reduce the amount of waste. A negative can be passed to disable slicing. Creates a #CoglTexture2DSliced that may internally be comprised of 1 or more #CoglTexture2D textures depending on GPU limitations. For example if the GPU only supports power-of-two sized textures then a sliced texture will turn a non-power-of-two size into a combination of smaller power-of-two sized textures. If the requested texture size is larger than is supported by the hardware then the texture will be sliced into smaller textures that can be accessed by the hardware. @max_waste is used as a threshold for recursively slicing the right-most or bottom-most slices into smaller sizes until the wasted padding at the bottom and right of the textures is less than specified. A negative @max_waste will disable slicing. The storage for the texture is not allocated before this function returns. You can call cogl_texture_allocate() to explicitly allocate the underlying storage or let Cogl automatically allocate storage lazily. It's possible for the allocation of a sliced texture to fail later due to impossible slicing constraints if a negative @max_waste value is given. If the given virtual texture size size is larger than is supported by the hardware but slicing is disabled the texture size would be too large to handle. A new #CoglTexture2DSliced object with no storage allocated yet. A #CoglContext The virtual width of your sliced texture. The virtual height of your sliced texture. The threshold of how wide a strip of wasted texels are allowed along the right and bottom textures before they must be sliced to reduce the amount of waste. A negative can be passed to disable slicing. See cogl_texture_set_components(). Only the alpha component Red and green components. Note that this can only be used if the %COGL_FEATURE_ID_TEXTURE_RG feature is advertised. Red, green and blue components Red, green, blue and alpha components Only a depth component Error codes that can be thrown when allocating textures. Unsupported size Unsupported format A primitive texture type that is unsupported by the driver was used A callback used with cogl_texture_foreach_in_region() to retrieve details of all the low-level `CoglTexture`s that make up a given #CoglTexture. A low-level #CoglTexture making up part of a #CoglTexture. A float 4-tuple ordered like (tx1,ty1,tx2,ty2) defining what region of the current @sub_texture maps to a sub-region of a #CoglTexture. (tx1,ty1) is the top-left sub-region coordinate and (tx2,ty2) is the bottom-right. These are low-level texture coordinates. A float 4-tuple ordered like (tx1,ty1,tx2,ty2) defining what sub-region of a #CoglTexture this low-level @sub_texture maps too. (tx1,ty1) is the top-left sub-region coordinate and (tx2,ty2) is the bottom-right. These are high-level meta-texture coordinates. A private pointer passed to cogl_texture_foreach_in_region(). Evaluates to %TRUE if @x holds a `CoglColor`. a #GValue A convenience vertex definition that can be used with cogl_primitive_new_p2(). The x component of a position attribute The y component of a position attribute A convenience vertex definition that can be used with cogl_primitive_new_p2c4(). The x component of a position attribute The y component of a position attribute The red component of a color attribute The blue component of a color attribute The green component of a color attribute The alpha component of a color attribute A convenience vertex definition that can be used with cogl_primitive_new_p2t2(). The x component of a position attribute The y component of a position attribute The s component of a texture coordinate attribute The t component of a texture coordinate attribute A convenience vertex definition that can be used with cogl_primitive_new_p3(). The x component of a position attribute The y component of a position attribute The z component of a position attribute A convenience vertex definition that can be used with cogl_primitive_new_p3t2(). The x component of a position attribute The y component of a position attribute The z component of a position attribute The s component of a texture coordinate attribute The t component of a texture coordinate attribute Different ways of interpreting vertices when drawing. FIXME, equivalent to `GL_POINTS` FIXME, equivalent to `GL_LINES` FIXME, equivalent to `GL_LINE_LOOP` FIXME, equivalent to `GL_LINE_STRIP` FIXME, equivalent to `GL_TRIANGLES` FIXME, equivalent to `GL_TRIANGLE_STRIP` FIXME, equivalent to `GL_TRIANGLE_FAN` 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(). Vertices are in a clockwise order Vertices are in a counter-clockwise order Identifies specific window system backends that Cogl supports. These can be used to query what backend Cogl is using or to try and explicitly select a backend to use. Implies no preference for which backend is used Use the no-op stub backend Use the GLX window system binding API Use EGL with the X window system via XLib Checks whether the preconditions for blitting between the formats are met. This does not imply that blitting will definitely succeed. @return TRUE if the preconditions for blitting between the formats are met. The #CoglPixelFormat to blit from The #CoglPixelFormat to blit to Parses a string definition of a color, filling the #CoglColor.red, #CoglColor.green, #CoglColor.blue and #CoglColor.alpha fields of @color. The @color is not allocated. The format of @str can be either one of: - an hexadecimal value in the form: `#rgb`, `#rrggbb`, `#rgba`, or `#rrggbbaa` - a RGB color in the form: `rgb(r, g, b)` - a RGB color in the form: `rgba(r, g, b, a)` - a HSL color in the form: `hsl(h, s, l)` -a HSL color in the form: `hsla(h, s, l, a)` where 'r', 'g', 'b' and 'a' are (respectively) the red, green, blue color intensities and the opacity. The 'h', 's' and 'l' are (respectively) the hue, saturation and luminance values. In the rgb() and rgba() formats, the 'r', 'g', and 'b' values are either integers between 0 and 255, or percentage values in the range between 0% and 100%; the percentages require the '%' character. The 'a' value, if specified, can only be a floating point value between 0.0 and 1.0. In the hls() and hlsa() formats, the 'h' value (hue) is an angle between 0 and 360.0 degrees; the 'l' and 's' values (luminance and saturation) are percentage values in the range between 0% and 100%. The 'a' value, if specified, can only be a floating point value between 0.0 and 1.0. Whitespace inside the definitions is ignored; no leading whitespace is allowed. If the alpha component is not specified then it is assumed to be set to be fully opaque. %TRUE if parsing succeeded, and %FALSE otherwise return location for a #CoglColor a string specifying a color Converts a color expressed in HLS (hue, luminance and saturation) values into a #CoglColor. return location for a #CoglColor hue value, in the 0 .. 360 range saturation value, in the 0 .. 1 range luminance value, in the 0 .. 1 range Creates a #GSource which handles Cogl's internal system event processing. a new #GSource A #CoglRenderer The priority of the #GSource Transforms a point whose position is given and returned as four float components. A 4x4 transformation matrix The X component of your points position The Y component of your points position The Z component of your points position The W component of your points position Projects an array of input points and writes the result to another array of output points. The output points always have 4 components (known as homogeneous coordinates). The output array can simply point to the input array to do the transform in-place. Here's an example with differing input/output strides: ```c typedef struct { float x,y, z; uint8_t r,g,b,a; float s,t,p; } MyInVertex; typedef struct { uint8_t r,g,b,a; float x,y,z; } MyOutVertex; MyInVertex vertices[N_VERTICES]; MyOutVertex results[N_VERTICES]; graphene_matrix_t matrix; my_load_vertices (vertices); my_get_matrix (&matrix); cogl_graphene_matrix_project_points_f3 (&matrix, sizeof (MyInVertex), &vertices[0].x, sizeof (MyOutVertex), &results[0].x, N_VERTICES); ``` A projection matrix The stride in bytes between input points. A pointer to the first component of the first input point. The stride in bytes between output points. A pointer to the first component of the first output point. The number of points to transform. Transforms an array of input points and writes the result to another array of output points. The input points can either have 2 or 3 components each. The output points always have 3 components. The output array can simply point to the input array to do the transform in-place. Here's an example with differing input/output strides: ```c typedef struct { float x,y; uint8_t r,g,b,a; float s,t,p; } MyInVertex; typedef struct { uint8_t r,g,b,a; float x,y,z; } MyOutVertex; MyInVertex vertices[N_VERTICES]; MyOutVertex results[N_VERTICES]; graphene_matrix_t matrix; my_load_vertices (vertices); my_get_matrix (&matrix); cogl_graphene_matrix_transform_points (&matrix, 2, sizeof (MyInVertex), &vertices[0].x, sizeof (MyOutVertex), &results[0].x, N_VERTICES); ``` A transformation matrix The number of position components for each input point. (either 2 or 3) The stride in bytes between input points. A pointer to the first component of the first input point. The stride in bytes between output points. A pointer to the first component of the first output point. The number of points to transform. Interface for high-level textures built from low-level textures like #CoglTexture2D. Cogl helps to make it easy to deal with high level textures such as `CoglAtlasTexture`s, `CoglSubTexture`s, #CoglTexturePixmapX11 textures and #CoglTexture2DSliced textures consistently. A #CoglTexture is a texture that might internally be represented by one or more low-level `CoglTexture`s such as #CoglTexture2D. These low-level textures are the only ones that a GPU really understands but because applications often want more high-level texture abstractions (such as storing multiple textures inside one larger "atlas" texture) it's desirable to be able to deal with these using a common interface. For example the GPU is not able to automatically handle repeating a texture that is part of a larger atlas texture but if you use %COGL_PIPELINE_WRAP_MODE_REPEAT with an atlas texture when drawing with cogl_rectangle() you should see that it "Just Works™" - at least if you don't use multi-texturing. The reason this works is because cogl_rectangle() internally understands the #CoglTexture interface and is able to manually resolve the low-level textures using this interface and by making multiple draw calls it can emulate the texture repeat modes. Cogl doesn't aim to pretend that meta-textures are just like real textures because it would get extremely complex to try and emulate low-level GPU semantics transparently for these textures. The low level drawing APIs of Cogl, such as cogl_primitive_draw() don't actually know anything about the #CoglTexture interface and its the developer's responsibility to resolve all textures referenced by a #CoglPipeline to low-level textures before drawing. If you want to develop custom primitive APIs like cogl_framebuffer_draw_rectangle() and you want to support drawing with `CoglAtlasTexture`s or `CoglSubTexture`s for example, then you will need to use this #CoglTexture interface to be able to resolve high-level textures into low-level textures before drawing with Cogl's low-level drawing APIs such as cogl_primitive_draw(). Most developers won't need to use this interface directly but still it is worth understanding the distinction between low-level and meta textures because you may find other references in the documentation that detail limitations of using meta-textures. Creates a #GParamSpec for properties using #CoglColor. the newly created #GParamSpec name of the property short name description (can be translatable) default value flags for the param spec Queries the number of bytes per pixel for a given format in the given plane. The number of bytes per pixel in the given format's given plane. The pixel format The index of the plane (should not be more than the number of planes in the given format). Returns the number of planes the given CoglPixelFormat specifies. The no. of planes of @format (at most %COGL_PIXEL_FORMAT_MAX_PLANES) The format for which to get the number of planes Returns a string representation of @format, useful for debugging purposes. A string representation of @format. a #CoglPixelFormat