isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-23 00:20:42 -05:00
Code Issues Packages Projects Releases Wiki Activity
97d5406aef
mutter/cogl/cogl-atlas.c

606 lines
21 KiB
C
Raw Normal View History

cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
* Copyright (C) 2010,2011 Intel Corporation.
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cogl-atlas.h"
#include "cogl-rectangle-map.h"
cogl: rename cogl-context.h cogl-context-private.h Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
2010-11-04 18:25:52 -04:00
#include "cogl-context-private.h"
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
#include "cogl-texture-private.h"
#include "cogl-texture-2d-private.h"
cogl-atlas: Use _cogl_texture_driver_size_supported Previously when creating a new rectangle map it would try increasingly larger texture sizes until GL_MAX_TEXTURE_SIZE is reached. This is bad because it queries state which should really be owned by the texture driver. Also GL_MAX_TEXTURE_SIZE is often a conservative estimate so larger texture sizes can be used if the proxy texture is queried instead.
2010-08-12 04:08:30 -04:00
#include "cogl-texture-driver.h"
cogl: rename CoglMaterial -> CoglPipeline 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.
2010-10-27 13:54:57 -04:00
#include "cogl-pipeline-opengl-private.h"
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
#include "cogl-debug.h"
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
#include "cogl-framebuffer-private.h"
#include "cogl-blit.h"
moves and renames _cogl_get_format_bpp This moves _cogl_get_format_bpp from cogl-bitmap.c to cogl.c and renames it to _cogl_pixel_format_get_bytes_per_pixel. This makes it clearer that it doesn't return bits per pixel and makes the naming consistent with other cogl api. The prototype has been moved to cogl-private.h since it seems we should be aiming to get rid of cogl-internal.h at some point. The patch also adds a simple gtk-doc comment since we might want to make this api public. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-13 18:02:04 -05:00
#include "cogl-private.h"
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
#include <stdlib.h>
cogl-atlas: Convert to be a CoglObject subclass To implement multiple atlases it will be useful to have ref-counting on the CoglAtlas so it makes sense to convert it to be a CoglObject.
2010-11-27 08:06:38 -05:00
static void _cogl_atlas_free (CoglAtlas *atlas);
COGL_OBJECT_INTERNAL_DEFINE (Atlas, atlas);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
CoglAtlas *
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
_cogl_atlas_new (CoglPixelFormat texture_format,
CoglAtlasFlags flags,
CoglAtlasUpdatePositionCallback update_position_cb)
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
{
CoglAtlas *atlas = g_new (CoglAtlas, 1);
atlas->update_position_cb = update_position_cb;
atlas->map = NULL;
atlas->texture = NULL;
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
atlas->flags = flags;
atlas->texture_format = texture_format;
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
g_hook_list_init (&atlas->pre_reorganize_callbacks, sizeof (GHook));
g_hook_list_init (&atlas->post_reorganize_callbacks, sizeof (GHook));
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
cogl-atlas: Convert to be a CoglObject subclass To implement multiple atlases it will be useful to have ref-counting on the CoglAtlas so it makes sense to convert it to be a CoglObject.
2010-11-27 08:06:38 -05:00
return _cogl_atlas_object_new (atlas);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
}
cogl-atlas: Convert to be a CoglObject subclass To implement multiple atlases it will be useful to have ref-counting on the CoglAtlas so it makes sense to convert it to be a CoglObject.
2010-11-27 08:06:38 -05:00
static void
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_atlas_free (CoglAtlas *atlas)
{
cogl-atlas: Convert to be a CoglObject subclass To implement multiple atlases it will be useful to have ref-counting on the CoglAtlas so it makes sense to convert it to be a CoglObject.
2010-11-27 08:06:38 -05:00
COGL_NOTE (ATLAS, "%p: Atlas destroyed", atlas);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
if (atlas->texture)
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
cogl_object_unref (atlas->texture);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
if (atlas->map)
_cogl_rectangle_map_free (atlas->map);
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
g_hook_list_clear (&atlas->pre_reorganize_callbacks);
g_hook_list_clear (&atlas->post_reorganize_callbacks);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
g_free (atlas);
}
typedef struct _CoglAtlasRepositionData
{
/* The current user data for this texture */
void *user_data;
/* The old and new positions of the texture */
CoglRectangleMapEntry old_position;
CoglRectangleMapEntry new_position;
} CoglAtlasRepositionData;
static void
_cogl_atlas_migrate (CoglAtlas *atlas,
unsigned int n_textures,
CoglAtlasRepositionData *textures,
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
CoglTexture *old_texture,
CoglTexture *new_texture,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
void *skip_user_data)
{
unsigned int i;
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
CoglBlitData blit_data;
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
/* If the 'disable migrate' flag is set then we won't actually copy
the textures to their new location. Instead we'll just invoke the
callback to update the position */
if ((atlas->flags & COGL_ATLAS_DISABLE_MIGRATION))
for (i = 0; i < n_textures; i++)
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
/* Update the texture position */
atlas->update_position_cb (textures[i].user_data,
new_texture,
&textures[i].new_position);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
else
{
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
_cogl_blit_begin (&blit_data, new_texture, old_texture);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
for (i = 0; i < n_textures; i++)
{
/* Skip the texture that is being added because it doesn't contain
any data yet */
if (textures[i].user_data != skip_user_data)
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
_cogl_blit (&blit_data,
textures[i].old_position.x,
textures[i].old_position.y,
textures[i].new_position.x,
textures[i].new_position.y,
textures[i].new_position.width,
textures[i].new_position.height);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
/* Update the texture position */
atlas->update_position_cb (textures[i].user_data,
new_texture,
&textures[i].new_position);
}
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
_cogl_blit_end (&blit_data);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
}
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
}
typedef struct _CoglAtlasGetRectanglesData
{
CoglAtlasRepositionData *textures;
/* Number of textures found so far */
unsigned int n_textures;
} CoglAtlasGetRectanglesData;
static void
_cogl_atlas_get_rectangles_cb (const CoglRectangleMapEntry *rectangle,
void *rect_data,
void *user_data)
{
CoglAtlasGetRectanglesData *data = user_data;
data->textures[data->n_textures].old_position = *rectangle;
data->textures[data->n_textures++].user_data = rect_data;
}
static void
_cogl_atlas_get_next_size (unsigned int *map_width,
unsigned int *map_height)
{
/* Double the size of the texture by increasing whichever dimension
is smaller */
if (*map_width < *map_height)
*map_width <<= 1;
else
*map_height <<= 1;
}
cogl-atlas: Verify that the chosen initial size is supported CoglAtlas chooses a fairly large default initial size of either 512x512 or 1024x1024 depending on the texture format. There is a chance that this size will not be supported on some platforms which would be catastrophic for the glyph cache because it would mean that it would always fail to put any glyphs in the cache so text wouldn't work. To fix this the atlas code now checks whether the chosen initial size is supported by the texture driver and if not it will get halved until it is supported.
2010-08-12 04:59:58 -04:00
static void
_cogl_atlas_get_initial_size (CoglPixelFormat format,
unsigned int *map_width,
unsigned int *map_height)
{
unsigned int size;
GLenum gl_intformat;
GLenum gl_type;
Move the cogl texture driver functions to a vtable The texture driver functions are now accessed through a vtable pointed to by a struct in the CoglContext so that eventually it will be possible to compile both the GL and GLES texture drivers into a single binary and then select between them at runtime.
2011-07-07 07:48:24 -04:00
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
format,
&gl_intformat,
NULL, /* gl_format */
&gl_type);
cogl-atlas: Verify that the chosen initial size is supported CoglAtlas chooses a fairly large default initial size of either 512x512 or 1024x1024 depending on the texture format. There is a chance that this size will not be supported on some platforms which would be catastrophic for the glyph cache because it would mean that it would always fail to put any glyphs in the cache so text wouldn't work. To fix this the atlas code now checks whether the chosen initial size is supported by the texture driver and if not it will get halved until it is supported.
2010-08-12 04:59:58 -04:00
/* At least on Intel hardware, the texture size will be rounded up
to at least 1MB so we might as well try to aim for that as an
initial minimum size. If the format is only 1 byte per pixel we
can use 1024x1024, otherwise we'll assume it will take 4 bytes
per pixel and use 512x512. */
moves and renames _cogl_get_format_bpp This moves _cogl_get_format_bpp from cogl-bitmap.c to cogl.c and renames it to _cogl_pixel_format_get_bytes_per_pixel. This makes it clearer that it doesn't return bits per pixel and makes the naming consistent with other cogl api. The prototype has been moved to cogl-private.h since it seems we should be aiming to get rid of cogl-internal.h at some point. The patch also adds a simple gtk-doc comment since we might want to make this api public. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-13 18:02:04 -05:00
if (_cogl_pixel_format_get_bytes_per_pixel (format) == 1)
cogl-atlas: Verify that the chosen initial size is supported CoglAtlas chooses a fairly large default initial size of either 512x512 or 1024x1024 depending on the texture format. There is a chance that this size will not be supported on some platforms which would be catastrophic for the glyph cache because it would mean that it would always fail to put any glyphs in the cache so text wouldn't work. To fix this the atlas code now checks whether the chosen initial size is supported by the texture driver and if not it will get halved until it is supported.
2010-08-12 04:59:58 -04:00
size = 1024;
else
size = 512;
/* Some platforms might not support this large size so we'll
decrease the size until it can */
while (size > 1 &&
Add a context parameter to all of the texture driver virtuals All of the texture driver virtual functions now take an explicit CoglContext parameter as a step towards removing the global context.
2012-03-22 13:04:47 -04:00
!ctx->texture_driver->size_supported (ctx,
GL_TEXTURE_2D,
cogl-atlas: Verify that the chosen initial size is supported CoglAtlas chooses a fairly large default initial size of either 512x512 or 1024x1024 depending on the texture format. There is a chance that this size will not be supported on some platforms which would be catastrophic for the glyph cache because it would mean that it would always fail to put any glyphs in the cache so text wouldn't work. To fix this the atlas code now checks whether the chosen initial size is supported by the texture driver and if not it will get halved until it is supported.
2010-08-12 04:59:58 -04:00
gl_intformat,
gl_type,
size, size))
size >>= 1;
*map_width = size;
*map_height = size;
}
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
static CoglRectangleMap *
cogl-atlas: Use _cogl_texture_driver_size_supported Previously when creating a new rectangle map it would try increasingly larger texture sizes until GL_MAX_TEXTURE_SIZE is reached. This is bad because it queries state which should really be owned by the texture driver. Also GL_MAX_TEXTURE_SIZE is often a conservative estimate so larger texture sizes can be used if the proxy texture is queried instead.
2010-08-12 04:08:30 -04:00
_cogl_atlas_create_map (CoglPixelFormat format,
unsigned int map_width,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
unsigned int map_height,
unsigned int n_textures,
CoglAtlasRepositionData *textures)
{
cogl-atlas: Use _cogl_texture_driver_size_supported Previously when creating a new rectangle map it would try increasingly larger texture sizes until GL_MAX_TEXTURE_SIZE is reached. This is bad because it queries state which should really be owned by the texture driver. Also GL_MAX_TEXTURE_SIZE is often a conservative estimate so larger texture sizes can be used if the proxy texture is queried instead.
2010-08-12 04:08:30 -04:00
GLenum gl_intformat;
GLenum gl_type;
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
Move the cogl texture driver functions to a vtable The texture driver functions are now accessed through a vtable pointed to by a struct in the CoglContext so that eventually it will be possible to compile both the GL and GLES texture drivers into a single binary and then select between them at runtime.
2011-07-07 07:48:24 -04:00
_COGL_GET_CONTEXT (ctx, NULL);
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
format,
&gl_intformat,
NULL, /* gl_format */
&gl_type);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
/* Keep trying increasingly larger atlases until we can fit all of
the textures */
Add a context parameter to all of the texture driver virtuals All of the texture driver virtual functions now take an explicit CoglContext parameter as a step towards removing the global context.
2012-03-22 13:04:47 -04:00
while (ctx->texture_driver->size_supported (ctx,
GL_TEXTURE_2D,
cogl-atlas: Use _cogl_texture_driver_size_supported Previously when creating a new rectangle map it would try increasingly larger texture sizes until GL_MAX_TEXTURE_SIZE is reached. This is bad because it queries state which should really be owned by the texture driver. Also GL_MAX_TEXTURE_SIZE is often a conservative estimate so larger texture sizes can be used if the proxy texture is queried instead.
2010-08-12 04:08:30 -04:00
gl_intformat,
gl_type,
map_width, map_height))
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
{
CoglRectangleMap *new_atlas = _cogl_rectangle_map_new (map_width,
map_height,
NULL);
unsigned int i;
cogl-atlas: Add some more debugging notes This adds some debugging notes which report when the atlas is trying various sizes.
2010-08-06 13:42:01 -04:00
COGL_NOTE (ATLAS, "Trying to resize the atlas to %ux%u",
map_width, map_height);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
/* Add all of the textures and keep track of the new position */
for (i = 0; i < n_textures; i++)
if (!_cogl_rectangle_map_add (new_atlas,
textures[i].old_position.width,
textures[i].old_position.height,
textures[i].user_data,
&textures[i].new_position))
break;
/* If the atlas can contain all of the textures then we have a
winner */
if (i >= n_textures)
return new_atlas;
cogl-atlas: Add some more debugging notes This adds some debugging notes which report when the atlas is trying various sizes.
2010-08-06 13:42:01 -04:00
else
COGL_NOTE (ATLAS, "Atlas size abandoned after trying "
"%u out of %u textures",
i, n_textures);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_rectangle_map_free (new_atlas);
_cogl_atlas_get_next_size (&map_width, &map_height);
}
/* If we get here then there's no atlas that can accommodate all of
the rectangles */
return NULL;
}
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
static CoglTexture2D *
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
_cogl_atlas_create_texture (CoglAtlas *atlas,
int width,
int height)
{
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
CoglTexture2D *tex;
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
_COGL_GET_CONTEXT (ctx, NULL);
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 10:46:18 -04:00
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
if ((atlas->flags & COGL_ATLAS_CLEAR_TEXTURE))
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint8_t *clear_data;
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
CoglBitmap *clear_bmp;
moves and renames _cogl_get_format_bpp This moves _cogl_get_format_bpp from cogl-bitmap.c to cogl.c and renames it to _cogl_pixel_format_get_bytes_per_pixel. This makes it clearer that it doesn't return bits per pixel and makes the naming consistent with other cogl api. The prototype has been moved to cogl-private.h since it seems we should be aiming to get rid of cogl-internal.h at some point. The patch also adds a simple gtk-doc comment since we might want to make this api public. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-13 18:02:04 -05:00
int bpp = _cogl_pixel_format_get_bytes_per_pixel (atlas->texture_format);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
/* Create a buffer of zeroes to initially clear the texture */
clear_data = g_malloc0 (width * height * bpp);
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 10:46:18 -04:00
clear_bmp = cogl_bitmap_new_for_data (ctx,
width,
height,
atlas->texture_format,
width * bpp,
clear_data);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
Add constructors which take a CoglBitmap to all primitive textures This adds public constructors which take a CoglBitmap to all primitive texture types. This constructor should be considered the canonical constructor for initializing the texture with data because it should be possible to wrap any type of data in a CoglBitmap. Having at least this single constructor avoids the need to have an explosion of constructors such as new_from_data, new_from_pixel_buffer and new_from_file etc. The already available internal bitmap constructor for CoglTexture2D has had its flags parameter removed under the assumption that flags do not make sense for primitive textures. The meta constructor cogl_texture_new_from_bitmap now just explicitly calls set_auto_mipmap after constructing the texture depending on the value of the COGL_TEXTURE_NO_AUTO_MIPMAP flag. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:10:04 -04:00
tex = cogl_texture_2d_new_from_bitmap (clear_bmp,
atlas->texture_format,
NULL);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
cogl_object_unref (clear_bmp);
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 10:46:18 -04:00
g_free (clear_data);
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
}
else
Make CoglTexture2D public as experimental API This exposes a CoglTexture2D typedef and adds the following experimental API: cogl_is_texture_2d cogl_texture_2d_new_with_size cogl_texture_2d_new_from_data cogl_texture_2d_new_from_foreign Since this is experimental API you need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h. Note: With these new entrypoints we now expect a CoglContext pointer to be passed in, instead of assuming there is a default context. The aim is that for Cogl 2.0 we won't have a default context so this is a step in that direction.
2011-05-16 19:05:54 -04:00
{
tex = cogl_texture_2d_new_with_size (ctx,
width, height,
atlas->texture_format,
NULL);
}
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
return tex;
}
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
static int
_cogl_atlas_compare_size_cb (const void *a,
const void *b)
{
const CoglAtlasRepositionData *ta = a;
const CoglAtlasRepositionData *tb = b;
unsigned int a_size, b_size;
a_size = ta->old_position.width * ta->old_position.height;
b_size = tb->old_position.width * tb->old_position.height;
return a_size < b_size ? 1 : a_size > b_size ? -1 : 0;
}
static void
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
_cogl_atlas_notify_pre_reorganize (CoglAtlas *atlas)
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
{
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
g_hook_list_invoke (&atlas->pre_reorganize_callbacks, FALSE);
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
}
static void
_cogl_atlas_notify_post_reorganize (CoglAtlas *atlas)
{
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
g_hook_list_invoke (&atlas->post_reorganize_callbacks, FALSE);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_atlas_reserve_space (CoglAtlas *atlas,
unsigned int width,
unsigned int height,
void *user_data)
{
CoglAtlasGetRectanglesData data;
CoglRectangleMap *new_map;
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
CoglTexture2D *new_tex;
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
unsigned int map_width, map_height;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool ret;
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
CoglRectangleMapEntry new_position;
/* Check if we can fit the rectangle into the existing map */
if (atlas->map &&
_cogl_rectangle_map_add (atlas->map, width, height,
user_data,
&new_position))
{
Allow multiple CoglAtlases for textures Previously Cogl would only ever use one atlas for textures and if it reached the maximum texture size then all other new textures would get their own GL texture. This patch makes it so that we create as many atlases as needed. This should avoid breaking up some batches and it will be particularly good if we switch to always using multi-texturing with a default shader that selects between multiple atlases using a vertex attribute. Whenever a new atlas is created it is stored in a GSList on the context. A weak weference is taken on the atlas using cogl_object_set_user_data so that it can be removed from the list when the atlas is destroyed. The atlas textures themselves take a reference to the atlas and this is the only thing that keeps the atlas alive. This means that once the atlas becomes empty it will automatically be destroyed. All of the COGL_NOTEs pertaining to atlases are now prefixed with the atlas pointer to make it clearer which atlas is changing.
2010-11-27 08:15:02 -05:00
COGL_NOTE (ATLAS, "%p: Atlas is %ix%i, has %i textures and is %i%% waste",
atlas,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_rectangle_map_get_width (atlas->map),
_cogl_rectangle_map_get_height (atlas->map),
_cogl_rectangle_map_get_n_rectangles (atlas->map),
cogl-atlas: Fix a compiler warning when Cogl debug is disabled When Cogl debugging is disabled then the 'waste' variable is not used so it throws a compiler warning. This patch removes the variable and the value is calculated directly as the parameter to COGL_NOTE.
2011-02-15 07:50:15 -05:00
/* waste as a percentage */
_cogl_rectangle_map_get_remaining_space (atlas->map) *
100 / (_cogl_rectangle_map_get_width (atlas->map) *
_cogl_rectangle_map_get_height (atlas->map)));
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
atlas->update_position_cb (user_data,
atlas->texture,
&new_position);
return TRUE;
}
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
/* If we make it here then we need to reorganize the atlas. First
we'll notify any users of the atlas that this is going to happen
so that for example in CoglAtlasTexture it can notify that the
storage has changed and cause a flush */
_cogl_atlas_notify_pre_reorganize (atlas);
/* Get an array of all the textures currently in the atlas. */
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
data.n_textures = 0;
if (atlas->map == NULL)
data.textures = g_malloc (sizeof (CoglAtlasRepositionData));
else
{
unsigned int n_rectangles =
_cogl_rectangle_map_get_n_rectangles (atlas->map);
data.textures = g_malloc (sizeof (CoglAtlasRepositionData) *
(n_rectangles + 1));
_cogl_rectangle_map_foreach (atlas->map,
_cogl_atlas_get_rectangles_cb,
&data);
}
/* Add the new rectangle as a dummy texture so that it can be
positioned with the rest */
data.textures[data.n_textures].old_position.x = 0;
data.textures[data.n_textures].old_position.y = 0;
data.textures[data.n_textures].old_position.width = width;
data.textures[data.n_textures].old_position.height = height;
data.textures[data.n_textures++].user_data = user_data;
/* The atlasing algorithm works a lot better if the rectangles are
added in decreasing order of size so we'll first sort the
array */
qsort (data.textures, data.n_textures,
sizeof (CoglAtlasRepositionData),
_cogl_atlas_compare_size_cb);
/* Try to create a new atlas that can contain all of the textures */
if (atlas->map)
{
map_width = _cogl_rectangle_map_get_width (atlas->map);
map_height = _cogl_rectangle_map_get_height (atlas->map);
cogl-atlas: Try the next size when there would be less than 6% waste Previously when the atlas needs to be migrated it would start by trying with the same size as the existing atlas if there is enough space for the new texture. However even if the atlas is completely sorted there will always be some amount of waste so when the atlas needs to grow it would usually end up redundantly trying the same size when it is very unlikely to fit. This patch changes it so that there must be at least 6% waste available after the new texture is added otherwise it will start with the next atlas size.
2010-08-06 13:42:43 -04:00
/* If there is enough space in for the new rectangle in the
existing atlas with at least 6% waste we'll start with the
same size, otherwise we'll immediately double it */
if ((map_width * map_height -
_cogl_rectangle_map_get_remaining_space (atlas->map) +
width * height) * 53 / 50 >
map_width * map_height)
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_atlas_get_next_size (&map_width, &map_height);
}
else
cogl-atlas: Verify that the chosen initial size is supported CoglAtlas chooses a fairly large default initial size of either 512x512 or 1024x1024 depending on the texture format. There is a chance that this size will not be supported on some platforms which would be catastrophic for the glyph cache because it would mean that it would always fail to put any glyphs in the cache so text wouldn't work. To fix this the atlas code now checks whether the chosen initial size is supported by the texture driver and if not it will get halved until it is supported.
2010-08-12 04:59:58 -04:00
_cogl_atlas_get_initial_size (atlas->texture_format,
&map_width, &map_height);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
cogl-atlas: Use _cogl_texture_driver_size_supported Previously when creating a new rectangle map it would try increasingly larger texture sizes until GL_MAX_TEXTURE_SIZE is reached. This is bad because it queries state which should really be owned by the texture driver. Also GL_MAX_TEXTURE_SIZE is often a conservative estimate so larger texture sizes can be used if the proxy texture is queried instead.
2010-08-12 04:08:30 -04:00
new_map = _cogl_atlas_create_map (atlas->texture_format,
map_width, map_height,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
data.n_textures, data.textures);
/* If we can't create a map with the texture then give up */
if (new_map == NULL)
{
Allow multiple CoglAtlases for textures Previously Cogl would only ever use one atlas for textures and if it reached the maximum texture size then all other new textures would get their own GL texture. This patch makes it so that we create as many atlases as needed. This should avoid breaking up some batches and it will be particularly good if we switch to always using multi-texturing with a default shader that selects between multiple atlases using a vertex attribute. Whenever a new atlas is created it is stored in a GSList on the context. A weak weference is taken on the atlas using cogl_object_set_user_data so that it can be removed from the list when the atlas is destroyed. The atlas textures themselves take a reference to the atlas and this is the only thing that keeps the atlas alive. This means that once the atlas becomes empty it will automatically be destroyed. All of the COGL_NOTEs pertaining to atlases are now prefixed with the atlas pointer to make it clearer which atlas is changing.
2010-11-27 08:15:02 -05:00
COGL_NOTE (ATLAS, "%p: Could not fit texture in the atlas", atlas);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
ret = FALSE;
}
/* We need to migrate the existing textures into a new texture */
cogl-atlas: Support multiple formats and clearing the texture _cogl_atlas_new now has two extra parameters to specify the format of the textures it creates as well as a set of flags to modify the behavious of the atlas. One of the flags causes the new textures to be cleared and the other causes migration to avoid actually copying the textures. This is needed to use CoglAtlas from the pango glyph cache because it needs to use COGL_PIXEL_A_8 and to clear the textures as it does not fill in the gaps between glyphs. It needs to avoid copying the textures so that it can work on GL implementations without FBO support.
2010-08-05 08:24:02 -04:00
else if ((new_tex = _cogl_atlas_create_texture
(atlas,
_cogl_rectangle_map_get_width (new_map),
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
_cogl_rectangle_map_get_height (new_map))) == NULL)
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
{
Allow multiple CoglAtlases for textures Previously Cogl would only ever use one atlas for textures and if it reached the maximum texture size then all other new textures would get their own GL texture. This patch makes it so that we create as many atlases as needed. This should avoid breaking up some batches and it will be particularly good if we switch to always using multi-texturing with a default shader that selects between multiple atlases using a vertex attribute. Whenever a new atlas is created it is stored in a GSList on the context. A weak weference is taken on the atlas using cogl_object_set_user_data so that it can be removed from the list when the atlas is destroyed. The atlas textures themselves take a reference to the atlas and this is the only thing that keeps the atlas alive. This means that once the atlas becomes empty it will automatically be destroyed. All of the COGL_NOTEs pertaining to atlases are now prefixed with the atlas pointer to make it clearer which atlas is changing.
2010-11-27 08:15:02 -05:00
COGL_NOTE (ATLAS, "%p: Could not create a CoglTexture2D", atlas);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_rectangle_map_free (new_map);
ret = FALSE;
}
else
{
int waste;
COGL_NOTE (ATLAS,
Allow multiple CoglAtlases for textures Previously Cogl would only ever use one atlas for textures and if it reached the maximum texture size then all other new textures would get their own GL texture. This patch makes it so that we create as many atlases as needed. This should avoid breaking up some batches and it will be particularly good if we switch to always using multi-texturing with a default shader that selects between multiple atlases using a vertex attribute. Whenever a new atlas is created it is stored in a GSList on the context. A weak weference is taken on the atlas using cogl_object_set_user_data so that it can be removed from the list when the atlas is destroyed. The atlas textures themselves take a reference to the atlas and this is the only thing that keeps the atlas alive. This means that once the atlas becomes empty it will automatically be destroyed. All of the COGL_NOTEs pertaining to atlases are now prefixed with the atlas pointer to make it clearer which atlas is changing.
2010-11-27 08:15:02 -05:00
"%p: Atlas %s with size %ix%i",
atlas,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
atlas->map == NULL ||
_cogl_rectangle_map_get_width (atlas->map) !=
_cogl_rectangle_map_get_width (new_map) ||
_cogl_rectangle_map_get_height (atlas->map) !=
_cogl_rectangle_map_get_height (new_map) ?
"resized" : "reorganized",
_cogl_rectangle_map_get_width (new_map),
_cogl_rectangle_map_get_height (new_map));
if (atlas->map)
{
/* Move all the textures to the right position in the new
texture. This will also update the texture's rectangle */
_cogl_atlas_migrate (atlas,
data.n_textures,
data.textures,
atlas->texture,
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
COGL_TEXTURE (new_tex),
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
user_data);
_cogl_rectangle_map_free (atlas->map);
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
cogl_object_unref (atlas->texture);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
}
else
/* We know there's only one texture so we can just directly
update the rectangle from its new position */
atlas->update_position_cb (data.textures[0].user_data,
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
COGL_TEXTURE (new_tex),
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
&data.textures[0].new_position);
atlas->map = new_map;
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
atlas->texture = COGL_TEXTURE (new_tex);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
waste = (_cogl_rectangle_map_get_remaining_space (atlas->map) *
100 / (_cogl_rectangle_map_get_width (atlas->map) *
_cogl_rectangle_map_get_height (atlas->map)));
Allow multiple CoglAtlases for textures Previously Cogl would only ever use one atlas for textures and if it reached the maximum texture size then all other new textures would get their own GL texture. This patch makes it so that we create as many atlases as needed. This should avoid breaking up some batches and it will be particularly good if we switch to always using multi-texturing with a default shader that selects between multiple atlases using a vertex attribute. Whenever a new atlas is created it is stored in a GSList on the context. A weak weference is taken on the atlas using cogl_object_set_user_data so that it can be removed from the list when the atlas is destroyed. The atlas textures themselves take a reference to the atlas and this is the only thing that keeps the atlas alive. This means that once the atlas becomes empty it will automatically be destroyed. All of the COGL_NOTEs pertaining to atlases are now prefixed with the atlas pointer to make it clearer which atlas is changing.
2010-11-27 08:15:02 -05:00
COGL_NOTE (ATLAS, "%p: Atlas is %ix%i, has %i textures and is %i%% waste",
atlas,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_rectangle_map_get_width (atlas->map),
_cogl_rectangle_map_get_height (atlas->map),
_cogl_rectangle_map_get_n_rectangles (atlas->map),
waste);
ret = TRUE;
}
g_free (data.textures);
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
_cogl_atlas_notify_post_reorganize (atlas);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
return ret;
}
void
_cogl_atlas_remove (CoglAtlas *atlas,
const CoglRectangleMapEntry *rectangle)
{
_cogl_rectangle_map_remove (atlas->map, rectangle);
Allow multiple CoglAtlases for textures Previously Cogl would only ever use one atlas for textures and if it reached the maximum texture size then all other new textures would get their own GL texture. This patch makes it so that we create as many atlases as needed. This should avoid breaking up some batches and it will be particularly good if we switch to always using multi-texturing with a default shader that selects between multiple atlases using a vertex attribute. Whenever a new atlas is created it is stored in a GSList on the context. A weak weference is taken on the atlas using cogl_object_set_user_data so that it can be removed from the list when the atlas is destroyed. The atlas textures themselves take a reference to the atlas and this is the only thing that keeps the atlas alive. This means that once the atlas becomes empty it will automatically be destroyed. All of the COGL_NOTEs pertaining to atlases are now prefixed with the atlas pointer to make it clearer which atlas is changing.
2010-11-27 08:15:02 -05:00
COGL_NOTE (ATLAS, "%p: Removed rectangle sized %ix%i",
atlas,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
rectangle->width,
rectangle->height);
Allow multiple CoglAtlases for textures Previously Cogl would only ever use one atlas for textures and if it reached the maximum texture size then all other new textures would get their own GL texture. This patch makes it so that we create as many atlases as needed. This should avoid breaking up some batches and it will be particularly good if we switch to always using multi-texturing with a default shader that selects between multiple atlases using a vertex attribute. Whenever a new atlas is created it is stored in a GSList on the context. A weak weference is taken on the atlas using cogl_object_set_user_data so that it can be removed from the list when the atlas is destroyed. The atlas textures themselves take a reference to the atlas and this is the only thing that keeps the atlas alive. This means that once the atlas becomes empty it will automatically be destroyed. All of the COGL_NOTEs pertaining to atlases are now prefixed with the atlas pointer to make it clearer which atlas is changing.
2010-11-27 08:15:02 -05:00
COGL_NOTE (ATLAS, "%p: Atlas is %ix%i, has %i textures and is %i%% waste",
atlas,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_rectangle_map_get_width (atlas->map),
_cogl_rectangle_map_get_height (atlas->map),
_cogl_rectangle_map_get_n_rectangles (atlas->map),
_cogl_rectangle_map_get_remaining_space (atlas->map) *
100 / (_cogl_rectangle_map_get_width (atlas->map) *
_cogl_rectangle_map_get_height (atlas->map)));
};
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
CoglTexture *
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
_cogl_atlas_copy_rectangle (CoglAtlas *atlas,
unsigned int x,
unsigned int y,
unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat format)
{
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
CoglTexture *tex;
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
CoglBlitData blit_data;
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
/* Create a new texture at the right size */
tex = cogl_texture_new_with_size (width, height, flags, format);
/* Blit the data out of the atlas to the new texture. If FBOs
aren't available this will end up having to copy the entire
atlas texture */
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
_cogl_blit_begin (&blit_data, tex, atlas->texture);
_cogl_blit (&blit_data,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
x, y,
0, 0,
width, height);
cogl-atlas: Try 4 different approaches for migrating textures Instead of directly banging GL to migrate textures the atlas now uses the CoglFramebuffer API. It will use one of four approaches; it can set up two FBOs and use _cogl_blit_framebuffer to copy between them; it can use a single target fbo and then render the source texture to the FBO using a Cogl draw call; it can use a single FBO and call glCopyTexSubImage2D; or it can fallback to reading all of the texture data back to system memory and uploading it again with a sub texture update. Previously GL calls were used directly because Cogl wasn't able to create a framebuffer without a stencil and depth buffer. However there is now an internal version of cogl_offscreen_new_to_texture which takes a set of flags to disable the two buffers. The code for blitting has now been moved into a separate file called cogl-blit.c because it has become quite long and it may be useful outside of the atlas at some point. The 4 different methods have a fixed order of preference which is: * Texture render between two FBOs * glBlitFramebuffer * glCopyTexSubImage2D * glGetTexImage + glTexSubImage2D Once a method is succesfully used it is tried first for all subsequent blits. The default default can be overridden by setting the environment variable COGL_ATLAS_DEFAULT_BLIT_MODE to one of the following values: * texture-render * framebuffer * copy-tex-sub-image * get-tex-data
2011-01-20 12:45:47 -05:00
_cogl_blit_end (&blit_data);
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
return tex;
}
void
_cogl_atlas_add_reorganize_callback (CoglAtlas *atlas,
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
GHookFunc pre_callback,
GHookFunc post_callback,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
void *user_data)
{
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
if (pre_callback)
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
{
GHook *hook = g_hook_alloc (&atlas->post_reorganize_callbacks);
hook->func = pre_callback;
hook->data = user_data;
g_hook_prepend (&atlas->pre_reorganize_callbacks, hook);
}
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
if (post_callback)
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
{
GHook *hook = g_hook_alloc (&atlas->pre_reorganize_callbacks);
hook->func = post_callback;
hook->data = user_data;
g_hook_prepend (&atlas->post_reorganize_callbacks, hook);
}
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
}
void
_cogl_atlas_remove_reorganize_callback (CoglAtlas *atlas,
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
GHookFunc pre_callback,
GHookFunc post_callback,
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
void *user_data)
{
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
if (pre_callback)
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
{
GHook *hook = g_hook_find_func_data (&atlas->pre_reorganize_callbacks,
FALSE,
pre_callback,
user_data);
if (hook)
g_hook_destroy_link (&atlas->pre_reorganize_callbacks, hook);
}
cogl-atlas-texture: Don't let textures be destroyed during migration If an atlas texture's last reference is held by the journal or by the last flushed pipeline then if an atlas migration is started it can cause a crash. This is because the atlas migration will cause a journal flush and can sometimes change the current pipeline which means that the texture would be destroyed during migration. This patch adds an extra 'post_reorganize' callback to the existing 'reorganize' callback (which is now renamed to 'pre_reorganize'). The pre_reorganize callback is now called before the atlas grabs a list of the current textures instead of after so that it doesn't matter if the journal flush destroys some of those textures. The pre_reorganize callback for CoglAtlasTexture grabs a reference to all of the textures so that they can not be destroyed when the migration changes the pipeline. In the post_reorganize callback the reference is removed again. http://bugzilla.clutter-project.org/show_bug.cgi?id=2538
2011-02-17 08:11:34 -05:00
if (post_callback)
cogl: Use GHookList instead of CoglCallbackList glib already has a data type to manage a list of callbacks called a GHookList so we might as well use it instead of maintaining Cogl's own type. The glib version may be slightly more efficient because it avoids using a GList and instead encodes the prev and next pointers directly in the GHook structure. It also has more features than CoglCallbackList.
2011-03-14 13:58:31 -04:00
{
GHook *hook = g_hook_find_func_data (&atlas->post_reorganize_callbacks,
FALSE,
post_callback,
user_data);
if (hook)
g_hook_destroy_link (&atlas->post_reorganize_callbacks, hook);
}
cogl-atlas-texture: Split out the atlas data structure Instead of storing a pointer to the CoglRectangleMap and a handle to the atlas texture in the context, there is a now a separate data structure called a CoglAtlas to manage these two. The context just contains a pointer to this. The code to reorganise the atlas has been moved from cogl-atlas-texture.c to cogl-atlas.c
2010-08-02 11:29:10 -04:00
}
Reference in New Issue Copy Permalink