cogl/gl-framebuffer: Split up into FBO and back drivers

One is for when we're painting to the back buffer (onscreen), and the
other when we're painting to an FBO (offscreen).

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1514>
This commit is contained in:
Jonas Ådahl 2020-10-19 21:19:15 +02:00 committed by Robert Mader
parent a6b0376a6c
commit 60e1516b1c
24 changed files with 1165 additions and 743 deletions

View File

@ -93,10 +93,6 @@ struct _CoglDriverVtable
float blue, float blue,
float alpha); float alpha);
void
(* framebuffer_query_bits) (CoglFramebuffer *framebuffer,
CoglFramebufferBits *bits);
void void
(* framebuffer_finish) (CoglFramebuffer *framebuffer); (* framebuffer_finish) (CoglFramebuffer *framebuffer);

View File

@ -58,6 +58,13 @@ cogl_framebuffer_driver_get_framebuffer (CoglFramebufferDriver *driver)
return priv->framebuffer; return priv->framebuffer;
} }
void
cogl_framebuffer_driver_query_bits (CoglFramebufferDriver *driver,
CoglFramebufferBits *bits)
{
COGL_FRAMEBUFFER_DRIVER_GET_CLASS (driver)->query_bits (driver, bits);
}
static void static void
cogl_framebuffer_driver_get_property (GObject *object, cogl_framebuffer_driver_get_property (GObject *object,
guint prop_id, guint prop_id,

View File

@ -30,6 +30,8 @@
#include "cogl-framebuffer.h" #include "cogl-framebuffer.h"
typedef struct _CoglFramebufferBits CoglFramebufferBits;
#define COGL_TYPE_FRAMEBUFFER_DRIVER (cogl_framebuffer_driver_get_type ()) #define COGL_TYPE_FRAMEBUFFER_DRIVER (cogl_framebuffer_driver_get_type ())
G_DECLARE_DERIVABLE_TYPE (CoglFramebufferDriver, G_DECLARE_DERIVABLE_TYPE (CoglFramebufferDriver,
cogl_framebuffer_driver, cogl_framebuffer_driver,
@ -39,9 +41,16 @@ G_DECLARE_DERIVABLE_TYPE (CoglFramebufferDriver,
struct _CoglFramebufferDriverClass struct _CoglFramebufferDriverClass
{ {
GObjectClass parent_cleass; GObjectClass parent_cleass;
void (* query_bits) (CoglFramebufferDriver *driver,
CoglFramebufferBits *bits);
}; };
CoglFramebuffer * CoglFramebuffer *
cogl_framebuffer_driver_get_framebuffer (CoglFramebufferDriver *driver); cogl_framebuffer_driver_get_framebuffer (CoglFramebufferDriver *driver);
void
cogl_framebuffer_driver_query_bits (CoglFramebufferDriver *driver,
CoglFramebufferBits *bits);
#endif /* COGL_FRAMEBUFFER_DRIVER_H */ #endif /* COGL_FRAMEBUFFER_DRIVER_H */

View File

@ -40,8 +40,16 @@
#include "cogl-attribute-private.h" #include "cogl-attribute-private.h"
#include "cogl-clip-stack.h" #include "cogl-clip-stack.h"
typedef enum
{
COGL_FRAMEBUFFER_DRIVER_TYPE_FBO,
COGL_FRAMEBUFFER_DRIVER_TYPE_BACK,
} CoglFramebufferDriverType;
struct _CoglFramebufferDriverConfig struct _CoglFramebufferDriverConfig
{ {
CoglFramebufferDriverType type;
gboolean disable_depth_and_stencil; gboolean disable_depth_and_stencil;
}; };
@ -98,7 +106,7 @@ typedef enum
COGL_READ_PIXELS_NO_FLIP = 1L << 30 COGL_READ_PIXELS_NO_FLIP = 1L << 30
} CoglPrivateReadPixelsFlags; } CoglPrivateReadPixelsFlags;
typedef struct typedef struct _CoglFramebufferBits
{ {
int red; int red;
int blue; int blue;

View File

@ -1126,15 +1126,24 @@ cogl_context_flush_framebuffer_state (CoglContext *ctx,
state); state);
} }
int static void
cogl_framebuffer_get_red_bits (CoglFramebuffer *framebuffer) cogl_framebuffer_query_bits (CoglFramebuffer *framebuffer,
CoglFramebufferBits *bits)
{ {
CoglFramebufferPrivate *priv = CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer); cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context;
g_return_if_fail (priv->driver);
cogl_framebuffer_driver_query_bits (priv->driver, bits);
}
int
cogl_framebuffer_get_red_bits (CoglFramebuffer *framebuffer)
{
CoglFramebufferBits bits; CoglFramebufferBits bits;
ctx->driver_vtable->framebuffer_query_bits (framebuffer, &bits); cogl_framebuffer_query_bits (framebuffer, &bits);
return bits.red; return bits.red;
} }
@ -1142,12 +1151,9 @@ cogl_framebuffer_get_red_bits (CoglFramebuffer *framebuffer)
int int
cogl_framebuffer_get_green_bits (CoglFramebuffer *framebuffer) cogl_framebuffer_get_green_bits (CoglFramebuffer *framebuffer)
{ {
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context;
CoglFramebufferBits bits; CoglFramebufferBits bits;
ctx->driver_vtable->framebuffer_query_bits (framebuffer, &bits); cogl_framebuffer_query_bits (framebuffer, &bits);
return bits.green; return bits.green;
} }
@ -1155,12 +1161,9 @@ cogl_framebuffer_get_green_bits (CoglFramebuffer *framebuffer)
int int
cogl_framebuffer_get_blue_bits (CoglFramebuffer *framebuffer) cogl_framebuffer_get_blue_bits (CoglFramebuffer *framebuffer)
{ {
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context;
CoglFramebufferBits bits; CoglFramebufferBits bits;
ctx->driver_vtable->framebuffer_query_bits (framebuffer, &bits); cogl_framebuffer_query_bits (framebuffer, &bits);
return bits.blue; return bits.blue;
} }
@ -1168,12 +1171,9 @@ cogl_framebuffer_get_blue_bits (CoglFramebuffer *framebuffer)
int int
cogl_framebuffer_get_alpha_bits (CoglFramebuffer *framebuffer) cogl_framebuffer_get_alpha_bits (CoglFramebuffer *framebuffer)
{ {
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context;
CoglFramebufferBits bits; CoglFramebufferBits bits;
ctx->driver_vtable->framebuffer_query_bits (framebuffer, &bits); cogl_framebuffer_query_bits (framebuffer, &bits);
return bits.alpha; return bits.alpha;
} }
@ -1181,12 +1181,9 @@ cogl_framebuffer_get_alpha_bits (CoglFramebuffer *framebuffer)
int int
cogl_framebuffer_get_depth_bits (CoglFramebuffer *framebuffer) cogl_framebuffer_get_depth_bits (CoglFramebuffer *framebuffer)
{ {
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context;
CoglFramebufferBits bits; CoglFramebufferBits bits;
ctx->driver_vtable->framebuffer_query_bits (framebuffer, &bits); cogl_framebuffer_query_bits (framebuffer, &bits);
return bits.depth; return bits.depth;
} }
@ -1194,12 +1191,9 @@ cogl_framebuffer_get_depth_bits (CoglFramebuffer *framebuffer)
int int
_cogl_framebuffer_get_stencil_bits (CoglFramebuffer *framebuffer) _cogl_framebuffer_get_stencil_bits (CoglFramebuffer *framebuffer)
{ {
CoglFramebufferPrivate *priv =
cogl_framebuffer_get_instance_private (framebuffer);
CoglContext *ctx = priv->context;
CoglFramebufferBits bits; CoglFramebufferBits bits;
ctx->driver_vtable->framebuffer_query_bits (framebuffer, &bits); cogl_framebuffer_query_bits (framebuffer, &bits);
return bits.stencil; return bits.stencil;
} }

View File

@ -56,6 +56,7 @@ _cogl_offscreen_new_with_texture_full (CoglTexture *texture,
g_return_val_if_fail (cogl_is_texture (texture), NULL); g_return_val_if_fail (cogl_is_texture (texture), NULL);
driver_config = (CoglFramebufferDriverConfig) { driver_config = (CoglFramebufferDriverConfig) {
.type = COGL_FRAMEBUFFER_DRIVER_TYPE_FBO,
.disable_depth_and_stencil = .disable_depth_and_stencil =
!!(flags & COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL), !!(flags & COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL),
}; };

View File

@ -34,20 +34,22 @@
#ifndef __COGL_FRAMEBUFFER_GL_PRIVATE_H__ #ifndef __COGL_FRAMEBUFFER_GL_PRIVATE_H__
#define __COGL_FRAMEBUFFER_GL_PRIVATE_H__ #define __COGL_FRAMEBUFFER_GL_PRIVATE_H__
#include "cogl-attribute-private.h"
#include "cogl-framebuffer-driver.h" #include "cogl-framebuffer-driver.h"
#include "cogl-gl-header.h"
#define COGL_TYPE_GL_FRAMEBUFFER (cogl_gl_framebuffer_get_type ()) #define COGL_TYPE_GL_FRAMEBUFFER (cogl_gl_framebuffer_get_type ())
G_DECLARE_FINAL_TYPE (CoglGlFramebuffer, cogl_gl_framebuffer, G_DECLARE_DERIVABLE_TYPE (CoglGlFramebuffer, cogl_gl_framebuffer,
COGL, GL_FRAMEBUFFER, COGL, GL_FRAMEBUFFER,
CoglFramebufferDriver) CoglFramebufferDriver)
gboolean struct _CoglGlFramebufferClass
_cogl_offscreen_gl_allocate (CoglOffscreen *offscreen, {
CoglOffscreenFlags flags, CoglFramebufferDriverClass parent_class;
GError **error);
void void (* bind) (CoglGlFramebuffer *gl_framebuffer,
_cogl_offscreen_gl_free (CoglOffscreen *offscreen); GLenum target);
};
void void
_cogl_framebuffer_gl_clear (CoglFramebuffer *framebuffer, _cogl_framebuffer_gl_clear (CoglFramebuffer *framebuffer,
@ -57,10 +59,6 @@ _cogl_framebuffer_gl_clear (CoglFramebuffer *framebuffer,
float blue, float blue,
float alpha); float alpha);
void
_cogl_framebuffer_gl_query_bits (CoglFramebuffer *framebuffer,
CoglFramebufferBits *bits);
void void
_cogl_framebuffer_gl_finish (CoglFramebuffer *framebuffer); _cogl_framebuffer_gl_finish (CoglFramebuffer *framebuffer);
@ -72,7 +70,8 @@ _cogl_framebuffer_gl_discard_buffers (CoglFramebuffer *framebuffer,
unsigned long buffers); unsigned long buffers);
void void
_cogl_framebuffer_gl_bind (CoglFramebuffer *framebuffer, GLenum target); cogl_gl_framebuffer_bind (CoglGlFramebuffer *gl_framebuffer,
GLenum target);
void void
_cogl_framebuffer_gl_draw_attributes (CoglFramebuffer *framebuffer, _cogl_framebuffer_gl_draw_attributes (CoglFramebuffer *framebuffer,

View File

@ -40,116 +40,12 @@
#include "driver/gl/cogl-framebuffer-gl-private.h" #include "driver/gl/cogl-framebuffer-gl-private.h"
#include "driver/gl/cogl-bitmap-gl-private.h" #include "driver/gl/cogl-bitmap-gl-private.h"
#include "driver/gl/cogl-buffer-gl-private.h" #include "driver/gl/cogl-buffer-gl-private.h"
#include "driver/gl/cogl-texture-gl-private.h"
#include <glib.h> #include <glib.h>
#include <string.h> #include <string.h>
#ifndef GL_FRAMEBUFFER G_DEFINE_ABSTRACT_TYPE (CoglGlFramebuffer, cogl_gl_framebuffer,
#define GL_FRAMEBUFFER 0x8D40 COGL_TYPE_FRAMEBUFFER_DRIVER)
#endif
#ifndef GL_RENDERBUFFER
#define GL_RENDERBUFFER 0x8D41
#endif
#ifndef GL_STENCIL_ATTACHMENT
#define GL_STENCIL_ATTACHMENT 0x8D00
#endif
#ifndef GL_COLOR_ATTACHMENT0
#define GL_COLOR_ATTACHMENT0 0x8CE0
#endif
#ifndef GL_FRAMEBUFFER_COMPLETE
#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
#endif
#ifndef GL_STENCIL_INDEX8
#define GL_STENCIL_INDEX8 0x8D48
#endif
#ifndef GL_DEPTH_STENCIL
#define GL_DEPTH_STENCIL 0x84F9
#endif
#ifndef GL_DEPTH24_STENCIL8
#define GL_DEPTH24_STENCIL8 0x88F0
#endif
#ifndef GL_DEPTH_ATTACHMENT
#define GL_DEPTH_ATTACHMENT 0x8D00
#endif
#ifndef GL_DEPTH_STENCIL_ATTACHMENT
#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
#endif
#ifndef GL_DEPTH_COMPONENT16
#define GL_DEPTH_COMPONENT16 0x81A5
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
#endif
#ifndef GL_READ_FRAMEBUFFER
#define GL_READ_FRAMEBUFFER 0x8CA8
#endif
#ifndef GL_DRAW_FRAMEBUFFER
#define GL_DRAW_FRAMEBUFFER 0x8CA9
#endif
#ifndef GL_TEXTURE_SAMPLES_IMG
#define GL_TEXTURE_SAMPLES_IMG 0x9136
#endif
#ifndef GL_PACK_INVERT_MESA
#define GL_PACK_INVERT_MESA 0x8758
#endif
#ifndef GL_PACK_REVERSE_ROW_ORDER_ANGLE
#define GL_PACK_REVERSE_ROW_ORDER_ANGLE 0x93A4
#endif
#ifndef GL_BACK_LEFT
#define GL_BACK_LEFT 0x0402
#endif
#ifndef GL_BACK_RIGHT
#define GL_BACK_RIGHT 0x0403
#endif
#ifndef GL_COLOR
#define GL_COLOR 0x1800
#endif
#ifndef GL_DEPTH
#define GL_DEPTH 0x1801
#endif
#ifndef GL_STENCIL
#define GL_STENCIL 0x1802
#endif
typedef struct _CoglGlFbo
{
GLuint fbo_handle;
GList *renderbuffers;
int samples_per_pixel;
} CoglGlFbo;
typedef struct _CoglGlFramebufferPrivate
{
CoglGlFbo gl_fbo;
gboolean dirty_bitmasks;
CoglFramebufferBits bits;
} CoglGlFramebufferPrivate;
struct _CoglGlFramebuffer
{
CoglFramebufferDriver parent;
};
G_DEFINE_TYPE_WITH_PRIVATE (CoglGlFramebuffer, cogl_gl_framebuffer,
COGL_TYPE_FRAMEBUFFER_DRIVER)
static void static void
_cogl_framebuffer_gl_flush_viewport_state (CoglFramebuffer *framebuffer) _cogl_framebuffer_gl_flush_viewport_state (CoglFramebuffer *framebuffer)
@ -352,464 +248,12 @@ cogl_gl_framebuffer_flush_state_differences (CoglGlFramebuffer *gl_framebuffer,
COGL_FLAGS_FOREACH_END; COGL_FLAGS_FOREACH_END;
} }
static CoglGlFramebuffer *
cogl_gl_framebuffer_from_framebuffer (CoglFramebuffer *framebuffer)
{
CoglFramebufferDriver *driver = cogl_framebuffer_get_driver (framebuffer);
g_assert (driver);
return COGL_GL_FRAMEBUFFER (driver);
}
void void
_cogl_framebuffer_gl_bind (CoglFramebuffer *framebuffer, GLenum target) cogl_gl_framebuffer_bind (CoglGlFramebuffer *gl_framebuffer,
GLenum target)
{ {
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer); COGL_GL_FRAMEBUFFER_GET_CLASS (gl_framebuffer)->bind (gl_framebuffer,
target);
if (COGL_IS_OFFSCREEN (framebuffer))
{
CoglGlFramebuffer *gl_framebuffer =
cogl_gl_framebuffer_from_framebuffer (framebuffer);
CoglGlFramebufferPrivate *priv =
cogl_gl_framebuffer_get_instance_private (gl_framebuffer);
GE (ctx, glBindFramebuffer (target, priv->gl_fbo.fbo_handle));
}
else
{
const CoglWinsysVtable *winsys =
_cogl_framebuffer_get_winsys (framebuffer);
winsys->onscreen_bind (COGL_ONSCREEN (framebuffer));
GE (ctx, glBindFramebuffer (target, 0));
/* Initialise the glDrawBuffer state the first time the context
* is bound to the default framebuffer. If the winsys is using a
* surfaceless context for the initial make current then the
* default draw buffer will be GL_NONE so we need to correct
* that. We can't do it any earlier because binding GL_BACK when
* there is no default framebuffer won't work */
if (!ctx->was_bound_to_onscreen)
{
if (ctx->glDrawBuffer)
{
GE (ctx, glDrawBuffer (GL_BACK));
}
else if (ctx->glDrawBuffers)
{
/* glDrawBuffer isn't available on GLES 3.0 so we need
* to be able to use glDrawBuffers as well. On GLES 2
* neither is available but the state should always be
* GL_BACK anyway so we don't need to set anything. On
* desktop GL this must be GL_BACK_LEFT instead of
* GL_BACK but as this code path will only be hit for
* GLES we can just use GL_BACK. */
static const GLenum buffers[] = { GL_BACK };
GE (ctx, glDrawBuffers (G_N_ELEMENTS (buffers), buffers));
}
ctx->was_bound_to_onscreen = TRUE;
}
}
}
static GList *
try_creating_renderbuffers (CoglContext *ctx,
int width,
int height,
CoglOffscreenAllocateFlags flags,
int n_samples)
{
GList *renderbuffers = NULL;
GLuint gl_depth_stencil_handle;
if (flags & COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH_STENCIL)
{
GLenum format;
/* WebGL adds a GL_DEPTH_STENCIL_ATTACHMENT and requires that we
* use the GL_DEPTH_STENCIL format. */
/* Although GL_OES_packed_depth_stencil is mostly equivalent to
* GL_EXT_packed_depth_stencil, one notable difference is that
* GL_OES_packed_depth_stencil doesn't allow GL_DEPTH_STENCIL to
* be passed as an internal format to glRenderbufferStorage.
*/
if (_cogl_has_private_feature
(ctx, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL))
format = GL_DEPTH_STENCIL;
else
{
g_return_val_if_fail (
_cogl_has_private_feature (ctx,
COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL),
NULL);
format = GL_DEPTH24_STENCIL8;
}
/* Create a renderbuffer for depth and stenciling */
GE (ctx, glGenRenderbuffers (1, &gl_depth_stencil_handle));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_stencil_handle));
if (n_samples)
GE (ctx, glRenderbufferStorageMultisampleIMG (GL_RENDERBUFFER,
n_samples,
format,
width, height));
else
GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, format,
width, height));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT,
GL_RENDERBUFFER,
gl_depth_stencil_handle));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER,
gl_depth_stencil_handle));
renderbuffers =
g_list_prepend (renderbuffers,
GUINT_TO_POINTER (gl_depth_stencil_handle));
}
if (flags & COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH)
{
GLuint gl_depth_handle;
GE (ctx, glGenRenderbuffers (1, &gl_depth_handle));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_handle));
/* For now we just ask for GL_DEPTH_COMPONENT16 since this is all that's
* available under GLES */
if (n_samples)
GE (ctx, glRenderbufferStorageMultisampleIMG (GL_RENDERBUFFER,
n_samples,
GL_DEPTH_COMPONENT16,
width, height));
else
GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
width, height));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, gl_depth_handle));
renderbuffers =
g_list_prepend (renderbuffers, GUINT_TO_POINTER (gl_depth_handle));
}
if (flags & COGL_OFFSCREEN_ALLOCATE_FLAG_STENCIL)
{
GLuint gl_stencil_handle;
GE (ctx, glGenRenderbuffers (1, &gl_stencil_handle));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_stencil_handle));
if (n_samples)
GE (ctx, glRenderbufferStorageMultisampleIMG (GL_RENDERBUFFER,
n_samples,
GL_STENCIL_INDEX8,
width, height));
else
GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, GL_STENCIL_INDEX8,
width, height));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, gl_stencil_handle));
renderbuffers =
g_list_prepend (renderbuffers, GUINT_TO_POINTER (gl_stencil_handle));
}
return renderbuffers;
}
static void
delete_renderbuffers (CoglContext *ctx, GList *renderbuffers)
{
GList *l;
for (l = renderbuffers; l; l = l->next)
{
GLuint renderbuffer = GPOINTER_TO_UINT (l->data);
GE (ctx, glDeleteRenderbuffers (1, &renderbuffer));
}
g_list_free (renderbuffers);
}
/*
* NB: This function may be called with a standalone GLES2 context
* bound so we can create a shadow framebuffer that wraps the same
* CoglTexture as the given CoglOffscreen. This function shouldn't
* modify anything in
*/
static gboolean
try_creating_fbo (CoglContext *ctx,
CoglTexture *texture,
int texture_level,
int texture_level_width,
int texture_level_height,
const CoglFramebufferConfig *config,
CoglOffscreenAllocateFlags flags,
CoglGlFbo *gl_fbo)
{
GLuint tex_gl_handle;
GLenum tex_gl_target;
GLenum status;
int n_samples;
if (!cogl_texture_get_gl_texture (texture, &tex_gl_handle, &tex_gl_target))
return FALSE;
if (tex_gl_target != GL_TEXTURE_2D
#ifdef HAVE_COGL_GL
&& tex_gl_target != GL_TEXTURE_RECTANGLE_ARB
#endif
)
return FALSE;
if (config->samples_per_pixel)
{
if (!ctx->glFramebufferTexture2DMultisampleIMG)
return FALSE;
n_samples = config->samples_per_pixel;
}
else
n_samples = 0;
/* We are about to generate and bind a new fbo, so we pretend to
* change framebuffer state so that the old framebuffer will be
* rebound again before drawing. */
ctx->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_BIND;
/* Generate framebuffer */
ctx->glGenFramebuffers (1, &gl_fbo->fbo_handle);
GE (ctx, glBindFramebuffer (GL_FRAMEBUFFER, gl_fbo->fbo_handle));
if (n_samples)
{
GE (ctx, glFramebufferTexture2DMultisampleIMG (GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
tex_gl_target, tex_gl_handle,
n_samples,
texture_level));
}
else
GE (ctx, glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
tex_gl_target, tex_gl_handle,
texture_level));
if (flags)
{
gl_fbo->renderbuffers =
try_creating_renderbuffers (ctx,
texture_level_width,
texture_level_height,
flags,
n_samples);
}
/* Make sure it's complete */
status = ctx->glCheckFramebufferStatus (GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
GE (ctx, glDeleteFramebuffers (1, &gl_fbo->fbo_handle));
delete_renderbuffers (ctx, gl_fbo->renderbuffers);
gl_fbo->renderbuffers = NULL;
return FALSE;
}
/* Update the real number of samples_per_pixel now that we have a
* complete framebuffer */
if (n_samples)
{
GLenum attachment = GL_COLOR_ATTACHMENT0;
GLenum pname = GL_TEXTURE_SAMPLES_IMG;
int texture_samples;
GE( ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER,
attachment,
pname,
&texture_samples) );
gl_fbo->samples_per_pixel = texture_samples;
}
return TRUE;
}
CoglFramebufferDriver *
_cogl_driver_gl_create_framebuffer_driver (CoglContext *context,
CoglFramebuffer *framebuffer,
const CoglFramebufferDriverConfig *driver_config,
GError **error)
{
CoglOffscreenAllocateFlags allocate_flags;
CoglOffscreen *offscreen;
CoglGlFramebuffer *gl_framebuffer;
CoglGlFramebufferPrivate *priv;
CoglGlFbo *gl_fbo;
const CoglFramebufferConfig *config;
CoglTexture *texture;
int texture_level;
int level_width;
int level_height;
if (COGL_IS_ONSCREEN (framebuffer))
{
return g_object_new (COGL_TYPE_GL_FRAMEBUFFER,
"framebuffer", framebuffer,
NULL);
}
offscreen = COGL_OFFSCREEN (framebuffer);
texture = cogl_offscreen_get_texture (offscreen);
texture_level = cogl_offscreen_get_texture_level (offscreen);
g_return_val_if_fail (texture_level < _cogl_texture_get_n_levels (texture),
FALSE);
_cogl_texture_get_level_size (texture,
texture_level,
&level_width,
&level_height,
NULL);
/* XXX: The framebuffer_object spec isn't clear in defining whether attaching
* a texture as a renderbuffer with mipmap filtering enabled while the
* mipmaps have not been uploaded should result in an incomplete framebuffer
* object. (different drivers make different decisions)
*
* To avoid an error with drivers that do consider this a problem we
* explicitly set non mipmapped filters here. These will later be reset when
* the texture is actually used for rendering according to the filters set on
* the corresponding CoglPipeline.
*/
_cogl_texture_gl_flush_legacy_texobj_filters (texture,
GL_NEAREST, GL_NEAREST);
config = cogl_framebuffer_get_config (framebuffer);
gl_framebuffer = g_object_new (COGL_TYPE_GL_FRAMEBUFFER,
"framebuffer", framebuffer,
NULL);
priv = cogl_gl_framebuffer_get_instance_private (gl_framebuffer);
gl_fbo = &priv->gl_fbo;
if ((driver_config->disable_depth_and_stencil &&
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = 0,
gl_fbo)) ||
(context->have_last_offscreen_allocate_flags &&
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = context->last_offscreen_allocate_flags,
gl_fbo)) ||
(
/* NB: WebGL introduces a DEPTH_STENCIL_ATTACHMENT and doesn't
* need an extension to handle _FLAG_DEPTH_STENCIL */
(_cogl_has_private_feature
(context, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL) ||
_cogl_has_private_feature
(context, COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL)) &&
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH_STENCIL,
gl_fbo)) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH |
COGL_OFFSCREEN_ALLOCATE_FLAG_STENCIL,
gl_fbo) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_STENCIL,
gl_fbo) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH,
gl_fbo) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = 0,
gl_fbo))
{
cogl_framebuffer_update_samples_per_pixel (framebuffer,
gl_fbo->samples_per_pixel);
if (!driver_config->disable_depth_and_stencil)
{
/* Record that the last set of flags succeeded so that we can
try that set first next time */
context->last_offscreen_allocate_flags = allocate_flags;
context->have_last_offscreen_allocate_flags = TRUE;
}
return COGL_FRAMEBUFFER_DRIVER (gl_framebuffer);
}
else
{
g_object_unref (gl_framebuffer);
g_set_error (error, COGL_FRAMEBUFFER_ERROR,
COGL_FRAMEBUFFER_ERROR_ALLOCATE,
"Failed to create an OpenGL framebuffer object");
return NULL;
}
}
static void
cogl_gl_framebuffer_dispose (GObject *object)
{
CoglGlFramebuffer *gl_framebuffer = COGL_GL_FRAMEBUFFER (object);
CoglGlFramebufferPrivate *priv =
cogl_gl_framebuffer_get_instance_private (gl_framebuffer);
CoglFramebufferDriver *driver = COGL_FRAMEBUFFER_DRIVER (object);
CoglFramebuffer *framebuffer =
cogl_framebuffer_driver_get_framebuffer (driver);
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
G_OBJECT_CLASS (cogl_gl_framebuffer_parent_class)->dispose (object);
delete_renderbuffers (ctx, priv->gl_fbo.renderbuffers);
GE (ctx, glDeleteFramebuffers (1, &priv->gl_fbo.fbo_handle));
} }
void void
@ -857,118 +301,6 @@ _cogl_framebuffer_gl_clear (CoglFramebuffer *framebuffer,
GE (ctx, glClear (gl_buffers)); GE (ctx, glClear (gl_buffers));
} }
static inline void
_cogl_framebuffer_init_bits (CoglFramebuffer *framebuffer)
{
CoglGlFramebuffer *gl_framebuffer =
cogl_gl_framebuffer_from_framebuffer (framebuffer);
CoglGlFramebufferPrivate *priv =
cogl_gl_framebuffer_get_instance_private (gl_framebuffer);
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
if (!priv->dirty_bitmasks)
return;
cogl_framebuffer_allocate (framebuffer, NULL);
cogl_context_flush_framebuffer_state (ctx,
framebuffer,
framebuffer,
COGL_FRAMEBUFFER_STATE_BIND);
#ifdef HAVE_COGL_GL
if ((ctx->driver == COGL_DRIVER_GL3 &&
COGL_IS_ONSCREEN (framebuffer)) ||
(_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS) &&
COGL_IS_OFFSCREEN (framebuffer)))
{
gboolean is_offscreen = COGL_IS_OFFSCREEN (framebuffer);
const struct {
GLenum attachment, pname;
size_t offset;
} params[] = {
{ is_offscreen ? GL_COLOR_ATTACHMENT0 : GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE,
offsetof (CoglFramebufferBits, red) },
{ is_offscreen ? GL_COLOR_ATTACHMENT0 : GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
offsetof (CoglFramebufferBits, green) },
{ is_offscreen ? GL_COLOR_ATTACHMENT0 : GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
offsetof (CoglFramebufferBits, blue) },
{ is_offscreen ? GL_COLOR_ATTACHMENT0 : GL_BACK_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
offsetof (CoglFramebufferBits, alpha) },
{ is_offscreen ? GL_DEPTH_ATTACHMENT : GL_DEPTH,
GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
offsetof (CoglFramebufferBits, depth) },
{ is_offscreen ? GL_STENCIL_ATTACHMENT : GL_STENCIL,
GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
offsetof (CoglFramebufferBits, stencil) },
};
int i;
for (i = 0; i < G_N_ELEMENTS (params); i++)
{
int *value =
(int *) ((uint8_t *) &priv->bits + params[i].offset);
GE( ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER,
params[i].attachment,
params[i].pname,
value) );
}
}
else
#endif /* HAVE_COGL_GL */
{
GE (ctx, glGetIntegerv (GL_RED_BITS, &priv->bits.red));
GE (ctx, glGetIntegerv (GL_GREEN_BITS, &priv->bits.green));
GE (ctx, glGetIntegerv (GL_BLUE_BITS, &priv->bits.blue));
GE (ctx, glGetIntegerv (GL_ALPHA_BITS, &priv->bits.alpha));
GE (ctx, glGetIntegerv (GL_DEPTH_BITS, &priv->bits.depth));
GE (ctx, glGetIntegerv (GL_STENCIL_BITS, &priv->bits.stencil));
}
/* If we don't have alpha textures then the alpha bits are actually
* stored in the red component */
if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) &&
COGL_IS_OFFSCREEN (framebuffer) &&
cogl_framebuffer_get_internal_format (framebuffer) == COGL_PIXEL_FORMAT_A_8)
{
priv->bits.alpha = priv->bits.red;
priv->bits.red = 0;
}
COGL_NOTE (OFFSCREEN,
"RGBA/D/S Bits for framebuffer[%p, %s]: %d, %d, %d, %d, %d, %d",
framebuffer,
COGL_IS_OFFSCREEN (framebuffer) ? "offscreen" : "onscreen",
priv->bits.red,
priv->bits.blue,
priv->bits.green,
priv->bits.alpha,
priv->bits.depth,
priv->bits.stencil);
priv->dirty_bitmasks = FALSE;
}
void
_cogl_framebuffer_gl_query_bits (CoglFramebuffer *framebuffer,
CoglFramebufferBits *bits)
{
CoglGlFramebuffer *gl_framebuffer =
cogl_gl_framebuffer_from_framebuffer (framebuffer);
CoglGlFramebufferPrivate *priv =
cogl_gl_framebuffer_get_instance_private (gl_framebuffer);
_cogl_framebuffer_init_bits (framebuffer);
/* TODO: cache these in some driver specific location not
* directly as part of CoglFramebuffer. */
*bits = priv->bits;
}
void void
_cogl_framebuffer_gl_finish (CoglFramebuffer *framebuffer) _cogl_framebuffer_gl_finish (CoglFramebuffer *framebuffer)
{ {
@ -1365,16 +697,9 @@ EXIT:
static void static void
cogl_gl_framebuffer_init (CoglGlFramebuffer *gl_framebuffer) cogl_gl_framebuffer_init (CoglGlFramebuffer *gl_framebuffer)
{ {
CoglGlFramebufferPrivate *priv =
cogl_gl_framebuffer_get_instance_private (gl_framebuffer);
priv->dirty_bitmasks = TRUE;
} }
static void static void
cogl_gl_framebuffer_class_init (CoglGlFramebufferClass *klass) cogl_gl_framebuffer_class_init (CoglGlFramebufferClass *klass)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = cogl_gl_framebuffer_dispose;
} }

