isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-26 01:50:42 -05:00
Code Issues Packages Projects Releases Wiki Activity
91a02e9107
mutter/cogl/cogl-driver.h

236 lines
8.3 KiB
C
Raw Normal View History

Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2012 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*/
#ifndef __COGL_DRIVER_H
#define __COGL_DRIVER_H
#include "cogl-context.h"
framebuffer: split GL code out from cogl-framebuffer.c This splits out most of the OpenGL specific code from cogl-framebuffer.c into cogl-framebuffer-gl.c and extends the CoglDriverVtable interface for cogl-framebuffer.c to use. There are hopes to support several different backends for Cogl eventually to hopefully get us closer to the metal so this makes some progress in organizing which parts of Cogl are OpenGL specific so these parts can potentially be switched out later. The only remaining use of OpenGL still in cogl-framebuffer.c is to handle cogl_framebuffer_read_pixels.
2012-08-31 19:04:00 -04:00
#include "cogl-offscreen.h"
#include "cogl-framebuffer-private.h"
attribute: Split out GL specific code As part of an on-going effort to enable non-opengl drivers for Cogl this splits out the GL specific code in cogl-attribute.c into cogl/driver/gl/cogl-attribute-gl.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7e20c39c47fa176aa5062867ff273bc2c41a2f22)
2012-09-19 15:04:24 -04:00
#include "cogl-attribute-private.h"
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
typedef struct _CoglDriverVtable CoglDriverVtable;
struct _CoglDriverVtable
{
texture-2d: factor out all GL specific code This factors out all of the OpenGL specific code in cogl-texture-2d.c into cogl-texture-2d-gl.c and where necessary adds indirection through the CoglDriver vtable so that we can eventually start to experiment with non-OpenGL backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ec57588671696bbe7ce714bdfe7324236146c9c0)
2012-09-10 16:45:33 -04:00
/* TODO: factor this out since this is OpenGL specific and
* so can be ignored by non-OpenGL drivers. */
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
(* pixel_format_from_gl_internal) (CoglContext *context,
GLenum gl_int_format,
CoglPixelFormat *out_format);
texture-2d: factor out all GL specific code This factors out all of the OpenGL specific code in cogl-texture-2d.c into cogl-texture-2d-gl.c and where necessary adds indirection through the CoglDriver vtable so that we can eventually start to experiment with non-OpenGL backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ec57588671696bbe7ce714bdfe7324236146c9c0)
2012-09-10 16:45:33 -04:00
/* TODO: factor this out since this is OpenGL specific and
* so can be ignored by non-OpenGL drivers. */
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
CoglPixelFormat
(* pixel_format_to_gl) (CoglContext *context,
CoglPixelFormat format,
GLenum *out_glintformat,
GLenum *out_glformat,
GLenum *out_gltype);
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
(* update_features) (CoglContext *context,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error);
framebuffer: split GL code out from cogl-framebuffer.c This splits out most of the OpenGL specific code from cogl-framebuffer.c into cogl-framebuffer-gl.c and extends the CoglDriverVtable interface for cogl-framebuffer.c to use. There are hopes to support several different backends for Cogl eventually to hopefully get us closer to the metal so this makes some progress in organizing which parts of Cogl are OpenGL specific so these parts can potentially be switched out later. The only remaining use of OpenGL still in cogl-framebuffer.c is to handle cogl_framebuffer_read_pixels.
2012-08-31 19:04:00 -04:00
CoglBool
(* offscreen_allocate) (CoglOffscreen *offscreen,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error);
framebuffer: split GL code out from cogl-framebuffer.c This splits out most of the OpenGL specific code from cogl-framebuffer.c into cogl-framebuffer-gl.c and extends the CoglDriverVtable interface for cogl-framebuffer.c to use. There are hopes to support several different backends for Cogl eventually to hopefully get us closer to the metal so this makes some progress in organizing which parts of Cogl are OpenGL specific so these parts can potentially be switched out later. The only remaining use of OpenGL still in cogl-framebuffer.c is to handle cogl_framebuffer_read_pixels.
2012-08-31 19:04:00 -04:00
void
(* offscreen_free) (CoglOffscreen *offscreen);
void
(* framebuffer_flush_state) (CoglFramebuffer *draw_buffer,
CoglFramebuffer *read_buffer,
CoglFramebufferState state);
void
(* framebuffer_clear) (CoglFramebuffer *framebuffer,
unsigned long buffers,
float red,
float green,
float blue,
float alpha);
void
(* framebuffer_query_bits) (CoglFramebuffer *framebuffer,
int *red,
int *green,
int *blue,
int *alpha);
void
(* framebuffer_finish) (CoglFramebuffer *framebuffer);
void
(* framebuffer_discard_buffers) (CoglFramebuffer *framebuffer,
unsigned long buffers);
void
(* framebuffer_draw_attributes) (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
CoglVerticesMode mode,
int first_vertex,
int n_vertices,
CoglAttribute **attributes,
int n_attributes,
CoglDrawFlags flags);
void
(* framebuffer_draw_indexed_attributes) (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
CoglVerticesMode mode,
int first_vertex,
int n_vertices,
CoglIndices *indices,
CoglAttribute **attributes,
int n_attributes,
CoglDrawFlags flags);
texture-2d: factor out all GL specific code This factors out all of the OpenGL specific code in cogl-texture-2d.c into cogl-texture-2d-gl.c and where necessary adds indirection through the CoglDriver vtable so that we can eventually start to experiment with non-OpenGL backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit ec57588671696bbe7ce714bdfe7324236146c9c0)
2012-09-10 16:45:33 -04:00
/* Destroys any driver specific resources associated with the given
* 2D texture. */
void
(* texture_2d_free) (CoglTexture2D *tex_2d);
/* Returns TRUE if the driver can support creating a 2D texture with
* the given geometry and specified internal format.
*/
CoglBool
(* texture_2d_can_create) (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format);
/* Initializes driver private state before allocating any specific
* storage for a 2D texture, where base texture and texture 2D
* members will already be initialized before passing control to
* the driver.
*/
void
(* texture_2d_init) (CoglTexture2D *tex_2d);
/* Instantiates a new CoglTexture2D object with un-initialized
* storage for a given size and internal format */
CoglTexture2D *
(* texture_2d_new_with_size) (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format,
CoglError **error);
/* Instantiates a new CoglTexture2D object with storage initialized
* with the contents of the given bitmap, using the specified
* internal format.
*/
CoglTexture2D *
(* texture_2d_new_from_bitmap) (CoglBitmap *bmp,
CoglPixelFormat internal_format,
CoglError **error);
#if defined (COGL_HAS_EGL_SUPPORT) && defined (EGL_KHR_image_base)
/* Instantiates a new CoglTexture2D object with storage initialized
* with the contents of the given EGL image.
*
* This is optional for drivers to support
*/
CoglTexture2D *
(* egl_texture_2d_new_from_image) (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format,
EGLImageKHR image,
CoglError **error);
#endif
/* Initialize the specified region of storage of the given texture
* with the contents of the specified framebuffer region
*/
void
(* texture_2d_copy_from_framebuffer) (CoglTexture2D *tex_2d,
CoglFramebuffer *src_fb,
int dst_x,
int dst_y,
int src_x,
int src_y,
int width,
int height);
/* If the given texture has a corresponding OpenGL texture handle
* then return that.
*
* This is optional
*/
unsigned int
(* texture_2d_get_gl_handle) (CoglTexture2D *tex_2d);
/* Update all mipmap levels > 0 */
void
(* texture_2d_generate_mipmap) (CoglTexture2D *tex_2d);
/* Initialize the specified region of storage of the given texture
* with the contents of the specified bitmap region
*/
void
(* texture_2d_copy_from_bitmap) (CoglTexture2D *tex_2d,
CoglBitmap *bitmap,
int dst_x,
int dst_y,
int src_x,
int src_y,
int width,
int height);
/* Reads back the full contents of the given texture and write it to
* @data in the given @format and with the given @rowstride.
*
* This is optional
*/
void
(* texture_2d_get_data) (CoglTexture2D *tex_2d,
CoglPixelFormat format,
unsigned int rowstride,
uint8_t *data);
attribute: Split out GL specific code As part of an on-going effort to enable non-opengl drivers for Cogl this splits out the GL specific code in cogl-attribute.c into cogl/driver/gl/cogl-attribute-gl.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 7e20c39c47fa176aa5062867ff273bc2c41a2f22)
2012-09-19 15:04:24 -04:00
/* Prepares for drawing by flushing the journal, framebuffer state,
* pipeline state and attribute state.
*/
void
(* flush_attributes_state) (CoglFramebuffer *framebuffer,
CoglPipeline *pipeline,
CoglFlushLayerState *layer_state,
CoglDrawFlags flags,
CoglAttribute **attributes,
int n_attributes);
clip-stack: Splits out opengl specific code As part of an on-going effort to enable non-opengl drivers for Cogl this splits out the opengl specific code in cogl-clip-stack.c into cogl/driver/cogl-clip-stack-gl.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit acf989f1bb628282c53d1249b2e3fc6f6579f1e9)
2012-09-19 15:37:32 -04:00
/* Flushes the clip stack to the GPU using a combination of the
* stencil buffer, scissor and clip plane state.
*/
void
(* clip_stack_flush) (CoglClipStack *stack, CoglFramebuffer *framebuffer);
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
};
#endif /* __COGL_DRIVER_H */
Reference in New Issue Copy Permalink