isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-25 12:32:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
a226b368f3
mutter/cogl/cogl-framebuffer-private.h

371 lines
12 KiB
C
Raw Normal View History

[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
/*
* 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
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
*/
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
#ifndef __COGL_FRAMEBUFFER_PRIVATE_H
#define __COGL_FRAMEBUFFER_PRIVATE_H
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
#include "cogl-object-private.h"
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
#include "cogl-matrix-stack.h"
cogl-clip-state: Adapt to experimental cogl2 API. The current clip state implementation couldn't be used in conjunction with the CoglPath experimental API. http://bugzilla.clutter-project.org/show_bug.cgi?id=2594 Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-03-02 17:45:25 +00:00
#include "cogl-clip-state-private.h"
journal: Support per-framebuffer journals Instead of having a single journal per context, we now have a CoglJournal object for each CoglFramebuffer. This means we now don't have to flush the journal when switching/pushing/popping between different framebuffers so for example a Clutter scene that involves some ClutterEffect actors that transiently redirect to an FBO can still be batched. This also allows us to track state in the journal that relates to the current frame of its associated framebuffer which we'll need for our optimization for using the CPU to handle reading a single pixel back from a framebuffer when we know the whole scene is currently comprised of simple rectangles in a journal.
2011-01-06 13:25:45 +00:00
#include "cogl-journal-private.h"
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 20:31:04 +00:00
#include "cogl-winsys-private.h"
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
#ifdef COGL_HAS_XLIB_SUPPORT
#include <X11/Xlib.h>
#endif
#ifdef COGL_HAS_GLX_SUPPORT
#include <GL/glx.h>
#include <GL/glxext.h>
#endif
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
typedef enum _CoglFramebufferType {
COGL_FRAMEBUFFER_TYPE_ONSCREEN,
COGL_FRAMEBUFFER_TYPE_OFFSCREEN
} CoglFramebufferType;
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
Rework how we search for winsys configs When creating new onscreen framebuffers we need to take the configuration in cogl terms and translate that into a configuration applicable to any given winsys, e.g. an EGLConfig or a GLXFBConfig or a PIXELFORMATDESCRIPTOR. Also when we first create a context we typically have to do a very similar thing because most OpenGL winsys APIs also associate a framebuffer config with the context and all future configs need to be compatible with that. This patch introduces an internal CoglFramebufferConfig to wrap up some of the configuration parameters that are common to CoglOnscreenTemplate and to CoglFramebuffer so we aim to re-use code when dealing with the above two problems. This patch also aims to rework the winsys code so it can be more naturally extended as we start adding more configureability to how onscreen framebuffers are created. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-22 22:55:57 +00:00
typedef struct
{
CoglSwapChain *swap_chain;
gboolean need_stencil;
onscreen: Support multisample based onscreen rendering This adds support for multisample based rendering of onscreen windows whereby multiple point samples per pixel can be requested and if the hardware supports that it results in reduced aliasing (especially considering the jagged edges of polygons) Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-21 20:27:13 +00:00
int samples_per_pixel;
template: Allow configuration of swap throttle This adds cogl_onscreen_template_set_swap_throttled() api that allows developers to specify their preference for swap buffer throttling up-front as part of the onscreen template that is used to create a CoglDisplay when initializing Cogl. This is desirable because some platforms may not support configuring swap throttling on a per framebuffer basis and also since applications often want to apply the same policy to all onscreen framebuffers anyway.
2012-01-16 11:26:45 +00:00
gboolean swap_throttled;
Rework how we search for winsys configs When creating new onscreen framebuffers we need to take the configuration in cogl terms and translate that into a configuration applicable to any given winsys, e.g. an EGLConfig or a GLXFBConfig or a PIXELFORMATDESCRIPTOR. Also when we first create a context we typically have to do a very similar thing because most OpenGL winsys APIs also associate a framebuffer config with the context and all future configs need to be compatible with that. This patch introduces an internal CoglFramebufferConfig to wrap up some of the configuration parameters that are common to CoglOnscreenTemplate and to CoglFramebuffer so we aim to re-use code when dealing with the above two problems. This patch also aims to rework the winsys code so it can be more naturally extended as we start adding more configureability to how onscreen framebuffers are created. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-22 22:55:57 +00:00
} CoglFramebufferConfig;
offscreen: Adds support for offscreen multisampling This adds support for multisample rendering to offscreen framebuffers. After an offscreen framebuffer is first instantiated using cogl_offscreen_new_to_texture() it is then possible to use cogl_framebuffer_set_samples_per_pixel() to request multisampling before the framebuffer is allocated. This also adds cogl_framebuffer_resolve_samples() for explicitly resolving point samples into pixels. Even though we currently only support the IMG_multisampled_render_to_texture extension which doesn't require an explicit resolve, the plan is to also support the EXT_framebuffer_multisample extension which uses the framebuffer_blit extension to issue an explicit resolve. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-23 12:55:12 +00:00
/* Flags to pass to _cogl_offscreen_new_to_texture_full */
typedef enum
{
COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL = 1
} CoglOffscreenFlags;
framebuffer: Optimize _cogl_framebuffer_flush_state() Previously the cost of _cogl_framebuffer_state_flush() would always scale by the total amount of state tracked by CoglFramebuffer even in cases where we knew up-front that we only wanted to flush a subset of the state or in cases where we requested to flush the same framebuffer multiple times with no changes being made to the framebuffer. We now track a set of state changed flags with each framebuffer and track the current read/draw buffers as part of the CoglContext so that we can quickly bail out when asked to flush the same framebuffer multiple times with no changes. _cogl_framebuffer_flush_state() now takes a mask of the state that we want to flush and the implementation has been redesigned so that the cost of checking what needs to be flushed and flushing those changes now scales by how much state we actually plan to update. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 15:53:40 +00:00
/* XXX: The order of these indices determines the order they are
* flushed.
*
* Flushing clip state may trash the modelview and projection matrices
* so we must do it before flushing the matrices.
*/
typedef enum _CoglFramebufferStateIndex
{
framebuffer: deal with winding state like other state We should not be deciding whether we need to really update the GL face winding state at the point where a new framebuffer has been pushed, we should be waiting until we have really been asked to flush some framebuffer state otherwise we may do redundant work if multiple framebuffers are pushed/popped before something is really drawn. This integrates the face winding state tracking with the design we have for handling most of the other framebuffer state so we benefit from the optimizations for minimizing the cost of _cogl_framebuffer_flush_state() Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 20:48:23 +00:00
COGL_FRAMEBUFFER_STATE_INDEX_BIND = 0,
COGL_FRAMEBUFFER_STATE_INDEX_VIEWPORT = 1,
COGL_FRAMEBUFFER_STATE_INDEX_CLIP = 2,
COGL_FRAMEBUFFER_STATE_INDEX_DITHER = 3,
COGL_FRAMEBUFFER_STATE_INDEX_MODELVIEW = 4,
COGL_FRAMEBUFFER_STATE_INDEX_PROJECTION = 5,
COGL_FRAMEBUFFER_STATE_INDEX_COLOR_MASK = 6,
COGL_FRAMEBUFFER_STATE_INDEX_FRONT_FACE_WINDING = 7,
COGL_FRAMEBUFFER_STATE_INDEX_MAX = 8
framebuffer: Optimize _cogl_framebuffer_flush_state() Previously the cost of _cogl_framebuffer_state_flush() would always scale by the total amount of state tracked by CoglFramebuffer even in cases where we knew up-front that we only wanted to flush a subset of the state or in cases where we requested to flush the same framebuffer multiple times with no changes being made to the framebuffer. We now track a set of state changed flags with each framebuffer and track the current read/draw buffers as part of the CoglContext so that we can quickly bail out when asked to flush the same framebuffer multiple times with no changes. _cogl_framebuffer_flush_state() now takes a mask of the state that we want to flush and the implementation has been redesigned so that the cost of checking what needs to be flushed and flushing those changes now scales by how much state we actually plan to update. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 15:53:40 +00:00
} CoglFramebufferStateIndex;
typedef enum _CoglFramebufferState
{
framebuffer: deal with winding state like other state We should not be deciding whether we need to really update the GL face winding state at the point where a new framebuffer has been pushed, we should be waiting until we have really been asked to flush some framebuffer state otherwise we may do redundant work if multiple framebuffers are pushed/popped before something is really drawn. This integrates the face winding state tracking with the design we have for handling most of the other framebuffer state so we benefit from the optimizations for minimizing the cost of _cogl_framebuffer_flush_state() Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 20:48:23 +00:00
COGL_FRAMEBUFFER_STATE_BIND = 1<<0,
COGL_FRAMEBUFFER_STATE_VIEWPORT = 1<<1,
COGL_FRAMEBUFFER_STATE_CLIP = 1<<2,
COGL_FRAMEBUFFER_STATE_DITHER = 1<<3,
COGL_FRAMEBUFFER_STATE_MODELVIEW = 1<<4,
COGL_FRAMEBUFFER_STATE_PROJECTION = 1<<5,
COGL_FRAMEBUFFER_STATE_COLOR_MASK = 1<<6,
COGL_FRAMEBUFFER_STATE_FRONT_FACE_WINDING = 1<<7
framebuffer: Optimize _cogl_framebuffer_flush_state() Previously the cost of _cogl_framebuffer_state_flush() would always scale by the total amount of state tracked by CoglFramebuffer even in cases where we knew up-front that we only wanted to flush a subset of the state or in cases where we requested to flush the same framebuffer multiple times with no changes being made to the framebuffer. We now track a set of state changed flags with each framebuffer and track the current read/draw buffers as part of the CoglContext so that we can quickly bail out when asked to flush the same framebuffer multiple times with no changes. _cogl_framebuffer_flush_state() now takes a mask of the state that we want to flush and the implementation has been redesigned so that the cost of checking what needs to be flushed and flushing those changes now scales by how much state we actually plan to update. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 15:53:40 +00:00
} CoglFramebufferState;
#define COGL_FRAMEBUFFER_STATE_ALL ((1<<COGL_FRAMEBUFFER_STATE_INDEX_MAX) - 1)
framebuffer: Replace CoglHandle with CoglFramebuffer * One more object converted to stop using CoglHandle re:a8c8cbee513
2010-07-07 13:41:54 +00:00
struct _CoglFramebuffer
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
{
framebuffer: Replace CoglHandle with CoglFramebuffer * One more object converted to stop using CoglHandle re:a8c8cbee513
2010-07-07 13:41:54 +00:00
CoglObject _parent;
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
CoglContext *context;
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
CoglFramebufferType type;
Rework how we search for winsys configs When creating new onscreen framebuffers we need to take the configuration in cogl terms and translate that into a configuration applicable to any given winsys, e.g. an EGLConfig or a GLXFBConfig or a PIXELFORMATDESCRIPTOR. Also when we first create a context we typically have to do a very similar thing because most OpenGL winsys APIs also associate a framebuffer config with the context and all future configs need to be compatible with that. This patch introduces an internal CoglFramebufferConfig to wrap up some of the configuration parameters that are common to CoglOnscreenTemplate and to CoglFramebuffer so we aim to re-use code when dealing with the above two problems. This patch also aims to rework the winsys code so it can be more naturally extended as we start adding more configureability to how onscreen framebuffers are created. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-22 22:55:57 +00:00
/* The user configuration before allocation... */
CoglFramebufferConfig config;
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
int width;
int height;
cogl-framebuffer: Try to track format of the framebuffer Previously in cogl_read_pixels we assume the format of the framebuffer is always premultiplied because that is the most likely format with the default Cogl blend mode. However when the framebuffer is bound to a texture we should be able to make a better guess at the format because we know the texture keeps track of the premult status. This patch adds an internal format member to CoglFramebuffer. For onscreen framebuffers we still assume it is RGBA_8888_PRE but for offscreen to textures we copy the texture format. cogl_read_pixels uses this to determine whether the data returned by glReadPixels will be premultiplied. http://bugzilla.clutter-project.org/show_bug.cgi?id=2414
2010-11-17 17:57:17 +00:00
/* Format of the pixels in the framebuffer (including the expected
premult state) */
CoglPixelFormat format;
Moves all GLX code down from Clutter to Cogl This migrates all the GLX window system code down from the Clutter backend code into a Cogl winsys. Moving OpenGL window system binding code down from Clutter into Cogl is the biggest blocker to having Cogl become a standalone 3D graphics library, so this is an important step in that direction.
2010-11-05 12:28:33 +00:00
gboolean allocated;
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
CoglMatrixStack *modelview_stack;
CoglMatrixStack *projection_stack;
viewport: consistently use floats for viewports OpenGL < 4.0 only supports integer based viewports and internally we have a mixture of code using floats and integers for viewports. This patch switches all viewports throughout clutter and cogl to be represented using floats considering that in the future we may want to take advantage of floating point viewports with modern hardware/drivers.
2011-02-01 16:51:58 +00:00
float viewport_x;
float viewport_y;
float viewport_width;
float viewport_height;
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
Separate out CoglClipStackState from cogl-clip-stack.c CoglClipStackState has now been renamed to CoglClipState and is moved to a separate file. CoglClipStack now just maintains a stack and doesn't worry about the rest of the state. CoglClipStack sill contains the code to flush the stack to GL.
2010-04-14 18:41:08 +00:00
CoglClipState clip_state;
Implement accessors for the color bits in a framebuffer Instead of using cogl_get_bitmasks() to query the GL machinery for the size of the color bits, we should store the values inside the CoglFramebuffer object and query them the first time we set the framebuffer as the current one. Currently, cogl_get_bitmasks() is re-implemented in terms of cogl_framebuffer_get_*_bits(). As soon as we are able to expose the CoglOnscreen framebuffer object in the public API we'll be able to deprecate cogl_get_bitmasks() altogether. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-04-26 17:08:45 +00:00
gboolean dirty_bitmasks;
int red_bits;
int blue_bits;
int green_bits;
int alpha_bits;
journal: Support per-framebuffer journals Instead of having a single journal per context, we now have a CoglJournal object for each CoglFramebuffer. This means we now don't have to flush the journal when switching/pushing/popping between different framebuffers so for example a Clutter scene that involves some ClutterEffect actors that transiently redirect to an FBO can still be batched. This also allows us to track state in the journal that relates to the current frame of its associated framebuffer which we'll need for our optimization for using the CPU to handle reading a single pixel back from a framebuffer when we know the whole scene is currently comprised of simple rectangles in a journal.
2011-01-06 13:25:45 +00:00
framebuffer: Add dither_enabled getter/setters This adds a getter and setter for requesting dithering to be enabled. Dithering is a hardware dependent technique to increase the visible color resolution beyond what the underlying hardware supports by playing tricks with the colors placed into the framebuffer to give the illusion of other colors. (For example this can be compared to half-toning used by some news papers to show varying levels of grey even though their may only be black and white are available). The results of enabling dithering are platform dependent and may have no effect. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-13 15:33:25 +00:00
gboolean dither_enabled;
Adds ColorMask support to Cogl This adds CoglPipeline and CoglFramebuffer support for setting a color mask which is a bit mask defining which color channels should be written to the current framebuffer. The final color mask is the intersection of the framebuffer color mask and the pipeline color mask. The framebuffer mask affects all rendering to the framebuffer while the pipeline masks can be used to affect individual primitives. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-07-11 01:27:54 +00:00
CoglColorMask color_mask;
framebuffer: Add dither_enabled getter/setters This adds a getter and setter for requesting dithering to be enabled. Dithering is a hardware dependent technique to increase the visible color resolution beyond what the underlying hardware supports by playing tricks with the colors placed into the framebuffer to give the illusion of other colors. (For example this can be compared to half-toning used by some news papers to show varying levels of grey even though their may only be black and white are available). The results of enabling dithering are platform dependent and may have no effect. Signed-off-by: Neil Roberts <neil@linux.intel.com>
2011-07-13 15:33:25 +00:00
framebuffer: adds cogl_framebuffer_get_samples_per_pixel It's useful to be able to query back the number of point_samples_per_pixel that may have previously be chosen using cogl_framebuffer_set_samples_per_pixel(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 14:47:42 +00:00
int samples_per_pixel;
journal: Support per-framebuffer journals Instead of having a single journal per context, we now have a CoglJournal object for each CoglFramebuffer. This means we now don't have to flush the journal when switching/pushing/popping between different framebuffers so for example a Clutter scene that involves some ClutterEffect actors that transiently redirect to an FBO can still be batched. This also allows us to track state in the journal that relates to the current frame of its associated framebuffer which we'll need for our optimization for using the CPU to handle reading a single pixel back from a framebuffer when we know the whole scene is currently comprised of simple rectangles in a journal.
2011-01-06 13:25:45 +00:00
/* We journal the textured rectangles we want to submit to OpenGL so
* we have an oppertunity to batch them together into less draw
* calls. */
CoglJournal *journal;
/* The scene of a given framebuffer may depend on images in other
* framebuffers... */
GList *deps;
cogl: Implements a software only read-pixel fast-path This adds a transparent optimization to cogl_read_pixels for when a single pixel is being read back and it happens that all the geometry of the current frame is still available in the framebuffer's associated journal. The intention is to indirectly optimize Clutter's render based picking mechanism in such a way that the 99% of cases where scenes are comprised of trivial quad primitives that can easily be intersected we can avoid the latency of kicking a GPU render and blocking for the result when we know we can calculate the result manually on the CPU probably faster than we could even kick a render. A nice property of this solution is that it maintains all the flexibility of the render based picking provided by Clutter and it can gracefully fall back to GPU rendering if actors are drawn using anything more complex than a quad for their geometry. It seems worth noting that there is a limitation to the extensibility of this approach in that it can only optimize picking a against geometry that passes through Cogl's journal which isn't something Clutter directly controls. For now though this really doesn't matter since basically all apps should end up hitting this fast-path. The current idea to address this longer term would be a pick2 vfunc for ClutterActor that can support geometry and render based input regions of actors and move this optimization up into Clutter instead. Note: currently we don't have a primitive count threshold to consider that there could be scenes with enough geometry for us to compensate for the cost of kicking a render and determine a result more efficiently by utilizing the GPU. We don't currently expect this to be common though. Note: in the future it could still be interesting to revive something like the wip/async-pbo-picking branch to provide an asynchronous read-pixels based optimization for Clutter picking in cases where more complex input regions that necessitate rendering are in use or if we do add a threshold for rendering as mentioned above.
2011-01-12 22:12:41 +00:00
/* As part of an optimization for reading-back single pixels from a
* framebuffer in some simple cases where the geometry is still
* available in the journal we need to track the bounds of the last
* region cleared, its color and we need to track when something
* does in fact draw to that region so it is no longer clear.
*/
float clear_color_red;
float clear_color_green;
float clear_color_blue;
float clear_color_alpha;
int clear_clip_x0;
int clear_clip_y0;
int clear_clip_x1;
int clear_clip_y1;
gboolean clear_clip_dirty;
framebuffer: Replace CoglHandle with CoglFramebuffer * One more object converted to stop using CoglHandle re:a8c8cbee513
2010-07-07 13:41:54 +00:00
};
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
typedef struct _CoglOffscreen
{
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
CoglFramebuffer _parent;
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
GLuint fbo_handle;
cogl: Support multiple fallbacks in cogl_offscreen_new_to_texture() The Intel drivers in Mesa 7.6 (and possibly earlier versions) don't support creating FBOs with a stencil buffer but without a depth buffer. This reworks framebuffer allocation so that we try a number of fallback options before failing. The options we try in order are: - the same options that were sucessful last time if available - combined depth and stencil - separate depth and stencil - just stencil, no depth - just depth, no stencil - neither depth or stencil
2009-11-30 20:04:41 +00:00
GSList *renderbuffers;
Rework how we search for winsys configs When creating new onscreen framebuffers we need to take the configuration in cogl terms and translate that into a configuration applicable to any given winsys, e.g. an EGLConfig or a GLXFBConfig or a PIXELFORMATDESCRIPTOR. Also when we first create a context we typically have to do a very similar thing because most OpenGL winsys APIs also associate a framebuffer config with the context and all future configs need to be compatible with that. This patch introduces an internal CoglFramebufferConfig to wrap up some of the configuration parameters that are common to CoglOnscreenTemplate and to CoglFramebuffer so we aim to re-use code when dealing with the above two problems. This patch also aims to rework the winsys code so it can be more naturally extended as we start adding more configureability to how onscreen framebuffers are created. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-22 22:55:57 +00:00
CoglTexture *texture;
offscreen: Adds support for offscreen multisampling This adds support for multisample rendering to offscreen framebuffers. After an offscreen framebuffer is first instantiated using cogl_offscreen_new_to_texture() it is then possible to use cogl_framebuffer_set_samples_per_pixel() to request multisampling before the framebuffer is allocated. This also adds cogl_framebuffer_resolve_samples() for explicitly resolving point samples into pixels. Even though we currently only support the IMG_multisampled_render_to_texture extension which doesn't require an explicit resolve, the plan is to also support the EXT_framebuffer_multisample extension which uses the framebuffer_blit extension to issue an explicit resolve. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-23 12:55:12 +00:00
int texture_level;
int texture_level_width;
int texture_level_height;
/* FIXME: _cogl_offscreen_new_to_texture_full should be made to use
* fb->config to configure if we want a depth or stencil buffer so
* we can get rid of these flags */
CoglOffscreenFlags create_flags;
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
} CoglOffscreen;
#define COGL_OFFSCREEN(X) ((CoglOffscreen *)(X))
void
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 20:31:04 +00:00
_cogl_framebuffer_init (CoglFramebuffer *framebuffer,
CoglContext *ctx,
CoglFramebufferType type,
CoglPixelFormat format,
int width,
int height);
Implement accessors for the color bits in a framebuffer Instead of using cogl_get_bitmasks() to query the GL machinery for the size of the color bits, we should store the values inside the CoglFramebuffer object and query them the first time we set the framebuffer as the current one. Currently, cogl_get_bitmasks() is re-implemented in terms of cogl_framebuffer_get_*_bits(). As soon as we are able to expose the CoglOnscreen framebuffer object in the public API we'll be able to deprecate cogl_get_bitmasks() altogether. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-04-26 17:08:45 +00:00
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 20:31:04 +00:00
void _cogl_framebuffer_free (CoglFramebuffer *framebuffer);
const CoglWinsysVtable *
_cogl_framebuffer_get_winsys (CoglFramebuffer *framebuffer);
Add temporary cogl-clutter.h to aid splitting out Cogl This gives us a way to clearly track the internal Cogl API that Clutter depends on. The aim is to split Cogl out from Clutter into a standalone 3D graphics API and eventually we want to get rid of any private interfaces for Clutter so its useful to have a handle on that task. Actually it's not as bad as I was expecting though.
2011-02-22 18:25:29 +00:00
framebuffer: Move clear code to cogl-framebuffer.c This moves the implementation of cogl_clear into cogl-framebuffer.c as two new internal functions _cogl_framebuffer_clear and _cogl_framebuffer_clear4f. It's not clear if this is what the API will look like as we make more of the CoglFramebuffer API public due to the limitations of using flags to identify buffers when framebuffers may contain any number of ancillary buffers but conceptually it makes some sense to tie the operation of clearing a color buffer to a framebuffer. The short term intention is to enable tracking the current clear color as a property of the framebuffer as part of an optimization for reading back single pixels when the geometry is simple enough that we can compute the result quickly on the CPU. (If the point doesn't intersect any geometry we'll need to return the last clear color.)
2011-01-05 15:30:04 +00:00
void
framebuffer: don't reference default fb in _clear apis Some of the functions we were calling in cogl_framebuffer_clear[4f] were referring to the current framebuffer, which would result in a crash if nothing had been pushed before trying to explicitly clear a given framebuffer. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-03 16:06:10 +00:00
_cogl_framebuffer_clear_without_flush4f (CoglFramebuffer *framebuffer,
unsigned long buffers,
float red,
float green,
float blue,
float alpha);
framebuffer: Move clear code to cogl-framebuffer.c This moves the implementation of cogl_clear into cogl-framebuffer.c as two new internal functions _cogl_framebuffer_clear and _cogl_framebuffer_clear4f. It's not clear if this is what the API will look like as we make more of the CoglFramebuffer API public due to the limitations of using flags to identify buffers when framebuffers may contain any number of ancillary buffers but conceptually it makes some sense to tie the operation of clearing a color buffer to a framebuffer. The short term intention is to enable tracking the current clear color as a property of the framebuffer as part of an optimization for reading back single pixels when the geometry is simple enough that we can compute the result quickly on the CPU. (If the point doesn't intersect any geometry we'll need to return the last clear color.)
2011-01-05 15:30:04 +00:00
cogl: Implements a software only read-pixel fast-path This adds a transparent optimization to cogl_read_pixels for when a single pixel is being read back and it happens that all the geometry of the current frame is still available in the framebuffer's associated journal. The intention is to indirectly optimize Clutter's render based picking mechanism in such a way that the 99% of cases where scenes are comprised of trivial quad primitives that can easily be intersected we can avoid the latency of kicking a GPU render and blocking for the result when we know we can calculate the result manually on the CPU probably faster than we could even kick a render. A nice property of this solution is that it maintains all the flexibility of the render based picking provided by Clutter and it can gracefully fall back to GPU rendering if actors are drawn using anything more complex than a quad for their geometry. It seems worth noting that there is a limitation to the extensibility of this approach in that it can only optimize picking a against geometry that passes through Cogl's journal which isn't something Clutter directly controls. For now though this really doesn't matter since basically all apps should end up hitting this fast-path. The current idea to address this longer term would be a pick2 vfunc for ClutterActor that can support geometry and render based input regions of actors and move this optimization up into Clutter instead. Note: currently we don't have a primitive count threshold to consider that there could be scenes with enough geometry for us to compensate for the cost of kicking a render and determine a result more efficiently by utilizing the GPU. We don't currently expect this to be common though. Note: in the future it could still be interesting to revive something like the wip/async-pbo-picking branch to provide an asynchronous read-pixels based optimization for Clutter picking in cases where more complex input regions that necessitate rendering are in use or if we do add a threshold for rendering as mentioned above.
2011-01-12 22:12:41 +00:00
void
_cogl_framebuffer_dirty (CoglFramebuffer *framebuffer);
Separate out CoglClipStackState from cogl-clip-stack.c CoglClipStackState has now been renamed to CoglClipState and is moved to a separate file. CoglClipStack now just maintains a stack and doesn't worry about the rest of the state. CoglClipStack sill contains the code to flush the stack to GL.
2010-04-14 18:41:08 +00:00
CoglClipState *
framebuffer: Replace CoglHandle with CoglFramebuffer * One more object converted to stop using CoglHandle re:a8c8cbee513
2010-07-07 13:41:54 +00:00
_cogl_framebuffer_get_clip_state (CoglFramebuffer *framebuffer);
Implement accessors for the color bits in a framebuffer Instead of using cogl_get_bitmasks() to query the GL machinery for the size of the color bits, we should store the values inside the CoglFramebuffer object and query them the first time we set the framebuffer as the current one. Currently, cogl_get_bitmasks() is re-implemented in terms of cogl_framebuffer_get_*_bits(). As soon as we are able to expose the CoglOnscreen framebuffer object in the public API we'll be able to deprecate cogl_get_bitmasks() altogether. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-04-26 17:08:45 +00:00
clip: rename get_clip_stack + add framebuffer_get_stack Instead of having _cogl_get/set_clip stack which reference the global CoglContext this instead makes those into CoglClipState method functions named _cogl_clip_state_get/set_stack that take an explicit pointer to a CoglClipState. This also adds _cogl_framebuffer_get/set_clip_stack convenience functions that avoid having to first get the ClipState from a framebuffer then the stack from that - so we can maintain the convenience of _cogl_get_clip_stack.
2011-01-12 19:30:30 +00:00
/*
* _cogl_framebuffer_get_clip_stack:
* @framebuffer: A #CoglFramebuffer
*
* Gets a pointer to the current clip stack. This can be used to later
* return to the same clip stack state with
* _cogl_framebuffer_set_clip_stack(). A reference is not taken on the
* stack so if you want to keep it you should call
* _cogl_clip_stack_ref().
*
* Return value: a pointer to the @framebuffer clip stack.
*/
CoglClipStack *
_cogl_framebuffer_get_clip_stack (CoglFramebuffer *framebuffer);
/*
* _cogl_framebuffer_set_clip_stack:
* @framebuffer: A #CoglFramebuffer
* @stack: a pointer to the replacement clip stack
*
* Replaces the @framebuffer clip stack with @stack.
*/
void
_cogl_framebuffer_set_clip_stack (CoglFramebuffer *framebuffer,
CoglClipStack *stack);
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
CoglMatrixStack *
framebuffer: Replace CoglHandle with CoglFramebuffer * One more object converted to stop using CoglHandle re:a8c8cbee513
2010-07-07 13:41:54 +00:00
_cogl_framebuffer_get_modelview_stack (CoglFramebuffer *framebuffer);
Implement accessors for the color bits in a framebuffer Instead of using cogl_get_bitmasks() to query the GL machinery for the size of the color bits, we should store the values inside the CoglFramebuffer object and query them the first time we set the framebuffer as the current one. Currently, cogl_get_bitmasks() is re-implemented in terms of cogl_framebuffer_get_*_bits(). As soon as we are able to expose the CoglOnscreen framebuffer object in the public API we'll be able to deprecate cogl_get_bitmasks() altogether. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-04-26 17:08:45 +00:00
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
CoglMatrixStack *
framebuffer: Replace CoglHandle with CoglFramebuffer * One more object converted to stop using CoglHandle re:a8c8cbee513
2010-07-07 13:41:54 +00:00
_cogl_framebuffer_get_projection_stack (CoglFramebuffer *framebuffer);
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
journal: Support per-framebuffer journals Instead of having a single journal per context, we now have a CoglJournal object for each CoglFramebuffer. This means we now don't have to flush the journal when switching/pushing/popping between different framebuffers so for example a Clutter scene that involves some ClutterEffect actors that transiently redirect to an FBO can still be batched. This also allows us to track state in the journal that relates to the current frame of its associated framebuffer which we'll need for our optimization for using the CPU to handle reading a single pixel back from a framebuffer when we know the whole scene is currently comprised of simple rectangles in a journal.
2011-01-06 13:25:45 +00:00
void
_cogl_framebuffer_add_dependency (CoglFramebuffer *framebuffer,
CoglFramebuffer *dependency);
void
_cogl_framebuffer_remove_all_dependencies (CoglFramebuffer *framebuffer);
void
_cogl_framebuffer_flush_journal (CoglFramebuffer *framebuffer);
void
_cogl_framebuffer_flush_dependency_journals (CoglFramebuffer *framebuffer);
cogl: Implements a software only read-pixel fast-path This adds a transparent optimization to cogl_read_pixels for when a single pixel is being read back and it happens that all the geometry of the current frame is still available in the framebuffer's associated journal. The intention is to indirectly optimize Clutter's render based picking mechanism in such a way that the 99% of cases where scenes are comprised of trivial quad primitives that can easily be intersected we can avoid the latency of kicking a GPU render and blocking for the result when we know we can calculate the result manually on the CPU probably faster than we could even kick a render. A nice property of this solution is that it maintains all the flexibility of the render based picking provided by Clutter and it can gracefully fall back to GPU rendering if actors are drawn using anything more complex than a quad for their geometry. It seems worth noting that there is a limitation to the extensibility of this approach in that it can only optimize picking a against geometry that passes through Cogl's journal which isn't something Clutter directly controls. For now though this really doesn't matter since basically all apps should end up hitting this fast-path. The current idea to address this longer term would be a pick2 vfunc for ClutterActor that can support geometry and render based input regions of actors and move this optimization up into Clutter instead. Note: currently we don't have a primitive count threshold to consider that there could be scenes with enough geometry for us to compensate for the cost of kicking a render and determine a result more efficiently by utilizing the GPU. We don't currently expect this to be common though. Note: in the future it could still be interesting to revive something like the wip/async-pbo-picking branch to provide an asynchronous read-pixels based optimization for Clutter picking in cases where more complex input regions that necessitate rendering are in use or if we do add a threshold for rendering as mentioned above.
2011-01-12 22:12:41 +00:00
gboolean
_cogl_framebuffer_try_fast_read_pixel (CoglFramebuffer *framebuffer,
int x,
int y,
CoglReadPixelsFlags source,
CoglPixelFormat format,
guint8 *pixel);
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
void
cogl-framebuffer: Separate the draw and read buffer The current framebuffer is now internally separated so that there can be a different draw and read buffer. This is required to use the GL_EXT_framebuffer_blit extension. The current draw and read buffers are stored as a pair in a single stack so that pushing the draw and read buffer is done simultaneously with the new _cogl_push_framebuffers internal function. Calling cogl_pop_framebuffer will restore both the draw and read buffer to the previous state. The public cogl_push_framebuffer function is layered on top of the new function so that it just pushes the same buffer for both drawing and reading. When flushing the framebuffer state, the cogl_framebuffer_flush_state function now tackes a pointer to both the draw and the read buffer. Anywhere that was just flushing the state for the current framebuffer with _cogl_get_framebuffer now needs to call both _cogl_get_draw_buffer and _cogl_get_read_buffer.
2011-02-02 14:23:53 +00:00
_cogl_framebuffer_flush_state (CoglFramebuffer *draw_buffer,
CoglFramebuffer *read_buffer,
framebuffer: Optimize _cogl_framebuffer_flush_state() Previously the cost of _cogl_framebuffer_state_flush() would always scale by the total amount of state tracked by CoglFramebuffer even in cases where we knew up-front that we only wanted to flush a subset of the state or in cases where we requested to flush the same framebuffer multiple times with no changes being made to the framebuffer. We now track a set of state changed flags with each framebuffer and track the current read/draw buffers as part of the CoglContext so that we can quickly bail out when asked to flush the same framebuffer multiple times with no changes. _cogl_framebuffer_flush_state() now takes a mask of the state that we want to flush and the implementation has been redesigned so that the cost of checking what needs to be flushed and flushing those changes now scales by how much state we actually plan to update. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-21 15:53:40 +00:00
CoglFramebufferState state);
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
framebuffer: Replace CoglHandle with CoglFramebuffer * One more object converted to stop using CoglHandle re:a8c8cbee513
2010-07-07 13:41:54 +00:00
CoglFramebuffer *
framebuffer: expose experimental cogl_get_draw_framebuffer This renames the two internal functions _cogl_get_draw/read_buffer as cogl_get_draw_framebuffer and _cogl_get_read_framebuffer. The former is now also exposed as experimental API.
2011-03-10 21:33:31 +00:00
_cogl_get_read_framebuffer (void);
Implement accessors for the color bits in a framebuffer Instead of using cogl_get_bitmasks() to query the GL machinery for the size of the color bits, we should store the values inside the CoglFramebuffer object and query them the first time we set the framebuffer as the current one. Currently, cogl_get_bitmasks() is re-implemented in terms of cogl_framebuffer_get_*_bits(). As soon as we are able to expose the CoglOnscreen framebuffer object in the public API we'll be able to deprecate cogl_get_bitmasks() altogether. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-04-26 17:08:45 +00:00
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
GSList *
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
_cogl_create_framebuffer_stack (void);
Implement accessors for the color bits in a framebuffer Instead of using cogl_get_bitmasks() to query the GL machinery for the size of the color bits, we should store the values inside the CoglFramebuffer object and query them the first time we set the framebuffer as the current one. Currently, cogl_get_bitmasks() is re-implemented in terms of cogl_framebuffer_get_*_bits(). As soon as we are able to expose the CoglOnscreen framebuffer object in the public API we'll be able to deprecate cogl_get_bitmasks() altogether. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
2010-04-26 17:08:45 +00:00
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
void
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
_cogl_free_framebuffer_stack (GSList *stack);
[draw-buffers] First pass at overhauling Cogl's framebuffer management Cogl's support for offscreen rendering was originally written just to support the clutter_texture_new_from_actor API and due to lack of documentation and several confusing - non orthogonal - side effects of using the API it wasn't really possible to use directly. This commit does a number of things: - It removes {gl,gles}/cogl-fbo.{c,h} and adds shared cogl-draw-buffer.{c,h} files instead which should be easier to maintain. - internally CoglFbo objects are now called CoglDrawBuffers. A CoglDrawBuffer is an abstract base class that is inherited from to implement CoglOnscreen and CoglOffscreen draw buffers. CoglOffscreen draw buffers will initially be used to support the cogl_offscreen_new_to_texture API, and CoglOnscreen draw buffers will start to be used internally to represent windows as we aim to migrate some of Clutter's backend code to Cogl. - It makes draw buffer objects the owners of the following state: - viewport - projection matrix stack - modelview matrix stack - clip state (This means when you switch between draw buffers you will automatically be switching to their associated viewport, matrix and clip state) Aside from hopefully making cogl_offscreen_new_to_texture be more useful short term by having simpler and well defined semantics for cogl_set_draw_buffer, as mentioned above this is the first step for a couple of other things: - Its a step toward moving ownership for windows down from Clutter backends into Cogl, by (internally at least) introducing the CoglOnscreen draw buffer. Note: the plan is that cogl_set_draw_buffer will accept on or offscreen draw buffer handles, and the "target" argument will become redundant since we will instead query the type of the given draw buffer handle. - Because we have a common type for on and offscreen framebuffers we can provide a unified API for framebuffer management. Things like: - blitting between buffers - managing ancillary buffers (e.g. attaching depth and stencil buffers) - size requisition - clearing
2009-09-25 13:34:34 +00:00
Add an internal _cogl_offscreen_new_to_texture_full function This function is the same as cogl_offscreen_new_to_texture but it takes a level parameter and a set of flags so that FBOs can be used to render to higher mipmap levels and to disable the depth and stencil buffers. cogl_offscreen_new_to_texture now just calls the new function with the level set to zero. This function could be useful in a few places in Cogl where we want to use FBOs as an implementation detail such as when copying between textures. http://bugzilla.clutter-project.org/show_bug.cgi?id=2414
2010-11-11 15:28:44 +00:00
/*
* _cogl_offscreen_new_to_texture_full:
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
* @texture: A #CoglTexture pointer
Add an internal _cogl_offscreen_new_to_texture_full function This function is the same as cogl_offscreen_new_to_texture but it takes a level parameter and a set of flags so that FBOs can be used to render to higher mipmap levels and to disable the depth and stencil buffers. cogl_offscreen_new_to_texture now just calls the new function with the level set to zero. This function could be useful in a few places in Cogl where we want to use FBOs as an implementation detail such as when copying between textures. http://bugzilla.clutter-project.org/show_bug.cgi?id=2414
2010-11-11 15:28:44 +00:00
* @create_flags: Flags specifying how to create the FBO
* @level: The mipmap level within the texture to target
*
* Creates a new offscreen buffer which will target the given
* texture. By default the buffer will have a depth and stencil
* buffer. This can be disabled by passing
* %COGL_OFFSCREEN_DISABLE_DEPTH_AND_STENCIL in @create_flags.
*
* Return value: the new CoglOffscreen object.
*/
CoglHandle
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
_cogl_offscreen_new_to_texture_full (CoglTexture *texture,
Add an internal _cogl_offscreen_new_to_texture_full function This function is the same as cogl_offscreen_new_to_texture but it takes a level parameter and a set of flags so that FBOs can be used to render to higher mipmap levels and to disable the depth and stencil buffers. cogl_offscreen_new_to_texture now just calls the new function with the level set to zero. This function could be useful in a few places in Cogl where we want to use FBOs as an implementation detail such as when copying between textures. http://bugzilla.clutter-project.org/show_bug.cgi?id=2414
2010-11-11 15:28:44 +00:00
CoglOffscreenFlags create_flags,
unsigned int level);
cogl-framebuffer: Separate the draw and read buffer The current framebuffer is now internally separated so that there can be a different draw and read buffer. This is required to use the GL_EXT_framebuffer_blit extension. The current draw and read buffers are stored as a pair in a single stack so that pushing the draw and read buffer is done simultaneously with the new _cogl_push_framebuffers internal function. Calling cogl_pop_framebuffer will restore both the draw and read buffer to the previous state. The public cogl_push_framebuffer function is layered on top of the new function so that it just pushes the same buffer for both drawing and reading. When flushing the framebuffer state, the cogl_framebuffer_flush_state function now tackes a pointer to both the draw and the read buffer. Anywhere that was just flushing the state for the current framebuffer with _cogl_get_framebuffer now needs to call both _cogl_get_draw_buffer and _cogl_get_read_buffer.
2011-02-02 14:23:53 +00:00
/*
* _cogl_push_framebuffers:
* @draw_buffer: A pointer to the buffer used for drawing
* @read_buffer: A pointer to the buffer used for reading back pixels
*
* Redirects drawing and reading to the specified framebuffers as in
* cogl_push_framebuffer() except that it allows the draw and read
* buffer to be different. The buffers are pushed as a pair so that
* they can later both be restored with a single call to
* cogl_pop_framebuffer().
*/
void
_cogl_push_framebuffers (CoglFramebuffer *draw_buffer,
CoglFramebuffer *read_buffer);
cogl-framebuffer: Add _cogl_blit_framebuffer This adds the _cogl_blit_framebuffer internal function which is a wrapper around glBlitFramebuffer. The API is changed from the GL version of the function to reflect the limitations provided by the GL_ANGLE_framebuffer_blit extension (eg, no scaling or mirroring).
2011-02-05 11:19:52 +00:00
/*
* _cogl_blit_framebuffer:
* @src_x: Source x position
* @src_y: Source y position
* @dst_x: Destination x position
* @dst_y: Destination y position
* @width: Width of region to copy
* @height: Height of region to copy
*
* This blits a region of the color buffer of the current draw buffer
* to the current read buffer. The draw and read buffers can be set up
* using _cogl_push_framebuffers(). This function should only be
make COGL_FEATURE_OFFSCREEN_BLIT a private feature Cogl doesn't expose public api for blitting between framebuffers so it doesn't make much sense to have this feature as part of the public api currently. We can't break the api by removing the enum but at least we no longer ever set the feature flag. We now have a replacement private feature flag COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT which cogl now checks for internally. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 21:47:42 +00:00
* called if the COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT feature is
cogl-framebuffer: Add _cogl_blit_framebuffer This adds the _cogl_blit_framebuffer internal function which is a wrapper around glBlitFramebuffer. The API is changed from the GL version of the function to reflect the limitations provided by the GL_ANGLE_framebuffer_blit extension (eg, no scaling or mirroring).
2011-02-05 11:19:52 +00:00
* advertised. The two buffers must both be offscreen and have the
* same format.
*
* Note that this function differs a lot from the glBlitFramebuffer
* function provided by the GL_EXT_framebuffer_blit extension. Notably
* it doesn't support having different sizes for the source and
* destination rectangle. This isn't supported by the corresponding
* GL_ANGLE_framebuffer_blit extension on GLES2.0 and it doesn't seem
* like a particularly useful feature. If the application wanted to
* scale the results it may make more sense to draw a primitive
* instead.
*
* We can only really support blitting between two offscreen buffers
* for this function on GLES2.0. This is because we effectively render
* upside down to offscreen buffers to maintain Cogl's representation
* of the texture coordinate system where 0,0 is the top left of the
* texture. If we were to blit from an offscreen to an onscreen buffer
* then we would need to mirror the blit along the x-axis but the GLES
* extension does not support this.
*
* The GL function is documented to be affected by the scissor. This
* function therefore ensure that an empty clip stack is flushed
* before performing the blit which means the scissor is effectively
* ignored.
*
* The function also doesn't support specifying the buffers to copy
* and instead only the color buffer is copied. When copying the depth
* or stencil buffers the extension on GLES2.0 only supports copying
* the full buffer which would be awkward to document with this
* API. If we wanted to support that feature it may be better to have
* a separate function to copy the entire buffer for a given mask.
*/
void
_cogl_blit_framebuffer (unsigned int src_x,
unsigned int src_y,
unsigned int dst_x,
unsigned int dst_y,
unsigned int width,
unsigned int height);
avoid touching fb matrix stack directly This ensures we don't touch a framebuffer's matrix stack directly if we are also relying on _cogl_framebuffer_flush_state(). We want to get to the point where we can set dirty flags against framebuffer state at the point it changes but that means we can't allow direct access to the matrix stack. _cogl_texture_draw_and_read() has now been changed so it uses cogl_framebuffer_ methods to update the matrix stacks including adding new internal _cogl_framebuffer_push/pop_projection() functions that allow us to set transient projections. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-20 18:50:29 +00:00
void
_cogl_framebuffer_push_projection (CoglFramebuffer *framebuffer);
void
_cogl_framebuffer_pop_projection (CoglFramebuffer *framebuffer);
framebuffer: Add CoglFramebuffer clip stack methods This adds CoglFramebuffer methods for accessing the clip stack. We plan on making some optimizations to how framebuffer state is flushed which will require us to track when a framebuffer's clip state has changed. This api also ties in to the longer term goal of removing the need for a default global CoglContext since these methods are all implicitly related to a specific context via their framebuffer argument. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-11-18 12:25:38 +00:00
void
_cogl_framebuffer_save_clip_stack (CoglFramebuffer *framebuffer);
void
_cogl_framebuffer_restore_clip_stack (CoglFramebuffer *framebuffer);
framebuffer: Flush the journal on destruction Instead of flushing the journal whenever the current framebuffer on a context is changed it is now flushed whenever the framebuffer is about to be destroyed instead. To do this it implements a custom unref function which detects when there is going to be exactly one reference on the framebuffer and then flushes its journal. The journal now always has a reference on the framebuffer whenever it is non-empty. That means the unref will only cause a flush if the only thing keeping the framebuffer alive is the entries in the journal. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 18:16:03 +00:00
void
_cogl_framebuffer_unref (CoglFramebuffer *framebuffer);
cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer API cogl_push_draw_buffer, cogl_set_draw_buffer and cogl_pop_draw_buffer are now deprecated and new code should use the new cogl_framebuffer_* API instead. Code that previously did: cogl_push_draw_buffer (); cogl_set_draw_buffer (COGL_OFFSCREEN_BUFFER, buffer); /* draw */ cogl_pop_draw_buffer (); should now be re-written as: cogl_push_framebuffer (buffer); /* draw */ cogl_pop_framebuffer (); As can be seen from the example above the rename has been used as an opportunity to remove the redundant target argument from cogl_set_draw_buffer; it now only takes one call to redirect to an offscreen buffer, and finally the term framebuffer may be a bit more familiar to anyone coming from an OpenGL background.
2009-11-26 19:06:35 +00:00
#endif /* __COGL_FRAMEBUFFER_PRIVATE_H */
Reference in New Issue Copy Permalink