View File

@ -0,0 +1,239 @@
/*
* Copyright (C) 2007,2008,2009,2012 Intel Corporation.
* Copyright (C) 2018 DisplayLink (UK) Ltd.
* Copyright (C) 2020 Red Hat
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "cogl-config.h"
#include "driver/gl/cogl-gl-framebuffer-back.h"
#include <gio/gio.h>
#include "cogl-context-private.h"
#include "cogl-framebuffer-private.h"
#include "cogl-offscreen-private.h"
#include "driver/gl/cogl-util-gl-private.h"
struct _CoglGlFramebufferBack
{
CoglGlFramebuffer parent;
gboolean dirty_bitmasks;
CoglFramebufferBits bits;
};
G_DEFINE_TYPE (CoglGlFramebufferBack, cogl_gl_framebuffer_back,
COGL_TYPE_GL_FRAMEBUFFER)
static gboolean
ensure_bits_initialized (CoglGlFramebufferBack *gl_framebuffer_back)
{
CoglFramebufferDriver *driver = COGL_FRAMEBUFFER_DRIVER (gl_framebuffer_back);
CoglFramebuffer *framebuffer =
cogl_framebuffer_driver_get_framebuffer (driver);
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
CoglFramebufferBits *bits = &gl_framebuffer_back->bits;
g_autoptr (GError) error = NULL;
if (!gl_framebuffer_back->dirty_bitmasks)
return TRUE;
cogl_context_flush_framebuffer_state (ctx,
framebuffer,
framebuffer,
COGL_FRAMEBUFFER_STATE_BIND);
#ifdef HAVE_COGL_GL
if (ctx->driver == COGL_DRIVER_GL3)
{
const struct {
GLenum attachment, pname;
size_t offset;
} params[] = {
{
.attachment = GL_BACK_LEFT,
.pname = GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE,
.offset = offsetof (CoglFramebufferBits, red),
},
{
.attachment = GL_BACK_LEFT,
.pname = GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
.offset = offsetof (CoglFramebufferBits, green),
},
{
.attachment = GL_BACK_LEFT,
.pname = GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
.offset = offsetof (CoglFramebufferBits, blue),
},
{
.attachment = GL_BACK_LEFT,
.pname = GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
.offset = offsetof (CoglFramebufferBits, alpha),
},
{
.attachment = GL_DEPTH,
.pname = GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
.offset = offsetof (CoglFramebufferBits, depth),
},
{
.attachment = GL_STENCIL,
.pname = GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
.offset = offsetof (CoglFramebufferBits, stencil),
},
};
int i;
for (i = 0; i < G_N_ELEMENTS (params); i++)
{
int *value =
(int *) ((uint8_t *) bits + params[i].offset);
GE (ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER,
params[i].attachment,
params[i].pname,
value));
}
}
else
#endif /* HAVE_COGL_GL */
{
GE (ctx, glGetIntegerv (GL_RED_BITS, &bits->red));
GE (ctx, glGetIntegerv (GL_GREEN_BITS, &bits->green));
GE (ctx, glGetIntegerv (GL_BLUE_BITS, &bits->blue));
GE (ctx, glGetIntegerv (GL_ALPHA_BITS, &bits->alpha));
GE (ctx, glGetIntegerv (GL_DEPTH_BITS, &bits->depth));
GE (ctx, glGetIntegerv (GL_STENCIL_BITS, &bits->stencil));
}
COGL_NOTE (FRAMEBUFFER,
"RGBA/D/S Bits for framebuffer[%p, %s]: %d, %d, %d, %d, %d, %d",
framebuffer,
COGL_IS_OFFSCREEN (framebuffer) ? "offscreen" : "onscreen",
bits->red,
bits->blue,
bits->green,
bits->alpha,
bits->depth,
bits->stencil);
gl_framebuffer_back->dirty_bitmasks = FALSE;
return TRUE;
}
static void
cogl_gl_framebuffer_back_query_bits (CoglFramebufferDriver *driver,
CoglFramebufferBits *bits)
{
CoglGlFramebufferBack *gl_framebuffer_back = COGL_GL_FRAMEBUFFER_BACK (driver);
if (!ensure_bits_initialized (gl_framebuffer_back))
return;
*bits = gl_framebuffer_back->bits;
}
static void
cogl_gl_framebuffer_back_bind (CoglGlFramebuffer *gl_framebuffer,
GLenum target)
{
CoglGlFramebufferBack *gl_framebuffer_back =
COGL_GL_FRAMEBUFFER_BACK (gl_framebuffer);
CoglFramebufferDriver *driver = COGL_FRAMEBUFFER_DRIVER (gl_framebuffer_back);
CoglFramebuffer *framebuffer =
cogl_framebuffer_driver_get_framebuffer (driver);
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
const CoglWinsysVtable *winsys =
_cogl_framebuffer_get_winsys (framebuffer);
winsys->onscreen_bind (COGL_ONSCREEN (framebuffer));
GE (ctx, glBindFramebuffer (target, 0));
/* Initialise the glDrawBuffer state the first time the context
* is bound to the default framebuffer. If the winsys is using a
* surfaceless context for the initial make current then the
* default draw buffer will be GL_NONE so we need to correct
* that. We can't do it any earlier because binding GL_BACK when
* there is no default framebuffer won't work */
if (!ctx->was_bound_to_onscreen)
{
if (ctx->glDrawBuffer)
{
GE (ctx, glDrawBuffer (GL_BACK));
}
else if (ctx->glDrawBuffers)
{
/* glDrawBuffer isn't available on GLES 3.0 so we need
* to be able to use glDrawBuffers as well. On GLES 2
* neither is available but the state should always be
* GL_BACK anyway so we don't need to set anything. On
* desktop GL this must be GL_BACK_LEFT instead of
* GL_BACK but as this code path will only be hit for
* GLES we can just use GL_BACK. */
static const GLenum buffers[] = { GL_BACK };
GE (ctx, glDrawBuffers (G_N_ELEMENTS (buffers), buffers));
}
ctx->was_bound_to_onscreen = TRUE;
}
}
CoglGlFramebufferBack *
cogl_gl_framebuffer_back_new (CoglFramebuffer *framebuffer,
const CoglFramebufferDriverConfig *driver_config,
GError **error)
{
if (!COGL_IS_ONSCREEN (framebuffer))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Incompatible framebuffer");
return NULL;
}
return g_object_new (COGL_TYPE_GL_FRAMEBUFFER_BACK,
"framebuffer", framebuffer,
NULL);
}
static void
cogl_gl_framebuffer_back_init (CoglGlFramebufferBack *gl_framebuffer_back)
{
gl_framebuffer_back->dirty_bitmasks = TRUE;
}
static void
cogl_gl_framebuffer_back_class_init (CoglGlFramebufferBackClass *klass)
{
CoglFramebufferDriverClass *driver_class =
COGL_FRAMEBUFFER_DRIVER_CLASS (klass);
CoglGlFramebufferClass *gl_framebuffer_class =
COGL_GL_FRAMEBUFFER_CLASS (klass);
driver_class->query_bits = cogl_gl_framebuffer_back_query_bits;
gl_framebuffer_class->bind = cogl_gl_framebuffer_back_bind;
}

