sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/cogl/cogl-texture-2d-sliced.c

1391 lines
46 KiB
C
Raw Normal View History

[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
* Copyright (C) 2007,2008,2009,2010 Intel Corporation.
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00: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 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
*
* Authors:
* Matthew Allum <mallum@openedhand.com>
* Neil Roberts <neil@linux.intel.com>
* Robert Bragg <robert@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cogl.h"
cogl: don't include cogl-debug.h in cogl.h or install cogl-debug.h is an internal header so it shouldn't have been included by cogl.h and the header shouldn't be installed either.
2010-07-25 20:36:41 +00:00
#include "cogl-debug.h"
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
#include "cogl-internal.h"
#include "cogl-util.h"
#include "cogl-bitmap.h"
#include "cogl-bitmap-private.h"
#include "cogl-texture-private.h"
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
#include "cogl-texture-2d-private.h"
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
#include "cogl-texture-2d-sliced-private.h"
#include "cogl-texture-driver.h"
cogl: rename cogl-context.h cogl-context-private.h Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
2010-11-04 22:25:52 +00:00
#include "cogl-context-private.h"
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
#include "cogl-handle.h"
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
#include "cogl-spans.h"
cogl: remove redundant _cogl_journal_flush prototype There was a redundant _cogl_journal_flush function prototype in cogl-primitives.h
2010-02-10 18:18:30 +00:00
#include "cogl-journal-private.h"
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 17:54:57 +00:00
#include "cogl-pipeline-opengl-private.h"
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
#include <string.h>
#include <stdlib.h>
#include <math.h>
static void _cogl_texture_2d_sliced_free (CoglTexture2DSliced *tex_2ds);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
COGL_TEXTURE_DEFINE (Texture2DSliced, texture_2d_sliced);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static const CoglTextureVtable cogl_texture_2d_sliced_vtable;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
typedef struct
{
CoglTexture2DSliced *tex;
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
CoglSpan *x_span;
CoglSpan *y_span;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
CoglTextureSliceCallback callback;
void *user_data;
} ForeachData;
static void
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
_cogl_texture_2d_sliced_foreach_cb (CoglTexture *texture,
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
const float *slice_coords,
const float *virtual_coords_in,
void *user_data)
{
float virtual_coords_out[4];
ForeachData *data = user_data;
/* Convert the virtual coordinates of the texture slice back to
coordinates in the space of the outer texture */
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
virtual_coords_out[0] = (virtual_coords_in[0] * data->x_span->size +
data->x_span->start) / data->tex->width;
virtual_coords_out[1] = (virtual_coords_in[1] * data->y_span->size +
data->y_span->start) / data->tex->height;
virtual_coords_out[2] = (virtual_coords_in[2] * data->x_span->size +
data->x_span->start) / data->tex->width;
virtual_coords_out[3] = (virtual_coords_in[3] * data->y_span->size +
data->y_span->start) / data->tex->height;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
Add a strong CoglTexture type to replace CoglHandle As part of the on going, incremental effort to purge the non type safe CoglHandle type from the Cogl API this patch tackles most of the CoglHandle uses relating to textures. We'd postponed making this change for quite a while because we wanted to have a clearer understanding of how we wanted to evolve the texture APIs towards Cogl 2.0 before exposing type safety here which would be difficult to change later since it would imply breaking APIs. The basic idea that we are steering towards now is that CoglTexture can be considered to be the most primitive interface we have for any object representing a texture. The texture interface would provide roughly these methods: cogl_texture_get_width cogl_texture_get_height cogl_texture_can_repeat cogl_texture_can_mipmap cogl_texture_generate_mipmap; cogl_texture_get_format cogl_texture_set_region cogl_texture_get_region Besides the texture interface we will then start to expose types corresponding to specific texture types: CoglTexture2D, CoglTexture3D, CoglTexture2DSliced, CoglSubTexture, CoglAtlasTexture and CoglTexturePixmapX11. We will then also expose an interface for the high-level texture types we have (such as CoglTexture2DSlice, CoglSubTexture and CoglAtlasTexture) called CoglMetaTexture. CoglMetaTexture is an additional interface that lets you iterate a virtual region of a meta texture and get mappings of primitive textures to sub-regions of that virtual region. Internally we already have this kind of abstraction for dealing with sliced texture, sub-textures and atlas textures in a consistent way, so this will just make that abstraction public. The aim here is to clarify that there is a difference between primitive textures (CoglTexture2D/3D) and some of the other high-level textures, and also enable developers to implement primitives that can support meta textures since they can only be used with the cogl_rectangle API currently. The thing that's not so clean-cut with this are the texture constructors we have currently; such as cogl_texture_new_from_file which no longer make sense when CoglTexture is considered to be an interface. These will basically just become convenient factory functions and it's just a bit unusual that they are within the cogl_texture namespace. It's worth noting here that all the texture type APIs will also have their own type specific constructors so these functions will only be used for the convenience of being able to create a texture without really wanting to know the details of what type of texture you need. Longer term for 2.0 we may come up with replacement names for these factory functions or the other thing we are considering is designing some asynchronous factory functions instead since it's so often detrimental to application performance to be blocked waiting for a texture to be uploaded to the GPU. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-08-24 20:30:34 +00:00
data->callback (texture,
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
slice_coords,
virtual_coords_out,
data->user_data);
}
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* To differentiate between texture coordinates of a specific, real, slice
* texture and the texture coordinates of the composite, sliced texture, the
* coordinates of the sliced texture are called "virtual" coordinates and the
* coordinates of slices are called "slice" coordinates. */
/* This function lets you iterate all the slices that lie within the given
* virtual coordinates of the parent sliced texture. */
/* Note: no guarantee is given about the order in which the slices will be
* visited */
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static void
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
_cogl_texture_2d_sliced_foreach_sub_texture_in_region (
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture *tex,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
float virtual_tx_1,
float virtual_ty_1,
float virtual_tx_2,
float virtual_ty_2,
CoglTextureSliceCallback callback,
void *user_data)
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
float width = tex_2ds->width;
float height = tex_2ds->height;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
CoglSpanIter iter_x;
CoglSpanIter iter_y;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
ForeachData data;
data.tex = COGL_TEXTURE_2D_SLICED (tex);
data.callback = callback;
data.user_data = user_data;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Slice spans are stored in denormalized coordinates, and this is what
* the _cogl_span_iter_* funcs expect to be given, so we scale the given
* virtual coordinates by the texture size to denormalize.
*/
/* XXX: I wonder if it's worth changing how we store spans so we can avoid
* the need to denormalize here */
virtual_tx_1 *= width;
virtual_ty_1 *= height;
virtual_tx_2 *= width;
virtual_ty_2 *= height;
/* Iterate the y axis of the virtual rectangle */
for (_cogl_span_iter_begin (&iter_y,
tex_2ds->slice_y_spans,
height,
virtual_ty_1,
virtual_ty_2);
!_cogl_span_iter_end (&iter_y);
_cogl_span_iter_next (&iter_y))
{
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
float y_intersect_start = iter_y.intersect_start;
float y_intersect_end = iter_y.intersect_end;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
float slice_ty1;
float slice_ty2;
if (iter_y.flipped)
{
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
y_intersect_start = iter_y.intersect_end;
y_intersect_end = iter_y.intersect_start;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
/* Localize slice texture coordinates */
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
slice_ty1 = y_intersect_start - iter_y.pos;
slice_ty2 = y_intersect_end - iter_y.pos;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Normalize slice texture coordinates */
slice_ty1 /= iter_y.span->size;
slice_ty2 /= iter_y.span->size;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
data.y_span = iter_y.span;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Iterate the x axis of the virtual rectangle */
for (_cogl_span_iter_begin (&iter_x,
tex_2ds->slice_x_spans,
width,
virtual_tx_1,
virtual_tx_2);
!_cogl_span_iter_end (&iter_x);
_cogl_span_iter_next (&iter_x))
{
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
float x_intersect_start = iter_x.intersect_start;
float x_intersect_end = iter_x.intersect_end;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
float slice_tx1;
float slice_tx2;
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
if (iter_x.flipped)
{
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
x_intersect_start = iter_x.intersect_end;
x_intersect_end = iter_x.intersect_start;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
/* Localize slice texture coordinates */
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
slice_tx1 = x_intersect_start - iter_x.pos;
slice_tx2 = x_intersect_end - iter_x.pos;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Normalize slice texture coordinates */
slice_tx1 /= iter_x.span->size;
slice_tx2 /= iter_x.span->size;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Fix the foreach callback for waste textures When converting the virtual coordinates of the underlying texture for a slice to virtual coordinates for the whole texture it was using the size and offset of the intersection as the size of the child texture. This would be incorrect if the texture contains waste or the texture coordinates are not the default. Instead the sliced foreach function now passes the CoglSpan to the callback instead of the intersection. http://bugzilla.clutter-project.org/show_bug.cgi?id=2398
2010-11-05 14:38:19 +00:00
data.x_span = iter_x.span;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Pluck out the cogl texture for this slice */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
iter_y.index * iter_x.array->len +
iter_x.index);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
_cogl_texture_foreach_sub_texture_in_region
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
(COGL_TEXTURE (slice_tex),
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
slice_tx1, slice_ty1, slice_tx2, slice_ty2,
_cogl_texture_2d_sliced_foreach_cb,
&data);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00: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-10 01:57:32 +00:00
static guint8 *
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
_cogl_texture_2d_sliced_allocate_waste_buffer (CoglTexture2DSliced *tex_2ds,
CoglPixelFormat format)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan *last_x_span;
CoglSpan *last_y_span;
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-10 01:57:32 +00:00
guint8 *waste_buf = NULL;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* If the texture has any waste then allocate a buffer big enough to
fill the gaps */
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
last_x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
tex_2ds->slice_x_spans->len - 1);
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
last_y_span = &g_array_index (tex_2ds->slice_y_spans, CoglSpan,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
tex_2ds->slice_y_spans->len - 1);
if (last_x_span->waste > 0 || last_y_span->waste > 0)
{
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-10 01:57:32 +00:00
int bpp = _cogl_get_format_bpp (format);
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan *first_x_span
= &g_array_index (tex_2ds->slice_x_spans, CoglSpan, 0);
CoglSpan *first_y_span
= &g_array_index (tex_2ds->slice_y_spans, CoglSpan, 0);
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-10 01:57:32 +00:00
unsigned int right_size = first_y_span->size * last_x_span->waste;
unsigned int bottom_size = first_x_span->size * last_y_span->waste;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
waste_buf = g_malloc (MAX (right_size, bottom_size) * bpp);
}
return waste_buf;
}
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
static void
_cogl_texture_2d_sliced_set_waste (CoglTexture2DSliced *tex_2ds,
CoglBitmap *source_bmp,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex,
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
guint8 *waste_buf,
CoglSpan *x_span,
CoglSpan *y_span,
CoglSpanIter *x_iter,
CoglSpanIter *y_iter,
int src_x,
int src_y,
int dst_x,
int dst_y)
{
gboolean need_x, need_y;
/* If the x_span is sliced and the upload touches the
rightmost pixels then fill the waste with copies of the
pixels */
need_x = x_span->waste > 0 &&
x_iter->intersect_end - x_iter->pos >= x_span->size - x_span->waste;
/* same for the bottom-most pixels */
need_y = y_span->waste > 0 &&
y_iter->intersect_end - y_iter->pos >= y_span->size - y_span->waste;
if (need_x || need_y)
{
int bmp_rowstride = _cogl_bitmap_get_rowstride (source_bmp);
CoglPixelFormat source_format = _cogl_bitmap_get_format (source_bmp);
int bpp = _cogl_get_format_bpp (source_format);
guint8 *bmp_data;
const guint8 *src;
guint8 *dst;
unsigned int wy, wx;
CoglBitmap *waste_bmp;
bmp_data = _cogl_bitmap_map (source_bmp, COGL_BUFFER_ACCESS_READ, 0);
if (bmp_data == NULL)
return;
if (need_x)
{
src = (bmp_data + ((src_y + (int) y_iter->intersect_start - dst_y) *
bmp_rowstride) +
(src_x + x_span->start + x_span->size -
x_span->waste - dst_x - 1) * bpp);
dst = waste_buf;
for (wy = 0;
wy < y_iter->intersect_end - y_iter->intersect_start;
wy++)
{
for (wx = 0; wx < x_span->waste; wx++)
{
memcpy (dst, src, bpp);
dst += bpp;
}
src += bmp_rowstride;
}
waste_bmp =
_cogl_bitmap_new_from_data (waste_buf,
source_format,
x_span->waste,
y_iter->intersect_end -
y_iter->intersect_start,
x_span->waste * bpp,
NULL,
NULL);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
cogl_texture_set_region_from_bitmap (COGL_TEXTURE (slice_tex),
Export API for uploading a tex subregion from a CoglBuffer This exposes 2 experimental functions that make it possible to upload a subregion of a texture from a CoglBuffer by first wrapping the buffer as a CoglBitmap and then allowing uploading of a subregion from a CoglBitmap. The new functions are: cogl_bitmap_new_from_buffer() and cogl_texture_set_region_from_bitmap() Actually for now we are exporting this API for practical reasons since we already had this API internally and it enables a specific feature that was requested, but it is worth nothing that it's quite likely we will replace these with functions that don't involve the CoglBitmap API at some point. For reference: The CoglBitmap API was actually removed from the 2.0 experimental API reference manual some time ago because the hope was that we'd come up with a neater replacement. It doesn't seem entirely clear what the scope of the CoglBitmap api is so it has became a bit of a dumping ground. CoglBitmap is used for image loading, as a means to represent the layout of image data and also internally deals with format conversions. Note: Because we are avoiding including CoglBitmap as part of the 2.0 API these functions aren't currently included in the 2.0 reference manual. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-07-25 21:14:08 +00:00
0, /* src_x */
0, /* src_y */
/* dst_x */
x_span->size - x_span->waste,
y_iter->intersect_start -
y_span->start, /* dst_y */
x_span->waste, /* dst_width */
/* dst_height */
y_iter->intersect_end -
y_iter->intersect_start,
waste_bmp);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
cogl_object_unref (waste_bmp);
}
if (need_y)
{
unsigned int copy_width, intersect_width;
src = (bmp_data + ((src_x + (int) x_iter->intersect_start - dst_x) *
bpp) +
(src_y + y_span->start + y_span->size - y_span->waste
- dst_y - 1) * bmp_rowstride);
dst = waste_buf;
if (x_iter->intersect_end - x_iter->pos
>= x_span->size - x_span->waste)
copy_width = x_span->size + x_iter->pos - x_iter->intersect_start;
else
copy_width = x_iter->intersect_end - x_iter->intersect_start;
intersect_width = x_iter->intersect_end - x_iter->intersect_start;
for (wy = 0; wy < y_span->waste; wy++)
{
memcpy (dst, src, intersect_width * bpp);
dst += intersect_width * bpp;
for (wx = intersect_width; wx < copy_width; wx++)
{
memcpy (dst, dst - bpp, bpp);
dst += bpp;
}
}
waste_bmp =
_cogl_bitmap_new_from_data (waste_buf,
source_format,
copy_width,
y_span->waste,
copy_width * bpp,
NULL,
NULL);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
cogl_texture_set_region_from_bitmap (COGL_TEXTURE (slice_tex),
Export API for uploading a tex subregion from a CoglBuffer This exposes 2 experimental functions that make it possible to upload a subregion of a texture from a CoglBuffer by first wrapping the buffer as a CoglBitmap and then allowing uploading of a subregion from a CoglBitmap. The new functions are: cogl_bitmap_new_from_buffer() and cogl_texture_set_region_from_bitmap() Actually for now we are exporting this API for practical reasons since we already had this API internally and it enables a specific feature that was requested, but it is worth nothing that it's quite likely we will replace these with functions that don't involve the CoglBitmap API at some point. For reference: The CoglBitmap API was actually removed from the 2.0 experimental API reference manual some time ago because the hope was that we'd come up with a neater replacement. It doesn't seem entirely clear what the scope of the CoglBitmap api is so it has became a bit of a dumping ground. CoglBitmap is used for image loading, as a means to represent the layout of image data and also internally deals with format conversions. Note: Because we are avoiding including CoglBitmap as part of the 2.0 API these functions aren't currently included in the 2.0 reference manual. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-07-25 21:14:08 +00:00
0, /* src_x */
0, /* src_y */
/* dst_x */
x_iter->intersect_start -
x_iter->pos,
/* dst_y */
y_span->size - y_span->waste,
copy_width, /* dst_width */
y_span->waste, /* dst_height */
waste_bmp);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
cogl_object_unref (waste_bmp);
}
_cogl_bitmap_unmap (source_bmp);
}
}
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
static gboolean
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
_cogl_texture_2d_sliced_upload_to_gl (CoglTexture2DSliced *tex_2ds,
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
CoglBitmap *bmp)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
CoglSpan *x_span;
CoglSpan *y_span;
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
int x, y;
guint8 *waste_buf;
CoglPixelFormat bmp_format;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
bmp_format = _cogl_bitmap_get_format (bmp);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00: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 12:11:58 +00:00
waste_buf = _cogl_texture_2d_sliced_allocate_waste_buffer (tex_2ds,
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
bmp_format);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Iterate vertical slices */
for (y = 0; y < tex_2ds->slice_y_spans->len; ++y)
{
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
y_span = &g_array_index (tex_2ds->slice_y_spans, CoglSpan, y);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Iterate horizontal slices */
for (x = 0; x < tex_2ds->slice_x_spans->len; ++x)
{
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-10 01:57:32 +00:00
int slice_num = y * tex_2ds->slice_x_spans->len + x;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
CoglSpanIter x_iter, y_iter;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan, x);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Pick the gl texture object handle */
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *, slice_num);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
cogl_texture_set_region_from_bitmap (COGL_TEXTURE (slice_tex),
Export API for uploading a tex subregion from a CoglBuffer This exposes 2 experimental functions that make it possible to upload a subregion of a texture from a CoglBuffer by first wrapping the buffer as a CoglBitmap and then allowing uploading of a subregion from a CoglBitmap. The new functions are: cogl_bitmap_new_from_buffer() and cogl_texture_set_region_from_bitmap() Actually for now we are exporting this API for practical reasons since we already had this API internally and it enables a specific feature that was requested, but it is worth nothing that it's quite likely we will replace these with functions that don't involve the CoglBitmap API at some point. For reference: The CoglBitmap API was actually removed from the 2.0 experimental API reference manual some time ago because the hope was that we'd come up with a neater replacement. It doesn't seem entirely clear what the scope of the CoglBitmap api is so it has became a bit of a dumping ground. CoglBitmap is used for image loading, as a means to represent the layout of image data and also internally deals with format conversions. Note: Because we are avoiding including CoglBitmap as part of the 2.0 API these functions aren't currently included in the 2.0 reference manual. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-07-25 21:14:08 +00:00
x_span->start, /* src x */
y_span->start, /* src y */
0, /* dst x */
0, /* dst y */
x_span->size -
x_span->waste, /* width */
y_span->size -
y_span->waste, /* height */
bmp);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Set up a fake iterator that covers the whole slice */
x_iter.intersect_start = x_span->start;
x_iter.intersect_end = (x_span->start +
x_span->size -
x_span->waste);
x_iter.pos = x_span->start;
y_iter.intersect_start = y_span->start;
y_iter.intersect_end = (y_span->start +
y_span->size -
y_span->waste);
y_iter.pos = y_span->start;
_cogl_texture_2d_sliced_set_waste (tex_2ds,
bmp,
slice_tex,
waste_buf,
x_span, y_span,
&x_iter, &y_iter,
0, /* src_x */
0, /* src_y */
0, /* dst_x */
0); /* dst_y */
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
}
if (waste_buf)
g_free (waste_buf);
return TRUE;
}
static gboolean
_cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
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-10 01:57:32 +00:00
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
CoglBitmap *source_bmp,
GLuint source_gl_format,
GLuint source_gl_type)
{
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan *x_span;
CoglSpan *y_span;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
CoglSpanIter x_iter;
CoglSpanIter y_iter;
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_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-10 01:57:32 +00:00
int source_x = 0, source_y = 0;
int inter_w = 0, inter_h = 0;
int local_x = 0, local_y = 0;
guint8 *waste_buf;
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
CoglPixelFormat source_format;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
source_format = _cogl_bitmap_get_format (source_bmp);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
waste_buf =
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
_cogl_texture_2d_sliced_allocate_waste_buffer (tex_2ds, source_format);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Iterate vertical spans */
for (source_y = src_y,
_cogl_span_iter_begin (&y_iter,
tex_2ds->slice_y_spans,
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
tex_2ds->height,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
dst_y,
dst_y + height);
!_cogl_span_iter_end (&y_iter);
_cogl_span_iter_next (&y_iter),
source_y += inter_h )
{
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
y_span = &g_array_index (tex_2ds->slice_y_spans, CoglSpan,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
y_iter.index);
/* Iterate horizontal spans */
for (source_x = src_x,
_cogl_span_iter_begin (&x_iter,
tex_2ds->slice_x_spans,
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
tex_2ds->width,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
dst_x,
dst_x + width);
!_cogl_span_iter_end (&x_iter);
_cogl_span_iter_next (&x_iter),
source_x += inter_w )
{
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-10 01:57:32 +00:00
int slice_num;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
x_iter.index);
/* Pick intersection width and height */
inter_w = (x_iter.intersect_end - x_iter.intersect_start);
inter_h = (y_iter.intersect_end - y_iter.intersect_start);
/* Localize intersection top-left corner to slice*/
local_x = (x_iter.intersect_start - x_iter.pos);
local_y = (y_iter.intersect_start - y_iter.pos);
slice_num = y_iter.index * tex_2ds->slice_x_spans->len + x_iter.index;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Pick slice texture */
slice_tex = g_array_index (tex_2ds->slice_textures,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *, slice_num);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
cogl_texture_set_region_from_bitmap (COGL_TEXTURE (slice_tex),
Export API for uploading a tex subregion from a CoglBuffer This exposes 2 experimental functions that make it possible to upload a subregion of a texture from a CoglBuffer by first wrapping the buffer as a CoglBitmap and then allowing uploading of a subregion from a CoglBitmap. The new functions are: cogl_bitmap_new_from_buffer() and cogl_texture_set_region_from_bitmap() Actually for now we are exporting this API for practical reasons since we already had this API internally and it enables a specific feature that was requested, but it is worth nothing that it's quite likely we will replace these with functions that don't involve the CoglBitmap API at some point. For reference: The CoglBitmap API was actually removed from the 2.0 experimental API reference manual some time ago because the hope was that we'd come up with a neater replacement. It doesn't seem entirely clear what the scope of the CoglBitmap api is so it has became a bit of a dumping ground. CoglBitmap is used for image loading, as a means to represent the layout of image data and also internally deals with format conversions. Note: Because we are avoiding including CoglBitmap as part of the 2.0 API these functions aren't currently included in the 2.0 reference manual. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-07-25 21:14:08 +00:00
source_x,
source_y,
local_x, /* dst x */
local_y, /* dst y */
inter_w, /* width */
inter_h, /* height */
source_bmp);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
_cogl_texture_2d_sliced_set_waste (tex_2ds,
source_bmp,
slice_tex,
waste_buf,
x_span, y_span,
&x_iter, &y_iter,
src_x, src_y,
dst_x, dst_y);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
}
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
g_free (waste_buf);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return TRUE;
}
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-10 01:57:32 +00:00
static int
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
_cogl_rect_slices_for_size (int size_to_fill,
int max_span_size,
int max_waste,
GArray *out_spans)
{
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-10 01:57:32 +00:00
int n_spans = 0;
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan span;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Init first slice span */
span.start = 0;
span.size = max_span_size;
span.waste = 0;
/* Repeat until whole area covered */
while (size_to_fill >= span.size)
{
/* Add another slice span of same size */
if (out_spans)
g_array_append_val (out_spans, span);
span.start += span.size;
size_to_fill -= span.size;
n_spans++;
}
/* Add one last smaller slice span */
if (size_to_fill > 0)
{
span.size = size_to_fill;
if (out_spans)
g_array_append_val (out_spans, span);
n_spans++;
}
return n_spans;
}
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-10 01:57:32 +00:00
static int
_cogl_pot_slices_for_size (int size_to_fill,
int max_span_size,
int max_waste,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
GArray *out_spans)
{
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-10 01:57:32 +00:00
int n_spans = 0;
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan span;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Init first slice span */
span.start = 0;
span.size = max_span_size;
span.waste = 0;
/* Fix invalid max_waste */
if (max_waste < 0)
max_waste = 0;
while (TRUE)
{
/* Is the whole area covered? */
if (size_to_fill > span.size)
{
/* Not yet - add a span of this size */
if (out_spans)
g_array_append_val (out_spans, span);
span.start += span.size;
size_to_fill -= span.size;
n_spans++;
}
else if (span.size - size_to_fill <= max_waste)
{
/* Yes and waste is small enough */
cogl-texture-2d-sliced: Use the smallest possible waste When picking a size for the last slice in a texture, Cogl would always pick the biggest power of two size that doesn't create too much waste and is less than or equal to the previous slice size. However this can end up creating a texture that is bigger than needed if there is a smaller power of two. For example, if the maximum waste is 127 (the current default) and we try to create a texture that is 257 pixels wide it will decide that the next power of two (512) is too much waste (255) so it will create the first slice at 256 pixels wide. Then we only have 1 pixel left to allocate but Cogl would pick the next smaller size that has a small enough waste which is 128. But of course 1 is already a power of two so that's redundantly oversized by 127. This patch fixes it so that whenever it finds a size that would be big enough, instead of using exactly that it picks the next power of two up from the size we need to fill. http://bugzilla.clutter-project.org/show_bug.cgi?id=2355
2010-10-05 16:17:53 +00:00
/* Pick the next power of two up from size_to_fill. This can
sometimes be less than the span.size that would be chosen
otherwise */
span.size = _cogl_util_next_p2 (size_to_fill);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
span.waste = span.size - size_to_fill;
if (out_spans)
g_array_append_val (out_spans, span);
return ++n_spans;
}
else
{
/* Yes but waste is too large */
while (span.size - size_to_fill > max_waste)
{
span.size /= 2;
g_assert (span.size > 0);
}
}
}
/* Can't get here */
return 0;
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
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 17:29:22 +00:00
_cogl_texture_2d_sliced_set_wrap_mode_parameters (CoglTexture *tex,
GLenum wrap_mode_s,
GLenum wrap_mode_t,
Rename the third texure coordinate from 'r' to 'p' Using 'r' to name the third component is problematic because that is commonly used to represent the red component of a vector representing a color. Under GLSL this is awkward because the texture swizzling for a vector uses a single letter for each component and the names for colors, textures and positions are synonymous. GLSL works around this by naming the components of the texture s, t, p and q. Cogl already effectively already exposes this naming because it exposes GLSL so it makes sense to use that naming consistently. Another alternative could be u, v and w. This is what Blender and Direct3D use. However the w component conflicts with the w component of a position vertex.
2010-07-12 16:01:32 +00:00
GLenum wrap_mode_p)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
int i;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Pass the set wrap mode on to all of the child textures */
for (i = 0; i < tex_2ds->slice_textures->len; i++)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex = g_array_index (tex_2ds->slice_textures,
CoglTexture2D *,
i);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
_cogl_texture_set_wrap_mode_parameters (COGL_TEXTURE (slice_tex),
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
wrap_mode_s,
wrap_mode_t,
wrap_mode_p);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
}
static gboolean
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
_cogl_texture_2d_sliced_slices_create (CoglContext *ctx,
CoglTexture2DSliced *tex_2ds,
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-10 01:57:32 +00:00
int width, int height,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglPixelFormat format)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
int max_width;
int max_height;
CoglTexture2D **slice_textures;
int n_x_slices;
int n_y_slices;
int n_slices;
int x, y;
CoglSpan *x_span;
CoglSpan *y_span;
GLenum gl_intformat;
GLenum gl_type;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00: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-10 01:57:32 +00:00
int (*slices_for_size) (int, int, int, GArray*);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Initialize size of largest slice according to supported features */
if (cogl_features_available (COGL_FEATURE_TEXTURE_NPOT))
{
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 12:11:58 +00:00
max_width = width;
max_height = height;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
slices_for_size = _cogl_rect_slices_for_size;
}
else
{
cogl: Make cogl_util_next_p2 internal and fix the documentation cogl_util_next_p2 is declared in cogl-util.h which is a private header so it shouldn't be possible for an application to use it. It's probably not a function we'd like to export from Cogl so it seems better to keep it private. This patch renames it to _cogl_util_next_p2 so that it won't be exported from the shared library. The documentation for the function is also slightly wrong because it stated that the function returned the next power greater than 'a'. However the code would actually return 'a' if it's already a power of two. I think the actual behaviour is more useful so this patch changes the documentation rather than the code.
2010-09-15 13:39:05 +00:00
max_width = _cogl_util_next_p2 (width);
max_height = _cogl_util_next_p2 (height);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
slices_for_size = _cogl_pot_slices_for_size;
}
Move the cogl texture driver functions to a vtable The texture driver functions are now accessed through a vtable pointed to by a struct in the CoglContext so that eventually it will be possible to compile both the GL and GLES texture drivers into a single binary and then select between them at runtime.
2011-07-07 11:48:24 +00:00
ctx->texture_driver->pixel_format_to_gl (format,
&gl_intformat,
NULL,
&gl_type);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Negative number means no slicing forced by the user */
if (tex_2ds->max_waste <= -1)
{
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan span;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Check if size supported else bail out */
Move the cogl texture driver functions to a vtable The texture driver functions are now accessed through a vtable pointed to by a struct in the CoglContext so that eventually it will be possible to compile both the GL and GLES texture drivers into a single binary and then select between them at runtime.
2011-07-07 11:48:24 +00:00
if (!ctx->texture_driver->size_supported (GL_TEXTURE_2D,
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 12:11:58 +00:00
gl_intformat,
gl_type,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
max_width,
max_height))
{
return FALSE;
}
n_x_slices = 1;
n_y_slices = 1;
/* Init span arrays */
tex_2ds->slice_x_spans = g_array_sized_new (FALSE, FALSE,
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
sizeof (CoglSpan),
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
1);
tex_2ds->slice_y_spans = g_array_sized_new (FALSE, FALSE,
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
sizeof (CoglSpan),
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
1);
/* Add a single span for width and height */
span.start = 0;
span.size = max_width;
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 12:11:58 +00:00
span.waste = max_width - width;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
g_array_append_val (tex_2ds->slice_x_spans, span);
span.size = max_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 12:11:58 +00:00
span.waste = max_height - height;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
g_array_append_val (tex_2ds->slice_y_spans, span);
}
else
{
/* Decrease the size of largest slice until supported by GL */
Move the cogl texture driver functions to a vtable The texture driver functions are now accessed through a vtable pointed to by a struct in the CoglContext so that eventually it will be possible to compile both the GL and GLES texture drivers into a single binary and then select between them at runtime.
2011-07-07 11:48:24 +00:00
while (!ctx->texture_driver->size_supported (GL_TEXTURE_2D,
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 12:11:58 +00:00
gl_intformat,
gl_type,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
max_width,
max_height))
{
/* Alternate between width and height */
if (max_width > max_height)
max_width /= 2;
else
max_height /= 2;
if (max_width == 0 || max_height == 0)
return FALSE;
}
/* Determine the slices required to cover the bitmap area */
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 12:11:58 +00:00
n_x_slices = slices_for_size (width,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
max_width, tex_2ds->max_waste,
NULL);
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 12:11:58 +00:00
n_y_slices = slices_for_size (height,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
max_height, tex_2ds->max_waste,
NULL);
/* Init span arrays with reserved size */
tex_2ds->slice_x_spans = g_array_sized_new (FALSE, FALSE,
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
sizeof (CoglSpan),
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
n_x_slices);
tex_2ds->slice_y_spans = g_array_sized_new (FALSE, FALSE,
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
sizeof (CoglSpan),
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
n_y_slices);
/* Fill span arrays with info */
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 12:11:58 +00:00
slices_for_size (width,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
max_width, tex_2ds->max_waste,
tex_2ds->slice_x_spans);
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 12:11:58 +00:00
slices_for_size (height,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
max_height, tex_2ds->max_waste,
tex_2ds->slice_y_spans);
}
/* Init and resize GL handle array */
n_slices = n_x_slices * n_y_slices;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
tex_2ds->slice_textures = g_array_sized_new (FALSE, FALSE,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
sizeof (CoglTexture2D *),
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
n_slices);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
g_array_set_size (tex_2ds->slice_textures, n_slices);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_textures = (CoglTexture2D **) tex_2ds->slice_textures->data;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Init each GL texture object */
for (y = 0; y < n_y_slices; ++y)
{
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
y_span = &g_array_index (tex_2ds->slice_y_spans, CoglSpan, y);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
for (x = 0; x < n_x_slices; ++x)
{
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
GError *error = NULL;
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan, x);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl debug: Makes COGL_DEBUG=all|verbose|help more useful COGL_DEBUG=all wasn't previously useful as there are several options that change the behaviour of Cogl and all together wouldn't help anyone debug anything. This patch makes it so COGL_DEBUG=all|verbose now only enables options that don't change the behaviour of Cogl, i.e. they only affect the amount of noise we'll print to a terminal. In addition to that this patch also improves the output from COGL_DEBUG=help so we now print a table of options including one liner descriptions of what each option enables.
2010-02-17 14:38:11 +00:00
COGL_NOTE (SLICING, "CREATE SLICE (%d,%d)\tsize (%d,%d)",
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
x, y,
x_span->size - x_span->waste,
y_span->size - y_span->waste);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
slice_textures[y * n_x_slices + x] =
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
cogl_texture_2d_new_with_size (ctx, x_span->size, y_span->size,
format, &error);
if (!slice_textures[y * n_x_slices + x])
{
g_array_set_size (tex_2ds->slice_textures, y * n_x_slices + x);
g_error_free (error);
return FALSE;
}
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
}
return TRUE;
}
static void
_cogl_texture_2d_sliced_slices_free (CoglTexture2DSliced *tex_2ds)
{
if (tex_2ds->slice_x_spans != NULL)
g_array_free (tex_2ds->slice_x_spans, TRUE);
if (tex_2ds->slice_y_spans != NULL)
g_array_free (tex_2ds->slice_y_spans, TRUE);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (tex_2ds->slice_textures != NULL)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00: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 09:01:43 +00:00
int i;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
for (i = 0; i < tex_2ds->slice_textures->len; i++)
{
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex =
g_array_index (tex_2ds->slice_textures, CoglTexture2D *, i);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
cogl_handle_unref (slice_tex);
}
g_array_free (tex_2ds->slice_textures, TRUE);
}
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
static void
_cogl_texture_2d_sliced_free (CoglTexture2DSliced *tex_2ds)
{
_cogl_texture_2d_sliced_slices_free (tex_2ds);
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 09:01:43 +00:00
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (tex_2ds));
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
static gboolean
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
_cogl_texture_2d_sliced_init_base (CoglContext *ctx,
CoglTexture2DSliced *tex_2ds,
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
int width,
int height,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglPixelFormat internal_format)
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
{
CoglTexture *tex = COGL_TEXTURE (tex_2ds);
journal: Support per-framebuffer journals Instead of having a single journal per context, we now have a CoglJournal object for each CoglFramebuffer. This means we now don't have to flush the journal when switching/pushing/popping between different framebuffers so for example a Clutter scene that involves some ClutterEffect actors that transiently redirect to an FBO can still be batched. This also allows us to track state in the journal that relates to the current frame of its associated framebuffer which we'll need for our optimization for using the CPU to handle reading a single pixel back from a framebuffer when we know the whole scene is currently comprised of simple rectangles in a journal.
2011-01-06 13:25:45 +00:00
_cogl_texture_init (tex, &cogl_texture_2d_sliced_vtable);
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
tex_2ds->slice_x_spans = NULL;
tex_2ds->slice_y_spans = NULL;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
tex_2ds->slice_textures = NULL;
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
/* Create slices for the given format and size */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
if (!_cogl_texture_2d_sliced_slices_create (ctx,
tex_2ds,
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
width,
height,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
internal_format))
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
return FALSE;
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
tex_2ds->width = width;
tex_2ds->height = height;
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
return TRUE;
}
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2DSliced *
cogl_texture_2d_sliced_new_with_size (CoglContext *ctx,
unsigned int width,
unsigned int height,
int max_waste,
CoglPixelFormat internal_format,
GError **error)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl: Move data only used for upload out of CoglTexture The CoglTexture struct previously contained some fields which are only used to upload data such as the CoglBitmap and the source GL format. These are now moved to a separate CoglTextureUploadData struct which only exists for the duration of one of the cogl_texture_*_new functions. In cogl-texture there are utility functions which operate on this new struct rather than on CoglTexture directly. Some of the fields that were previously stored in the CoglBitmap struct are now copied to the CoglTexture such as the width, height, format and internal GL format. The rowstride was previously stored in CoglTexture and this was publicly accessible with the cogl_texture_get_rowstride function. However this doesn't seem to be a useful function because there is no need to use the same rowstride again when uploading or downloading new data. Instead cogl_texture_get_rowstride now just calculates a suitable rowstride from the format and width of the texture.
2009-11-26 17:32:52 +00:00
CoglTexture2DSliced *tex_2ds;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Since no data, we need some internal format */
if (internal_format == COGL_PIXEL_FORMAT_ANY)
[cogl-texture-2d-sliced] allow COGL_FORMAT_ANY with _new_with_size() It's useful when initialzing offscreen draw buffers to be able to ask Cogl to create a texture of a given size and with the default internal pixel format.
2009-10-31 00:01:44 +00:00
internal_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Init texture with empty bitmap */
tex_2ds = g_new (CoglTexture2DSliced, 1);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
tex_2ds->max_waste = max_waste;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
if (!_cogl_texture_2d_sliced_init_base (ctx,
tex_2ds,
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
width, height,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
internal_format))
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
{
_cogl_texture_2d_sliced_free (tex_2ds);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
g_set_error (error,
COGL_ERROR,
COGL_ERROR_NO_MEMORY,
"Not enough memory to allocate texture slices");
return NULL;
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
}
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return _cogl_texture_2d_sliced_handle_new (tex_2ds);
}
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2DSliced *
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
_cogl_texture_2d_sliced_new_from_bitmap (CoglBitmap *bmp,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
CoglTextureFlags flags,
CoglPixelFormat internal_format)
{
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
CoglTexture2DSliced *tex_2ds;
CoglBitmap *dst_bmp;
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
int width, height;
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
_COGL_GET_CONTEXT (ctx, NULL);
g_return_val_if_fail (cogl_is_bitmap (bmp), NULL);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
width = _cogl_bitmap_get_width (bmp);
height = _cogl_bitmap_get_height (bmp);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Create new texture and fill with loaded data */
tex_2ds = g_new0 (CoglTexture2DSliced, 1);
if (flags & COGL_TEXTURE_NO_SLICING)
tex_2ds->max_waste = -1;
else
tex_2ds->max_waste = COGL_TEXTURE_MAX_WASTE;
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
dst_bmp = _cogl_texture_prepare_for_upload (bmp,
internal_format,
&internal_format,
&gl_intformat,
&gl_format,
&gl_type);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
if (dst_bmp == NULL)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
_cogl_texture_2d_sliced_free (tex_2ds);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
return NULL;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
if (!_cogl_texture_2d_sliced_init_base (ctx,
tex_2ds,
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
width, height,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
internal_format))
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
goto error;
if (!_cogl_texture_2d_sliced_upload_to_gl (tex_2ds,
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
dst_bmp))
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
goto error;
cogl_object_unref (dst_bmp);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return _cogl_texture_2d_sliced_handle_new (tex_2ds);
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 17:44:16 +00:00
error:
cogl_object_unref (dst_bmp);
_cogl_texture_2d_sliced_free (tex_2ds);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
return NULL;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2DSliced *
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
_cogl_texture_2d_sliced_new_from_foreign (GLuint gl_handle,
GLenum gl_target,
GLuint width,
GLuint height,
GLuint x_pot_waste,
GLuint y_pot_waste,
CoglPixelFormat format)
{
/* NOTE: width, height and internal format are not queriable
cogl-texture: for foreign textures; always trust user geom We now never query the width and height of the given texture object from OpenGL. The problem is that the user may be creating a Cogl texture from a texture_from_pixmap object where glTexImage2D was never called and the texture_from_pixmap spec doesn't clarify that it's reliable to query the width from OpenGL. This should address: http://bugzilla.openedhand.com/show_bug.cgi?id=1502 Thanks to Johan Bilien for reporting
2010-02-16 14:23:11 +00:00
* in GLES, hence such a function prototype.
*/
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
GLint gl_width = 0;
GLint gl_height = 0;
CoglTexture2DSliced *tex_2ds;
CoglTexture *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-10 01:57:32 +00:00
CoglSpan x_span;
CoglSpan y_span;
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *tex_2d;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
_COGL_GET_CONTEXT (ctx, NULL);
Make CoglTexture2D public as experimental API This exposes a CoglTexture2D typedef and adds the following experimental API: cogl_is_texture_2d cogl_texture_2d_new_with_size cogl_texture_2d_new_from_data cogl_texture_2d_new_from_foreign Since this is experimental API you need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h. Note: With these new entrypoints we now expect a CoglContext pointer to be passed in, instead of assuming there is a default context. The aim is that for Cogl 2.0 we won't have a default context so this is a step in that direction.
2011-05-16 23:05:54 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* This should only be called when the texture target is 2D. If a
rectangle texture is used then _cogl_texture_new_from_foreign
will create a cogl_texture_rectangle instead */
g_assert (gl_target == GL_TEXTURE_2D);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
gl_width = width + x_pot_waste;
gl_height = height + y_pot_waste;
/* Validate pot waste */
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (x_pot_waste < 0 || x_pot_waste >= width ||
y_pot_waste < 0 || y_pot_waste >= height)
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
return NULL;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
Make CoglTexture2D public as experimental API This exposes a CoglTexture2D typedef and adds the following experimental API: cogl_is_texture_2d cogl_texture_2d_new_with_size cogl_texture_2d_new_from_data cogl_texture_2d_new_from_foreign Since this is experimental API you need to define COGL_ENABLE_EXPERIMENTAL_API before including cogl.h. Note: With these new entrypoints we now expect a CoglContext pointer to be passed in, instead of assuming there is a default context. The aim is that for Cogl 2.0 we won't have a default context so this is a step in that direction.
2011-05-16 23:05:54 +00:00
tex_2d = cogl_texture_2d_new_from_foreign (ctx,
gl_target,
gl_width,
gl_height,
format,
NULL);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (!tex_2d)
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
return NULL;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* The texture 2d backend may use a different pixel format if it
queries the actual texture so we'll refetch the format it
actually used */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
format = cogl_texture_get_format (COGL_TEXTURE (tex_2d));
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Create new texture */
tex_2ds = g_new0 (CoglTexture2DSliced, 1);
tex = COGL_TEXTURE (tex_2ds);
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
tex->vtable = &cogl_texture_2d_sliced_vtable;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
tex_2ds->width = gl_width - x_pot_waste;
tex_2ds->height = gl_height - y_pot_waste;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
tex_2ds->max_waste = 0;
/* Create slice arrays */
tex_2ds->slice_x_spans =
g_array_sized_new (FALSE, FALSE,
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
sizeof (CoglSpan), 1);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
tex_2ds->slice_y_spans =
g_array_sized_new (FALSE, FALSE,
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
sizeof (CoglSpan), 1);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
tex_2ds->slice_textures =
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
g_array_sized_new (FALSE, FALSE,
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
sizeof (CoglTexture2D *), 1);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Store info for a single slice */
x_span.start = 0;
x_span.size = gl_width;
x_span.waste = x_pot_waste;
g_array_append_val (tex_2ds->slice_x_spans, x_span);
y_span.start = 0;
y_span.size = gl_height;
y_span.waste = y_pot_waste;
g_array_append_val (tex_2ds->slice_y_spans, y_span);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
g_array_append_val (tex_2ds->slice_textures, tex_2d);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return _cogl_texture_2d_sliced_handle_new (tex_2ds);
}
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 09:01:43 +00:00
static gboolean
_cogl_texture_2d_sliced_is_foreign (CoglTexture *tex)
{
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Make sure slices were created */
if (tex_2ds->slice_textures == NULL)
return FALSE;
/* Pass the call on to the first slice */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, 0);
return _cogl_texture_is_foreign (COGL_TEXTURE (slice_tex));
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 09:01:43 +00: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-10 01:57:32 +00:00
static int
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
_cogl_texture_2d_sliced_get_max_waste (CoglTexture *tex)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return tex_2ds->max_waste;
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static gboolean
_cogl_texture_2d_sliced_is_sliced (CoglTexture *tex)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (tex_2ds->slice_textures == NULL)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return FALSE;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (tex_2ds->slice_textures->len <= 1)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return FALSE;
return TRUE;
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static gboolean
_cogl_texture_2d_sliced_can_hardware_repeat (CoglTexture *tex)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan *x_span;
CoglSpan *y_span;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* If there's more than one texture then we can't hardware repeat */
if (tex_2ds->slice_textures->len != 1)
return FALSE;
/* If there's any waste then we can't hardware repeat */
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan, 0);
y_span = &g_array_index (tex_2ds->slice_y_spans, CoglSpan, 0);
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (x_span->waste > 0 || y_span->waste > 0)
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
return FALSE;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Otherwise pass the query on to the single slice texture */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, 0);
return _cogl_texture_can_hardware_repeat (COGL_TEXTURE (slice_tex));
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static void
_cogl_texture_2d_sliced_transform_coords_to_gl (CoglTexture *tex,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
float *s,
float *t)
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
CoglSpan *x_span;
CoglSpan *y_span;
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
g_assert (!_cogl_texture_2d_sliced_is_sliced (tex));
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Don't include the waste in the texture coordinates */
[cogl-spans] split out cogl-spans code from cogl-texture-2d-sliced When we implement atlas textures we will probably want to use the spans API to handle texture repeating so it doesn't make sense to leave the code in cogl-texture-2d-sliced.c. Since it's a standalone set of data structures and algorithms it also seems reasonable to split out from cogl-texture.
2009-09-23 14:11:55 +00:00
x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan, 0);
y_span = &g_array_index (tex_2ds->slice_y_spans, CoglSpan, 0);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
*s *= tex_2ds->width / (float)x_span->size;
*t *= tex_2ds->height / (float)y_span->size;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Let the child texture further transform the coords */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, 0);
_cogl_texture_transform_coords_to_gl (COGL_TEXTURE (slice_tex), s, t);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
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 21:49:04 +00: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 09:22:04 +00:00
_cogl_texture_2d_sliced_transform_quad_coords_to_gl (CoglTexture *tex,
float *coords)
{
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 21:49:04 +00:00
gboolean need_repeat = FALSE;
int i;
/* This is a bit lazy - in the case where the quad lies entirely
* within a single slice we could avoid the fallback. But that
* could likely lead to visual inconsistency if the fallback involves
* dropping layers, so this might be the right thing to do anyways.
*/
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 09:22:04 +00:00
if (_cogl_texture_2d_sliced_is_sliced (tex))
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 21:49:04 +00:00
return COGL_TRANSFORM_SOFTWARE_REPEAT;
for (i = 0; i < 4; i++)
if (coords[i] < 0.0f || coords[i] > 1.0f)
need_repeat = TRUE;
if (need_repeat && !_cogl_texture_2d_sliced_can_hardware_repeat (tex))
return COGL_TRANSFORM_SOFTWARE_REPEAT;
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 09:22:04 +00:00
_cogl_texture_2d_sliced_transform_coords_to_gl (tex, coords + 0, coords + 1);
_cogl_texture_2d_sliced_transform_coords_to_gl (tex, coords + 2, coords + 3);
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 21:49:04 +00:00
return (need_repeat
? COGL_TRANSFORM_HARDWARE_REPEAT : COGL_TRANSFORM_NO_REPEAT);
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 09:22:04 +00:00
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static gboolean
_cogl_texture_2d_sliced_get_gl_texture (CoglTexture *tex,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
GLuint *out_gl_handle,
GLenum *out_gl_target)
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (tex_2ds->slice_textures == NULL)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return FALSE;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (tex_2ds->slice_textures->len < 1)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return FALSE;
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, 0);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
return cogl_texture_get_gl_texture (COGL_TEXTURE (slice_tex),
out_gl_handle, out_gl_target);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static void
_cogl_texture_2d_sliced_set_filters (CoglTexture *tex,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
GLenum min_filter,
GLenum mag_filter)
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
int i;
/* Make sure slices were created */
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (tex_2ds->slice_textures == NULL)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Apply new filters to every slice. The slice texture itself should
cache the value and avoid resubmitting the same filter value to
GL */
for (i = 0; i < tex_2ds->slice_textures->len; i++)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, i);
_cogl_texture_set_filters (COGL_TEXTURE (slice_tex),
min_filter, mag_filter);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
}
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static void
cogl-texture: Replace the ensure_mipmaps virtual with pre_paint Instead of the ensure_mipmaps virtual that is only called whenever the texture is about to be rendered with a min filter that needs the mipmap, there is now a pre_paint virtual that is always called when the texture is about to be painted in any way. It has a flags parameter which is used to specify whether the mipmap will be needed. This is useful for CoglTexturePixmapX11 because it needs to do stuff before painting that is unrelated to mipmapping.
2010-06-09 16:39:59 +00:00
_cogl_texture_2d_sliced_pre_paint (CoglTexture *tex,
CoglTexturePrePaintFlags flags)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
int i;
/* Make sure slices were created */
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
if (tex_2ds->slice_textures == NULL)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Pass the pre-paint on to every slice */
for (i = 0; i < tex_2ds->slice_textures->len; i++)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex = g_array_index (tex_2ds->slice_textures,
CoglTexture2D *, i);
_cogl_texture_pre_paint (COGL_TEXTURE (slice_tex), flags);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00: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 09:22:04 +00:00
static void
_cogl_texture_2d_sliced_ensure_non_quad_rendering (CoglTexture *tex)
{
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
int i;
/* Make sure slices were created */
if (tex_2ds->slice_textures == NULL)
return;
/* Pass the call on to every slice */
for (i = 0; i < tex_2ds->slice_textures->len; i++)
{
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex = g_array_index (tex_2ds->slice_textures,
CoglTexture2D *, i);
_cogl_texture_ensure_non_quad_rendering (COGL_TEXTURE (slice_tex));
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00: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 09:22:04 +00:00
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static gboolean
_cogl_texture_2d_sliced_set_region (CoglTexture *tex,
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
int src_x,
int src_y,
int dst_x,
int dst_y,
unsigned int dst_width,
unsigned int dst_height,
cogl-texture: Share the common code in the set_region virtual There was a lot of common code that was copied to all of the backends to convert the data to a suitable format and wrap it into a CoglBitmap so that it can be passed to _cogl_texture_driver_upload_subregion_to_gl. This patch moves the common code to cogl-texture.c so that the virtual just takes a CoglBitmap that is already in the right format.
2010-07-08 14:15:22 +00:00
CoglBitmap *bmp)
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
{
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
cogl-texture: Share the common code in the set_region virtual There was a lot of common code that was copied to all of the backends to convert the data to a suitable format and wrap it into a CoglBitmap so that it can be passed to _cogl_texture_driver_upload_subregion_to_gl. This patch moves the common code to cogl-texture.c so that the virtual just takes a CoglBitmap that is already in the right format.
2010-07-08 14:15:22 +00:00
GLenum gl_format;
GLenum gl_type;
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
Move the cogl texture driver functions to a vtable The texture driver functions are now accessed through a vtable pointed to by a struct in the CoglContext so that eventually it will be possible to compile both the GL and GLES texture drivers into a single binary and then select between them at runtime.
2011-07-07 11:48:24 +00:00
_COGL_GET_CONTEXT (ctx, FALSE);
texture: Call _cogl_texture_prepare_for_upload in set_region impl Instead of calling _cogl_texutre_prepare_for_upload in cogl_texture_set_region_from_bitmap the call is now deferred to the implementation of the virtual for set_region. This is needed if the texture backend is using a different format for the actual GL texture than what is reported by cogl_texture_get_format. This happens for example with atlas textures which report the original internal format specified when the texture was created but actually always store the data in an RGBA texture. Also when creating an atlas texture from a bitmap it was preparing the bitmap to be uploaded to the original format instead of the format of the actual texture used for the atlas. Then it was using cogl_texture_set_region_from_bitmap to upload the 5 pieces to make the copies of the edge pixels. This would end up converting the image to the actual format 5 times. The atlas textures have now been changed to prepare the bitmap for the right format. https://bugzilla.gnome.org/show_bug.cgi?id=657840 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-08-31 16:22:20 +00:00
bmp = _cogl_texture_prepare_for_upload (bmp,
cogl_texture_get_format (tex),
NULL,
NULL,
&gl_format,
&gl_type);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
/* Send data to GL */
_cogl_texture_2d_sliced_upload_subregion_to_gl (tex_2ds,
src_x, src_y,
dst_x, dst_y,
dst_width, dst_height,
cogl-texture: Share the common code in the set_region virtual There was a lot of common code that was copied to all of the backends to convert the data to a suitable format and wrap it into a CoglBitmap so that it can be passed to _cogl_texture_driver_upload_subregion_to_gl. This patch moves the common code to cogl-texture.c so that the virtual just takes a CoglBitmap that is already in the right format.
2010-07-08 14:15:22 +00:00
bmp,
gl_format,
gl_type);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
texture: Call _cogl_texture_prepare_for_upload in set_region impl Instead of calling _cogl_texutre_prepare_for_upload in cogl_texture_set_region_from_bitmap the call is now deferred to the implementation of the virtual for set_region. This is needed if the texture backend is using a different format for the actual GL texture than what is reported by cogl_texture_get_format. This happens for example with atlas textures which report the original internal format specified when the texture was created but actually always store the data in an RGBA texture. Also when creating an atlas texture from a bitmap it was preparing the bitmap to be uploaded to the original format instead of the format of the actual texture used for the atlas. Then it was using cogl_texture_set_region_from_bitmap to upload the 5 pieces to make the copies of the edge pixels. This would end up converting the image to the actual format 5 times. The atlas textures have now been changed to prepare the bitmap for the right format. https://bugzilla.gnome.org/show_bug.cgi?id=657840 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-08-31 16:22:20 +00:00
cogl_object_unref (bmp);
[cogl-texture] Split CoglTexture into an abstract class + CoglTexture2dSliced cogl-texture-2d-sliced provides an implementation of CoglTexture and this seperation lays the foundation for potentially supporting atlas textures, pixmap textures (as in GLX_EXT_texture_from_pixmap) and fast-path GL_TEXTURE_{1D,2D,3D,RECTANGLE} textures in a maintainable fashion.
2009-08-30 10:36:11 +00:00
return TRUE;
}
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
static CoglPixelFormat
_cogl_texture_2d_sliced_get_format (CoglTexture *tex)
{
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Make sure slices were created */
if (tex_2ds->slice_textures == NULL)
return 0;
/* Pass the call on to the first slice */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, 0);
return cogl_texture_get_format (COGL_TEXTURE (slice_tex));
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
}
static GLenum
_cogl_texture_2d_sliced_get_gl_format (CoglTexture *tex)
{
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
CoglTexture2D *slice_tex;
cogl-texture-2d-sliced: Use the other backends for the slices Instead of directly manipulating GL textures itself, CoglTexture2DSliced now works in terms of CoglHandles. It creates the texture slices using cogl_texture_new_with_size which should always end up creating a CoglTexture2D because the size should fit. This allows us to avoid replicating some code such as the first pixel mipmap tracking and it better enforces the separation that each texture backend is the only place that contains code dealing with each texture target.
2010-10-04 13:34:24 +00:00
/* Make sure slices were created */
if (tex_2ds->slice_textures == NULL)
return 0;
/* Pass the call on to the first slice */
texture-2d-sliced: make CoglTexture2DSliced public This make the CoglTexture2DSliced type public and adds cogl_texture_2d_sliced_new_with_size() as an experimental API that can be used to construct a sliced texture without any initial data. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 10:53:20 +00:00
slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, 0);
return _cogl_texture_get_gl_format (COGL_TEXTURE (slice_tex));
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00: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-10 01:57:32 +00:00
static int
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
_cogl_texture_2d_sliced_get_width (CoglTexture *tex)
{
return COGL_TEXTURE_2D_SLICED (tex)->width;
}
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-10 01:57:32 +00:00
static int
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
_cogl_texture_2d_sliced_get_height (CoglTexture *tex)
{
return COGL_TEXTURE_2D_SLICED (tex)->height;
}
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
static const CoglTextureVtable
cogl_texture_2d_sliced_vtable =
{
_cogl_texture_2d_sliced_set_region,
Use FBOs and use cogl_read_pixels() to efficiently read partial textures * cogl_texture_get_data() is converted to use _cogl_texture_foreach_sub_texture_in_region() to iterate through the underlying textures. * When we need to read only a portion of the underlying texture, we set up a FBO and use _cogl_read_pixels() to read the portion we need. This is enormously more efficient for reading a small portion of a large atlas texture. * The CoglAtlasTexture, CoglSubTexture, and CoglTexture2dSliced implementation of get_texture() are removed. http://bugzilla.clutter-project.org/show_bug.cgi?id=2414
2010-11-12 16:02:13 +00:00
NULL, /* get_data */
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
_cogl_texture_2d_sliced_foreach_sub_texture_in_region,
_cogl_texture_2d_sliced_get_max_waste,
_cogl_texture_2d_sliced_is_sliced,
_cogl_texture_2d_sliced_can_hardware_repeat,
_cogl_texture_2d_sliced_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 09:22:04 +00:00
_cogl_texture_2d_sliced_transform_quad_coords_to_gl,
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
_cogl_texture_2d_sliced_get_gl_texture,
_cogl_texture_2d_sliced_set_filters,
cogl-texture: Replace the ensure_mipmaps virtual with pre_paint Instead of the ensure_mipmaps virtual that is only called whenever the texture is about to be rendered with a min filter that needs the mipmap, there is now a pre_paint virtual that is always called when the texture is about to be painted in any way. It has a flags parameter which is used to specify whether the mipmap will be needed. This is useful for CoglTexturePixmapX11 because it needs to do stuff before painting that is unrelated to mipmapping.
2010-06-09 16:39:59 +00:00
_cogl_texture_2d_sliced_pre_paint,
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 09:22:04 +00:00
_cogl_texture_2d_sliced_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 17:29:22 +00:00
_cogl_texture_2d_sliced_set_wrap_mode_parameters,
cogl: Move all of the fields from CoglTexture to CoglTexture2DSliced Most of the fields that were previously in CoglTexture are specific to the implementation of CoglTexture2DSliced so they should be placed there instead. For example, the 'mipmaps_dirty' flag is an implementation detail of the ensure_mipmaps function so it doesn't make sense to force all texture backends to have this function. Other fields such as width, height, gl_format and format may make sense for all textures but I've added them as virtual functions instead. This may make more sense for a sub-texture backend for example where it can calculate these based on the full texture.
2009-11-26 18:58:17 +00:00
_cogl_texture_2d_sliced_get_format,
_cogl_texture_2d_sliced_get_gl_format,
_cogl_texture_2d_sliced_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 09:01:43 +00:00
_cogl_texture_2d_sliced_get_height,
_cogl_texture_2d_sliced_is_foreign
cogl: Use a vtable for the texture backends instead of a type and switch Instead of storing an enum with the backend type for each texture and then using a switch statement to decide which function to call, we should store pointers to all of the functions in a struct and have each texture point to that struct. This is potentially slightly faster when there are more backends and it makes implementing new backends easier because it's more obvious which functions have to be implemented.
2009-11-25 13:39:45 +00:00
};
Copy permalink