summaryrefslogtreecommitdiff
path: root/cogl/cogl-framebuffer.c
Commit message (Collapse)AuthorAgeFilesLines
...
* Remove unused _cogl_swap_buffers_notifyRobert Bragg2011-04-111-5/+0
| | | | | | | | | | Recently _cogl_swap_buffers_notify was added (in 142b229c5c26) so that Cogl would be notified when Clutter performs a swap buffers request for a given onscreen framebuffer. It was expected this would be required for the recent cogl_read_pixel optimization that was implemented (ref 1bdb0e6e98db) but in the end it wasn't used. Since it wasn't used in the end this patch removes the API.
* cogl: rename cogl-context.h cogl-context-private.hRobert Bragg2011-04-111-1/+1
| | | | | Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
* offscreen: Plug a leak in an error pathEmmanuele Bassi2011-04-041-1/+6
| | | | | | | | | When creating a CoglOffscreen we take a reference on the texture handle, but in case of error we never release it. We should take that reference only on success. http://bugzilla.clutter-project.org/show_bug.cgi?id=2620
* viewport: consistently use floats for viewportsRobert Bragg2011-03-071-11/+12
| | | | | | | | 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.
* cogl-framebuffer: Add _cogl_blit_framebufferNeil Roberts2011-02-151-0/+46
| | | | | | | 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).
* cogl-framebuffer: Separate the draw and read bufferNeil Roberts2011-02-151-60/+175
| | | | | | | | | | | | | | | | | | | 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.
* cogl-framebuffer: Fix flushing the framebuffer on pushNeil Roberts2011-02-101-5/+10
| | | | | | | | | | | | | | When pushing a framebuffer it would previously push COGL_INVALID_HANDLE to the top of the framebuffer stack so that when it later calls cogl_set_framebuffer it will recognise that the framebuffer is different and replace the top with the new pointer. This isn't ideal because it breaks the code to flush the journal because _cogl_framebuffer_flush_journal is called with the value of the old pointer which is NULL. That function was checking for a NULL pointer so it wouldn't actually flush. It also would mean that if you pushed the same framebuffer twice we would end up dirtying state unnecessarily. To fix this cogl_push_framebuffer now pushes a reference to the current framebuffer instead.
* cogl-framebuffer: Remove all dependencies after a flushNeil Roberts2011-02-101-0/+1
| | | | | | | After a dependent framebuffer is added to a framebuffer it was never getting removed. Once the journal for a framebuffer is flushed we no longer depend on any framebuffers so the list should be cleared. This was causing leaks of offscreens and textures.
* framebuffer: flush journal when switching framebuffersRobert Bragg2011-01-241-4/+22
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | There is currently a problem with per-framebuffer journals in that it's possible to create a framebuffer from a texture which then gets rendered too but the framebuffer (and corresponding journal) can be freed before the texture gets used to draw with. Conceptually we want to make sure when freeing a framebuffer that - if it is associated with a texture - we flush the journal as the last thing before really freeing the framebuffer's meta data. Technically though this is awkward to implement since the obvious mechanism for us to be notified about the framebuffer's destruction (by setting some user data internally with a callback) notifies when the framebuffer has a ref-count of 0. This means we'd have to be careful what we do with the framebuffer to consider e.g. recursive destruction; anything that would set more user data on the framebuffer while it is being destroyed and ensuring nothing else gets notified of the framebuffer's destruction before the journal has been flushed. For simplicity, for now, this patch provides another solution which is to flush framebuffer journals whenever we switch away from a given framebuffer via cogl_set_framebuffer or cogl_push/pop_framebuffer. The disadvantage of this approach is that we can't batch all the geometry of a scene that involves intermediate renders to offscreen framebufers. Clutter is doing this more and more with applications that use the ClutterEffect APIs so this is a shame. Hopefully this will only be a stop-gap solution while we consider how to reliably support journal logging across framebuffer changes.
* cogl-debug: Split the flags to support more than 32Neil Roberts2011-01-241-2/+2
| | | | | | | | | | | The CoglDebugFlags are now stored in an array of unsigned ints rather than a single variable. The flags are accessed using macros instead of directly peeking at the cogl_debug_flags variable. The index values are stored in the enum rather than the actual mask values so that the enum doesn't need to be more than 32 bits wide. The hope is that the code to determine the index into the array can be optimized out by the compiler so it should have exactly the same performance as the old code.
* debug: Adds a COGL_DEBUG=disable-fast-read-pixel optionRobert Bragg2011-01-211-0/+3
| | | | | | | | COGL_DEBUG=disable-fast-read-pixel can be used to disable the optimization for reading a single pixel colour back by looking at the geometry in the journal and not involving the GPU. With this disabled we will always flush the journal, rendering to the framebuffer and then use glReadPixels to get the result.
* cogl: Implements a software only read-pixel fast-pathRobert Bragg2011-01-211-3/+193
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | 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.
* cogl: Adds _cogl_swap_buffers_notify for clutter backendsRobert Bragg2011-01-211-0/+5
| | | | | | | | | | | | | This adds a stop-gap mechanism for Cogl to know when the window system is requested to present the current backbuffer to the frontbuffer by adding a _cogl_swap_buffers_notify function that backends are now expected to call right after issuing the equivalent request to OpenGL vie the platforms OpenGL binding layer. This (blindly) updates all the backends to call this new function. For now Cogl doesn't do anything with the notification but the intention is to use it as part of a planned read-pixel optimization which will need to reset some state at the start of each new frame.
* clip: rename get_clip_stack + add framebuffer_get_stackRobert Bragg2011-01-211-0/+17
| | | | | | | | | | | | 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.
* journal: Support per-framebuffer journalsRobert Bragg2011-01-211-14/+97
| | | | | | | | | | | | | | | 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.
* framebuffer: Move clear code to cogl-framebuffer.cRobert Bragg2011-01-211-0/+103
| | | | | | | | | | | | | | | | 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.)
* Remove the GLES2 wrapperNeil Roberts2010-12-131-5/+1
| | | | | | The GLES2 wrapper is no longer needed because the shader generation is done within the GLSL fragend and vertend and any functions that are different for GLES2 are now guarded by #ifdefs.
* cogl-matrix-stack: Convert to be a CoglObjectNeil Roberts2010-12-131-2/+2
| | | | | We will want to use ref-counting on the CoglMatrixStack so it might as well be a CoglObject.
* cogl-framebuffer: Try to track format of the framebufferNeil Roberts2010-11-241-0/+15
| | | | | | | | | | | | | | | 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
* Add an internal _cogl_offscreen_new_to_texture_full functionNeil Roberts2010-11-241-24/+76
| | | | | | | | | | | | 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
* cogl-framebuffer: Add a flag to skip flushing the clip stateNeil Roberts2010-11-041-1/+2
| | | | | | This adds a flag to avoid flushing the clip state when flushing the framebuffer state. This will be used by the journal to manage its own clip state flushing.
* cogl: Move the clip stack dirtiness to the context rather than the FBNeil Roberts2010-11-041-1/+1
| | | | | | | | | | | | | | | | | | Previously we tracked whether the clip stack needs flushing as part of the CoglClipState which is part of the CoglFramebuffer state. This is a bit odd because most of the clipping state (such as the clip planes and the scissor) are part of the GL context's state rather than the framebuffer. We were marking the clip state on the framebuffer dirty every time we change the framebuffer anyway so it seems to make more sense to have the dirtiness be part of the global context. Instead of a just a single boolean to record whether the state needs flushing, the CoglContext now holds a reference to the clip stack that was flushed. That way we can flush arbitrary stack states and if it happens to be the same as the state already flushed then Cogl will do nothing. This will be useful if we log the clip stack in the journal because then we will need to flush unrelated clip stack states for each batch.
* cogl: rename CoglMaterial -> CoglPipelineRobert Bragg2010-11-031-1/+1
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
* cogl-framebuffer.c: GL_DEPTH_STENCIL not supported in glesJammy Zhou2010-09-231-0/+2
| | | | | | | | There is GL_INVALID_ENUM error for GL_DEPTH_STENCIL when call glRenderbufferStorage() with OpenGL ES backend. So enable this only for OpenGL backend. Signed-off-by: Robert Bragg <robert@linux.intel.com>
* cogl-framebuffer: fix leak when popping framebufferRobert Bragg2010-09-141-1/+1
| | | | | | We were using g_slist_remove_link instead of g_slist_delete_link resulting in a memory leak. Thanks to Simon Lanzmich for reporting this bug.
* cogl-framebuffer: Clear the renderbuffer list on failureNeil Roberts2010-09-131-0/+4
| | | | | | | | | When try_creating_fbo fails it deletes any intermediate render buffers that were created. However it doesn't clear the list so I think if it failed a second time it would try to delete the render buffers again. This could potentially cause problems if a subsequent fbo is created because the destructor for the original might delete the renderbuffers of the new fbo.
* cogl: don't include cogl-debug.h in cogl.h or installRobert Bragg2010-08-021-0/+1
| | | | | cogl-debug.h is an internal header so it shouldn't have been included by cogl.h and the header shouldn't be installed either.
* Don't define public cogl_is_* functions for internal typesNeil Roberts2010-07-091-4/+4
| | | | | | | This adds a COGL_OBJECT_INTERNAL_DEFINE macro and friends that are the same as COGL_OBJECT_DEFINE except that they prefix the cogl_is_* function with an underscore so that it doesn't get exported in the shared library.
* cogl: Don't define the deprecated ref/unref accessors for new typesNeil Roberts2010-07-091-0/+1
| | | | | | | | | | | Previously COGL_OBJECT_DEFINE would always define deprecated cogl_$type_{ref,unref} functions even if the type is new or if the type is entirely internal. An application would still find it difficult to use these because they wouldn't be in the headers, but it still looks bad that they are exported from the shared library. This patch changes it so that the deprecated ref counting functions are defined using a separate macro and only the types that have these functions in the headers call this macro.
* framebuffer: Replace CoglHandle with CoglFramebuffer *Robert Bragg2010-07-071-72/+49
| | | | One more object converted to stop using CoglHandle re:a8c8cbee513
* cogl: Initialize the framebuffer bits on state flushEmmanuele Bassi2010-06-101-2/+5
| | | | | | | | The place where we actually change the framebuffer is _cogl_framebuffer_flush_state(), so if we changed to a new frame buffer we need to initialize the color bits there. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
* cogl-framebuffer: Use the FBO extension for color sizesEmmanuele Bassi2010-06-101-4/+74
| | | | | | | | | | | OpenGL 3.0 deprecated querying of the GL_{RED,GREEN,BLUE}_BITS constants, and the FBO extension provides a mechanism to query for the color buffer sizes which *should* work even with the default framebuffer. Unfortunately, this doesn't seem to hold for Mesa - so we just use this for the offscreen CoglFramebuffer type, and we fall back to glGetIntegerv() for the onscreen one. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
* cogl: Hide cogl_framebuffer_get_*_bits()Emmanuele Bassi2010-06-101-4/+4
| | | | | | These accessors should be private, for the time being. http://bugzilla.openedhand.com/show_bug.cgi?id=2094
* Merge branch 'wip/framebuffer-bits'Emmanuele Bassi2010-05-211-0/+57
|\ | | | | | | | | * wip/framebuffer-bits: Implement accessors for the color bits in a framebuffer
| * Implement accessors for the color bits in a framebufferEmmanuele Bassi2010-05-051-0/+57
| | | | | | | | | | | | | | | | | | | | | | | | | | | | 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
* | cogl-framebuffer: Flush journal when creating fboOwen W. Taylor2010-05-101-2/+5
|/ | | | | | | | | | | | | Since framebuffer state is not flushed prior to replaying the journal, the trick of marking the framebuffer dirty prior to calling glBindFramebuffer() doesn't work... the outstanding journal entries will get replayed to the newly created framebuffer. Fix this by flushing the journal as well. http://bugzilla.openedhand.com/show_bug.cgi?id=2110 Signed-off-by: Robert Bragg <robert@linux.intel.com>
* Separate out CoglClipStackState from cogl-clip-stack.cNeil Roberts2010-04-151-5/+5
| | | | | | | 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.
* Remove mentions of the FSF addressEmmanuele Bassi2010-03-011-3/+3
| | | | | | | | | | | | | | | 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
* cogl debug: Adds glViewport call tracingRobert Bragg2010-02-231-0/+6
| | | | | | To aid in the debugging of Clutter stage resize issues this adds a COGL_DEBUG=opengl option that will trace "some select OpenGL calls" (currently just glViewport calls)
* cogl: remove redundant _cogl_journal_flush prototypeRobert Bragg2010-02-121-0/+1
| | | | | There was a redundant _cogl_journal_flush function prototype in cogl-primitives.h
* cogl-framebuffer: Return gboolean from try_creating_fboNeil Roberts2010-01-141-28/+28
| | | | | | | | | | | | | | | | | | | | When try_creating_fbo fails it returns 0 to report the error and if it succeeds it returns ‘flags’. However cogl_offscreen_new_to_texture also passes in 0 for the flags as the last fallback to create the fbo with nothing but the color buffer. In that case it will return 0 regardless of whether it succeeded so the last fallback will always be considered a failure. To fix this it now just returns a gboolean to indicate whether it succeeded and the flags used for each attempt is assigned when passing the argument rather than from the return value of the function. Also if the only configuration that succeeded was with flags==0 then it would always try all combinations because last_working_flags would also be zero. To avoid this it now uses a separate gboolean to mark whether we found a successful set of flags. http://bugzilla.openedhand.com/show_bug.cgi?id=1873
* cogl-framebuffer: Add some missing GL definesNeil Roberts2010-01-121-0/+6
| | | | | | | Since 755cce33a7 the framebuffer code is using the GL enums GL_DEPTH_ATTACHMENT and GL_DEPTH_COMPONENT16. These aren't available directly under GLES except with the OES suffix so we need to define them manually as we do with the other framebuffer constants.
* cogl: Support multiple fallbacks in cogl_offscreen_new_to_texture()Robert Bragg2010-01-111-83/+155
| | | | | | | | | | | | | | | 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
* framebuffers: cogl_offscreen_new_to_texture should take a ref on the textureRobert Bragg2010-01-081-0/+3
| | | | | | We weren't taking a reference on the texture to be used as the color buffer for offscreen rendering, so it was possible to free the texture leaving the framebuffer in an inconsistent state.
* cogl: Use #ifdef GL around GL_TEXTURE_RECTANGLE_ARBNeil Roberts2009-12-021-2/+5
| | | | | | | Commit 558b17ee1e added support for rectangle textures to the framebuffer code. Under GLES there is no GL_TEXTURE_RECTANGLE_ARB definition so this was breaking the build. The rest of Cogl uses ifdef's around that constant so we should do the same here.
* cogl: deprecate cogl_draw_buffer API and replace with a cogl_framebuffer APIRobert Bragg2009-11-261-0/+618
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.
View Lorry Controller Status