brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ebb05bcb64
mutter/cogl/cogl-atlas-texture.c

1093 lines
40 KiB
C
Raw Normal View History

cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
cogl-atlas-texture: Flush the journal before adding a new texture When the atlas is reorganised we could potentially be moving around textures that are already referenced in the journal. We therefore need to flush the journal otherwise they will be rendered with incorrect texture coordinates. We also need to flush the journal even if we are not reorganizing so that we can rely on the old texture contents remaining in the atlas after migrating a texture out.
2010-02-12 10:33:56 -05:00
* Copyright (C) 2009,2010 Intel Corporation.
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05: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
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 07:56:10 -05:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cogl.h"
#include "cogl-internal.h"
#include "cogl-util.h"
#include "cogl-texture-private.h"
#include "cogl-atlas-texture-private.h"
#include "cogl-texture-2d-private.h"
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
#include "cogl-sub-texture-private.h"
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
#include "cogl-context.h"
#include "cogl-handle.h"
#include "cogl-texture-driver.h"
#include "cogl-atlas.h"
cogl-atlas-texture: Flush the journal before adding a new texture When the atlas is reorganised we could potentially be moving around textures that are already referenced in the journal. We therefore need to flush the journal otherwise they will be rendered with incorrect texture coordinates. We also need to flush the journal even if we are not reorganizing so that we can rely on the old texture contents remaining in the atlas after migrating a texture out.
2010-02-12 10:33:56 -05:00
#include "cogl-journal-private.h"
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
#include <stdlib.h>
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
#ifdef HAVE_COGL_GLES2
#include "../gles/cogl-gles2-wrapper.h"
#else /* HAVE_COGL_GLES2 */
#define glGenFramebuffers ctx->drv.pf_glGenFramebuffers
#define glBindFramebuffer ctx->drv.pf_glBindFramebuffer
#define glFramebufferTexture2D ctx->drv.pf_glFramebufferTexture2D
#define glCheckFramebufferStatus ctx->drv.pf_glCheckFramebufferStatus
#define glDeleteFramebuffers ctx->drv.pf_glDeleteFramebuffers
#endif /* HAVE_COGL_GLES2 */
#ifndef GL_FRAMEBUFFER
#define GL_FRAMEBUFFER 0x8D40
#endif
#ifndef GL_FRAMEBUFFER_BINDING
#define GL_FRAMEBUFFER_BINDING 0x8CA6
#endif
#ifndef GL_COLOR_ATTACHMENT0
#define GL_COLOR_ATTACHMENT0 0x8CE0
#endif
#ifndef GL_FRAMEBUFFER_COMPLETE
#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
#endif
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
static void _cogl_atlas_texture_free (CoglAtlasTexture *sub_tex);
cogl-texture: List texture subclass types rather than hardcoding them Instead of having a hardcoded series of if-statements in cogl_is_texture to determine which types should appear as texture subclasses, they are now stored in a GSList attached to the Cogl context. The list is amended to using a new cogl_texture_register_type function. There is a convenience macro called COGL_TEXTURE_DEFINE which uses COGL_HANDLE_DEFINE_WITH_CODE to register the texture type when the _get_type() function is first called.
2010-06-11 08:50:36 -04:00
COGL_TEXTURE_DEFINE (AtlasTexture, atlas_texture);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
static const CoglTextureVtable cogl_atlas_texture_vtable;
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
/* If we want to do mulitple blits from a texture (such as when
reorganizing the atlas) then it's quicker to download all of the
data once and upload multiple times from that. This struct is used
to keep the image data for a series of blits */
typedef struct _CoglAtlasTextureBlitData
{
CoglHandle src_tex, dst_tex;
/* If we're using an FBO to blit, then FBO will be non-zero and
old_fbo will be the previous framebuffer binding */
GLuint fbo, old_fbo;
/* If we're not using an FBO then we g_malloc a buffer and copy the
complete texture data in */
unsigned char *image_data;
CoglPixelFormat format;
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
int bpp;
unsigned int src_height, src_width;
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
GLenum dst_gl_target;
} CoglAtlasTextureBlitData;
static void
_cogl_atlas_texture_blit_begin (CoglAtlasTextureBlitData *data,
CoglHandle dst_tex,
CoglHandle src_tex)
{
GLenum src_gl_target;
GLuint src_gl_texture;
GLuint dst_gl_texture;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
data->dst_tex = dst_tex;
data->src_tex = src_tex;
data->fbo = 0;
/* If we can use an FBO then we don't need to download the data and
we can tell GL to blit directly between the textures */
if (cogl_features_available (COGL_FEATURE_OFFSCREEN) &&
!cogl_texture_is_sliced (dst_tex) &&
cogl_texture_get_gl_texture (src_tex, &src_gl_texture, &src_gl_target) &&
cogl_texture_get_gl_texture (dst_tex, &dst_gl_texture,
&data->dst_gl_target))
{
/* Ideally we would use the cogl-offscreen API here, but I'd
rather avoid creating a stencil renderbuffer which you can't
currently do */
/* Preserve the previous framebuffer binding so we don't trample
on cogl-offscreen */
data->old_fbo = 0;
GE( glGetIntegerv (GL_FRAMEBUFFER_BINDING, (GLint *) &data->old_fbo) );
_cogl_texture_set_filters (src_tex, GL_NEAREST, GL_NEAREST);
/* Create an FBO to read from the src texture */
GE( glGenFramebuffers (1, &data->fbo) );
GE( glBindFramebuffer (GL_FRAMEBUFFER, data->fbo) );
GE( glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
src_gl_target, src_gl_texture, 0) );
if (glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
/* The FBO failed for whatever reason so we'll fallback to
reading the texture data */
GE( glBindFramebuffer (GL_FRAMEBUFFER, data->old_fbo) );
GE( glDeleteFramebuffers (1, &data->fbo) );
data->fbo = 0;
}
material: Avoid redundant glBindTexture calls This adds a _cogl_bind_gl_texture_transient function that should be used instead of glBindTexture so we can have a consistent cache of the textures bound to each texture unit so we can avoid some redundant binding.
2010-04-26 05:01:43 -04:00
_cogl_bind_gl_texture_transient (data->dst_gl_target,
dst_gl_texture,
FALSE);
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
}
if (data->fbo)
COGL_NOTE (ATLAS, "Blit set up using an FBO");
else
{
/* We need to retrieve the entire texture data (there is no
glGetTexSubImage2D) */
data->format = cogl_texture_get_format (src_tex);
data->bpp = _cogl_get_format_bpp (data->format);
data->src_width = cogl_texture_get_width (src_tex);
data->src_height = cogl_texture_get_height (src_tex);
data->image_data = g_malloc (data->bpp * data->src_width *
data->src_height);
cogl_texture_get_data (src_tex, data->format,
data->src_width * data->bpp, data->image_data);
}
}
static void
_cogl_atlas_texture_blit (CoglAtlasTextureBlitData *data,
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned int src_x,
unsigned int src_y,
unsigned int dst_x,
unsigned int dst_y,
unsigned int width,
unsigned int height)
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
{
/* If we have an FBO then we can do a fast blit */
if (data->fbo)
GE( glCopyTexSubImage2D (data->dst_gl_target, 0, dst_x, dst_y, src_x, src_y,
width, height) );
else
cogl_texture_set_region (data->dst_tex,
src_x, src_y,
dst_x, dst_y,
width, height,
data->src_width, data->src_height,
data->format,
data->src_width * data->bpp,
data->image_data);
}
static void
_cogl_atlas_texture_blit_end (CoglAtlasTextureBlitData *data)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
if (data->fbo)
{
GE( glBindFramebuffer (GL_FRAMEBUFFER, data->old_fbo) );
GE( glDeleteFramebuffers (1, &data->fbo) );
}
else
g_free (data->image_data);
}
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
static void
_cogl_atlas_texture_foreach_sub_texture_in_region (
CoglTexture *tex,
float virtual_tx_1,
float virtual_ty_1,
float virtual_tx_2,
float virtual_ty_2,
CoglTextureSliceCallback callback,
void *user_data)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
_cogl_texture_foreach_sub_texture_in_region (atlas_tex->sub_texture,
virtual_tx_1,
virtual_ty_1,
virtual_tx_2,
virtual_ty_2,
callback,
user_data);
}
static void
Split the wrap mode of _cogl_texture_set_wrap_mode into three GL supports setting different wrap modes for the s, t and r coordinates so we should design the backend interface to support that also. The r coordinate is not currently used by any of the backends but we might as well have it to make life easier if we ever add support for 3D textures. http://bugzilla.openedhand.com/show_bug.cgi?id=2063
2010-03-25 13:29:22 -04:00
_cogl_atlas_texture_set_wrap_mode_parameters (CoglTexture *tex,
GLenum wrap_mode_s,
GLenum wrap_mode_t,
GLenum wrap_mode_r)
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
Split the wrap mode of _cogl_texture_set_wrap_mode into three GL supports setting different wrap modes for the s, t and r coordinates so we should design the backend interface to support that also. The r coordinate is not currently used by any of the backends but we might as well have it to make life easier if we ever add support for 3D textures. http://bugzilla.openedhand.com/show_bug.cgi?id=2063
2010-03-25 13:29:22 -04:00
_cogl_texture_set_wrap_mode_parameters (atlas_tex->sub_texture,
wrap_mode_s,
wrap_mode_t,
wrap_mode_r);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
}
static void
cogl-atlas-texture: Remove textures from the atlas when mipmapping is required Mipmaps don't work very well in the current atlas because there is not enough padding between the textures. If ensure_mipmaps is called it will now create a new texture and migrate the atlased texture to it. It will use the same blit mechanism as when migrating so it will try to use an FBO for a fast blit. However if this is not possible it will end up downloading the data for the entire atlas which is not ideal.
2009-12-05 08:48:03 -05:00
_cogl_atlas_texture_remove_from_atlas (CoglAtlasTexture *atlas_tex)
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
{
if (atlas_tex->in_atlas)
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
{
cogl-atlas-texture: Remove textures from the atlas when mipmapping is required Mipmaps don't work very well in the current atlas because there is not enough padding between the textures. If ensure_mipmaps is called it will now create a new texture and migrate the atlased texture to it. It will use the same blit mechanism as when migrating so it will try to use an FBO for a fast blit. However if this is not possible it will end up downloading the data for the entire atlas which is not ideal.
2009-12-05 08:48:03 -05:00
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_remove_rectangle (ctx->atlas, &atlas_tex->rectangle);
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
COGL_NOTE (ATLAS, "Removed rectangle sized %ix%i",
atlas_tex->rectangle.width,
atlas_tex->rectangle.height);
COGL_NOTE (ATLAS, "Atlas is %ix%i, has %i textures and is %i%% waste",
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_get_width (ctx->atlas),
_cogl_atlas_get_height (ctx->atlas),
_cogl_atlas_get_n_rectangles (ctx->atlas),
_cogl_atlas_get_remaining_space (ctx->atlas) * 100 /
(_cogl_atlas_get_width (ctx->atlas) *
_cogl_atlas_get_height (ctx->atlas)));
cogl-atlas-texture: Remove textures from the atlas when mipmapping is required Mipmaps don't work very well in the current atlas because there is not enough padding between the textures. If ensure_mipmaps is called it will now create a new texture and migrate the atlased texture to it. It will use the same blit mechanism as when migrating so it will try to use an FBO for a fast blit. However if this is not possible it will end up downloading the data for the entire atlas which is not ideal.
2009-12-05 08:48:03 -05:00
atlas_tex->in_atlas = FALSE;
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
}
cogl-atlas-texture: Remove textures from the atlas when mipmapping is required Mipmaps don't work very well in the current atlas because there is not enough padding between the textures. If ensure_mipmaps is called it will now create a new texture and migrate the atlased texture to it. It will use the same blit mechanism as when migrating so it will try to use an FBO for a fast blit. However if this is not possible it will end up downloading the data for the entire atlas which is not ideal.
2009-12-05 08:48:03 -05:00
}
static void
_cogl_atlas_texture_free (CoglAtlasTexture *atlas_tex)
{
_cogl_atlas_texture_remove_from_atlas (atlas_tex);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
cogl_handle_unref (atlas_tex->sub_texture);
cogl-atlas-texture: Fix a memory leak The CoglAtlasTexture struct was not being freed in _cogl_atlas_texture_free so there would be a small leak whenever a texture was destroyed. Thanks to Robert Bragg for spotting this.
2010-04-13 12:26:03 -04:00
material: Avoid redundant glBindTexture calls This adds a _cogl_bind_gl_texture_transient function that should be used instead of glBindTexture so we can have a consistent cache of the textures bound to each texture unit so we can avoid some redundant binding.
2010-04-26 05:01:43 -04:00
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (atlas_tex));
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
}
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
static int
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
_cogl_atlas_texture_get_max_waste (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return cogl_texture_get_max_waste (atlas_tex->sub_texture);
}
static gboolean
_cogl_atlas_texture_is_sliced (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return cogl_texture_is_sliced (atlas_tex->sub_texture);
}
static gboolean
_cogl_atlas_texture_can_hardware_repeat (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return _cogl_texture_can_hardware_repeat (atlas_tex->sub_texture);
}
static void
_cogl_atlas_texture_transform_coords_to_gl (CoglTexture *tex,
float *s,
float *t)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
_cogl_texture_transform_coords_to_gl (atlas_tex->sub_texture, s, t);
}
Fix checks for out-of-bounds coordinates and repeats Add a return result from CoglTexture.transform_quad_coords_to_gl(), so that we can properly determine the nature of repeats in the face of GL_TEXTURE_RECTANGLE_ARB, where the returned coordinates are not normalized. The comment "We also work out whether any of the texture coordinates are outside the range [0.0,1.0]. We need to do this after calling transform_coords_to_gl in case the texture backend is munging the coordinates (such as in the sub texture backend)." is disregarded and removed, since it's actually the virtual coordinates that determine whether we repeat, not the GL coordinates. Warnings about disregarded layers are used in all cases where applicable, including for subtextures. http://bugzilla.openedhand.com/show_bug.cgi?id=2016 Signed-off-by: Neil Roberts <neil@linux.intel.com>
2010-03-01 16:49:04 -05:00
static CoglTransformResult
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
_cogl_atlas_texture_transform_quad_coords_to_gl (CoglTexture *tex,
float *coords)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return _cogl_texture_transform_quad_coords_to_gl (atlas_tex->sub_texture,
coords);
}
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
static gboolean
_cogl_atlas_texture_get_gl_texture (CoglTexture *tex,
GLuint *out_gl_handle,
GLenum *out_gl_target)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return cogl_texture_get_gl_texture (atlas_tex->sub_texture,
out_gl_handle,
out_gl_target);
}
static void
_cogl_atlas_texture_set_filters (CoglTexture *tex,
GLenum min_filter,
GLenum mag_filter)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
_cogl_texture_set_filters (atlas_tex->sub_texture, min_filter, mag_filter);
}
static void
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
_cogl_atlas_texture_migrate_out_of_atlas (CoglAtlasTexture *atlas_tex)
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
{
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
/* Make sure this texture is not in the atlas */
cogl-atlas-texture: Remove textures from the atlas when mipmapping is required Mipmaps don't work very well in the current atlas because there is not enough padding between the textures. If ensure_mipmaps is called it will now create a new texture and migrate the atlased texture to it. It will use the same blit mechanism as when migrating so it will try to use an FBO for a fast blit. However if this is not possible it will end up downloading the data for the entire atlas which is not ideal.
2009-12-05 08:48:03 -05:00
if (atlas_tex->in_atlas)
{
CoglAtlasTextureBlitData blit_data;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
COGL_NOTE (ATLAS, "Migrating texture out of the atlas");
atlas: fix some journal flushing issues 1) Always flush when migrating textures out of an atlas because although it's true that the original texture data will remain valid in the original texture we can't assume that journal entries have resolved the GL texture that will be used. This is only true if a layer0_override has been used. 2) Don't flush at the point of creating a new atlas simply flush immediately before reorganizing an atlas. This means we are now assuming that we will never see recursion due to atlas textures being modified during a journal flush. This means it's the responsibility of the primitives code to _ensure_mipmaps for example not the responsibility of _cogl_material_flush_gl_state.
2010-06-04 11:42:30 -04:00
/* We don't know if any materials may currently be referenced in
* the journal that depend on the current underlying GL texture
* storage so we flush the journal before migrating.
*
* We are assuming that texture atlas migration never happens
* during a flush so we don't have to consider recursion here.
*/
_cogl_journal_flush ();
cogl-atlas-texture: Flush the journal before adding a new texture When the atlas is reorganised we could potentially be moving around textures that are already referenced in the journal. We therefore need to flush the journal otherwise they will be rendered with incorrect texture coordinates. We also need to flush the journal even if we are not reorganizing so that we can rely on the old texture contents remaining in the atlas after migrating a texture out.
2010-02-12 10:33:56 -05:00
CoglMaterial: Implements sparse materials design This is a complete overhaul of the data structures used to manage CoglMaterial state. We have these requirements that were aiming to meet: (Note: the references to "renderlists" correspond to the effort to support scenegraph level shuffling of Clutter actor primitives so we can minimize GPU state changes) Sparse State: We wanted a design that allows sparse descriptions of state so it scales well as we make CoglMaterial responsible for more and more state. It needs to scale well in terms of memory usage and the cost of operations we need to apply to materials such as comparing, copying and flushing their state. I.e. we would rather have these things scale by the number of real changes a material represents not by how much overall state CoglMaterial becomes responsible for. Cheap Copies: As we add support for renderlists in Clutter we will need to be able to get an immutable handle for a given material's current state so that we can retain a record of a primitive with its associated material without worrying that changes to the original material will invalidate that record. No more flush override options: We want to get rid of the flush overrides mechanism we currently use to deal with texture fallbacks, wrap mode changes and to handle the use of highlevel CoglTextures that need to be resolved into lowlevel textures before flushing the material state. The flush options structure has been expanding in size and the structure is logged with every journal entry so it is not an approach that scales well at all. It also makes flushing material state that much more complex. Weak Materials: Again for renderlists we need a way to create materials derived from other materials but without the strict requirement that modifications to the original material wont affect the derived ("weak") material. The only requirement is that its possible to later check if the original material has been changed. A summary of the new design: A CoglMaterial now basically represents a diff against its parent. Each material has a single parent and a mask of state that it changes. Each group of state (such as the blending state) has an "authority" which is found by walking up from a given material through its ancestors checking the difference mask until a match for that group is found. There is only one root node to the graph of all materials, which is the default material first created when Cogl is being initialized. All the groups of state are divided into two types, such that infrequently changed state belongs in a separate "BigState" structure that is only allocated and attached to a material when necessary. CoglMaterialLayers are another sparse structure. Like CoglMaterials they represent a diff against their parent and all the layers are part of another graph with the "default_layer_0" layer being the root node that Cogl creates during initialization. Copying a material is now basically just a case of slice allocating a CoglMaterial, setting the parent to be the source being copied and zeroing the mask of changes. Flush overrides should now be handled by simply relying on the cheapness of copying a material and making changes to it. (This will be done in a follow on commit) Weak material support will be added in a follow on commit.
2010-04-08 07:21:04 -04:00
/* Notify cogl-material.c that the texture's underlying GL texture
* storage is changing so it knows it may need to bind a new texture
* if the CoglTexture is reused with the same texture unit. */
_cogl_material_texture_storage_change_notify (atlas_tex);
cogl-atlas-texture: Remove textures from the atlas when mipmapping is required Mipmaps don't work very well in the current atlas because there is not enough padding between the textures. If ensure_mipmaps is called it will now create a new texture and migrate the atlased texture to it. It will use the same blit mechanism as when migrating so it will try to use an FBO for a fast blit. However if this is not possible it will end up downloading the data for the entire atlas which is not ideal.
2009-12-05 08:48:03 -05:00
cogl_handle_unref (atlas_tex->sub_texture);
/* Create a new texture at the right size, not including the
border */
atlas_tex->sub_texture =
cogl_texture_new_with_size (atlas_tex->rectangle.width - 2,
atlas_tex->rectangle.height - 2,
COGL_TEXTURE_NO_ATLAS,
atlas_tex->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_texture_blit_begin (&blit_data, atlas_tex->sub_texture,
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
ctx->atlas_texture);
cogl-atlas-texture: Remove textures from the atlas when mipmapping is required Mipmaps don't work very well in the current atlas because there is not enough padding between the textures. If ensure_mipmaps is called it will now create a new texture and migrate the atlased texture to it. It will use the same blit mechanism as when migrating so it will try to use an FBO for a fast blit. However if this is not possible it will end up downloading the data for the entire atlas which is not ideal.
2009-12-05 08:48:03 -05:00
_cogl_atlas_texture_blit (&blit_data,
atlas_tex->rectangle.x + 1,
atlas_tex->rectangle.y + 1,
0, 0,
atlas_tex->rectangle.width - 2,
atlas_tex->rectangle.height - 2);
_cogl_atlas_texture_blit_end (&blit_data);
_cogl_atlas_texture_remove_from_atlas (atlas_tex);
}
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
}
static void
_cogl_atlas_texture_ensure_mipmaps (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Mipmaps do not work well with the current atlas so instead we'll
just migrate the texture out and use a regular texture */
_cogl_atlas_texture_migrate_out_of_atlas (atlas_tex);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
/* Forward on to the sub texture */
_cogl_texture_ensure_mipmaps (atlas_tex->sub_texture);
}
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
static void
_cogl_atlas_texture_ensure_non_quad_rendering (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Sub textures can't support non-quad rendering so we'll just
migrate the texture out */
_cogl_atlas_texture_migrate_out_of_atlas (atlas_tex);
/* Forward on to the sub texture */
_cogl_texture_ensure_non_quad_rendering (atlas_tex->sub_texture);
}
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
static gboolean
_cogl_atlas_texture_set_region_with_border (CoglAtlasTexture *atlas_tex,
int src_x,
int src_y,
int dst_x,
int dst_y,
unsigned int dst_width,
unsigned int dst_height,
int width,
int height,
CoglPixelFormat format,
unsigned int rowstride,
const guint8 *data)
{
_COGL_GET_CONTEXT (ctx, FALSE);
/* Copy the central data */
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
if (!cogl_texture_set_region (ctx->atlas_texture,
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
src_x, src_y,
dst_x + atlas_tex->rectangle.x + 1,
dst_y + atlas_tex->rectangle.y + 1,
dst_width,
dst_height,
width, height,
format,
rowstride,
data))
return FALSE;
/* Update the left edge pixels */
if (dst_x == 0 &&
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
!cogl_texture_set_region (ctx->atlas_texture,
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
src_x, src_y,
atlas_tex->rectangle.x,
dst_y + atlas_tex->rectangle.y + 1,
1, dst_height,
width, height,
format, rowstride,
data))
return FALSE;
/* Update the right edge pixels */
if (dst_x + dst_width == atlas_tex->rectangle.width - 2 &&
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
!cogl_texture_set_region (ctx->atlas_texture,
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
src_x + dst_width - 1, src_y,
atlas_tex->rectangle.x +
atlas_tex->rectangle.width - 1,
dst_y + atlas_tex->rectangle.y + 1,
1, dst_height,
width, height,
format, rowstride,
data))
return FALSE;
/* Update the top edge pixels */
if (dst_y == 0 &&
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
!cogl_texture_set_region (ctx->atlas_texture,
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
src_x, src_y,
dst_x + atlas_tex->rectangle.x + 1,
atlas_tex->rectangle.y,
dst_width, 1,
width, height,
format, rowstride,
data))
return FALSE;
/* Update the bottom edge pixels */
if (dst_y + dst_height == atlas_tex->rectangle.height - 2 &&
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
!cogl_texture_set_region (ctx->atlas_texture,
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
src_x, src_y + dst_height - 1,
dst_x + atlas_tex->rectangle.x + 1,
atlas_tex->rectangle.y +
atlas_tex->rectangle.height - 1,
dst_width, 1,
width, height,
format, rowstride,
data))
return FALSE;
return TRUE;
}
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
static gboolean
_cogl_atlas_texture_set_region (CoglTexture *tex,
int src_x,
int src_y,
int dst_x,
int dst_y,
unsigned int dst_width,
unsigned int dst_height,
int width,
int height,
CoglPixelFormat format,
unsigned int rowstride,
const guint8 *data)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* If the texture is in the atlas then we need to copy the edge
pixels to the border */
if (atlas_tex->in_atlas)
{
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
int bpp;
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
CoglBitmap source_bmp;
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
CoglBitmap tmp_bmp;
gboolean tmp_bmp_owner = FALSE;
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
gboolean success;
/* Check for valid format */
if (format == COGL_PIXEL_FORMAT_ANY)
return FALSE;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
/* Shortcut out early if the image is empty */
if (width == 0 || height == 0)
return TRUE;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
/* Init source bitmap */
source_bmp.width = width;
source_bmp.height = height;
source_bmp.format = format;
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
source_bmp.data = (guint8 *)data;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
/* Rowstride from width if none specified */
bpp = _cogl_get_format_bpp (format);
source_bmp.rowstride = (rowstride == 0) ? width * bpp : rowstride;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
/* Prepare the bitmap so that it will do the premultiplication
conversion */
_cogl_texture_prepare_for_upload (&source_bmp,
atlas_tex->format,
NULL,
&tmp_bmp,
&tmp_bmp_owner,
NULL, NULL, NULL);
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
/* Upload the data ignoring the premult bit */
success =
_cogl_atlas_texture_set_region_with_border (atlas_tex,
src_x, src_y,
dst_x, dst_y,
dst_width, dst_height,
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
tmp_bmp.width,
tmp_bmp.height,
tmp_bmp.format &
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
~COGL_PREMULT_BIT,
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
tmp_bmp.rowstride,
tmp_bmp.data);
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
/* Free data if owner */
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
if (tmp_bmp_owner)
g_free (tmp_bmp.data);
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
return success;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
}
else
/* Otherwise we can just forward on to the sub texture */
return cogl_texture_set_region (atlas_tex->sub_texture,
src_x, src_y,
dst_x, dst_y,
dst_width, dst_height,
width, height,
format, rowstride,
data);
}
static int
_cogl_atlas_texture_get_data (CoglTexture *tex,
CoglPixelFormat format,
unsigned int rowstride,
guint8 *data)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return cogl_texture_get_data (atlas_tex->sub_texture,
format,
rowstride,
data);
}
static CoglPixelFormat
_cogl_atlas_texture_get_format (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* We don't want to forward this on the sub-texture because it isn't
the necessarily the same format. This will happen if the texture
isn't pre-multiplied */
return atlas_tex->format;
}
static GLenum
_cogl_atlas_texture_get_gl_format (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return _cogl_texture_get_gl_format (atlas_tex->sub_texture);
}
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
static int
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
_cogl_atlas_texture_get_width (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return cogl_texture_get_width (atlas_tex->sub_texture);
}
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
static int
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
_cogl_atlas_texture_get_height (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
/* Forward on to the sub texture */
return cogl_texture_get_height (atlas_tex->sub_texture);
}
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
static CoglHandle
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
_cogl_atlas_texture_create_sub_texture (CoglHandle full_texture,
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
const CoglAtlasRectangle *rectangle)
{
/* Create a subtexture for the given rectangle not including the
1-pixel border */
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
return _cogl_sub_texture_new (full_texture,
rectangle->x + 1,
rectangle->y + 1,
rectangle->width - 2,
rectangle->height - 2);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
}
typedef struct _CoglAtlasTextureRepositionData
{
/* The current texture which already has a position */
CoglAtlasTexture *texture;
/* The new position of the texture */
CoglAtlasRectangle new_position;
} CoglAtlasTextureRepositionData;
static void
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
_cogl_atlas_texture_migrate (unsigned int n_textures,
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
CoglAtlasTextureRepositionData *textures,
CoglHandle old_texture,
CoglHandle new_texture,
CoglAtlasTexture *skip_texture)
{
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned int i;
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
CoglAtlasTextureBlitData blit_data;
atlas: fix some journal flushing issues 1) Always flush when migrating textures out of an atlas because although it's true that the original texture data will remain valid in the original texture we can't assume that journal entries have resolved the GL texture that will be used. This is only true if a layer0_override has been used. 2) Don't flush at the point of creating a new atlas simply flush immediately before reorganizing an atlas. This means we are now assuming that we will never see recursion due to atlas textures being modified during a journal flush. This means it's the responsibility of the primitives code to _ensure_mipmaps for example not the responsibility of _cogl_material_flush_gl_state.
2010-06-04 11:42:30 -04:00
/* We don't know if any materials may currently be referenced in the
* journal that depend on the current underlying GL texture storage
* so we flush the journal before migrating.
*
* We are assuming that texture atlas migration never happens during
* a flush so we don't have to consider recursion here.
*/
_cogl_journal_flush ();
cogl-atlas-texture: Flush the journal before starting blit not after _cogl_atlas_texture_blit_begin binds a texture to use as the destination and it expects it to stay bound until _cogl_atlas_texture_end_blit is called. However there was a call to _cogl_journal_flush directly after setting up the blit state which could cause the wrong texture to be bound. This just moves the flush to before the call to _cogl_atlas_texture_blit_begin. This was breaking test-cogl-sub-texture.
2010-06-09 09:42:18 -04:00
_cogl_atlas_texture_blit_begin (&blit_data, new_texture, old_texture);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
for (i = 0; i < n_textures; i++)
{
CoglMaterial: Implements sparse materials design This is a complete overhaul of the data structures used to manage CoglMaterial state. We have these requirements that were aiming to meet: (Note: the references to "renderlists" correspond to the effort to support scenegraph level shuffling of Clutter actor primitives so we can minimize GPU state changes) Sparse State: We wanted a design that allows sparse descriptions of state so it scales well as we make CoglMaterial responsible for more and more state. It needs to scale well in terms of memory usage and the cost of operations we need to apply to materials such as comparing, copying and flushing their state. I.e. we would rather have these things scale by the number of real changes a material represents not by how much overall state CoglMaterial becomes responsible for. Cheap Copies: As we add support for renderlists in Clutter we will need to be able to get an immutable handle for a given material's current state so that we can retain a record of a primitive with its associated material without worrying that changes to the original material will invalidate that record. No more flush override options: We want to get rid of the flush overrides mechanism we currently use to deal with texture fallbacks, wrap mode changes and to handle the use of highlevel CoglTextures that need to be resolved into lowlevel textures before flushing the material state. The flush options structure has been expanding in size and the structure is logged with every journal entry so it is not an approach that scales well at all. It also makes flushing material state that much more complex. Weak Materials: Again for renderlists we need a way to create materials derived from other materials but without the strict requirement that modifications to the original material wont affect the derived ("weak") material. The only requirement is that its possible to later check if the original material has been changed. A summary of the new design: A CoglMaterial now basically represents a diff against its parent. Each material has a single parent and a mask of state that it changes. Each group of state (such as the blending state) has an "authority" which is found by walking up from a given material through its ancestors checking the difference mask until a match for that group is found. There is only one root node to the graph of all materials, which is the default material first created when Cogl is being initialized. All the groups of state are divided into two types, such that infrequently changed state belongs in a separate "BigState" structure that is only allocated and attached to a material when necessary. CoglMaterialLayers are another sparse structure. Like CoglMaterials they represent a diff against their parent and all the layers are part of another graph with the "default_layer_0" layer being the root node that Cogl creates during initialization. Copying a material is now basically just a case of slice allocating a CoglMaterial, setting the parent to be the source being copied and zeroing the mask of changes. Flush overrides should now be handled by simply relying on the cheapness of copying a material and making changes to it. (This will be done in a follow on commit) Weak material support will be added in a follow on commit.
2010-04-08 07:21:04 -04:00
/* Notify cogl-material.c that the texture's underlying GL texture
* storage is changing so it knows it may need to bind a new texture
* if the CoglTexture is reused with the same texture unit. */
_cogl_material_texture_storage_change_notify (textures[i].texture);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
/* Skip the texture that is being added because it doesn't contain
any data yet */
if (textures[i].texture != skip_texture)
{
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
_cogl_atlas_texture_blit (&blit_data,
textures[i].texture->rectangle.x,
textures[i].texture->rectangle.y,
textures[i].new_position.x,
textures[i].new_position.y,
textures[i].new_position.width,
textures[i].new_position.height);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
/* Update the sub texture */
cogl_handle_unref (textures[i].texture->sub_texture);
textures[i].texture->sub_texture =
_cogl_atlas_texture_create_sub_texture (new_texture,
&textures[i].new_position);
}
/* Update the texture position */
textures[i].texture->rectangle = textures[i].new_position;
}
cogl-atlas-texture: Try to do texture blits using an FBO When reorganizing the textures, we can avoid downloading the entire texture data if we bind the source texture in a framebuffer object and copy the destination using glCopyTexSubImage2D. This is also implemented using a much faster path in Mesa. Currently it is calling the GL framebuffer API directly but ideally it would use the Cogl offscreen API. However there is no way to tell Cogl not to create a stencil renderbuffer which seems like a waste in this situation. If FBOs are not available it will fallback to reading back the entire texture data as before.
2009-12-05 08:24:01 -05:00
_cogl_atlas_texture_blit_end (&blit_data);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
}
typedef struct _CoglAtlasTextureGetRectanglesData
{
CoglAtlasTextureRepositionData *textures;
/* Number of textures found so far */
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned int n_textures;
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
} CoglAtlasTextureGetRectanglesData;
static void
_cogl_atlas_texture_get_rectangles_cb (const CoglAtlasRectangle *rectangle,
gpointer rectangle_data,
gpointer user_data)
{
CoglAtlasTextureGetRectanglesData *data = user_data;
data->textures[data->n_textures++].texture = rectangle_data;
}
static void
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
_cogl_atlas_texture_get_next_size (unsigned int *atlas_width,
unsigned int *atlas_height)
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
{
/* Double the size of the texture by increasing whichever dimension
is smaller */
if (*atlas_width < *atlas_height)
*atlas_width <<= 1;
else
*atlas_height <<= 1;
}
static CoglAtlas *
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
_cogl_atlas_texture_create_atlas (unsigned int atlas_width,
unsigned int atlas_height,
unsigned int n_textures,
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
CoglAtlasTextureRepositionData *textures)
{
GLint max_texture_size = 1024;
GE( glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_texture_size) );
/* Sanity check that we're not going to get stuck in an infinite
loop if the maximum texture size has the high bit set */
if ((max_texture_size & (1 << (sizeof (GLint) * 8 - 2))))
max_texture_size >>= 1;
/* Keep trying increasingly larger atlases until we can fit all of
the textures */
while (atlas_width < max_texture_size && atlas_height < max_texture_size)
{
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
CoglAtlas *new_atlas = _cogl_atlas_new (atlas_width, atlas_height, NULL);
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned int i;
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
/* Add all of the textures and keep track of the new position */
for (i = 0; i < n_textures; i++)
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
if (!_cogl_atlas_add_rectangle (new_atlas,
textures[i].texture->rectangle.width,
textures[i].texture->rectangle.height,
textures[i].texture,
&textures[i].new_position))
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
break;
/* If the atlas can contain all of the textures then we have a
winner */
if (i >= n_textures)
return new_atlas;
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_free (new_atlas);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
_cogl_atlas_texture_get_next_size (&atlas_width, &atlas_height);
}
/* If we get here then there's no atlas that can accommodate all of
the rectangles */
return NULL;
}
static int
_cogl_atlas_texture_compare_size_cb (const void *a,
const void *b)
{
const CoglAtlasTextureRepositionData *ta = a;
const CoglAtlasTextureRepositionData *tb = b;
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned int a_size, b_size;
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
a_size = ta->texture->rectangle.width * ta->texture->rectangle.height;
b_size = tb->texture->rectangle.width * tb->texture->rectangle.height;
return a_size < b_size ? 1 : a_size > b_size ? -1 : 0;
}
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
static gboolean
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
_cogl_atlas_texture_reserve_space (CoglAtlasTexture *new_sub_tex,
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned int width,
unsigned int height)
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
{
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
CoglAtlasTextureGetRectanglesData data;
CoglAtlas *new_atlas;
CoglHandle new_tex;
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
unsigned int atlas_width, atlas_height;
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
gboolean ret;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
_COGL_GET_CONTEXT (ctx, FALSE);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
/* Check if we can fit the rectangle into the existing atlas */
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
if (ctx->atlas && _cogl_atlas_add_rectangle (ctx->atlas, width, height,
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
new_sub_tex,
&new_sub_tex->rectangle))
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
{
COGL_NOTE (ATLAS, "Atlas is %ix%i, has %i textures and is %i%% waste",
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_get_width (ctx->atlas),
_cogl_atlas_get_height (ctx->atlas),
_cogl_atlas_get_n_rectangles (ctx->atlas),
_cogl_atlas_get_remaining_space (ctx->atlas) * 100 /
(_cogl_atlas_get_width (ctx->atlas) *
_cogl_atlas_get_height (ctx->atlas)));
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
return TRUE;
}
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
/* We need to reorganise the atlas so we'll get an array of all the
textures currently in the atlas. */
data.n_textures = 0;
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
if (ctx->atlas == NULL)
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
data.textures = g_malloc (sizeof (CoglAtlasTextureRepositionData));
else
{
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
data.textures =
g_malloc (sizeof (CoglAtlasTextureRepositionData) *
(_cogl_atlas_get_n_rectangles (ctx->atlas) + 1));
_cogl_atlas_foreach (ctx->atlas, _cogl_atlas_texture_get_rectangles_cb,
&data);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
}
/* Add the new rectangle as a dummy texture so that it can be
positioned with the rest */
data.textures[data.n_textures++].texture = new_sub_tex;
/* 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 (CoglAtlasTextureRepositionData),
_cogl_atlas_texture_compare_size_cb);
/* Try to create a new atlas that can contain all of the textures */
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
if (ctx->atlas)
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
{
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
atlas_width = _cogl_atlas_get_width (ctx->atlas);
atlas_height = _cogl_atlas_get_height (ctx->atlas);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
/* If there is enough space in the existing for the new
rectangle in the existing atlas we'll start with the same
size, otherwise we'll immediately double it */
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
if (_cogl_atlas_get_remaining_space (ctx->atlas) < width * height)
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
_cogl_atlas_texture_get_next_size (&atlas_width, &atlas_height);
}
else
{
/* Start with an initial size of 256x256 */
atlas_width = 256;
atlas_height = 256;
}
new_atlas = _cogl_atlas_texture_create_atlas (atlas_width, atlas_height,
data.n_textures, data.textures);
/* If we can't create an atlas with the texture then give up */
if (new_atlas == NULL)
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
{
COGL_NOTE (ATLAS, "Could not fit texture in the atlas");
ret = FALSE;
}
cogl-atlas-texture: Check for errors when creating the atlas texture cogl_texture_2d_new may fail in certain circumstances so cogl_atlas_texture_reserve_space should detect this and also fail. This will cause cogl_texture_new to fallback to a sliced texture. Thanks to Vladimir Ivakin for reporting this problem.
2010-02-16 06:58:47 -05:00
/* We need to migrate the existing textures into a new texture */
else if ((new_tex =
_cogl_texture_2d_new_with_size (_cogl_atlas_get_width (new_atlas),
_cogl_atlas_get_height (new_atlas),
COGL_TEXTURE_NONE,
COGL_PIXEL_FORMAT_RGBA_8888)) ==
COGL_INVALID_HANDLE)
{
COGL_NOTE (ATLAS, "Could not create a CoglTexture2D");
_cogl_atlas_free (new_atlas);
ret = FALSE;
}
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
else
{
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
COGL_NOTE (ATLAS,
"Atlas %s with size %ix%i",
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
ctx->atlas == NULL ||
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_get_width (ctx->atlas) !=
_cogl_atlas_get_width (new_atlas) ||
_cogl_atlas_get_height (ctx->atlas) !=
_cogl_atlas_get_height (new_atlas) ?
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
"resized" : "reorganized",
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_get_width (new_atlas),
_cogl_atlas_get_height (new_atlas));
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
if (ctx->atlas)
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
{
/* Move all the textures to the right position in the new
texture. This will also update the texture's rectangle */
_cogl_atlas_texture_migrate (data.n_textures,
data.textures,
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
ctx->atlas_texture,
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
new_tex,
new_sub_tex);
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_free (ctx->atlas);
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
cogl_handle_unref (ctx->atlas_texture);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
}
else
/* We know there's only one texture so we can just directly
update the rectangle from its new position */
data.textures[0].texture->rectangle = data.textures[0].new_position;
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
ctx->atlas = new_atlas;
ctx->atlas_texture = new_tex;
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
COGL_NOTE (ATLAS, "Atlas is %ix%i, has %i textures and is %i%% waste",
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_get_width (ctx->atlas),
_cogl_atlas_get_height (ctx->atlas),
_cogl_atlas_get_n_rectangles (ctx->atlas),
_cogl_atlas_get_remaining_space (ctx->atlas) * 100 /
(_cogl_atlas_get_width (ctx->atlas) *
_cogl_atlas_get_height (ctx->atlas)));
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
ret = TRUE;
}
g_free (data.textures);
return ret;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
}
CoglHandle
_cogl_atlas_texture_new_from_bitmap (CoglHandle bmp_handle,
CoglTextureFlags flags,
CoglPixelFormat internal_format)
{
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
CoglAtlasTexture *atlas_tex;
CoglBitmap *bmp = (CoglBitmap *) bmp_handle;
CoglBitmap dst_bmp;
gboolean dst_bmp_owner;
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
_COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);
g_return_val_if_fail (bmp_handle != COGL_INVALID_HANDLE, COGL_INVALID_HANDLE);
cogl-atlas-texture: Add a debug option to disable the atlas If the user specifies the 'disable-atlas' debug option then no texture will be put in the atlas.
2010-01-21 10:34:19 -05:00
/* Don't put textures in the atlas if the user has explicitly
requested to disable it */
if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_DISABLE_ATLAS))
return COGL_INVALID_HANDLE;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
/* We can't put the texture in the atlas if there are any special
flags. This precludes textures with COGL_TEXTURE_NO_ATLAS and
COGL_TEXTURE_NO_SLICING from being atlased */
if (flags)
return COGL_INVALID_HANDLE;
/* We can't atlas zero-sized textures because it breaks the atlas
data structure */
if (bmp->width < 1 || bmp->height < 1)
return COGL_INVALID_HANDLE;
cogl-atlas-texture: Don't use the atlas if FBOs aren't supported If FBOs aren't supported then it will end up very slow to reorganize the atlas. Also currently the CoglTexture2D backend will refuse to create any textures anyway so the full atlas texture won't be created.
2010-02-16 07:01:18 -05:00
/* If we can't use FBOs or we can't read back texture data then it
will be too slow to migrate textures and we shouldn't use the
atlas */
if (!cogl_features_available (COGL_FEATURE_TEXTURE_READ_PIXELS) ||
!cogl_features_available (COGL_FEATURE_OFFSCREEN))
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
return COGL_INVALID_HANDLE;
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
COGL_NOTE (ATLAS, "Adding texture of size %ix%i", bmp->width, bmp->height);
cogl-texture: Split out _cogl_texture_prepare_for_upload The Cogl atlas code was using _cogl_texture_prepare_for_upload with a NULL pointer for the dst_bmp to determine the internal format of the texture without converting the bitmap. It needs to do this to decide whether the texture will go in the atlas before wasting time on the conversion. This use of the function is a little confusing so that part of it has been split out into a new function called _cogl_texture_determine_internal_format. The code to decide whether a premult conversion is needed has also been split out.
2010-02-03 17:54:44 -05:00
internal_format = _cogl_texture_determine_internal_format (bmp->format,
internal_format);
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
/* If the texture is in a strange format then we can't use it */
if (internal_format != COGL_PIXEL_FORMAT_RGB_888 &&
(internal_format & ~COGL_PREMULT_BIT) != COGL_PIXEL_FORMAT_RGBA_8888)
{
cogl-texture-atlas: Add some debugging notes This adds an 'atlas' category to the COGL_DEBUG environment variable. When enabled Cogl will display messages when textures are added to the atlas and when the atlas is reorganized.
2009-12-04 13:55:53 -05:00
COGL_NOTE (ATLAS, "Texture can not be added because the "
"format is unsupported");
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
return COGL_INVALID_HANDLE;
}
/* We need to allocate the texture now because we need the pointer
to set as the data for the rectangle in the atlas */
atlas_tex = g_new (CoglAtlasTexture, 1);
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
/* We need to fill in the texture size now because it is used in the
reserve_space function below. We add two pixels for the border */
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
atlas_tex->rectangle.width = bmp->width + 2;
atlas_tex->rectangle.height = bmp->height + 2;
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
/* Try to make some space in the atlas for the texture */
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
if (!_cogl_atlas_texture_reserve_space (atlas_tex,
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
atlas_tex->rectangle.width,
atlas_tex->rectangle.height))
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
{
g_free (atlas_tex);
return COGL_INVALID_HANDLE;
}
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
if (!_cogl_texture_prepare_for_upload (bmp,
internal_format,
&internal_format,
&dst_bmp,
&dst_bmp_owner,
&gl_intformat,
&gl_format,
&gl_type))
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
{
cogl-atlas: Make the cogl_atlas_* API internal This just adds an underscore to every entry point for the CoglAtlas API so that it's not exported.
2010-02-03 14:54:12 -05:00
_cogl_atlas_remove_rectangle (ctx->atlas, &atlas_tex->rectangle);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
g_free (atlas_tex);
return COGL_INVALID_HANDLE;
}
atlas_tex->_parent.vtable = &cogl_atlas_texture_vtable;
atlas_tex->format = internal_format;
atlas_tex->in_atlas = TRUE;
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
atlas_tex->sub_texture =
cogl-atlas-texture: Use a single atlas for both RGB and RGBA textures The internal format of the atlas texture is still set to the appropriate format so Cogl will disable blending for textures that are intended to be RGB. This should end up ignoring the alpha channel from the texture in the atlas. This makes the code slightly easier to maintain and should also improve the chances of batching.
2010-01-29 07:19:42 -05:00
_cogl_atlas_texture_create_sub_texture (ctx->atlas_texture,
cogl-atlas-texture: Support reorganizing the atlas when it is full When space can't be found in the atlas for a new texture it will now try to reorganize the atlas to make space. A new CoglAtlas is created and all of the textures are readded in decreasing size order. If the textures still don't fit then the size of the atlas is doubled until either we find a space or we reach the texture size limits. If we successfully find an organization that fits then all of the textures will be migrated to a new texture. This involves copying the texture data into CPU memory and then uploading it again. Potentially it could eventually use a PBO or an FBO to transfer the image without going through the CPU. The algorithm for laying out the textures works a lot better if the rectangles are added in order so we might eventually want some API for creating multiple textures in one go to avoid reorganizing the atlas as far as possible.
2009-12-04 13:24:15 -05:00
&atlas_tex->rectangle);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
/* Defer to set_region so that we can share the code for copying the
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
edge pixels to the border. We don't want to pass the actual
format of the converted texture because otherwise it will get
unpremultiplied. */
_cogl_atlas_texture_set_region_with_border (atlas_tex,
0, 0,
0, 0,
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
dst_bmp.width,
dst_bmp.height,
dst_bmp.width,
dst_bmp.height,
dst_bmp.format &
cogl-atlas-texture: Fix premultiplied texture formats When uploading texture data it was just calling cogl_texture_set_data on the large texture. This would attempt to convert the data to the format of the large texture. All of the textures with alpha channels are stored together regardless of whether they are premultiplied so this was causing premultiplied textures to be unpremultiplied again. It now just uploads the data ignoring the premult bit of the format so that it only gets converted once.
2010-01-18 05:53:00 -05:00
~COGL_PREMULT_BIT,
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
dst_bmp.rowstride,
dst_bmp.data);
if (dst_bmp_owner)
g_free (dst_bmp.data);
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
return _cogl_atlas_texture_handle_new (atlas_tex);
}
static const CoglTextureVtable
cogl_atlas_texture_vtable =
{
_cogl_atlas_texture_set_region,
_cogl_atlas_texture_get_data,
_cogl_atlas_texture_foreach_sub_texture_in_region,
_cogl_atlas_texture_get_max_waste,
_cogl_atlas_texture_is_sliced,
_cogl_atlas_texture_can_hardware_repeat,
_cogl_atlas_texture_transform_coords_to_gl,
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
_cogl_atlas_texture_transform_quad_coords_to_gl,
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
_cogl_atlas_texture_get_gl_texture,
_cogl_atlas_texture_set_filters,
_cogl_atlas_texture_ensure_mipmaps,
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
_cogl_atlas_texture_ensure_non_quad_rendering,
Split the wrap mode of _cogl_texture_set_wrap_mode into three GL supports setting different wrap modes for the s, t and r coordinates so we should design the backend interface to support that also. The r coordinate is not currently used by any of the backends but we might as well have it to make life easier if we ever add support for 3D textures. http://bugzilla.openedhand.com/show_bug.cgi?id=2063
2010-03-25 13:29:22 -04:00
_cogl_atlas_texture_set_wrap_mode_parameters,
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
_cogl_atlas_texture_get_format,
_cogl_atlas_texture_get_gl_format,
_cogl_atlas_texture_get_width,
material: Avoid redundant glBindTexture calls This adds a _cogl_bind_gl_texture_transient function that should be used instead of glBindTexture so we can have a consistent cache of the textures bound to each texture unit so we can avoid some redundant binding.
2010-04-26 05:01:43 -04:00
_cogl_atlas_texture_get_height,
NULL /* is_foreign */
cogl: Add an atlased texture backend This adds a CoglAtlas type which is a data structure that keeps track of unused sub rectangles of a larger rectangle. There is a new atlased texture backend which uses this to put multiple textures into a single larger texture. Currently the atlas is always sized 256x256 and the textures are never moved once they are put in. Eventually it needs to be able to reorganise the atlas and grow it if necessary. It also needs to migrate the textures out of the atlas if mipmaps are required.
2009-12-04 08:06:32 -05:00
};
Reference in New Issue Copy Permalink