View File

@ -0,0 +1,41 @@
/*
* Copyright (C) 2020 Red Hat
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#ifndef COGL_GL_FRAMEBUFFER_BACK_H
#define COGL_GL_FRAMEBUFFER_BACK_H
#include "cogl-framebuffer-gl-private.h"
#define COGL_TYPE_GL_FRAMEBUFFER_BACK (cogl_gl_framebuffer_back_get_type ())
G_DECLARE_FINAL_TYPE (CoglGlFramebufferBack, cogl_gl_framebuffer_back,
COGL, GL_FRAMEBUFFER_BACK,
CoglGlFramebuffer)
CoglGlFramebufferBack *
cogl_gl_framebuffer_back_new (CoglFramebuffer *framebuffer,
const CoglFramebufferDriverConfig *driver_config,
GError **error);
#endif /* COGL_GL_FRAMEBUFFER_BACK_H */

View File

@ -0,0 +1,611 @@
/*
* Copyright (C) 2007,2008,2009,2012 Intel Corporation.
* Copyright (C) 2018 DisplayLink (UK) Ltd.
* Copyright (C) 2020 Red Hat
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "cogl-config.h"
#include "driver/gl/cogl-gl-framebuffer-fbo.h"
#include <gio/gio.h>
#include "cogl-context-private.h"
#include "cogl-framebuffer-private.h"
#include "cogl-offscreen-private.h"
#include "driver/gl/cogl-texture-gl-private.h"
#include "driver/gl/cogl-util-gl-private.h"
typedef struct _CoglGlFbo
{
GLuint fbo_handle;
GList *renderbuffers;
int samples_per_pixel;
} CoglGlFbo;
struct _CoglGlFramebufferFbo
{
CoglGlFramebuffer parent;
CoglGlFbo gl_fbo;
gboolean dirty_bitmasks;
CoglFramebufferBits bits;
};
G_DEFINE_TYPE (CoglGlFramebufferFbo, cogl_gl_framebuffer_fbo,
COGL_TYPE_GL_FRAMEBUFFER)
static gboolean
ensure_bits_initialized (CoglGlFramebufferFbo *gl_framebuffer_fbo)
{
CoglFramebufferDriver *driver = COGL_FRAMEBUFFER_DRIVER (gl_framebuffer_fbo);
CoglFramebuffer *framebuffer =
cogl_framebuffer_driver_get_framebuffer (driver);
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
CoglFramebufferBits *bits = &gl_framebuffer_fbo->bits;
g_autoptr (GError) error = NULL;
if (!gl_framebuffer_fbo->dirty_bitmasks)
return TRUE;
cogl_context_flush_framebuffer_state (ctx,
framebuffer,
framebuffer,
COGL_FRAMEBUFFER_STATE_BIND);
#ifdef HAVE_COGL_GL
if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_QUERY_FRAMEBUFFER_BITS))
{
const struct {
GLenum attachment, pname;
size_t offset;
} params[] = {
{
.attachment = GL_COLOR_ATTACHMENT0,
.pname = GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE,
.offset = offsetof (CoglFramebufferBits, red),
},
{
.attachment = GL_COLOR_ATTACHMENT0,
.pname = GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
.offset = offsetof (CoglFramebufferBits, green),
},
{
.attachment = GL_COLOR_ATTACHMENT0,
.pname = GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
.offset = offsetof (CoglFramebufferBits, blue),
},
{
.attachment = GL_COLOR_ATTACHMENT0,
.pname = GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
.offset = offsetof (CoglFramebufferBits, alpha),
},
{
.attachment = GL_DEPTH_ATTACHMENT,
.pname = GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
.offset = offsetof (CoglFramebufferBits, depth),
},
{
.attachment = GL_STENCIL_ATTACHMENT,
.pname = GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
.offset = offsetof (CoglFramebufferBits, stencil),
},
};
int i;
for (i = 0; i < G_N_ELEMENTS (params); i++)
{
int *value =
(int *) ((uint8_t *) bits + params[i].offset);
GE (ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER,
params[i].attachment,
params[i].pname,
value));
}
}
else
#endif /* HAVE_COGL_GL */
{
GE (ctx, glGetIntegerv (GL_RED_BITS, &bits->red));
GE (ctx, glGetIntegerv (GL_GREEN_BITS, &bits->green));
GE (ctx, glGetIntegerv (GL_BLUE_BITS, &bits->blue));
GE (ctx, glGetIntegerv (GL_ALPHA_BITS, &bits->alpha));
GE (ctx, glGetIntegerv (GL_DEPTH_BITS, &bits->depth));
GE (ctx, glGetIntegerv (GL_STENCIL_BITS, &bits->stencil));
}
if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES) &&
(cogl_framebuffer_get_internal_format (framebuffer) ==
COGL_PIXEL_FORMAT_A_8))
{
bits->alpha = bits->red;
bits->red = 0;
}
COGL_NOTE (FRAMEBUFFER,
"RGBA/D/S Bits for framebuffer[%p, %s]: %d, %d, %d, %d, %d, %d",
framebuffer,
COGL_IS_OFFSCREEN (framebuffer) ? "offscreen" : "onscreen",
bits->red,
bits->blue,
bits->green,
bits->alpha,
bits->depth,
bits->stencil);
gl_framebuffer_fbo->dirty_bitmasks = FALSE;
return TRUE;
}
static void
cogl_gl_framebuffer_fbo_query_bits (CoglFramebufferDriver *driver,
CoglFramebufferBits *bits)
{
CoglGlFramebufferFbo *gl_framebuffer_fbo = COGL_GL_FRAMEBUFFER_FBO (driver);
if (!ensure_bits_initialized (gl_framebuffer_fbo))
return;
*bits = gl_framebuffer_fbo->bits;
}
static void
cogl_gl_framebuffer_fbo_bind (CoglGlFramebuffer *gl_framebuffer,
GLenum target)
{
CoglGlFramebufferFbo *gl_framebuffer_fbo =
COGL_GL_FRAMEBUFFER_FBO (gl_framebuffer);
CoglFramebufferDriver *driver = COGL_FRAMEBUFFER_DRIVER (gl_framebuffer_fbo);
CoglFramebuffer *framebuffer =
cogl_framebuffer_driver_get_framebuffer (driver);
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
GE (ctx, glBindFramebuffer (target, gl_framebuffer_fbo->gl_fbo.fbo_handle));
}
static GList *
try_creating_renderbuffers (CoglContext *ctx,
int width,
int height,
CoglOffscreenAllocateFlags flags,
int n_samples)
{
GList *renderbuffers = NULL;
GLuint gl_depth_stencil_handle;
if (flags & COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH_STENCIL)
{
GLenum format;
/* WebGL adds a GL_DEPTH_STENCIL_ATTACHMENT and requires that we
* use the GL_DEPTH_STENCIL format. */
/* Although GL_OES_packed_depth_stencil is mostly equivalent to
* GL_EXT_packed_depth_stencil, one notable difference is that
* GL_OES_packed_depth_stencil doesn't allow GL_DEPTH_STENCIL to
* be passed as an internal format to glRenderbufferStorage.
*/
if (_cogl_has_private_feature
(ctx, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL))
format = GL_DEPTH_STENCIL;
else
{
g_return_val_if_fail (
_cogl_has_private_feature (ctx,
COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL),
NULL);
format = GL_DEPTH24_STENCIL8;
}
/* Create a renderbuffer for depth and stenciling */
GE (ctx, glGenRenderbuffers (1, &gl_depth_stencil_handle));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_stencil_handle));
if (n_samples)
GE (ctx, glRenderbufferStorageMultisampleIMG (GL_RENDERBUFFER,
n_samples,
format,
width, height));
else
GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, format,
width, height));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT,
GL_RENDERBUFFER,
gl_depth_stencil_handle));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER,
gl_depth_stencil_handle));
renderbuffers =
g_list_prepend (renderbuffers,
GUINT_TO_POINTER (gl_depth_stencil_handle));
}
if (flags & COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH)
{
GLuint gl_depth_handle;
GE (ctx, glGenRenderbuffers (1, &gl_depth_handle));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_depth_handle));
/* For now we just ask for GL_DEPTH_COMPONENT16 since this is all that's
* available under GLES */
if (n_samples)
GE (ctx, glRenderbufferStorageMultisampleIMG (GL_RENDERBUFFER,
n_samples,
GL_DEPTH_COMPONENT16,
width, height));
else
GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
width, height));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, gl_depth_handle));
renderbuffers =
g_list_prepend (renderbuffers, GUINT_TO_POINTER (gl_depth_handle));
}
if (flags & COGL_OFFSCREEN_ALLOCATE_FLAG_STENCIL)
{
GLuint gl_stencil_handle;
GE (ctx, glGenRenderbuffers (1, &gl_stencil_handle));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, gl_stencil_handle));
if (n_samples)
GE (ctx, glRenderbufferStorageMultisampleIMG (GL_RENDERBUFFER,
n_samples,
GL_STENCIL_INDEX8,
width, height));
else
GE (ctx, glRenderbufferStorage (GL_RENDERBUFFER, GL_STENCIL_INDEX8,
width, height));
GE (ctx, glBindRenderbuffer (GL_RENDERBUFFER, 0));
GE (ctx, glFramebufferRenderbuffer (GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, gl_stencil_handle));
renderbuffers =
g_list_prepend (renderbuffers, GUINT_TO_POINTER (gl_stencil_handle));
}
return renderbuffers;
}
static void
delete_renderbuffers (CoglContext *ctx,
GList *renderbuffers)
{
GList *l;
for (l = renderbuffers; l; l = l->next)
{
GLuint renderbuffer = GPOINTER_TO_UINT (l->data);
GE (ctx, glDeleteRenderbuffers (1, &renderbuffer));
}
g_list_free (renderbuffers);
}
/*
* NB: This function may be called with a standalone GLES2 context
* bound so we can create a shadow framebuffer that wraps the same
* CoglTexture as the given CoglOffscreen. This function shouldn't
* modify anything in
*/
static gboolean
try_creating_fbo (CoglContext *ctx,
CoglTexture *texture,
int texture_level,
int texture_level_width,
int texture_level_height,
const CoglFramebufferConfig *config,
CoglOffscreenAllocateFlags flags,
CoglGlFbo *gl_fbo)
{
GLuint tex_gl_handle;
GLenum tex_gl_target;
GLenum status;
int n_samples;
if (!cogl_texture_get_gl_texture (texture, &tex_gl_handle, &tex_gl_target))
return FALSE;
if (tex_gl_target != GL_TEXTURE_2D
#ifdef HAVE_COGL_GL
&& tex_gl_target != GL_TEXTURE_RECTANGLE_ARB
#endif
)
return FALSE;
if (config->samples_per_pixel)
{
if (!ctx->glFramebufferTexture2DMultisampleIMG)
return FALSE;
n_samples = config->samples_per_pixel;
}
else
n_samples = 0;
/* We are about to generate and bind a new fbo, so we pretend to
* change framebuffer state so that the old framebuffer will be
* rebound again before drawing. */
ctx->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_BIND;
/* Generate framebuffer */
ctx->glGenFramebuffers (1, &gl_fbo->fbo_handle);
GE (ctx, glBindFramebuffer (GL_FRAMEBUFFER, gl_fbo->fbo_handle));
if (n_samples)
{
GE (ctx, glFramebufferTexture2DMultisampleIMG (GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
tex_gl_target, tex_gl_handle,
n_samples,
texture_level));
}
else
GE (ctx, glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
tex_gl_target, tex_gl_handle,
texture_level));
if (flags)
{
gl_fbo->renderbuffers =
try_creating_renderbuffers (ctx,
texture_level_width,
texture_level_height,
flags,
n_samples);
}
/* Make sure it's complete */
status = ctx->glCheckFramebufferStatus (GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
GE (ctx, glDeleteFramebuffers (1, &gl_fbo->fbo_handle));
delete_renderbuffers (ctx, gl_fbo->renderbuffers);
gl_fbo->renderbuffers = NULL;
return FALSE;
}
/* Update the real number of samples_per_pixel now that we have a
* complete framebuffer */
if (n_samples)
{
GLenum attachment = GL_COLOR_ATTACHMENT0;
GLenum pname = GL_TEXTURE_SAMPLES_IMG;
int texture_samples;
GE( ctx, glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER,
attachment,
pname,
&texture_samples) );
gl_fbo->samples_per_pixel = texture_samples;
}
return TRUE;
}
CoglGlFramebufferFbo *
cogl_gl_framebuffer_fbo_new (CoglFramebuffer *framebuffer,
const CoglFramebufferDriverConfig *driver_config,
GError **error)
{
CoglContext *context = cogl_framebuffer_get_context (framebuffer);
CoglOffscreen *offscreen;
CoglTexture *texture;
int texture_level;
int level_width;
int level_height;
const CoglFramebufferConfig *config;
CoglGlFbo *gl_fbo;
CoglGlFramebufferFbo *gl_framebuffer_fbo;
CoglOffscreenAllocateFlags allocate_flags;
if (!COGL_IS_OFFSCREEN (framebuffer))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Incompatible framebuffer");
return NULL;
}
offscreen = COGL_OFFSCREEN (framebuffer);
texture = cogl_offscreen_get_texture (offscreen);
texture_level = cogl_offscreen_get_texture_level (offscreen);
g_return_val_if_fail (texture_level < _cogl_texture_get_n_levels (texture),
NULL);
_cogl_texture_get_level_size (texture,
texture_level,
&level_width,
&level_height,
NULL);
/* XXX: The framebuffer_object spec isn't clear in defining whether attaching
* a texture as a renderbuffer with mipmap filtering enabled while the
* mipmaps have not been uploaded should result in an incomplete framebuffer
* object. (different drivers make different decisions)
*
* To avoid an error with drivers that do consider this a problem we
* explicitly set non mipmapped filters here. These will later be reset when
* the texture is actually used for rendering according to the filters set on
* the corresponding CoglPipeline.
*/
_cogl_texture_gl_flush_legacy_texobj_filters (texture,
GL_NEAREST, GL_NEAREST);
config = cogl_framebuffer_get_config (framebuffer);
gl_framebuffer_fbo = g_object_new (COGL_TYPE_GL_FRAMEBUFFER_FBO,
"framebuffer", framebuffer,
NULL);
gl_fbo = &gl_framebuffer_fbo->gl_fbo;
if ((driver_config->disable_depth_and_stencil &&
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = 0,
gl_fbo)) ||
(context->have_last_offscreen_allocate_flags &&
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = context->last_offscreen_allocate_flags,
gl_fbo)) ||
(
/* NB: WebGL introduces a DEPTH_STENCIL_ATTACHMENT and doesn't
* need an extension to handle _FLAG_DEPTH_STENCIL */
(_cogl_has_private_feature
(context, COGL_PRIVATE_FEATURE_EXT_PACKED_DEPTH_STENCIL) ||
_cogl_has_private_feature
(context, COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL)) &&
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH_STENCIL,
gl_fbo)) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH |
COGL_OFFSCREEN_ALLOCATE_FLAG_STENCIL,
gl_fbo) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_STENCIL,
gl_fbo) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = COGL_OFFSCREEN_ALLOCATE_FLAG_DEPTH,
gl_fbo) ||
try_creating_fbo (context,
texture,
texture_level,
level_width,
level_height,
config,
allocate_flags = 0,
gl_fbo))
{
cogl_framebuffer_update_samples_per_pixel (framebuffer,
gl_fbo->samples_per_pixel);
if (!driver_config->disable_depth_and_stencil)
{
/* Record that the last set of flags succeeded so that we can
try that set first next time */
context->last_offscreen_allocate_flags = allocate_flags;
context->have_last_offscreen_allocate_flags = TRUE;
}
return gl_framebuffer_fbo;
}
else
{
g_object_unref (gl_framebuffer_fbo);
g_set_error (error, COGL_FRAMEBUFFER_ERROR,
COGL_FRAMEBUFFER_ERROR_ALLOCATE,
"Failed to create an OpenGL framebuffer object");
return NULL;
}
}
static void
cogl_gl_framebuffer_fbo_dispose (GObject *object)
{
CoglGlFramebufferFbo *gl_framebuffer_fbo = COGL_GL_FRAMEBUFFER_FBO (object);
CoglFramebufferDriver *driver = COGL_FRAMEBUFFER_DRIVER (gl_framebuffer_fbo);
CoglFramebuffer *framebuffer =
cogl_framebuffer_driver_get_framebuffer (driver);
CoglContext *ctx = cogl_framebuffer_get_context (framebuffer);
delete_renderbuffers (ctx, gl_framebuffer_fbo->gl_fbo.renderbuffers);
gl_framebuffer_fbo->gl_fbo.renderbuffers = NULL;
if (gl_framebuffer_fbo->gl_fbo.fbo_handle)
{
GE (ctx, glDeleteFramebuffers (1,
&gl_framebuffer_fbo->gl_fbo.fbo_handle));
gl_framebuffer_fbo->gl_fbo.fbo_handle = 0;
}
G_OBJECT_CLASS (cogl_gl_framebuffer_fbo_parent_class)->dispose (object);
}
static void
cogl_gl_framebuffer_fbo_init (CoglGlFramebufferFbo *gl_framebuffer_fbo)
{
gl_framebuffer_fbo->dirty_bitmasks = TRUE;
}
static void
cogl_gl_framebuffer_fbo_class_init (CoglGlFramebufferFboClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
CoglFramebufferDriverClass *driver_class =
COGL_FRAMEBUFFER_DRIVER_CLASS (klass);
CoglGlFramebufferClass *gl_framebuffer_class =
COGL_GL_FRAMEBUFFER_CLASS (klass);
object_class->dispose = cogl_gl_framebuffer_fbo_dispose;
driver_class->query_bits = cogl_gl_framebuffer_fbo_query_bits;
gl_framebuffer_class->bind = cogl_gl_framebuffer_fbo_bind;
}

