isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-22 16:10:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
32fbd0ada6
mutter/cogl/cogl-texture-2d-sliced.c

1345 lines
45 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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 07:56:10 -05:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
[cogl-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 06:36:11 -04: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
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 16:36:41 -04:00
#include "cogl-debug.h"
moves and renames _cogl_get_format_bpp This moves _cogl_get_format_bpp from cogl-bitmap.c to cogl.c and renames it to _cogl_pixel_format_get_bytes_per_pixel. This makes it clearer that it doesn't return bits per pixel and makes the naming consistent with other cogl api. The prototype has been moved to cogl-private.h since it seems we should be aiming to get rid of cogl-internal.h at some point. The patch also adds a simple gtk-doc comment since we might want to make this api public. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-13 18:02:04 -05:00
#include "cogl-private.h"
[cogl-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 06:36:11 -04:00
#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 09:34:24 -04: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 06:36:11 -04: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 18:25:52 -04:00
#include "cogl-context-private.h"
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
#include "cogl-object-private.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 10:11:55 -04: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 13:18:30 -05: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 13:54:57 -04:00
#include "cogl-pipeline-opengl-private.h"
Fix places that ignore the COGL_TEXTURE_NO_AUTO_MIPMAP flag Two of the meta texture constructors which take a flags parameter were ignoring the COGL_TEXTURE_NO_AUTO_MIPMAP flag when creating an underlying CoglTexture2D. These have now been fixed to call cogl_primitive_texture_set_auto_mipmap after constructing the texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 11:25:25 -04:00
#include "cogl-primitive-texture.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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 08:39:45 -05:00
static const CoglTextureVtable cogl_texture_2d_sliced_vtable;
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
typedef struct _ForeachData
{
CoglMetaTextureCallback callback;
void *user_data;
float x_normalize_factor;
float y_normalize_factor;
} ForeachData;
static void
re_normalize_sub_texture_coords_cb (CoglTexture *sub_texture,
const float *sub_texture_coords,
const float *meta_coords,
void *user_data)
{
ForeachData *data = user_data;
float re_normalized_coords[4] =
{
sub_texture_coords[0] * data->x_normalize_factor,
sub_texture_coords[1] * data->y_normalize_factor,
sub_texture_coords[2] * data->x_normalize_factor,
sub_texture_coords[3] * data->y_normalize_factor
};
data->callback (sub_texture, re_normalized_coords, meta_coords,
data->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 08:39:45 -05: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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04:00
float virtual_tx_1,
float virtual_ty_1,
float virtual_tx_2,
float virtual_ty_2,
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
CoglMetaTextureCallback callback,
[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 06:36:11 -04:00
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 08:39:45 -05:00
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
CoglSpan *x_spans = (CoglSpan *)tex_2ds->slice_x_spans->data;
CoglSpan *y_spans = (CoglSpan *)tex_2ds->slice_y_spans->data;
CoglTexture **textures = (CoglTexture **)tex_2ds->slice_textures->data;
float un_normalized_coords[4];
ForeachData data;
/* NB: its convenient for us to store non-normalized coordinates in
* our CoglSpans but that means we need to un-normalize the incoming
* virtual coordinates and make sure we re-normalize the coordinates
* before calling the given callback.
[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 06:36:11 -04:00
*/
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
data.callback = callback;
data.user_data = user_data;
data.x_normalize_factor = 1.0f / tex_2ds->width;
data.y_normalize_factor = 1.0f / tex_2ds->height;
un_normalized_coords[0] = virtual_tx_1 * data.x_normalize_factor;
un_normalized_coords[1] = virtual_ty_1 * data.y_normalize_factor;
un_normalized_coords[2] = virtual_tx_2 * data.x_normalize_factor;
un_normalized_coords[3] = virtual_ty_2 * data.y_normalize_factor;
_cogl_texture_spans_foreach_in_region (x_spans,
tex_2ds->slice_x_spans->len,
y_spans,
tex_2ds->slice_y_spans->len,
textures,
un_normalized_coords,
1, /* x_normalize_factor */
1, /* y_normalize_factor */
COGL_PIPELINE_WRAP_MODE_REPEAT,
COGL_PIPELINE_WRAP_MODE_REPEAT,
re_normalize_sub_texture_coords_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 06:36:11 -04:00
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static uint8_t *
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 12:32:52 -05: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 06:36:11 -04: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 10:11:55 -04:00
CoglSpan *last_x_span;
CoglSpan *last_y_span;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint8_t *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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04:00
tex_2ds->slice_y_spans->len - 1);
if (last_x_span->waste > 0 || last_y_span->waste > 0)
{
moves and renames _cogl_get_format_bpp This moves _cogl_get_format_bpp from cogl-bitmap.c to cogl.c and renames it to _cogl_pixel_format_get_bytes_per_pixel. This makes it clearer that it doesn't return bits per pixel and makes the naming consistent with other cogl api. The prototype has been moved to cogl-private.h since it seems we should be aiming to get rid of cogl-internal.h at some point. The patch also adds a simple gtk-doc comment since we might want to make this api public. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-13 18:02:04 -05:00
int bpp = _cogl_pixel_format_get_bytes_per_pixel (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 10:11:55 -04: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-09 20:57:32 -05: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04:00
CoglTexture2D *slice_tex,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint8_t *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 09:34:24 -04:00
CoglSpan *x_span,
CoglSpan *y_span,
CoglSpanIter *x_iter,
CoglSpanIter *y_iter,
int src_x,
int src_y,
int dst_x,
int dst_y)
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool need_x, need_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 09:34:24 -04:00
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 10:46:18 -04:00
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
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 09:34:24 -04:00
/* 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)
{
Make _cogl_bitmap_get_{width,height,format,rowstride} public This are now marked as public experimental Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-25 15:18:05 -05:00
int bmp_rowstride = cogl_bitmap_get_rowstride (source_bmp);
CoglPixelFormat source_format = cogl_bitmap_get_format (source_bmp);
moves and renames _cogl_get_format_bpp This moves _cogl_get_format_bpp from cogl-bitmap.c to cogl.c and renames it to _cogl_pixel_format_get_bytes_per_pixel. This makes it clearer that it doesn't return bits per pixel and makes the naming consistent with other cogl api. The prototype has been moved to cogl-private.h since it seems we should be aiming to get rid of cogl-internal.h at some point. The patch also adds a simple gtk-doc comment since we might want to make this api public. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-13 18:02:04 -05:00
int bpp = _cogl_pixel_format_get_bytes_per_pixel (source_format);
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint8_t *bmp_data;
const uint8_t *src;
uint8_t *dst;
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 09:34:24 -04:00
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) +
spans: Represent spans with floating point precision Instead of using integers to represent spans we now use floats instead. This means we are no longer forced to iterate using non-normalized coordinates so we should hopefully be able to avoid numerous redundant unnormalize/normalize steps when using the spans api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-23 15:20:49 -04:00
(src_x + (int)x_span->start + (int)x_span->size -
(int)x_span->waste - dst_x - 1) * bpp);
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 09:34:24 -04:00
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;
}
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 10:46:18 -04:00
waste_bmp = cogl_bitmap_new_for_data (ctx,
x_span->waste,
y_iter->intersect_end -
y_iter->intersect_start,
source_format,
x_span->waste * bpp,
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 09:34:24 -04: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 06:53:20 -04: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 17:14:08 -04: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 09:34:24 -04: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) +
spans: Represent spans with floating point precision Instead of using integers to represent spans we now use floats instead. This means we are no longer forced to iterate using non-normalized coordinates so we should hopefully be able to avoid numerous redundant unnormalize/normalize steps when using the spans api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-23 15:20:49 -04:00
(src_y + (int)y_span->start + (int)y_span->size -
(int)y_span->waste - dst_y - 1) * bmp_rowstride);
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 09:34:24 -04:00
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;
}
}
Add a public cogl_bitmap_new_for_data This creates a CoglBitmap which points into an existing buffer in system memory. That way it can be used to create a texture or to read pixel data into. The function replaces the existing internal function _cogl_bitmap_new_from_data but removes the destroy notify call back. If the application wants notification of destruction it can just use the cogl_object_set_user_data function as normal. Internally there is now a convenience function to create a bitmap for system memory and automatically free the buffer using that mechanism. The name of the function is inspired by cairo_image_surface_create_for_data which has similar semantics. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-13 10:46:18 -04:00
waste_bmp = cogl_bitmap_new_for_data (ctx,
copy_width,
y_span->waste,
source_format,
copy_width * bpp,
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 09:34:24 -04: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 06:53:20 -04: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 17:14:08 -04: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 09:34:24 -04:00
cogl_object_unref (waste_bmp);
}
_cogl_bitmap_unmap (source_bmp);
}
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
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 12:32:52 -05: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 09:34:24 -04: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 06:36:11 -04:00
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglSpan *x_span;
CoglSpan *y_span;
CoglTexture2D *slice_tex;
int x, y;
uint8_t *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 06:36:11 -04:00
Make _cogl_bitmap_get_{width,height,format,rowstride} public This are now marked as public experimental Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-25 15:18:05 -05: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 06:36:11 -04:00
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
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 13:44:16 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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-09 20:57:32 -05: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 09:34:24 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:53:20 -04: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 17:14:08 -04: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 09:34:24 -04: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 06:36:11 -04:00
}
}
if (waste_buf)
g_free (waste_buf);
return TRUE;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
[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 06:36:11 -04:00
_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-09 20:57:32 -05: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 06:36:11 -04: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 10:11:55 -04:00
CoglSpan *x_span;
CoglSpan *y_span;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglSpanIter x_iter;
CoglSpanIter y_iter;
CoglTexture2D *slice_tex;
int source_x = 0, source_y = 0;
int inter_w = 0, inter_h = 0;
int local_x = 0, local_y = 0;
uint8_t *waste_buf;
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 06:36:11 -04:00
Make _cogl_bitmap_get_{width,height,format,rowstride} public This are now marked as public experimental Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-25 15:18:05 -05: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 06:36:11 -04: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 12:32:52 -05: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 13:44:16 -04: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 06:36:11 -04:00
/* Iterate vertical spans */
for (source_y = src_y,
_cogl_span_iter_begin (&y_iter,
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
(CoglSpan *)tex_2ds->slice_y_spans->data,
tex_2ds->slice_y_spans->len,
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 13:58:17 -05: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 06:36:11 -04:00
dst_y,
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
dst_y + height,
COGL_PIPELINE_WRAP_MODE_REPEAT);
[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 06:36:11 -04:00
!_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 10:11:55 -04: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 06:36:11 -04:00
y_iter.index);
/* Iterate horizontal spans */
for (source_x = src_x,
_cogl_span_iter_begin (&x_iter,
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
(CoglSpan *)tex_2ds->slice_x_spans->data,
tex_2ds->slice_x_spans->len,
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 13:58:17 -05: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 06:36:11 -04:00
dst_x,
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
dst_x + width,
COGL_PIPELINE_WRAP_MODE_REPEAT);
[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 06:36:11 -04:00
!_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-09 20:57:32 -05: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:53:20 -04: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 17:14:08 -04: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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-09 20:57:32 -05: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 06:36:11 -04: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-09 20:57:32 -05: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 10:11:55 -04: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 06:36:11 -04: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-09 20:57:32 -05: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 06:36:11 -04: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-09 20:57:32 -05: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 10:11:55 -04: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 06:36:11 -04: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 12:17:53 -04: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 06:36:11 -04: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 08:39:45 -05: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 13:29:22 -04: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 12:01:32 -04: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 06:36:11 -04: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 08:39:45 -05: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:36:11 -04:00
}
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
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 06:53:20 -04: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-09 20:57:32 -05: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 06:53:20 -04: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 06:36:11 -04: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 06:53:20 -04: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;
Use the internal format to check if the texture size is supported Until now, we hardcoded the internal format to GL_RGBA and used the internal format returned by pixel_format_to_gl() as the format for checking the texture size and format we're asked to create. Let's use the proper internal format/format from now on. This is needed as a later patch introduces DEPTH and DEPTH_STENCIL textures. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec45f60ee2545f88302da314bcdbe1439c4ba9c9)
2012-05-23 09:47:57 -04:00
GLenum gl_format;
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 06:53:20 -04:00
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 06:36:11 -04:00
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
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 06:36:11 -04:00
/* Initialize size of largest slice according to supported features */
features: Support more than 32 features! Currently features are represented as bits in a 32bit mask so we obviously can't have more than 32 features with that approach. The new approach is to use the COGL_FLAGS_ macros which lets us handle bitmasks without a size limit and we change the public api to accept individual feature enums instead of a mask. This way there is no limit on the number of features we can add to Cogl. Instead of using cogl_features_available() there is a new cogl_has_feature() function and for checking multiple features there is cogl_has_features() which takes a zero terminated vararg list of features. In addition to being able to check for individual features this also adds a way to query all the features currently available via cogl_foreach_feature() which will call a callback for each feature. Since the new functions take an explicit context pointer there is also no longer any ambiguity over when users can first start to query features. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 17:31:12 -04:00
if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT))
[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 06:36:11 -04:00
{
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
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 06:36:11 -04: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 09:39:05 -04: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 06:36:11 -04:00
slices_for_size = _cogl_pot_slices_for_size;
}
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
format,
&gl_intformat,
Use the internal format to check if the texture size is supported Until now, we hardcoded the internal format to GL_RGBA and used the internal format returned by pixel_format_to_gl() as the format for checking the texture size and format we're asked to create. Let's use the proper internal format/format from now on. This is needed as a later patch introduces DEPTH and DEPTH_STENCIL textures. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec45f60ee2545f88302da314bcdbe1439c4ba9c9)
2012-05-23 09:47:57 -04:00
&gl_format,
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
&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 09:34:24 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04:00
/* Check if size supported else bail out */
Add a context parameter to all of the texture driver virtuals All of the texture driver virtual functions now take an explicit CoglContext parameter as a step towards removing the global context.
2012-03-22 13:04:47 -04:00
if (!ctx->texture_driver->size_supported (ctx,
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 07:11:58 -05:00
gl_intformat,
Use the internal format to check if the texture size is supported Until now, we hardcoded the internal format to GL_RGBA and used the internal format returned by pixel_format_to_gl() as the format for checking the texture size and format we're asked to create. Let's use the proper internal format/format from now on. This is needed as a later patch introduces DEPTH and DEPTH_STENCIL textures. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec45f60ee2545f88302da314bcdbe1439c4ba9c9)
2012-05-23 09:47:57 -04:00
gl_format,
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 07:11:58 -05: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 06:36:11 -04: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 07:11:58 -05: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 06:36:11 -04:00
g_array_append_val (tex_2ds->slice_y_spans, span);
}
else
{
/* Decrease the size of largest slice until supported by GL */
Add a context parameter to all of the texture driver virtuals All of the texture driver virtual functions now take an explicit CoglContext parameter as a step towards removing the global context.
2012-03-22 13:04:47 -04:00
while (!ctx->texture_driver->size_supported (ctx,
GL_TEXTURE_2D,
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
gl_intformat,
Use the internal format to check if the texture size is supported Until now, we hardcoded the internal format to GL_RGBA and used the internal format returned by pixel_format_to_gl() as the format for checking the texture size and format we're asked to create. Let's use the proper internal format/format from now on. This is needed as a later patch introduces DEPTH and DEPTH_STENCIL textures. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec45f60ee2545f88302da314bcdbe1439c4ba9c9)
2012-05-23 09:47:57 -04:00
gl_format,
cogl: Let GL do the format conversion when uploading texture data Cogl accepts a pixel format for both the data in memory and the internal format to be used for the texture. If they do not match then it would convert them using the CoglBitmap functions before uploading the data. However, GL also lets you specify both formats so it makes more sense to let GL do the conversion. The driver may need the texture in a specific format so it may end up being converted anyway. The cogl_texture_upload_data functions have been removed and replaced with a single function to prepare the bitmap. This will only do the premultiplication conversion because that is the only part that GL can't do directly.
2010-02-01 07:11:58 -05:00
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 06:36:11 -04: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 07:11:58 -05: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 06:36:11 -04: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 07:11:58 -05: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 07:11:58 -05: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 06:36:11 -04: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 07:11:58 -05: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 06:53:20 -04: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 10:11:55 -04: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 06:36:11 -04: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 09:38:11 -05: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 06:36:11 -04:00
x, y,
spans: Represent spans with floating point precision Instead of using integers to represent spans we now use floats instead. This means we are no longer forced to iterate using non-normalized coordinates so we should hopefully be able to avoid numerous redundant unnormalize/normalize steps when using the spans api. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-23 15:20:49 -04:00
(int)(x_span->size - x_span->waste),
(int)(y_span->size - 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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04:00
{
material: Avoid redundant glBindTexture calls This adds a _cogl_bind_gl_texture_transient function that should be used instead of glBindTexture so we can have a consistent cache of the textures bound to each texture unit so we can avoid some redundant binding.
2010-04-26 05:01:43 -04:00
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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04:00
CoglTexture2D *slice_tex =
g_array_index (tex_2ds->slice_textures, CoglTexture2D *, i);
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
cogl_object_unref (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 09:34:24 -04:00
}
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 06:36:11 -04: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 05:01:43 -04: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 06:36:11 -04:00
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
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 06:53:20 -04: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 13:44:16 -04: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 06:53:20 -04: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 12:32:52 -05: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 08:25:45 -05: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 12:32:52 -05: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 09:34:24 -04: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 12:32:52 -05: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 13:44:16 -04: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 06:53:20 -04: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 13:44:16 -04: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 06:53:20 -04: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 13:44:16 -04: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 12:32:52 -05: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 13:44:16 -04: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 12:32:52 -05: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 06:53:20 -04: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 06:36:11 -04: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 12:32:52 -05: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 06:36:11 -04: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-30 20:01:44 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 06:53:20 -04: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 13:44:16 -04: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 06:53:20 -04: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 13:44:16 -04: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 06:53:20 -04: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 13:44:16 -04:00
}
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
return _cogl_texture_2d_sliced_object_new (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 06:36:11 -04: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 06:53:20 -04: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 13:44:16 -04: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 06:36:11 -04: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 13:44:16 -04:00
CoglTexture2DSliced *tex_2ds;
CoglBitmap *dst_bmp;
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
int width, height;
bitmap: Store a pointer to the context This adds a context member to CoglBitmap which stores the context it was created with. That way it can be used in texture constructors which use a bitmap. There is also an internal private function to get the context out of the bitmap which all of the texture constructors now use. _cogl_texture_3d_new_from_bitmap has had its context parameter removed so that it more closely matches the other bitmap constructors. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 08:57:42 -04:00
CoglContext *ctx;
Fix places that ignore the COGL_TEXTURE_NO_AUTO_MIPMAP flag Two of the meta texture constructors which take a flags parameter were ignoring the COGL_TEXTURE_NO_AUTO_MIPMAP flag when creating an underlying CoglTexture2D. These have now been fixed to call cogl_primitive_texture_set_auto_mipmap after constructing the texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 11:25:25 -04:00
int 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 06:53:20 -04:00
Start to reduce dependence on glib Since we've had several developers from admirable projects say they would like to use Cogl but would really prefer not to pull in gobject,gmodule and glib as extra dependencies we are investigating if we can get to the point where glib is only an optional dependency. Actually we feel like we only make minimal use of glib anyway, so it may well be quite straightforward to achieve this. This adds a --disable-glib configure option that can be used to disable features that depend on glib. Actually --disable-glib doesn't strictly disable glib at this point because it's more helpful if cogl continues to build as we make incremental progress towards this. The first use of glib that this patch tackles is the use of g_return_val_if_fail and g_return_if_fail which have been replaced with equivalent _COGL_RETURN_VAL_IF_FAIL and _COGL_RETURN_IF_FAIL macros. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 17:34:30 -04:00
_COGL_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 06:36:11 -04:00
bitmap: Store a pointer to the context This adds a context member to CoglBitmap which stores the context it was created with. That way it can be used in texture constructors which use a bitmap. There is also an internal private function to get the context out of the bitmap which all of the texture constructors now use. _cogl_texture_3d_new_from_bitmap has had its context parameter removed so that it more closely matches the other bitmap constructors. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 08:57:42 -04:00
ctx = _cogl_bitmap_get_context (bmp);
Make _cogl_bitmap_get_{width,height,format,rowstride} public This are now marked as public experimental Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-25 15:18:05 -05: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 06:36:11 -04: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 13:44:16 -04: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 06:53:20 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 06:53:20 -04: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 13:44:16 -04: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 06:53:20 -04: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 13:44:16 -04: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 09:34:24 -04: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 13:44:16 -04:00
goto error;
cogl_object_unref (dst_bmp);
Fix places that ignore the COGL_TEXTURE_NO_AUTO_MIPMAP flag Two of the meta texture constructors which take a flags parameter were ignoring the COGL_TEXTURE_NO_AUTO_MIPMAP flag when creating an underlying CoglTexture2D. These have now been fixed to call cogl_primitive_texture_set_auto_mipmap after constructing the texture. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 11:25:25 -04:00
if ((flags & COGL_TEXTURE_NO_AUTO_MIPMAP))
for (i = 0; i < tex_2ds->slice_textures->len; i++)
{
CoglPrimitiveTexture *slice_tex;
slice_tex = g_array_index (tex_2ds->slice_textures,
CoglPrimitiveTexture *,
i);
cogl_primitive_texture_set_auto_mipmap (slice_tex, FALSE);
}
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
return _cogl_texture_2d_sliced_object_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 13:44:16 -04: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 06:53:20 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 09:23:11 -05: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 06:36:11 -04: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-09 20:57:32 -05: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 06:53:20 -04: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 06:36:11 -04: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 06:53:20 -04: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 19:05:54 -04: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 06:36:11 -04: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 19:05:54 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04: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 13:58:17 -05: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04:00
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
return _cogl_texture_2d_sliced_object_new (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 06:36:11 -04:00
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
material: Avoid redundant glBindTexture calls This adds a _cogl_bind_gl_texture_transient function that should be used instead of glBindTexture so we can have a consistent cache of the textures bound to each texture unit so we can avoid some redundant binding.
2010-04-26 05:01:43 -04:00
_cogl_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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:53:20 -04: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 05:01:43 -04:00
}
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
static int
cogl: 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 08:39:45 -05: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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04:00
return tex_2ds->max_waste;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
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 08:39:45 -05:00
_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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04:00
return FALSE;
return TRUE;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
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 08:39:45 -05:00
_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 06:36:11 -04: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 08:39:45 -05: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 06:53:20 -04: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 10:11:55 -04: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 06:36:11 -04: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 09:34:24 -04: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 10:11:55 -04: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 09:34:24 -04: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 13:58:17 -05: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 09:34:24 -04: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 06:53:20 -04: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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04: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 08:39:45 -05: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 10:11:55 -04: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 06:53:20 -04: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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04: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 10:11:55 -04: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 06:36:11 -04: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 13:58:17 -05: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 06:36:11 -04: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 09:34:24 -04: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 06:53:20 -04: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 06:36:11 -04: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 16:49:04 -05:00
static CoglTransformResult
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
_cogl_texture_2d_sliced_transform_quad_coords_to_gl (CoglTexture *tex,
float *coords)
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool need_repeat = FALSE;
Fix checks for out-of-bounds coordinates and repeats Add a return result from CoglTexture.transform_quad_coords_to_gl(), so that we can properly determine the nature of repeats in the face of GL_TEXTURE_RECTANGLE_ARB, where the returned coordinates are not normalized. The comment "We also work out whether any of the texture coordinates are outside the range [0.0,1.0]. We need to do this after calling transform_coords_to_gl in case the texture backend is munging the coordinates (such as in the sub texture backend)." is disregarded and removed, since it's actually the virtual coordinates that determine whether we repeat, not the GL coordinates. Warnings about disregarded layers are used in all cases where applicable, including for subtextures. http://bugzilla.openedhand.com/show_bug.cgi?id=2016 Signed-off-by: Neil Roberts <neil@linux.intel.com>
2010-03-01 16:49:04 -05:00
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 04:22:04 -05: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 16:49:04 -05: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 04:22:04 -05: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 16:49:04 -05: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 04:22:04 -05:00
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
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 08:39:45 -05:00
_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 06:36:11 -04: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 08:39:45 -05: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 06:53:20 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04: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 08:39:45 -05: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 06:53:20 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04: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 08:39:45 -05: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 12:39:59 -04: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 06:36:11 -04: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 08:39:45 -05: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 09:34:24 -04: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 06:36:11 -04: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 06:53:20 -04: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 06:36:11 -04:00
}
}
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04:00
}
cogl: Make CoglSubTexture only work for quad rendering The sub texture backend doesn't work well as a completely general texture backend because for example when rendering with cogl_polygon it needs to be able to tranform arbitrary texture coordinates without reference to the other coordintes. This can't be done when the texture coordinates are a multiple of one because sometimes the coordinate should represent the left or top edge and sometimes it should represent the bottom or top edge. For example if the s coordinates are 0 and 1 then 1 represents the right edge but if they are 1 and 2 then 1 represents the left edge. Instead the sub-textures are now documented not to support coordinates outside the range [0,1]. The coordinates for the sub-region are now represented as integers as this helps avoid rounding issues. The region can no longer be a super-region of the texture as this simplifies the code quite a lot. There are two new texture virtual functions: transform_quad_coords_to_gl - This transforms two pairs of coordinates representing a quad. It will return FALSE if the coordinates can not be transformed. The sub texture backend uses this to detect coordinates that require repeating which causes cogl-primitives to use manual repeating. ensure_non_quad_rendering - This is used in cogl_polygon and cogl_vertex_buffer to inform the texture backend that transform_quad_to_gl is going to be used. The atlas backend migrates the texture out of the atlas when it hits this.
2010-01-18 04:22:04 -05:00
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
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 08:39:45 -05:00
_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 06:36:11 -04: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 10:15:22 -04: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 06:36:11 -04: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 08:39:45 -05: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 10:15:22 -04: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 06:36:11 -04:00
Move the cogl texture driver functions to a vtable The texture driver functions are now accessed through a vtable pointed to by a struct in the CoglContext so that eventually it will be possible to compile both the GL and GLES texture drivers into a single binary and then select between them at runtime.
2011-07-07 07:48:24 -04:00
_COGL_GET_CONTEXT (ctx, 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 12:22:20 -04: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 06:36:11 -04: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 10:15:22 -04: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 06:36:11 -04: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 12:22:20 -04: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 06:36:11 -04: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 13:58:17 -05: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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:53:20 -04: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 13:58:17 -05: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 09:34:24 -04: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 06:53:20 -04: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 09:34:24 -04: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 06:53:20 -04: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 13:58:17 -05:00
}
cogl: improves header and coding style consistency We've had complaints that our Cogl code/headers are a bit "special" so this is a first pass at tidying things up by giving them some consistency. These changes are all consistent with how new code in Cogl is being written, but the style isn't consistently applied across all code yet. There are two parts to this patch; but since each one required a large amount of effort to maintain tidy indenting it made sense to combine the changes to reduce the time spent re indenting the same lines. The first change is to use a consistent style for declaring function prototypes in headers. Cogl headers now consistently use this style for prototypes: return_type cogl_function_name (CoglType arg0, CoglType arg1); Not everyone likes this style, but it seems that most of the currently active Cogl developers agree on it. The second change is to constrain the use of redundant glib data types in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all been replaced with int, unsigned int, float, long, unsigned long and char respectively. When talking about pixel data; use of guchar has been replaced with guint8, otherwise unsigned char can be used. The glib types that we continue to use for portability are gboolean, gint{8,16,32,64}, guint{8,16,32,64} and gsize. The general intention is that Cogl should look palatable to the widest range of C programmers including those outside the Gnome community so - especially for the public API - we want to minimize the number of foreign looking typedefs.
2010-02-09 20:57:32 -05:00
static int
cogl: 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 13:58:17 -05: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-09 20:57:32 -05: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 13:58:17 -05:00
_cogl_texture_2d_sliced_get_height (CoglTexture *tex)
{
return COGL_TEXTURE_2D_SLICED (tex)->height;
}
Add _cogl_texture_get_type() This adds an internal function to get the type of the underlying hardware texture for any CoglTexture. It can return one of three values to represent 2D textures, 3D textures or rectangle textures. The idea is that this can be used as a replacement for cogl_texture_get_gl_texture when only the target is required to make it a bit less GL-centric. The implementation adds a new virtual function which all of the texture backends now implement. The enum is in a public header because a later patch will want to use it from the CoglPipeline API. We may want to consider making the function public too later. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 06:19:04 -05:00
static CoglTextureType
_cogl_texture_2d_sliced_get_type (CoglTexture *tex)
{
return COGL_TEXTURE_TYPE_2D;
}
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 08:39:45 -05:00
static const CoglTextureVtable
cogl_texture_2d_sliced_vtable =
{
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:09:43 -04:00
FALSE, /* not primitive */
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 08:39:45 -05:00
_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 11:02:13 -05: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 08:39:45 -05: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 04:22:04 -05: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 08:39:45 -05: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 12:39:59 -04: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 04:22:04 -05: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 13:29:22 -04: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 13:58:17 -05: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 05:01:43 -04:00
_cogl_texture_2d_sliced_get_height,
Add _cogl_texture_get_type() This adds an internal function to get the type of the underlying hardware texture for any CoglTexture. It can return one of three values to represent 2D textures, 3D textures or rectangle textures. The idea is that this can be used as a replacement for cogl_texture_get_gl_texture when only the target is required to make it a bit less GL-centric. The implementation adds a new virtual function which all of the texture backends now implement. The enum is in a public header because a later patch will want to use it from the CoglPipeline API. We may want to consider making the function public too later. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 06:19:04 -05:00
_cogl_texture_2d_sliced_get_type,
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:09:43 -04:00
_cogl_texture_2d_sliced_is_foreign,
NULL /* set_auto_mipmap */
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 08:39:45 -05:00
};
Reference in New Issue Copy Permalink