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

405 lines
14 KiB
C
Raw Normal View History

Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2007,2008,2009 Intel Corporation.
*
* 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/>.
*
*
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37: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
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"
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
#include "cogl-util.h"
#include "cogl-bitmap.h"
#include "cogl-bitmap-private.h"
#include "cogl-texture-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.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"
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
#include "cogl-handle.h"
#include "cogl-primitives.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"
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
#include <string.h>
#include <stdlib.h>
#include <math.h>
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
static void
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
_cogl_texture_driver_gen (CoglContext *ctx,
GLenum gl_target,
GLsizei n,
GLuint *textures)
cogl: new textures sould have GL_TEXTURE_MIN_FILTER set to GL_LINEAR The only way the user has to set the mipmap filters is through the material/layer API. This API defaults to GL_LINEAR/GL_LINEAR for the max and min filters. With the main use case of cogl being 2D interfaces, it makes sense do default to GL_LINEAR for the min filter. When creating new textures, we did not set any filter on them, using OpenGL defaults': GL_NEAREST_MIPMAP_LINEAR for the min filter and GL_LINEAR for the max filter. This will make the driver allocate memory for the mipmap tree, memory that will not be used in the nominal case (as the material API defaults to GL_LINEAR). This patch tries to ensure that the min filter is set to GL_LINEAR before any glTexImage*() call is done on the texture by setting the filter when generating new OpenGL handles.
2010-01-25 06:21:05 -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
unsigned int i;
cogl: new textures sould have GL_TEXTURE_MIN_FILTER set to GL_LINEAR The only way the user has to set the mipmap filters is through the material/layer API. This API defaults to GL_LINEAR/GL_LINEAR for the max and min filters. With the main use case of cogl being 2D interfaces, it makes sense do default to GL_LINEAR for the min filter. When creating new textures, we did not set any filter on them, using OpenGL defaults': GL_NEAREST_MIPMAP_LINEAR for the min filter and GL_LINEAR for the max filter. This will make the driver allocate memory for the mipmap tree, memory that will not be used in the nominal case (as the material API defaults to GL_LINEAR). This patch tries to ensure that the min filter is set to GL_LINEAR before any glTexImage*() call is done on the texture by setting the filter when generating new OpenGL handles.
2010-01-25 06:21:05 -05:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE (ctx, glGenTextures (n, textures));
cogl: new textures sould have GL_TEXTURE_MIN_FILTER set to GL_LINEAR The only way the user has to set the mipmap filters is through the material/layer API. This API defaults to GL_LINEAR/GL_LINEAR for the max and min filters. With the main use case of cogl being 2D interfaces, it makes sense do default to GL_LINEAR for the min filter. When creating new textures, we did not set any filter on them, using OpenGL defaults': GL_NEAREST_MIPMAP_LINEAR for the min filter and GL_LINEAR for the max filter. This will make the driver allocate memory for the mipmap tree, memory that will not be used in the nominal case (as the material API defaults to GL_LINEAR). This patch tries to ensure that the min filter is set to GL_LINEAR before any glTexImage*() call is done on the texture by setting the filter when generating new OpenGL handles.
2010-01-25 06:21:05 -05:00
for (i = 0; i < n; i++)
{
material: Avoid redundant glBindTexture calls This adds a _cogl_bind_gl_texture_transient function that should be used instead of glBindTexture so we can have a consistent cache of the textures bound to each texture unit so we can avoid some redundant binding.
2010-04-26 05:01:43 -04:00
_cogl_bind_gl_texture_transient (gl_target,
textures[i],
FALSE);
cogl: new textures sould have GL_TEXTURE_MIN_FILTER set to GL_LINEAR The only way the user has to set the mipmap filters is through the material/layer API. This API defaults to GL_LINEAR/GL_LINEAR for the max and min filters. With the main use case of cogl being 2D interfaces, it makes sense do default to GL_LINEAR for the min filter. When creating new textures, we did not set any filter on them, using OpenGL defaults': GL_NEAREST_MIPMAP_LINEAR for the min filter and GL_LINEAR for the max filter. This will make the driver allocate memory for the mipmap tree, memory that will not be used in the nominal case (as the material API defaults to GL_LINEAR). This patch tries to ensure that the min filter is set to GL_LINEAR before any glTexImage*() call is done on the texture by setting the filter when generating new OpenGL handles.
2010-01-25 06:21:05 -05:00
switch (gl_target)
{
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
/* GL_TEXTURE_MAG_FILTER defaults to GL_LINEAR, no need to set it */
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glTexParameteri (gl_target,
GL_TEXTURE_MIN_FILTER,
GL_LINEAR) );
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
break;
case GL_TEXTURE_RECTANGLE_ARB:
/* Texture rectangles already default to GL_LINEAR so nothing
needs to be done */
break;
cogl: new textures sould have GL_TEXTURE_MIN_FILTER set to GL_LINEAR The only way the user has to set the mipmap filters is through the material/layer API. This API defaults to GL_LINEAR/GL_LINEAR for the max and min filters. With the main use case of cogl being 2D interfaces, it makes sense do default to GL_LINEAR for the min filter. When creating new textures, we did not set any filter on them, using OpenGL defaults': GL_NEAREST_MIPMAP_LINEAR for the min filter and GL_LINEAR for the max filter. This will make the driver allocate memory for the mipmap tree, memory that will not be used in the nominal case (as the material API defaults to GL_LINEAR). This patch tries to ensure that the min filter is set to GL_LINEAR before any glTexImage*() call is done on the texture by setting the filter when generating new OpenGL handles.
2010-01-25 06:21:05 -05:00
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
default:
g_assert_not_reached();
}
cogl: new textures sould have GL_TEXTURE_MIN_FILTER set to GL_LINEAR The only way the user has to set the mipmap filters is through the material/layer API. This API defaults to GL_LINEAR/GL_LINEAR for the max and min filters. With the main use case of cogl being 2D interfaces, it makes sense do default to GL_LINEAR for the min filter. When creating new textures, we did not set any filter on them, using OpenGL defaults': GL_NEAREST_MIPMAP_LINEAR for the min filter and GL_LINEAR for the max filter. This will make the driver allocate memory for the mipmap tree, memory that will not be used in the nominal case (as the material API defaults to GL_LINEAR). This patch tries to ensure that the min filter is set to GL_LINEAR before any glTexImage*() call is done on the texture by setting the filter when generating new OpenGL handles.
2010-01-25 06:21:05 -05:00
}
}
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
/* OpenGL - unlike GLES - can upload a sub region of pixel data from a larger
* source buffer */
static void
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
prep_gl_for_pixels_upload_full (CoglContext *ctx,
int pixels_rowstride,
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
int image_height,
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
int pixels_src_x,
int pixels_src_y,
int pixels_bpp)
{
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glPixelStorei (GL_UNPACK_ROW_LENGTH,
pixels_rowstride / pixels_bpp) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glPixelStorei (GL_UNPACK_SKIP_PIXELS, pixels_src_x) );
GE( ctx, glPixelStorei (GL_UNPACK_SKIP_ROWS, pixels_src_y) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
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_3D))
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glPixelStorei (GL_UNPACK_IMAGE_HEIGHT, image_height) );
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
_cogl_texture_prep_gl_alignment_for_pixels_upload (pixels_rowstride);
}
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
static void
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
_cogl_texture_driver_prep_gl_for_pixels_upload (CoglContext *ctx,
int pixels_rowstride,
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
int pixels_bpp)
{
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
prep_gl_for_pixels_upload_full (ctx, pixels_rowstride, 0, 0, 0, pixels_bpp);
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
}
/* OpenGL - unlike GLES - can download pixel data into a sub region of
* a larger destination buffer */
static void
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
prep_gl_for_pixels_download_full (CoglContext *ctx,
int pixels_rowstride,
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
int image_height,
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
int pixels_src_x,
int pixels_src_y,
int pixels_bpp)
{
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glPixelStorei (GL_PACK_ROW_LENGTH, pixels_rowstride / pixels_bpp) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glPixelStorei (GL_PACK_SKIP_PIXELS, pixels_src_x) );
GE( ctx, glPixelStorei (GL_PACK_SKIP_ROWS, pixels_src_y) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
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_3D))
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glPixelStorei (GL_PACK_IMAGE_HEIGHT, image_height) );
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
_cogl_texture_prep_gl_alignment_for_pixels_download (pixels_rowstride);
}
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
static void
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
_cogl_texture_driver_prep_gl_for_pixels_download (CoglContext *ctx,
int pixels_rowstride,
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
int pixels_bpp)
{
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
prep_gl_for_pixels_download_full (ctx, pixels_rowstride, 0, 0, 0, pixels_bpp);
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37: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
static void
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
_cogl_texture_driver_upload_subregion_to_gl (CoglContext *ctx,
GLenum gl_target,
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
GLuint gl_handle,
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
gboolean is_foreign,
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height,
CoglBitmap *source_bmp,
GLuint source_gl_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
GLuint source_gl_type)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04: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
guint8 *data;
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
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);
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
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
data = _cogl_bitmap_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0);
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
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
/* Setup gl alignment to match rowstride and top-left corner */
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
prep_gl_for_pixels_upload_full (ctx,
cogl_bitmap_get_rowstride (source_bmp),
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
0,
src_x,
src_y,
bpp);
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
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
_cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign);
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
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glTexSubImage2D (gl_target, 0,
dst_x, dst_y,
width, height,
source_gl_format,
source_gl_type,
data) );
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
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
_cogl_bitmap_unbind (source_bmp);
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37: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
static void
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
_cogl_texture_driver_upload_to_gl (CoglContext *ctx,
GLenum gl_target,
cogl: Add _cogl_texture_driver_upload_to_gl This provides a way to upload the entire data for a texture without having to first call glTexImage and then glTexSubImage. This should be faster especially with indirect rendering where it would needlessy send the data for the texture twice.
2009-11-30 07:15:05 -05:00
GLuint gl_handle,
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
gboolean is_foreign,
cogl: Add _cogl_texture_driver_upload_to_gl This provides a way to upload the entire data for a texture without having to first call glTexImage and then glTexSubImage. This should be faster especially with indirect rendering where it would needlessy send the data for the texture twice.
2009-11-30 07:15:05 -05:00
CoglBitmap *source_bmp,
GLint internal_gl_format,
GLuint source_gl_format,
GLuint source_gl_type)
{
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
guint8 *data;
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
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);
cogl: Add _cogl_texture_driver_upload_to_gl This provides a way to upload the entire data for a texture without having to first call glTexImage and then glTexSubImage. This should be faster especially with indirect rendering where it would needlessy send the data for the texture twice.
2009-11-30 07:15:05 -05:00
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
data = _cogl_bitmap_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0);
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
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
/* Setup gl alignment to match rowstride and top-left corner */
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
prep_gl_for_pixels_upload_full (ctx,
cogl_bitmap_get_rowstride (source_bmp),
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
0, 0, 0, bpp);
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
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
_cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign);
cogl: Add _cogl_texture_driver_upload_to_gl This provides a way to upload the entire data for a texture without having to first call glTexImage and then glTexSubImage. This should be faster especially with indirect rendering where it would needlessy send the data for the texture twice.
2009-11-30 07:15:05 -05:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glTexImage2D (gl_target, 0,
internal_gl_format,
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
cogl_bitmap_get_width (source_bmp),
cogl_bitmap_get_height (source_bmp),
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
0,
source_gl_format,
source_gl_type,
data) );
cogl: Add _cogl_texture_driver_upload_to_gl This provides a way to upload the entire data for a texture without having to first call glTexImage and then glTexSubImage. This should be faster especially with indirect rendering where it would needlessy send the data for the texture twice.
2009-11-30 07:15:05 -05:00
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
_cogl_bitmap_unbind (source_bmp);
cogl: Add _cogl_texture_driver_upload_to_gl This provides a way to upload the entire data for a texture without having to first call glTexImage and then glTexSubImage. This should be faster especially with indirect rendering where it would needlessy send the data for the texture twice.
2009-11-30 07:15:05 -05: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
static void
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
_cogl_texture_driver_upload_to_gl_3d (CoglContext *ctx,
GLenum gl_target,
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
GLuint gl_handle,
gboolean is_foreign,
GLint height,
GLint depth,
CoglBitmap *source_bmp,
GLint internal_gl_format,
GLuint source_gl_format,
GLuint source_gl_type)
{
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
guint8 *data;
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
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);
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
data = _cogl_bitmap_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0);
/* Setup gl alignment to match rowstride and top-left corner */
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
prep_gl_for_pixels_upload_full (ctx,
cogl_bitmap_get_rowstride (source_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
(cogl_bitmap_get_height (source_bmp) /
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
depth),
0, 0, bpp);
_cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign);
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glTexImage3D (gl_target,
0, /* level */
internal_gl_format,
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
cogl_bitmap_get_width (source_bmp),
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
height,
depth,
0,
source_gl_format,
source_gl_type,
data) );
Add an internal _cogl_bitmap_new_from_buffer This function creates a CoglBitmap which internally references a CoglBuffer. The map and unmap functions will divert to mapping the buffer. There are also now bind and unbind functions which should be used instead of map and unmap whenever the data doesn't need to be read from the CPU but will instead be passed to GL for packing or unpacking. For bitmaps created from buffers this just binds the bitmap. cogl_texture_new_from_buffer now just uses this function to wrap the buffer in a bitmap rather than trying to bind the buffer immediately. This means that the buffer will be bound only at the point right before the texture data is uploaded. This approach means that using a pixel array will take the fastest upload route if possible, but can still fallback to copying the data by mapping the buffer if some conversion is needed. Previously it would just crash in this case because the texture functions were all passed a NULL pointer. http://bugzilla.clutter-project.org/show_bug.cgi?id=2112
2010-07-15 08:05:55 -04:00
_cogl_bitmap_unbind (source_bmp);
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -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
static gboolean
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
_cogl_texture_driver_gl_get_tex_image (CoglContext *ctx,
GLenum gl_target,
GLenum dest_gl_format,
GLenum dest_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
guint8 *dest)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
{
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE (ctx, glGetTexImage (gl_target,
0, /* level */
dest_gl_format,
dest_gl_type,
(GLvoid *)dest));
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
return TRUE;
}
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
static gboolean
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
_cogl_texture_driver_size_supported_3d (CoglContext *ctx,
GLenum gl_target,
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
GLenum gl_format,
GLenum gl_type,
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
int width,
int height,
int depth)
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
{
GLenum proxy_target;
GLint new_width = 0;
if (gl_target == GL_TEXTURE_3D)
proxy_target = GL_PROXY_TEXTURE_3D;
else
/* Unknown target, assume it's not supported */
return FALSE;
/* Proxy texture allows for a quick check for supported size */
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glTexImage3D (proxy_target, 0, GL_RGBA,
width, height, depth, 0 /* border */,
gl_format, gl_type, NULL) );
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glGetTexLevelParameteriv (proxy_target, 0,
GL_TEXTURE_WIDTH, &new_width) );
Add a Cogl texture 3D backend This adds a publicly exposed experimental API for a 3D texture backend. There is a feature flag which can be checked for whether 3D textures are supported. Although we require OpenGL 1.2 which has 3D textures in core, GLES only provides them through an extension so the feature can be used to detect that. The textures can be created with one of two new API functions :- cogl_texture_3d_new_with_size and cogl_texture_3d_new_from_data There is also internally a new_from_bitmap function. new_from_data is implemented in terms of this function. The two constructors are effectively the only way to upload data to a 3D texture. It does not work to call glTexImage2D with the GL_TEXTURE_3D target so the virtual for cogl_texture_set_region does nothing. It would be possible to make cogl_texture_get_data do something sensible like returning all of the images as a single long image but this is not currently implemented and instead the virtual just always fails. We may want to add API specific to the 3D texture backend to get and set a sub region of the texture. All of those three functions can throw a GError. This will happen if the GPU does not support 3D textures or it does not support NPOTs and an NPOT size is requested. It will also fail if the FBO extension is not supported and the COGL_TEXTURE_NO_AUTO_MIPMAP flag is not given. This could be avoided by copying the code for the GL_GENERATE_MIPMAP TexParameter fallback, but in the interests of keeping the code simple this is not yet done. This adds a couple of functions to cogl-texture-driver for uploading 3D data and querying the 3D proxy texture. prep_gl_for_pixels_upload_full now also takes sets the GL_UNPACK_IMAGE_HEIGHT parameter so that 3D textures can have padding between the images. Whenever 3D texture is uploading, both the height of the images and the height of all of the data is specified (either explicitly or implicilty from the CoglBitmap) so that the image height can be deduced by dividing by the depth.
2010-07-01 17:04:59 -04:00
return new_width != 0;
}
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
static gboolean
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
_cogl_texture_driver_size_supported (CoglContext *ctx,
GLenum gl_target,
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
GLenum gl_format,
GLenum gl_type,
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
int width,
int height)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
{
cogl: Add an internal CoglTextureRectangle backend This adds an internal rectangle texture backend which is mostly based on the CoglTexture2D backend. It will throw assert failures if any operations are attempted that rectangle textures don't support, such as mipmapping or hardware repeating.
2010-06-10 10:33:34 -04:00
GLenum proxy_target;
GLint new_width = 0;
if (gl_target == GL_TEXTURE_2D)
proxy_target = GL_PROXY_TEXTURE_2D;
#if HAVE_COGL_GL
else if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
proxy_target = GL_PROXY_TEXTURE_RECTANGLE_ARB;
#endif
else
/* Unknown target, assume it's not supported */
return FALSE;
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
cogl: Add an internal CoglTextureRectangle backend This adds an internal rectangle texture backend which is mostly based on the CoglTexture2D backend. It will throw assert failures if any operations are attempted that rectangle textures don't support, such as mipmapping or hardware repeating.
2010-06-10 10:33:34 -04:00
/* Proxy texture allows for a quick check for supported size */
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glTexImage2D (proxy_target, 0, GL_RGBA,
width, height, 0 /* border */,
gl_format, gl_type, NULL) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glGetTexLevelParameteriv (proxy_target, 0,
GL_TEXTURE_WIDTH, &new_width) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
cogl: Add an internal CoglTextureRectangle backend This adds an internal rectangle texture backend which is mostly based on the CoglTexture2D backend. It will throw assert failures if any operations are attempted that rectangle textures don't support, such as mipmapping or hardware repeating.
2010-06-10 10:33:34 -04:00
return new_width != 0;
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37: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
static void
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
_cogl_texture_driver_try_setting_gl_border_color
(CoglContext *ctx,
GLuint gl_target,
const GLfloat *transparent_color)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
{
/* Use a transparent border color so that we can leave the
color buffer alone when using texture co-ordinates
outside of the texture */
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glTexParameterfv (gl_target, GL_TEXTURE_BORDER_COLOR,
transparent_color) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37: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
static gboolean
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
_cogl_texture_driver_allows_foreign_gl_target (CoglContext *ctx,
GLenum gl_target)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
{
/* GL_ARB_texture_rectangle textures are supported if they are
created from foreign because some chipsets have trouble with
GL_ARB_texture_non_power_of_two. There is no Cogl call to create
them directly to emphasize the fact that they don't work fully
(for example, no mipmapping and complicated shader support) */
/* Allow 2-dimensional or rectangle textures only */
cogl: Remove the CGL_* defines These macros used to define Cogl wrappers for the GLenum values. There are now Cogl enums everywhere in the API where these were required so we shouldn't need them anymore. They were in the public headers but as they are not neccessary and were not in the API docs for Clutter 1.0 it should be safe to remove them.
2010-01-12 09:43:36 -05:00
if (gl_target != GL_TEXTURE_2D && gl_target != GL_TEXTURE_RECTANGLE_ARB)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
return FALSE;
return TRUE;
}
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
static void
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
_cogl_texture_driver_gl_generate_mipmaps (CoglContext *ctx,
GLenum gl_target)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
{
Use all core GL functions through indirect pointers cogl-ext-functions.h now contains definitions for all of the core GL and GLES functions that we would normally link to directly. All of the code has changed to access them through the cogl context pointer. The GE macro now takes an extra parameter to specify the context because the macro itself needs to make GL calls but various points in the Cogl source use different names for the context variable.
2011-07-06 16:51:00 -04:00
GE( ctx, glGenerateMipmap (gl_target) );
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37: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
static CoglPixelFormat
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
_cogl_texture_driver_find_best_gl_get_data_format
(CoglContext *context,
CoglPixelFormat format,
GLenum *closest_gl_format,
GLenum *closest_gl_type)
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37:11 -04:00
{
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
return context->driver_vtable->pixel_format_to_gl (context,
format,
NULL, /* don't need */
closest_gl_format,
closest_gl_type);
Improve cogl-texture maintainability by moving 90% into cogl/common This splits the limited components that differed between cogl/{gl,gles}/cogl-texture.c into new {gl,gles}/cogl-texture-driver.c files and the rest that can now be shared into cogl/common/cogl-texture.c
2009-07-27 19:37: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
const CoglTextureDriver
_cogl_texture_driver_gl =
{
_cogl_texture_driver_gen,
_cogl_texture_driver_prep_gl_for_pixels_upload,
_cogl_texture_driver_upload_subregion_to_gl,
_cogl_texture_driver_upload_to_gl,
_cogl_texture_driver_upload_to_gl_3d,
_cogl_texture_driver_prep_gl_for_pixels_download,
_cogl_texture_driver_gl_get_tex_image,
_cogl_texture_driver_size_supported,
_cogl_texture_driver_size_supported_3d,
_cogl_texture_driver_try_setting_gl_border_color,
_cogl_texture_driver_allows_foreign_gl_target,
_cogl_texture_driver_gl_generate_mipmaps,
_cogl_texture_driver_find_best_gl_get_data_format
};
Reference in New Issue Copy Permalink