View File

@ -0,0 +1,41 @@
/*
* Copyright (C) 2020 Red Hat
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#ifndef COGL_GL_FRAMEBUFFER_FBO_H
#define COGL_GL_FRAMEBUFFER_FBO_H
#include "driver/gl/cogl-framebuffer-gl-private.h"
#define COGL_TYPE_GL_FRAMEBUFFER_FBO (cogl_gl_framebuffer_fbo_get_type ())
G_DECLARE_FINAL_TYPE (CoglGlFramebufferFbo, cogl_gl_framebuffer_fbo,
COGL, GL_FRAMEBUFFER_FBO,
CoglGlFramebuffer)
CoglGlFramebufferFbo *
cogl_gl_framebuffer_fbo_new (CoglFramebuffer *framebuffer,
const CoglFramebufferDriverConfig *driver_config,
GError **error);
#endif /* COGL_GL_FRAMEBUFFER_FBO_H */

View File

@ -146,4 +146,87 @@ _cogl_gl_util_parse_gl_version (const char *version_string,
CoglGraphicsResetStatus CoglGraphicsResetStatus
_cogl_gl_get_graphics_reset_status (CoglContext *context); _cogl_gl_get_graphics_reset_status (CoglContext *context);
#ifndef GL_FRAMEBUFFER
#define GL_FRAMEBUFFER 0x8D40
#endif
#ifndef GL_RENDERBUFFER
#define GL_RENDERBUFFER 0x8D41
#endif
#ifndef GL_STENCIL_ATTACHMENT
#define GL_STENCIL_ATTACHMENT 0x8D00
#endif
#ifndef GL_COLOR_ATTACHMENT0
#define GL_COLOR_ATTACHMENT0 0x8CE0
#endif
#ifndef GL_FRAMEBUFFER_COMPLETE
#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
#endif
#ifndef GL_STENCIL_INDEX8
#define GL_STENCIL_INDEX8 0x8D48
#endif
#ifndef GL_DEPTH_STENCIL
#define GL_DEPTH_STENCIL 0x84F9
#endif
#ifndef GL_DEPTH24_STENCIL8
#define GL_DEPTH24_STENCIL8 0x88F0
#endif
#ifndef GL_DEPTH_ATTACHMENT
#define GL_DEPTH_ATTACHMENT 0x8D00
#endif
#ifndef GL_DEPTH_STENCIL_ATTACHMENT
#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
#endif
#ifndef GL_DEPTH_COMPONENT16
#define GL_DEPTH_COMPONENT16 0x81A5
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
#endif
#ifndef GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
#endif
#ifndef GL_READ_FRAMEBUFFER
#define GL_READ_FRAMEBUFFER 0x8CA8
#endif
#ifndef GL_DRAW_FRAMEBUFFER
#define GL_DRAW_FRAMEBUFFER 0x8CA9
#endif
#ifndef GL_TEXTURE_SAMPLES_IMG
#define GL_TEXTURE_SAMPLES_IMG 0x9136
#endif
#ifndef GL_PACK_INVERT_MESA
#define GL_PACK_INVERT_MESA 0x8758
#endif
#ifndef GL_PACK_REVERSE_ROW_ORDER_ANGLE
#define GL_PACK_REVERSE_ROW_ORDER_ANGLE 0x93A4
#endif
#ifndef GL_BACK_LEFT
#define GL_BACK_LEFT 0x0402
#endif
#ifndef GL_BACK_RIGHT
#define GL_BACK_RIGHT 0x0403
#endif
#ifndef GL_COLOR
#define GL_COLOR 0x1800
#endif
#ifndef GL_DEPTH
#define GL_DEPTH 0x1801
#endif
#ifndef GL_STENCIL
#define GL_STENCIL 0x1802
#endif
#endif /* _COGL_UTIL_GL_PRIVATE_H_ */ #endif /* _COGL_UTIL_GL_PRIVATE_H_ */

View File

@ -35,6 +35,8 @@
#include "cogl-types.h" #include "cogl-types.h"
#include "cogl-context-private.h" #include "cogl-context-private.h"
#include "driver/gl/cogl-framebuffer-gl-private.h" #include "driver/gl/cogl-framebuffer-gl-private.h"
#include "driver/gl/cogl-gl-framebuffer-fbo.h"
#include "driver/gl/cogl-gl-framebuffer-back.h"
#include "driver/gl/cogl-pipeline-opengl-private.h" #include "driver/gl/cogl-pipeline-opengl-private.h"
#include "driver/gl/cogl-util-gl-private.h" #include "driver/gl/cogl-util-gl-private.h"
@ -131,6 +133,46 @@ _cogl_driver_gl_context_deinit (CoglContext *context)
g_free (context->driver_context); g_free (context->driver_context);
} }
CoglFramebufferDriver *
_cogl_driver_gl_create_framebuffer_driver (CoglContext *context,
CoglFramebuffer *framebuffer,
const CoglFramebufferDriverConfig *driver_config,
GError **error)
{
g_return_val_if_fail (driver_config, NULL);
switch (driver_config->type)
{
case COGL_FRAMEBUFFER_DRIVER_TYPE_FBO:
{
CoglGlFramebufferFbo *gl_framebuffer_fbo;
gl_framebuffer_fbo = cogl_gl_framebuffer_fbo_new (framebuffer,
driver_config,
error);
if (!gl_framebuffer_fbo)
return NULL;
return COGL_FRAMEBUFFER_DRIVER (gl_framebuffer_fbo);
}
case COGL_FRAMEBUFFER_DRIVER_TYPE_BACK:
{
CoglGlFramebufferBack *gl_framebuffer_back;
gl_framebuffer_back = cogl_gl_framebuffer_back_new (framebuffer,
driver_config,
error);
if (!gl_framebuffer_back)
return NULL;
return COGL_FRAMEBUFFER_DRIVER (gl_framebuffer_back);
}
}
g_assert_not_reached ();
return NULL;
}
void void
_cogl_driver_gl_flush_framebuffer_state (CoglContext *ctx, _cogl_driver_gl_flush_framebuffer_state (CoglContext *ctx,
CoglFramebuffer *draw_buffer, CoglFramebuffer *draw_buffer,
@ -138,6 +180,7 @@ _cogl_driver_gl_flush_framebuffer_state (CoglContext *ctx,
CoglFramebufferState state) CoglFramebufferState state)
{ {
CoglGlFramebuffer *draw_gl_framebuffer; CoglGlFramebuffer *draw_gl_framebuffer;
CoglGlFramebuffer *read_gl_framebuffer;
unsigned long differences; unsigned long differences;
/* We can assume that any state that has changed for the current /* We can assume that any state that has changed for the current
@ -193,13 +236,20 @@ _cogl_driver_gl_flush_framebuffer_state (CoglContext *ctx,
if (G_UNLIKELY (!cogl_framebuffer_is_allocated (read_buffer))) if (G_UNLIKELY (!cogl_framebuffer_is_allocated (read_buffer)))
cogl_framebuffer_allocate (read_buffer, NULL); cogl_framebuffer_allocate (read_buffer, NULL);
draw_gl_framebuffer =
COGL_GL_FRAMEBUFFER (cogl_framebuffer_get_driver (draw_buffer));
read_gl_framebuffer =
COGL_GL_FRAMEBUFFER (cogl_framebuffer_get_driver (read_buffer));
/* We handle buffer binding separately since the method depends on whether /* We handle buffer binding separately since the method depends on whether
* we are binding the same buffer for read and write or not unlike all * we are binding the same buffer for read and write or not unlike all
* other state that only relates to the draw_buffer. */ * other state that only relates to the draw_buffer. */
if (differences & COGL_FRAMEBUFFER_STATE_BIND) if (differences & COGL_FRAMEBUFFER_STATE_BIND)
{ {
if (draw_buffer == read_buffer) if (draw_buffer == read_buffer)
_cogl_framebuffer_gl_bind (draw_buffer, GL_FRAMEBUFFER); {
cogl_gl_framebuffer_bind (draw_gl_framebuffer, GL_FRAMEBUFFER);
}
else else
{ {
/* NB: Currently we only take advantage of binding separate /* NB: Currently we only take advantage of binding separate
@ -207,15 +257,13 @@ _cogl_driver_gl_flush_framebuffer_state (CoglContext *ctx,
g_return_if_fail (cogl_has_feature g_return_if_fail (cogl_has_feature
(ctx, COGL_FEATURE_ID_BLIT_FRAMEBUFFER)); (ctx, COGL_FEATURE_ID_BLIT_FRAMEBUFFER));
_cogl_framebuffer_gl_bind (draw_buffer, GL_DRAW_FRAMEBUFFER); cogl_gl_framebuffer_bind (draw_gl_framebuffer, GL_DRAW_FRAMEBUFFER);
_cogl_framebuffer_gl_bind (read_buffer, GL_READ_FRAMEBUFFER); cogl_gl_framebuffer_bind (read_gl_framebuffer, GL_READ_FRAMEBUFFER);
} }
differences &= ~COGL_FRAMEBUFFER_STATE_BIND; differences &= ~COGL_FRAMEBUFFER_STATE_BIND;
} }
draw_gl_framebuffer =
COGL_GL_FRAMEBUFFER (cogl_framebuffer_get_driver (draw_buffer));
cogl_gl_framebuffer_flush_state_differences (draw_gl_framebuffer, cogl_gl_framebuffer_flush_state_differences (draw_gl_framebuffer,
differences); differences);

View File

@ -572,7 +572,6 @@ _cogl_driver_gl =
_cogl_driver_gl_create_framebuffer_driver, _cogl_driver_gl_create_framebuffer_driver,
_cogl_driver_gl_flush_framebuffer_state, _cogl_driver_gl_flush_framebuffer_state,
_cogl_framebuffer_gl_clear, _cogl_framebuffer_gl_clear,
_cogl_framebuffer_gl_query_bits,
_cogl_framebuffer_gl_finish, _cogl_framebuffer_gl_finish,
_cogl_framebuffer_gl_flush, _cogl_framebuffer_gl_flush,
_cogl_framebuffer_gl_discard_buffers, _cogl_framebuffer_gl_discard_buffers,

View File

@ -460,7 +460,6 @@ _cogl_driver_gles =
_cogl_driver_gl_create_framebuffer_driver, _cogl_driver_gl_create_framebuffer_driver,
_cogl_driver_gl_flush_framebuffer_state, _cogl_driver_gl_flush_framebuffer_state,
_cogl_framebuffer_gl_clear, _cogl_framebuffer_gl_clear,
_cogl_framebuffer_gl_query_bits,
_cogl_framebuffer_gl_finish, _cogl_framebuffer_gl_finish,
_cogl_framebuffer_gl_flush, _cogl_framebuffer_gl_flush,
_cogl_framebuffer_gl_discard_buffers, _cogl_framebuffer_gl_discard_buffers,

View File

@ -100,7 +100,6 @@ _cogl_driver_nop =
_cogl_driver_nop_create_framebuffer_driver, _cogl_driver_nop_create_framebuffer_driver,
_cogl_driver_nop_flush_framebuffer_state, _cogl_driver_nop_flush_framebuffer_state,
_cogl_framebuffer_nop_clear, _cogl_framebuffer_nop_clear,
_cogl_framebuffer_nop_query_bits,
_cogl_framebuffer_nop_finish, _cogl_framebuffer_nop_finish,
_cogl_framebuffer_nop_flush, _cogl_framebuffer_nop_flush,
_cogl_framebuffer_nop_discard_buffers, _cogl_framebuffer_nop_discard_buffers,

View File

@ -45,10 +45,6 @@ _cogl_framebuffer_nop_clear (CoglFramebuffer *framebuffer,
float blue, float blue,
float alpha); float alpha);
void
_cogl_framebuffer_nop_query_bits (CoglFramebuffer *framebuffer,
CoglFramebufferBits *bits);
void void
_cogl_framebuffer_nop_finish (CoglFramebuffer *framebuffer); _cogl_framebuffer_nop_finish (CoglFramebuffer *framebuffer);

View File

@ -45,13 +45,6 @@ _cogl_framebuffer_nop_clear (CoglFramebuffer *framebuffer,
{ {
} }
void
_cogl_framebuffer_nop_query_bits (CoglFramebuffer *framebuffer,
CoglFramebufferBits *bits)
{
memset (bits, 0, sizeof (CoglFramebufferBits));
}
void void
_cogl_framebuffer_nop_finish (CoglFramebuffer *framebuffer) _cogl_framebuffer_nop_finish (CoglFramebuffer *framebuffer)
{ {

View File

@ -27,6 +27,8 @@
#include "cogl-nop-framebuffer.h" #include "cogl-nop-framebuffer.h"
#include "cogl-framebuffer-private.h"
struct _CoglNopFramebuffer struct _CoglNopFramebuffer
{ {
CoglFramebufferDriver parent; CoglFramebufferDriver parent;
@ -35,6 +37,13 @@ struct _CoglNopFramebuffer
G_DEFINE_TYPE (CoglNopFramebuffer, cogl_nop_framebuffer, G_DEFINE_TYPE (CoglNopFramebuffer, cogl_nop_framebuffer,
COGL_TYPE_FRAMEBUFFER_DRIVER) COGL_TYPE_FRAMEBUFFER_DRIVER)
static void
cogl_nop_framebuffer_query_bits (CoglFramebufferDriver *driver,
CoglFramebufferBits *bits)
{
memset (bits, 0, sizeof (CoglFramebufferBits));
}
static void static void
cogl_nop_framebuffer_init (CoglNopFramebuffer *nop_framebuffer) cogl_nop_framebuffer_init (CoglNopFramebuffer *nop_framebuffer)
{ {
@ -43,4 +52,8 @@ cogl_nop_framebuffer_init (CoglNopFramebuffer *nop_framebuffer)
static void static void
cogl_nop_framebuffer_class_init (CoglNopFramebufferClass *klass) cogl_nop_framebuffer_class_init (CoglNopFramebufferClass *klass)
{ {
CoglFramebufferDriverClass *driver_class =
COGL_FRAMEBUFFER_DRIVER_CLASS (klass);
driver_class->query_bits = cogl_nop_framebuffer_query_bits;
} }

View File

@ -155,6 +155,10 @@ cogl_common_driver_sources = [
'driver/gl/cogl-util-gl.c', 'driver/gl/cogl-util-gl.c',
'driver/gl/cogl-framebuffer-gl-private.h', 'driver/gl/cogl-framebuffer-gl-private.h',
'driver/gl/cogl-framebuffer-gl.c', 'driver/gl/cogl-framebuffer-gl.c',
'driver/gl/cogl-gl-framebuffer-back.c',
'driver/gl/cogl-gl-framebuffer-back.h',
'driver/gl/cogl-gl-framebuffer-fbo.c',
'driver/gl/cogl-gl-framebuffer-fbo.h',
'driver/gl/cogl-texture-gl-private.h', 'driver/gl/cogl-texture-gl-private.h',
'driver/gl/cogl-texture-gl.c', 'driver/gl/cogl-texture-gl.c',
'driver/gl/cogl-texture-2d-gl-private.h', 'driver/gl/cogl-texture-2d-gl-private.h',

View File

@ -1131,8 +1131,14 @@ cogl_onscreen_glx_new (CoglContext *context,
int width, int width,
int height) int height)
{ {
CoglFramebufferDriverConfig driver_config;
driver_config = (CoglFramebufferDriverConfig) {
.type = COGL_FRAMEBUFFER_DRIVER_TYPE_BACK,
};
return g_object_new (COGL_TYPE_ONSCREEN_GLX, return g_object_new (COGL_TYPE_ONSCREEN_GLX,
"context", context, "context", context,
"driver-config", &driver_config,
"width", width, "width", width,
"height", height, "height", height,
NULL); NULL);

View File

@ -338,8 +338,14 @@ cogl_onscreen_xlib_new (CoglContext *context,
int width, int width,
int height) int height)
{ {
CoglFramebufferDriverConfig driver_config;
driver_config = (CoglFramebufferDriverConfig) {
.type = COGL_FRAMEBUFFER_DRIVER_TYPE_BACK,
};
return g_object_new (COGL_TYPE_ONSCREEN_XLIB, return g_object_new (COGL_TYPE_ONSCREEN_XLIB,
"context", context, "context", context,
"driver-config", &driver_config,
"width", width, "width", width,
"height", height, "height", height,
NULL); NULL);

View File

@ -1979,9 +1979,14 @@ meta_onscreen_native_new (MetaRendererNative *renderer_native,
int height) int height)
{ {
MetaOnscreenNative *onscreen_native; MetaOnscreenNative *onscreen_native;
CoglFramebufferDriverConfig driver_config;
driver_config = (CoglFramebufferDriverConfig) {
.type = COGL_FRAMEBUFFER_DRIVER_TYPE_BACK,
};
onscreen_native = g_object_new (META_TYPE_ONSCREEN_NATIVE, onscreen_native = g_object_new (META_TYPE_ONSCREEN_NATIVE,
"context", cogl_context, "context", cogl_context,
"driver-config", &driver_config,
"width", width, "width", width,
"height", height, "height", height,
NULL); NULL);