2616ae0fa9
This adds a new CoglDriver for GL 3 called COGL_DRIVER_GL3. When requested, the GLX, EGL and SDL2 winsyss will set the necessary attributes to request a forward-compatible core profile 3.1 context. That means it will have no deprecated features. To simplify the explosion of checks for specific combinations of context->driver, many of these conditionals have now been replaced with private feature flags that are checked instead. The GL and GLES drivers now initialise these private feature flags depending on which driver is used. The fixed function backends now explicitly check whether the fixed function private feature is available which means the GL3 driver will fall back to always using the GLSL progend. Since Rob's latest patches the GLSL progend no longer uses any fixed function API anyway so it should just work. The driver is currently lower priority than COGL_DRIVER_GL so it will not be used unless it is specificly requested. We may want to change this priority at some point because apparently Mesa can make some memory savings if a core profile context is used. In GL 3, getting the combined extensions string with glGetString is deprecated so this patch changes it to use glGetStringi to build up an array of extensions instead. _cogl_context_get_gl_extensions now returns this array instead of trying to return a const string. The caller is expected to free the array. Some issues with this patch: • GL 3 does not support GL_ALPHA format textures. We should probably make this a feature flag or something. Cogl uses this to render text which currently just throws a GL error and breaks so it's pretty important to do something about this before considering the GL3 driver to be stable. • GL 3 doesn't support client side vertex buffers. This probably doesn't matter because CoglBuffer won't normally use malloc'd buffers if VBOs are available, but it might but worth making malloc'd buffers a private feature and forcing it not to use them. • GL 3 doesn't support the default vertex array object. This patch just makes it create and bind a single non-default vertex array object which gets used just like the normal default object. Ideally it would be good to use vertex array objects properly and attach them to a CoglPrimitive to cache the state. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 66c9db993595b3a22e63f4c201ea468bc9b88cb6)
392 lines
12 KiB
C
392 lines
12 KiB
C
/*
|
|
* Cogl
|
|
*
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
|
*
|
|
* Copyright (C) 2007,2008,2009 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, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
|
|
#error "Only <cogl/cogl.h> can be included directly."
|
|
#endif
|
|
|
|
#ifndef __COGL_RENDERER_H__
|
|
#define __COGL_RENDERER_H__
|
|
|
|
#include <glib.h>
|
|
|
|
#include <cogl/cogl-types.h>
|
|
#include <cogl/cogl-onscreen-template.h>
|
|
#include <cogl/cogl-error.h>
|
|
|
|
G_BEGIN_DECLS
|
|
|
|
/**
|
|
* SECTION:cogl-renderer
|
|
* @short_description: 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 or
|
|
* WGL.
|
|
*
|
|
* 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().
|
|
*
|
|
* <note>Many applications don't need to explicitly use
|
|
* cogl_renderer_new() or cogl_display_new() and can just jump
|
|
* straight to cogl_context_new() and pass a %NULL display argument so
|
|
* Cogl will automatically connect and setup a renderer and
|
|
* display.</note>
|
|
*/
|
|
|
|
|
|
/**
|
|
* COGL_RENDERER_ERROR:
|
|
*
|
|
* An error domain for exceptions reported by Cogl
|
|
*/
|
|
#define COGL_RENDERER_ERROR cogl_renderer_error_quark ()
|
|
|
|
uint32_t
|
|
cogl_renderer_error_quark (void);
|
|
|
|
typedef struct _CoglRenderer CoglRenderer;
|
|
|
|
/**
|
|
* cogl_is_renderer:
|
|
* @object: A #CoglObject pointer
|
|
*
|
|
* Determines if the given @object is a #CoglRenderer
|
|
*
|
|
* Return value: %TRUE if @object is a #CoglRenderer, else %FALSE.
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
CoglBool
|
|
cogl_is_renderer (void *object);
|
|
|
|
/**
|
|
* cogl_renderer_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 or
|
|
* WGL.
|
|
*
|
|
* While the renderer is unconnected it can be configured so that
|
|
* applications may specify backend constraints, such as "must use
|
|
* x11" for example via cogl_renderer_add_criteria().
|
|
*
|
|
* 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().
|
|
*
|
|
* <note>Many applications don't need to explicitly use
|
|
* cogl_renderer_new() or cogl_display_new() and can just jump
|
|
* straight to cogl_context_new() and pass a %NULL display argument
|
|
* so Cogl will automatically connect and setup a renderer and
|
|
* display.</note>
|
|
*
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
CoglRenderer *
|
|
cogl_renderer_new (void);
|
|
|
|
/* optional configuration APIs */
|
|
|
|
/**
|
|
* CoglWinsysID:
|
|
* @COGL_WINSYS_ID_ANY: Implies no preference for which backend is used
|
|
* @COGL_WINSYS_ID_STUB: Use the no-op stub backend
|
|
* @COGL_WINSYS_ID_GLX: Use the GLX window system binding API
|
|
* @COGL_WINSYS_ID_EGL_XLIB: Use EGL with the X window system via XLib
|
|
* @COGL_WINSYS_ID_EGL_NULL: Use EGL with the PowerVR NULL window system
|
|
* @COGL_WINSYS_ID_EGL_GDL: Use EGL with the GDL platform
|
|
* @COGL_WINSYS_ID_EGL_WAYLAND: Use EGL with the Wayland window system
|
|
* @COGL_WINSYS_ID_EGL_KMS: Use EGL with the KMS platform
|
|
* @COGL_WINSYS_ID_EGL_ANDROID: Use EGL with the Android platform
|
|
* @COGL_WINSYS_ID_WGL: Use the Microsoft Windows WGL binding API
|
|
* @COGL_WINSYS_ID_SDL: Use the SDL window system
|
|
*
|
|
* 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.
|
|
*/
|
|
typedef enum
|
|
{
|
|
COGL_WINSYS_ID_ANY,
|
|
COGL_WINSYS_ID_STUB,
|
|
COGL_WINSYS_ID_GLX,
|
|
COGL_WINSYS_ID_EGL_XLIB,
|
|
COGL_WINSYS_ID_EGL_NULL,
|
|
COGL_WINSYS_ID_EGL_GDL,
|
|
COGL_WINSYS_ID_EGL_WAYLAND,
|
|
COGL_WINSYS_ID_EGL_KMS,
|
|
COGL_WINSYS_ID_EGL_ANDROID,
|
|
COGL_WINSYS_ID_WGL,
|
|
COGL_WINSYS_ID_SDL
|
|
} CoglWinsysID;
|
|
|
|
/**
|
|
* cogl_renderer_set_winsys_id:
|
|
* @renderer: A #CoglRenderer
|
|
* @winsys_id: An ID of the winsys you explicitly want to use.
|
|
*
|
|
* This allows you to explicitly select a winsys backend to use instead
|
|
* of letting Cogl automatically select a backend.
|
|
*
|
|
* if you select an unsupported backend then cogl_renderer_connect()
|
|
* will fail and report an error.
|
|
*
|
|
* This may only be called on an un-connected #CoglRenderer.
|
|
*/
|
|
void
|
|
cogl_renderer_set_winsys_id (CoglRenderer *renderer,
|
|
CoglWinsysID winsys_id);
|
|
|
|
/**
|
|
* cogl_renderer_get_winsys_id:
|
|
* @renderer: A #CoglRenderer
|
|
*
|
|
* Queries which window system backend Cogl has chosen to use.
|
|
*
|
|
* This may only be called on a connected #CoglRenderer.
|
|
*
|
|
* Returns: The #CoglWinsysID corresponding to the chosen window
|
|
* system backend.
|
|
*/
|
|
CoglWinsysID
|
|
cogl_renderer_get_winsys_id (CoglRenderer *renderer);
|
|
|
|
/**
|
|
* cogl_renderer_get_n_fragment_texture_units:
|
|
* @renderer: A #CoglRenderer
|
|
*
|
|
* Queries how many texture units can be used from fragment programs
|
|
*
|
|
* Returns: the number of texture image units.
|
|
*
|
|
* Since: 1.8
|
|
* Stability: Unstable
|
|
*/
|
|
int
|
|
cogl_renderer_get_n_fragment_texture_units (CoglRenderer *renderer);
|
|
|
|
/**
|
|
* cogl_renderer_check_onscreen_template:
|
|
* @renderer: A #CoglRenderer
|
|
* @onscreen_template: A #CoglOnscreenTemplate
|
|
* @error: A pointer to a #CoglError for reporting exceptions
|
|
*
|
|
* Tests if a given @onscreen_template can be supported with the given
|
|
* @renderer.
|
|
*
|
|
* Return value: %TRUE if the @onscreen_template can be supported,
|
|
* else %FALSE.
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
CoglBool
|
|
cogl_renderer_check_onscreen_template (CoglRenderer *renderer,
|
|
CoglOnscreenTemplate *onscreen_template,
|
|
CoglError **error);
|
|
|
|
/* Final connection API */
|
|
|
|
/**
|
|
* cogl_renderer_connect:
|
|
* @renderer: An unconnected #CoglRenderer
|
|
* @error a pointer to a #CoglError for reporting exceptions
|
|
*
|
|
* 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.
|
|
*
|
|
* Return value: %TRUE if there was no error while connecting the
|
|
* given @renderer. %FALSE if there was an error.
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
CoglBool
|
|
cogl_renderer_connect (CoglRenderer *renderer, CoglError **error);
|
|
|
|
/**
|
|
* CoglRendererConstraint:
|
|
* @COGL_RENDERER_CONSTRAINT_USES_X11: Require the renderer to be X11 based
|
|
* @COGL_RENDERER_CONSTRAINT_USES_XLIB: Require the renderer to be X11
|
|
* based and use Xlib
|
|
* @COGL_RENDERER_CONSTRAINT_USES_EGL: Require the renderer to be EGL based
|
|
* @COGL_RENDERER_CONSTRAINT_SUPPORTS_COGL_GLES2: Require that the
|
|
* renderer supports creating a #CoglGLES2Context via
|
|
* cogl_gles2_context_new(). This can be used to integrate GLES 2.0
|
|
* code into Cogl based applications.
|
|
*
|
|
* These constraint flags are hard-coded features of the different renderer
|
|
* backends. Sometimes a platform may support multiple rendering options which
|
|
* Cogl will usually choose from automatically. Some of these features are
|
|
* important to higher level applications and frameworks though, such as
|
|
* whether a renderer is X11 based because an application might only support
|
|
* X11 based input handling. An application might also need to ensure EGL is
|
|
* used internally too if they depend on access to an EGLDisplay for some
|
|
* purpose.
|
|
*
|
|
* Applications should ideally minimize how many of these constraints
|
|
* they depend on to ensure maximum portability.
|
|
*
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
typedef enum
|
|
{
|
|
COGL_RENDERER_CONSTRAINT_USES_X11 = (1 << 0),
|
|
COGL_RENDERER_CONSTRAINT_USES_XLIB = (1 << 1),
|
|
COGL_RENDERER_CONSTRAINT_USES_EGL = (1 << 2),
|
|
COGL_RENDERER_CONSTRAINT_SUPPORTS_COGL_GLES2 = (1 << 3)
|
|
} CoglRendererConstraint;
|
|
|
|
|
|
/**
|
|
* cogl_renderer_add_constraint:
|
|
* @renderer: An unconnected #CoglRenderer
|
|
* @constraint: A #CoglRendererConstraint to add
|
|
*
|
|
* This adds a renderer selection @constraint.
|
|
*
|
|
* Applications should ideally minimize how many of these constraints they
|
|
* depend on to ensure maximum portability.
|
|
*
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
void
|
|
cogl_renderer_add_constraint (CoglRenderer *renderer,
|
|
CoglRendererConstraint constraint);
|
|
|
|
/**
|
|
* cogl_renderer_remove_constraint:
|
|
* @renderer: An unconnected #CoglRenderer
|
|
* @constraint: A #CoglRendererConstraint to remove
|
|
*
|
|
* This removes a renderer selection @constraint.
|
|
*
|
|
* Applications should ideally minimize how many of these constraints they
|
|
* depend on to ensure maximum portability.
|
|
*
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
void
|
|
cogl_renderer_remove_constraint (CoglRenderer *renderer,
|
|
CoglRendererConstraint constraint);
|
|
|
|
/**
|
|
* CoglDriver:
|
|
* @COGL_DRIVER_ANY: Implies no preference for which driver is used
|
|
* @COGL_DRIVER_NOP: A No-Op driver.
|
|
* @COGL_DRIVER_GL: An OpenGL driver.
|
|
* @COGL_DRIVER_GL3: An OpenGL driver using the core GL 3.1 profile
|
|
* @COGL_DRIVER_GLES1: An OpenGL ES 1.1 driver.
|
|
* @COGL_DRIVER_GLES2: An OpenGL ES 2.0 driver.
|
|
*
|
|
* Identifiers for underlying hardware drivers that may be used by
|
|
* Cogl for rendering.
|
|
*
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
typedef enum
|
|
{
|
|
COGL_DRIVER_ANY,
|
|
COGL_DRIVER_NOP,
|
|
COGL_DRIVER_GL,
|
|
COGL_DRIVER_GL3,
|
|
COGL_DRIVER_GLES1,
|
|
COGL_DRIVER_GLES2
|
|
} CoglDriver;
|
|
|
|
/**
|
|
* cogl_renderer_set_driver:
|
|
* @renderer: An unconnected #CoglRenderer
|
|
*
|
|
* 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.
|
|
*
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
void
|
|
cogl_renderer_set_driver (CoglRenderer *renderer,
|
|
CoglDriver driver);
|
|
|
|
/**
|
|
* cogl_renderer_get_driver:
|
|
* @renderer: A connected #CoglRenderer
|
|
*
|
|
* Queries what underlying driver is being used by Cogl.
|
|
*
|
|
* This may only be called on a connected #CoglRenderer.
|
|
*
|
|
* Since: 1.10
|
|
* Stability: unstable
|
|
*/
|
|
CoglDriver
|
|
cogl_renderer_get_driver (CoglRenderer *renderer);
|
|
|
|
G_END_DECLS
|
|
|
|
#endif /* __COGL_RENDERER_H__ */
|
|
|