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

719 lines
24 KiB
C
Raw Normal View History

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
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 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
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*
* Authors:
* Neil Roberts <neil@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"
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
#include "cogl-util.h"
#include "cogl-texture-private.h"
#include "cogl-texture-rectangle-private.h"
#include "cogl-texture-driver.h"
cogl: rename cogl-context.h cogl-context-private.h Since we plan to add public cogl_context_* API we need to rename the current cogl-context.h which contains private member details.
2010-11-04 18:25:52 -04:00
#include "cogl-context-private.h"
Removes all remaining use of CoglHandle Removing CoglHandle has been an on going goal for quite a long time now and finally this patch removes the last remaining uses of the CoglHandle type and the cogl_handle_ apis. Since the big remaining users of CoglHandle were the cogl_program_ and cogl_shader_ apis which have replaced with the CoglSnippets api this patch removes both of these apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6ed3aaf4be21d605a1ed3176b3ea825933f85cf0) Since the original patch was done after removing deprecated API this back ported patch doesn't affect deprecated API and so actually this cherry-pick doesn't remove all remaining use of CoglHandle as it did for the master branch of Cogl.
2012-04-16 09:14:10 -04:00
#include "cogl-object-private.h"
cogl: 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
#include "cogl-journal-private.h"
cogl: rename CoglMaterial -> CoglPipeline This applies an API naming change that's been deliberated over for a while now which is to rename CoglMaterial to CoglPipeline. For now the new pipeline API is marked as experimental and public headers continue to talk about materials not pipelines. The CoglMaterial API is now maintained in terms of the cogl_pipeline API internally. Currently this API is targeting Cogl 2.0 so we will have time to integrate it properly with other upcoming Cogl 2.0 work. The basic reasons for the rename are: - That the term "material" implies to many people that they are constrained to fragment processing; perhaps as some kind of high-level texture abstraction. - In Clutter they get exposed by ClutterTexture actors which may be re-inforcing this misconception. - When comparing how other frameworks use the term material, a material sometimes describes a multi-pass fragment processing technique which isn't the case in Cogl. - In code, "CoglPipeline" will hopefully be a much more self documenting summary of what these objects represent; a full GPU pipeline configuration including, for example, vertex processing, fragment processing and blending. - When considering the API documentation story, at some point we need a document introducing developers to how the "GPU pipeline" works so it should become intuitive that CoglPipeline maps back to that description of the GPU pipeline. - This is consistent in terminology and concept to OpenGL 4's new pipeline object which is a container for program objects. Note: The cogl-material.[ch] files have been renamed to cogl-material-compat.[ch] because otherwise git doesn't seem to treat the change as a moving the old cogl-material.c->cogl-pipeline.c and so we loose all our git-blame history.
2010-10-27 13:54:57 -04:00
#include "cogl-pipeline-opengl-private.h"
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
#include "cogl-error-private.h"
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
#include "cogl-util-gl-private.h"
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
#include <string.h>
#include <math.h>
/* These aren't defined under GLES */
#ifndef GL_TEXTURE_RECTANGLE_ARB
#define GL_TEXTURE_RECTANGLE_ARB 0x84F5
#endif
#ifndef GL_CLAMP
#define GL_CLAMP 0x2900
#endif
#ifndef GL_CLAMP_TO_BORDER
#define GL_CLAMP_TO_BORDER 0x812D
#endif
static void _cogl_texture_rectangle_free (CoglTextureRectangle *tex_rect);
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
COGL_TEXTURE_DEFINE (TextureRectangle, texture_rectangle);
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
static const CoglTextureVtable cogl_texture_rectangle_vtable;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
cogl: 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
can_use_wrap_mode (GLenum wrap_mode)
{
return (wrap_mode == GL_CLAMP ||
wrap_mode == GL_CLAMP_TO_EDGE ||
wrap_mode == GL_CLAMP_TO_BORDER);
}
static void
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
_cogl_texture_rectangle_gl_flush_legacy_texobj_wrap_modes (CoglTexture *tex,
GLenum wrap_mode_s,
GLenum wrap_mode_t,
GLenum wrap_mode_p)
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
{
CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
CoglContext *ctx = tex->context;
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
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
/* Only set the wrap mode if it's different from the current value
to avoid too many GL calls. Texture rectangle doesn't make use of
the r coordinate so we can ignore its wrap mode */
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
if (tex_rect->gl_legacy_texobj_wrap_mode_s != wrap_mode_s ||
tex_rect->gl_legacy_texobj_wrap_mode_t != wrap_mode_t)
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
{
g_assert (can_use_wrap_mode (wrap_mode_s));
g_assert (can_use_wrap_mode (wrap_mode_t));
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
_cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
tex_rect->gl_texture,
tex_rect->is_foreign);
GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_WRAP_S, wrap_mode_s) );
GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_WRAP_T, wrap_mode_t) );
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
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
tex_rect->gl_legacy_texobj_wrap_mode_s = wrap_mode_s;
tex_rect->gl_legacy_texobj_wrap_mode_t = wrap_mode_t;
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
}
}
static void
_cogl_texture_rectangle_free (CoglTextureRectangle *tex_rect)
{
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
if (!tex_rect->is_foreign && tex_rect->gl_texture)
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
_cogl_delete_gl_texture (tex_rect->gl_texture);
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
/* Chain up */
_cogl_texture_free (COGL_TEXTURE (tex_rect));
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
_cogl_texture_rectangle_can_create (CoglContext *ctx,
unsigned int width,
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
unsigned int height,
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
CoglPixelFormat internal_format,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
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 gl_intformat;
Use the internal format to check if the texture size is supported Until now, we hardcoded the internal format to GL_RGBA and used the internal format returned by pixel_format_to_gl() as the format for checking the texture size and format we're asked to create. Let's use the proper internal format/format from now on. This is needed as a later patch introduces DEPTH and DEPTH_STENCIL textures. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec45f60ee2545f88302da314bcdbe1439c4ba9c9)
2012-05-23 09:47:57 -04:00
GLenum gl_format;
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 gl_type;
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_RECTANGLE))
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error,
COGL_TEXTURE_ERROR,
COGL_TEXTURE_ERROR_TYPE,
"The CoglTextureRectangle feature isn't available");
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
return FALSE;
}
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
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
internal_format,
&gl_intformat,
Use the internal format to check if the texture size is supported Until now, we hardcoded the internal format to GL_RGBA and used the internal format returned by pixel_format_to_gl() as the format for checking the texture size and format we're asked to create. Let's use the proper internal format/format from now on. This is needed as a later patch introduces DEPTH and DEPTH_STENCIL textures. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec45f60ee2545f88302da314bcdbe1439c4ba9c9)
2012-05-23 09:47:57 -04:00
&gl_format,
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
&gl_type);
cogl: 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
/* Check that the driver can create a texture with that size */
Add a context parameter to all of the texture driver virtuals All of the texture driver virtual functions now take an explicit CoglContext parameter as a step towards removing the global context.
2012-03-22 13:04:47 -04:00
if (!ctx->texture_driver->size_supported (ctx,
GL_TEXTURE_RECTANGLE_ARB,
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
gl_intformat,
Use the internal format to check if the texture size is supported Until now, we hardcoded the internal format to GL_RGBA and used the internal format returned by pixel_format_to_gl() as the format for checking the texture size and format we're asked to create. Let's use the proper internal format/format from now on. This is needed as a later patch introduces DEPTH and DEPTH_STENCIL textures. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ec45f60ee2545f88302da314bcdbe1439c4ba9c9)
2012-05-23 09:47:57 -04:00
gl_format,
cogl: 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
gl_type,
width,
height))
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error,
COGL_TEXTURE_ERROR,
COGL_TEXTURE_ERROR_SIZE,
"The requested texture size + format is unsupported");
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
return FALSE;
}
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 TRUE;
}
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:09:43 -04:00
static void
_cogl_texture_rectangle_set_auto_mipmap (CoglTexture *tex,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool value)
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:09:43 -04:00
{
/* Rectangle textures currently never support mipmapping so there's
no point in doing anything here */
}
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
static CoglTextureRectangle *
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
_cogl_texture_rectangle_create_base (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format)
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
{
CoglTextureRectangle *tex_rect = g_new (CoglTextureRectangle, 1);
CoglTexture *tex = COGL_TEXTURE (tex_rect);
texture: add width/height members to base CoglTexture There was a lot of redundancy in how we tracked the width and height of different texture types which is greatly simplified by adding width and height members to CoglTexture directly and removing the get_width and get_height vfuncs from CoglTextureVtable Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3236e47723e4287d5e0023f29083521aeffc75dd)
2012-11-22 16:46:54 -05:00
_cogl_texture_init (tex, ctx, width, height, &cogl_texture_rectangle_vtable);
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
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
tex_rect->gl_texture = 0;
texture-rectangle: Initialize is_foreign So we don't read an initializes value later on. Caught by valgrind: Conditional jump or move depends on uninitialised value(s) _cogl_object_texture_rectangle_indirect_free (cogl-texture-rectangle.c:105) _cogl_object_context_indirect_free (cogl-context.c:453) ... main (text.c:149) Signed-off-by: Damien Lespiau <damien.lespiau@intel.com> Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 90415aae9495749a2a9e85fb17425a3c7f6a08c8)
2013-08-26 16:51:55 -04:00
tex_rect->is_foreign = FALSE;
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05: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
/* We default to GL_LINEAR for both filters */
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
tex_rect->gl_legacy_texobj_min_filter = GL_LINEAR;
tex_rect->gl_legacy_texobj_mag_filter = GL_LINEAR;
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
/* Wrap mode not yet set */
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
tex_rect->gl_legacy_texobj_wrap_mode_s = GL_FALSE;
tex_rect->gl_legacy_texobj_wrap_mode_t = GL_FALSE;
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
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
tex_rect->internal_format = internal_format;
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
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
return _cogl_texture_rectangle_object_new (tex_rect);
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
}
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
CoglTextureRectangle *
cogl_texture_rectangle_new_with_size (CoglContext *ctx,
int width,
int height,
CoglPixelFormat internal_format,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
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
{
CoglTextureRectangle *tex_rect;
/* Since no data, we need some internal format */
if (internal_format == COGL_PIXEL_FORMAT_ANY)
internal_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE;
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
tex_rect =_cogl_texture_rectangle_create_base (ctx,
width, height,
internal_format);
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
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
/* XXX: This api has been changed for Cogl 2.0 on the master branch
* to not take a CoglError to allow the storage to be allocated
* lazily but since Mutter uses this api we are currently
* maintaining the semantics of immediately allocating the storage
*/
if (!cogl_texture_allocate (COGL_TEXTURE (tex_rect), error))
{
cogl_object_unref (tex_rect);
return NULL;
}
return tex_rect;
}
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
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
static CoglBool
_cogl_texture_rectangle_allocate (CoglTexture *tex,
CoglError **error)
{
CoglContext *ctx = tex->context;
CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
GLenum gl_error;
GLenum gl_texture;
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
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
if (!_cogl_texture_rectangle_can_create (ctx,
tex->width,
tex->height,
tex_rect->internal_format,
error))
return FALSE;
ctx->driver_vtable->pixel_format_to_gl (ctx,
tex_rect->internal_format,
&gl_intformat,
&gl_format,
&gl_type);
gl_texture =
Use GL_ARB_texture_swizzle to emulate GL_ALPHA textures The core profile of GL3 has removed support for component-alpha textures. Previously the GL3 driver would just ignore this and try to create them anyway. This would generate a GL error on Mesa. To fix this the GL texture driver will now create a GL_RED texture when GL_ALPHA textures are not supported natively. It will then set a texture swizzle using the GL_ARB_texture_swizzle extension so that the alpha component will be taken from the red component of the texture. The swizzle is part of the texture object state so it only needs to be set once when the texture is created. The ‘gen’ virtual function of the texture driver has been changed to also take the internal format as a parameter. The GL driver will now set the swizzle as appropriate here. The GL3 driver now reports an error if the texture swizzle extension is not available because Cogl can't really work properly without out it. The extension is part of GL 3.3 so it is quite likely that it has wide support from drivers. Eventually we could get rid of this requirement if we have our own GLSL front-end and we could generate the swizzle ourselves. When uploading or downloading texture data to or from a component-alpha texture, we can no longer rely on GL to do the conversion. The swizzle doesn't have any effect on the texture data functions. In these cases Cogl will now force an intermediate buffer to be used and it will manually do the conversion as it does for the GLES drivers. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 32bacf81ebaa3be21a8f26af07d8f6eed6607652)
2012-11-19 12:28:52 -05:00
ctx->texture_driver->gen (ctx,
GL_TEXTURE_RECTANGLE_ARB,
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
tex_rect->internal_format);
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
_cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
gl_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
tex_rect->is_foreign);
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
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
/* Clear any GL errors */
while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR)
;
ctx->glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, gl_intformat,
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
tex->width, tex->height, 0, gl_format, gl_type, NULL);
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
if (_cogl_gl_util_catch_out_of_memory (ctx, error))
{
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
GE( ctx, glDeleteTextures (1, &gl_texture) );
return FALSE;
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
}
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
tex_rect->gl_texture = gl_texture;
tex_rect->gl_format = gl_intformat;
return TRUE;
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
}
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
CoglTextureRectangle *
Add constructors which take a CoglBitmap to all primitive textures This adds public constructors which take a CoglBitmap to all primitive texture types. This constructor should be considered the canonical constructor for initializing the texture with data because it should be possible to wrap any type of data in a CoglBitmap. Having at least this single constructor avoids the need to have an explosion of constructors such as new_from_data, new_from_pixel_buffer and new_from_file etc. The already available internal bitmap constructor for CoglTexture2D has had its flags parameter removed under the assumption that flags do not make sense for primitive textures. The meta constructor cogl_texture_new_from_bitmap now just explicitly calls set_auto_mipmap after constructing the texture depending on the value of the COGL_TEXTURE_NO_AUTO_MIPMAP flag. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:10:04 -04:00
cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp,
CoglPixelFormat internal_format,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
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
{
CoglTextureRectangle *tex_rect;
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
CoglBitmap *upload_bmp;
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
CoglContext *ctx;
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
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
_COGL_RETURN_VAL_IF_FAIL (cogl_is_bitmap (bmp), NULL);
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
bitmap: Store a pointer to the context This adds a context member to CoglBitmap which stores the context it was created with. That way it can be used in texture constructors which use a bitmap. There is also an internal private function to get the context out of the bitmap which all of the texture constructors now use. _cogl_texture_3d_new_from_bitmap has had its context parameter removed so that it more closely matches the other bitmap constructors. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 08:57:42 -04:00
ctx = _cogl_bitmap_get_context (bmp);
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
internal_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_texture_determine_internal_format (cogl_bitmap_get_format (bmp),
cogl-bitmap: Encapsulate the CoglBitmap even internally The CoglBitmap struct is now only defined within cogl-bitmap.c so that all of its members can now only be accessed with accessor functions. To get to the data pointer for the bitmap image you must first call _cogl_bitmap_map and later call _cogl_bitmap_unmap. The map function takes the same arguments as cogl_pixel_array_map so that eventually we can make a bitmap optionally internally divert to a pixel array. There is a _cogl_bitmap_new_from_data function which constructs a new bitmap object and takes ownership of the data pointer. The function gets passed a destroy callback which gets called when the bitmap is freed. This is similar to how gdk_pixbuf_new_from_data works. Alternatively NULL can be passed for the destroy function which means that the caller will manage the life of the pointer (but must guarantee that it stays alive at least until the bitmap is freed). This mechanism is used instead of the old approach of creating a CoglBitmap struct on the stack and manually filling in the members. It could also later be used to create a CoglBitmap that owns a GdkPixbuf ref so that we don't necessarily have to copy the GdkPixbuf data when converting to a bitmap. There is also _cogl_bitmap_new_shared. This creates a bitmap using a reference to another CoglBitmap for the data. This is a bit of a hack but it is needed by the atlas texture backend which wants to divert the set_region virtual to another texture but it needs to override the format of the bitmap to ignore the premult flag.
2010-07-07 13:44:16 -04:00
internal_format);
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
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
if (!_cogl_texture_rectangle_can_create (ctx,
cogl_bitmap_get_width (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 (bmp),
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
internal_format,
Add constructors which take a CoglBitmap to all primitive textures This adds public constructors which take a CoglBitmap to all primitive texture types. This constructor should be considered the canonical constructor for initializing the texture with data because it should be possible to wrap any type of data in a CoglBitmap. Having at least this single constructor avoids the need to have an explosion of constructors such as new_from_data, new_from_pixel_buffer and new_from_file etc. The already available internal bitmap constructor for CoglTexture2D has had its flags parameter removed under the assumption that flags do not make sense for primitive textures. The meta constructor cogl_texture_new_from_bitmap now just explicitly calls set_auto_mipmap after constructing the texture depending on the value of the COGL_TEXTURE_NO_AUTO_MIPMAP flag. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:10:04 -04:00
error))
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
return NULL;
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
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
upload_bmp =
_cogl_bitmap_convert_for_upload (bmp,
internal_format,
FALSE, /* can't convert in place */
error);
if (upload_bmp == NULL)
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
return NULL;
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
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
cogl_bitmap_get_format (upload_bmp),
NULL, /* internal format */
&gl_format,
&gl_type);
ctx->driver_vtable->pixel_format_to_gl (ctx,
internal_format,
&gl_intformat,
NULL,
NULL);
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
tex_rect = _cogl_texture_rectangle_create_base (ctx,
cogl_bitmap_get_width (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 (bmp),
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
internal_format);
Use GL_ARB_texture_swizzle to emulate GL_ALPHA textures The core profile of GL3 has removed support for component-alpha textures. Previously the GL3 driver would just ignore this and try to create them anyway. This would generate a GL error on Mesa. To fix this the GL texture driver will now create a GL_RED texture when GL_ALPHA textures are not supported natively. It will then set a texture swizzle using the GL_ARB_texture_swizzle extension so that the alpha component will be taken from the red component of the texture. The swizzle is part of the texture object state so it only needs to be set once when the texture is created. The ‘gen’ virtual function of the texture driver has been changed to also take the internal format as a parameter. The GL driver will now set the swizzle as appropriate here. The GL3 driver now reports an error if the texture swizzle extension is not available because Cogl can't really work properly without out it. The extension is part of GL 3.3 so it is quite likely that it has wide support from drivers. Eventually we could get rid of this requirement if we have our own GLSL front-end and we could generate the swizzle ourselves. When uploading or downloading texture data to or from a component-alpha texture, we can no longer rely on GL to do the conversion. The swizzle doesn't have any effect on the texture data functions. In these cases Cogl will now force an intermediate buffer to be used and it will manually do the conversion as it does for the GLES drivers. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 32bacf81ebaa3be21a8f26af07d8f6eed6607652)
2012-11-19 12:28:52 -05:00
tex_rect->gl_texture =
ctx->texture_driver->gen (ctx,
GL_TEXTURE_RECTANGLE_ARB,
internal_format);
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
if (!ctx->texture_driver->upload_to_gl (ctx,
GL_TEXTURE_RECTANGLE_ARB,
tex_rect->gl_texture,
FALSE,
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
upload_bmp,
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
gl_intformat,
gl_format,
gl_type,
error))
{
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
cogl_object_unref (upload_bmp);
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
cogl_object_unref (tex_rect);
return NULL;
}
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
tex_rect->gl_format = gl_intformat;
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
cogl_object_unref (upload_bmp);
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
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
_cogl_texture_set_allocated (COGL_TEXTURE (tex_rect), TRUE);
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
return tex_rect;
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
}
texture: Make CoglTextureRectangle experimentally public This exposes CoglTextureRectangle in the experimental cogl 2.0 api. For now we just expose a single constructor; cogl_texture_rectangle_new_with_size() but we can add more later. This is part of going work to improve our texture apis with more emphasis on providing low-level access to the varying semantics of different texture types understood by the gpu instead of only trying to present a lowest common denominator api. CoglTextureRectangle is notably useful for never being restricted to power of two sizes and for being sampled with non-normalized texture coordinates which can be convenient for use a lookup tables in glsl due to not needing separate uniforms for mapping normalized coordinates to texels. Unlike CoglTexture2D though rectangle textures can't have a mipmap and they only support the _CLAMP_TO_EDGE wrap mode. Applications wanting to use CoglTextureRectangle should first check cogl_has_feature (COGL_FEATURE_ID_TEXTURE_RECTANGLE). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-14 04:25:12 -04:00
CoglTextureRectangle *
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
cogl_texture_rectangle_new_from_foreign (CoglContext *ctx,
unsigned int gl_handle,
int width,
int height,
CoglPixelFormat format,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
{
/* NOTE: width, height and internal format are not queriable
* in GLES, hence such a function prototype.
*/
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
GLenum gl_error = 0;
GLint gl_compressed = GL_FALSE;
GLenum gl_int_format = 0;
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
CoglTextureRectangle *tex_rect;
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
/* Assert that it is a valid GL texture object */
g_return_val_if_fail (ctx->glIsTexture (gl_handle), NULL);
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
Add a context parameter to all of the texture driver virtuals All of the texture driver virtual functions now take an explicit CoglContext parameter as a step towards removing the global context.
2012-03-22 13:04:47 -04:00
if (!ctx->texture_driver->allows_foreign_gl_target (ctx,
GL_TEXTURE_RECTANGLE_ARB))
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error,
COGL_SYSTEM_ERROR,
COGL_SYSTEM_ERROR_UNSUPPORTED,
"Foreign GL_TEXTURE_RECTANGLE textures are not "
"supported by your system");
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
return NULL;
}
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
/* Make sure binding succeeds */
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
while ((gl_error = ctx->glGetError ()) != GL_NO_ERROR)
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
;
_cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB, gl_handle, TRUE);
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
if (ctx->glGetError () != GL_NO_ERROR)
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error,
COGL_SYSTEM_ERROR,
COGL_SYSTEM_ERROR_UNSUPPORTED,
"Failed to bind foreign GL_TEXTURE_RECTANGLE texture");
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
return NULL;
}
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
/* Obtain texture parameters */
Replace some #if HAVE_COGL_GL lines with #ifdef This was generating warnings when the GL driver is disabled. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f26682dcc04642fed9db959c63d6c6e4261d2148) Conflicts: cogl/cogl-auto-texture.c
2013-01-24 06:40:19 -05:00
#ifdef HAVE_COGL_GL
Query rectangle tex parameters when creating a foreign texture on GL3 Previously when creating a foreign rectangle texture it would ignore the passed in texture information and query the texture directly when using COGL_DRIVER_GL. However this should also work for COGL_DRIVER_GL3. This patch changes it to check the private feature flags for the texture querying feature instead of directly checking the driver value. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 258c98b82027cb5074afe7844ff3954bbe928757)
2013-01-24 06:51:06 -05:00
if ((ctx->private_feature_flags &
COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS))
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
{
GLint val;
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0,
GL_TEXTURE_COMPRESSED,
&gl_compressed) );
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0,
GL_TEXTURE_INTERNAL_FORMAT,
&val) );
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
gl_int_format = val;
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
/* If we can query GL for the actual pixel format then we'll ignore
the passed in format and use that. */
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
if (!ctx->driver_vtable->pixel_format_from_gl_internal (ctx,
gl_int_format,
&format))
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error,
COGL_SYSTEM_ERROR,
COGL_SYSTEM_ERROR_UNSUPPORTED,
"Unsupported internal format for foreign texture");
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
return NULL;
}
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
}
else
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
#endif
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
{
/* Otherwise we'll assume we can derive the GL format from the
passed in format */
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
format,
&gl_int_format,
NULL,
NULL);
Dynamically load the GL or GLES library The GL or GLES library is now dynamically loaded by the CoglRenderer so that it can choose between GL, GLES1 and GLES2 at runtime. The library is loaded by the renderer because it needs to be done before calling eglInitialize. There is a new environment variable called COGL_DRIVER to choose between gl, gles1 or gles2. The #ifdefs for HAVE_COGL_GL, HAVE_COGL_GLES and HAVE_COGL_GLES2 have been changed so that they don't assume the ifdefs are mutually exclusive. They haven't been removed entirely so that it's possible to compile the GLES backends without the the enums from the GL headers. When using GLX the winsys additionally dynamically loads libGL because that also contains the GLX API. It can't be linked in directly because that would probably conflict with the GLES API if the EGL is selected. When compiling with EGL support the library links directly to libEGL because it doesn't contain any GL API so it shouldn't have any conflicts. When building for WGL or OSX Cogl still directly links against the GL API so there is a #define in config.h so that Cogl won't try to dlopen the library. Cogl-pango previously had a #ifdef to detect when the GL backend is used so that it can sneakily pass GL_QUADS to cogl_vertex_buffer_draw. This is now changed so that it queries the CoglContext for the backend. However to get this to work Cogl now needs to export the _cogl_context_get_default symbol and cogl-pango needs some extra -I flags to so that it can include cogl-context-private.h
2011-07-07 15:44:56 -04:00
}
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
/* Note: We always trust the given width and height without querying
* the texture object because the user may be creating a Cogl
* texture for a texture_from_pixmap object where glTexImage2D may
* not have been called and the texture_from_pixmap spec doesn't
* clarify that it is reliable to query back the size from OpenGL.
*/
/* Validate width and height */
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
g_return_val_if_fail (width > 0 && height > 0, NULL);
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
/* Compressed texture images not supported */
if (gl_compressed == GL_TRUE)
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error,
COGL_SYSTEM_ERROR,
COGL_SYSTEM_ERROR_UNSUPPORTED,
"Compressed foreign textures aren't currently supported");
texture-rectangle: Make new_from_foreign api public This adds a new public cogl_texture_rectangle_new_from_foreign() function so that we can look at removing the generic cogl_texture_new_from_foreign(). Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit af02792b336bb492c5bd11afc34a5dcd417503f6)
2012-08-31 21:16:53 -04:00
return NULL;
}
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
/* Create new texture */
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
tex_rect = _cogl_texture_rectangle_create_base (ctx, width, height, format);
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
/* Setup bitmap info */
tex_rect->is_foreign = TRUE;
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
tex_rect->internal_format = format;
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
tex_rect->gl_texture = gl_handle;
tex_rect->gl_format = gl_int_format;
/* Unknown filter */
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
tex_rect->gl_legacy_texobj_min_filter = GL_FALSE;
tex_rect->gl_legacy_texobj_mag_filter = GL_FALSE;
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
_cogl_texture_set_allocated (COGL_TEXTURE (tex_rect), TRUE);
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
return tex_rect;
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -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
static int
_cogl_texture_rectangle_get_max_waste (CoglTexture *tex)
{
return -1;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
cogl: 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
_cogl_texture_rectangle_is_sliced (CoglTexture *tex)
{
return FALSE;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
cogl: 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
_cogl_texture_rectangle_can_hardware_repeat (CoglTexture *tex)
{
return FALSE;
}
static void
_cogl_texture_rectangle_transform_coords_to_gl (CoglTexture *tex,
float *s,
float *t)
{
texture: add width/height members to base CoglTexture There was a lot of redundancy in how we tracked the width and height of different texture types which is greatly simplified by adding width and height members to CoglTexture directly and removing the get_width and get_height vfuncs from CoglTextureVtable Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3236e47723e4287d5e0023f29083521aeffc75dd)
2012-11-22 16:46:54 -05:00
*s *= tex->width;
*t *= tex->height;
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
}
static CoglTransformResult
_cogl_texture_rectangle_transform_quad_coords_to_gl (CoglTexture *tex,
float *coords)
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool need_repeat = FALSE;
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
int i;
for (i = 0; i < 4; i++)
{
if (coords[i] < 0.0f || coords[i] > 1.0f)
need_repeat = TRUE;
texture: add width/height members to base CoglTexture There was a lot of redundancy in how we tracked the width and height of different texture types which is greatly simplified by adding width and height members to CoglTexture directly and removing the get_width and get_height vfuncs from CoglTextureVtable Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3236e47723e4287d5e0023f29083521aeffc75dd)
2012-11-22 16:46:54 -05:00
coords[i] *= (i & 1) ? tex->height : tex->width;
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 (need_repeat ? COGL_TRANSFORM_SOFTWARE_REPEAT
: COGL_TRANSFORM_NO_REPEAT);
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
cogl: 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
_cogl_texture_rectangle_get_gl_texture (CoglTexture *tex,
GLuint *out_gl_handle,
GLenum *out_gl_target)
{
CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
if (out_gl_handle)
*out_gl_handle = tex_rect->gl_texture;
if (out_gl_target)
*out_gl_target = GL_TEXTURE_RECTANGLE_ARB;
return TRUE;
}
static void
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
_cogl_texture_rectangle_gl_flush_legacy_texobj_filters (CoglTexture *tex,
GLenum min_filter,
GLenum mag_filter)
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
{
CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
CoglContext *ctx = tex->context;
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
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
if (min_filter == tex_rect->gl_legacy_texobj_min_filter
&& mag_filter == tex_rect->gl_legacy_texobj_mag_filter)
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;
/* Rectangle textures don't support mipmapping */
g_assert (min_filter == GL_LINEAR || min_filter == GL_NEAREST);
/* Store new values */
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
tex_rect->gl_legacy_texobj_min_filter = min_filter;
tex_rect->gl_legacy_texobj_mag_filter = mag_filter;
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
/* Apply new filters to 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
_cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
tex_rect->gl_texture,
tex_rect->is_foreign);
GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
mag_filter) );
GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
min_filter) );
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
}
static void
_cogl_texture_rectangle_pre_paint (CoglTexture *tex,
CoglTexturePrePaintFlags flags)
{
/* Rectangle textures don't support mipmaps */
g_assert ((flags & COGL_TEXTURE_NEEDS_MIPMAP) == 0);
}
static void
_cogl_texture_rectangle_ensure_non_quad_rendering (CoglTexture *tex)
{
/* Nothing needs to be done */
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
_cogl_texture_rectangle_set_region (CoglTexture *tex,
int src_x,
int src_y,
int dst_x,
int dst_y,
int dst_width,
int dst_height,
texture: expose mipmap level in set region apis cogl_texture_set_region() and cogl_texture_set_region_from_bitmap() now have a level argument so image data can be uploaded to a specific mipmap level. The prototype for cogl_texture_set_region was also updated to simplify the arguments. The arguments for cogl_texture_set_region_from_bitmap were reordered to be consistent with cogl_texture_set_region with the source related arguments listed first followed by the destination arguments. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3a336a8adcd406b53731a6de0e7d97ba7932c1a8) Note: Public API changes were reverted in cherry-picking this patch
2012-11-09 12:55:54 -05:00
int level,
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
CoglBitmap *bmp,
CoglError **error)
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
{
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
CoglBitmap *upload_bmp;
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
GLenum gl_format;
GLenum gl_type;
CoglContext *ctx = tex->context;
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
CoglBool status;
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
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
upload_bmp =
_cogl_bitmap_convert_for_upload (bmp,
cogl_texture_get_format (tex),
FALSE, /* can't convert in place */
error);
if (upload_bmp == NULL)
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
return FALSE;
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
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
cogl_bitmap_get_format (upload_bmp),
NULL, /* internal format */
&gl_format,
&gl_type);
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
/* Send data to GL */
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
status =
ctx->texture_driver->upload_subregion_to_gl (ctx,
texture: expose mipmap level in set region apis cogl_texture_set_region() and cogl_texture_set_region_from_bitmap() now have a level argument so image data can be uploaded to a specific mipmap level. The prototype for cogl_texture_set_region was also updated to simplify the arguments. The arguments for cogl_texture_set_region_from_bitmap were reordered to be consistent with cogl_texture_set_region with the source related arguments listed first followed by the destination arguments. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3a336a8adcd406b53731a6de0e7d97ba7932c1a8) Note: Public API changes were reverted in cherry-picking this patch
2012-11-09 12:55:54 -05:00
tex,
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
FALSE,
src_x, src_y,
dst_x, dst_y,
dst_width, dst_height,
texture: expose mipmap level in set region apis cogl_texture_set_region() and cogl_texture_set_region_from_bitmap() now have a level argument so image data can be uploaded to a specific mipmap level. The prototype for cogl_texture_set_region was also updated to simplify the arguments. The arguments for cogl_texture_set_region_from_bitmap were reordered to be consistent with cogl_texture_set_region with the source related arguments listed first followed by the destination arguments. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3a336a8adcd406b53731a6de0e7d97ba7932c1a8) Note: Public API changes were reverted in cherry-picking this patch
2012-11-09 12:55:54 -05:00
level,
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
upload_bmp,
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
gl_format,
gl_type,
error);
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
texture: remove _cogl_texture_prepare_for_upload This removes the gl centric _cogl_texture_prepare_for_upload api from cogl-texture.c and instead adds a _cogl_bitmap_convert_for_upload() api which everything now uses instead. GL specific code that needed the gl internal/format/type enums returned by _cogl_texture_prepare_for_upload now use ->pixel_format_to_gl directly. Since there was a special case optimization in cogl_texture_new_from_file that aimed to avoid copying the temporary bitmap that's created for the given file and allow conversions to happen in-place the new _cogl_bitmap_convert_for_upload() api supports converting in place depending on a 'can_convert_in_place' argument. This ability to convert bitmaps in-place has been integrated across the different components as appropriate. In updating cogl-texture-2d-sliced.c this was able to remove a number of other GL specific parts to how spans are setup. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit e190dd23c655da34b9c5c263a9f6006dcc0413b0) Conflicts: cogl/cogl-auto-texture.c cogl/cogl.symbols
2013-06-07 19:28:14 -04:00
cogl_object_unref (upload_bmp);
texture: Call _cogl_texture_prepare_for_upload in set_region impl Instead of calling _cogl_texutre_prepare_for_upload in cogl_texture_set_region_from_bitmap the call is now deferred to the implementation of the virtual for set_region. This is needed if the texture backend is using a different format for the actual GL texture than what is reported by cogl_texture_get_format. This happens for example with atlas textures which report the original internal format specified when the texture was created but actually always store the data in an RGBA texture. Also when creating an atlas texture from a bitmap it was preparing the bitmap to be uploaded to the original format instead of the format of the actual texture used for the atlas. Then it was using cogl_texture_set_region_from_bitmap to upload the 5 pieces to make the copies of the edge pixels. This would end up converting the image to the actual format 5 times. The atlas textures have now been changed to prepare the bitmap for the right format. https://bugzilla.gnome.org/show_bug.cgi?id=657840 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-08-31 12:22:20 -04:00
Allow propogation of OOM errors to apps This allows apps to catch out-of-memory errors when allocating textures. Textures can be pretty huge at times and so it's quite possible for an application to try and allocate more memory than is available. It's also very possible that the application can take some action in response to reduce memory pressure (such as freeing up texture caches perhaps) so we shouldn't just automatically abort like we do for trivial heap allocations. These public functions now take a CoglError argument so applications can catch out of memory errors: cogl_buffer_map cogl_buffer_map_range cogl_buffer_set_data cogl_framebuffer_read_pixels_into_bitmap cogl_pixel_buffer_new cogl_texture_new_from_data cogl_texture_new_from_bitmap Note: we've been quite conservative with how many apis we let throw OOM CoglErrors since we don't really want to put a burdon on developers to be checking for errors with every cogl api call. So long as there is some lower level api for apps to use that let them catch OOM errors for everything necessary that's enough and we don't have to make more convenient apis more awkward to use. The main focus is on bitmaps and texture allocations since they can be particularly large and prone to failing. A new cogl_attribute_buffer_new_with_size() function has been added in case developers need to catch OOM errors when allocating attribute buffers whereby they can first use _buffer_new_with_size() (which doesn't take a CoglError) followed by cogl_buffer_set_data() which will lazily allocate the buffer storage and report OOM errors. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit f7735e141ad537a253b02afa2a8238f96340b978) Note: since we can't break the API for Cogl 1.x then actually the main purpose of cherry picking this patch is to keep in-line with changes on the master branch so that we can easily cherry-pick patches. All the api changes relating stable apis released on the 1.12 branch have been reverted as part of cherry-picking this patch so this most just applies all the internal plumbing changes that enable us to correctly propagate OOM errors.
2012-11-08 12:54:10 -05:00
return status;
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
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
_cogl_texture_rectangle_get_data (CoglTexture *tex,
CoglPixelFormat format,
Fix a warning in the vtable for texture_2d_get_data The function pointer for texture_2d_get_data in the driver vtable was expecting an unsigned int for the rowstride but the definition in cogl-texture-2d-gl.c took a size_t so it was giving an annoying warning. This normalizes them both to just take an int. This seems to better match the pattern used for cogl_bitmap_new_from_data and cogl_texture_2d_new_from_data. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 003f080531d5368835081568779b031ef4f09a77)
2012-09-26 12:05:01 -04:00
int rowstride,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint8_t *data)
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
{
cogl-texture: Share the common code in the get_data virtual Previously cogl_texture_get_data would pretty much directly pass on to the get_data texture virtual function. This ended up with a lot of common code that was copied to all of the backends. For example, the method is expected to return the required data size if the data pointer is NULL and to calculate its own rowstride if the rowstride is 0. Also it needs to convert the downloaded data if GL can't support that format directly. This patch moves the common code to cogl-texture.c so the virtual is always called with a format that can be downloaded directly by GL and with a valid rowstride. If the download fails then the virtual can return FALSE in which case cogl-texture will use the draw and read fallback.
2010-07-08 08:54:37 -04:00
CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
texture: Add a context pointer to each texture As part of our on-going goal to remove our dependence on a global Cogl context this patch adds a pointer to the context to each CoglTexture so that the various texture apis no longer need to use _COGL_GET_CONTEXT. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 83131072eea395f18ab0525ea2446f443a6033b1)
2012-09-07 10:26:34 -04:00
CoglContext *ctx = tex->context;
int bpp;
GLenum gl_format;
GLenum gl_type;
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
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
bpp = _cogl_pixel_format_get_bytes_per_pixel (format);
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
Add a vtable for the driver Cogl already had a vtable for the texture driver. This ended up being used for some things that are not strictly related to texturing such as converting between pixel formats and GL enums. Some other functions that are driver dependent such as updating the features were not indirected through a vtable but instead switched directly by looking at the ctx->driver enum value. This patch normalises to the two uses by adding a separate vtable for driver functions not related to texturing and moves the pixel format conversion functions to it from the texture driver vtable. It also adds a context parameter to all of the functions in the new driver vtable so that they won't have to rely on the global context.
2012-03-22 12:32:56 -04:00
ctx->driver_vtable->pixel_format_to_gl (ctx,
format,
NULL, /* internal format */
&gl_format,
&gl_type);
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
Use GL_PACK_ALIGNMENT of 1 whenever possible The Intel driver currently has an optimisation when calling glReadPixels into a PBO so that it will use a blit instead of the Mesa fallback path. However this only works if the GL_PACK_ALIGNMENT is exactly 1, even if this would be equivalent to a higher alignment value because the bpp*width is already aligned. To make it more likely to hit this fast path, we now detect this situation and explicitly use an alignment of 1. To make this work the texture driver needs to be passed down the bpp*width as well as the rowstride when configuring the alignment. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-22 07:40:16 -04:00
ctx->texture_driver->prep_gl_for_pixels_download (ctx,
rowstride,
texture: add width/height members to base CoglTexture There was a lot of redundancy in how we tracked the width and height of different texture types which is greatly simplified by adding width and height members to CoglTexture directly and removing the get_width and get_height vfuncs from CoglTextureVtable Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 3236e47723e4287d5e0023f29083521aeffc75dd)
2012-11-22 16:46:54 -05:00
tex->width,
Use GL_PACK_ALIGNMENT of 1 whenever possible The Intel driver currently has an optimisation when calling glReadPixels into a PBO so that it will use a blit instead of the Mesa fallback path. However this only works if the GL_PACK_ALIGNMENT is exactly 1, even if this would be equivalent to a higher alignment value because the bpp*width is already aligned. To make it more likely to hit this fast path, we now detect this situation and explicitly use an alignment of 1. To make this work the texture driver needs to be passed down the bpp*width as well as the rowstride when configuring the alignment. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-22 07:40:16 -04:00
bpp);
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
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
_cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
tex_rect->gl_texture,
tex_rect->is_foreign);
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
return ctx->texture_driver->gl_get_tex_image (ctx,
GL_TEXTURE_RECTANGLE_ARB,
cogl-texture: Share the common code in the get_data virtual Previously cogl_texture_get_data would pretty much directly pass on to the get_data texture virtual function. This ended up with a lot of common code that was copied to all of the backends. For example, the method is expected to return the required data size if the data pointer is NULL and to calculate its own rowstride if the rowstride is 0. Also it needs to convert the downloaded data if GL can't support that format directly. This patch moves the common code to cogl-texture.c so the virtual is always called with a format that can be downloaded directly by GL and with a valid rowstride. If the download fails then the virtual can return FALSE in which case cogl-texture will use the draw and read fallback.
2010-07-08 08:54:37 -04:00
gl_format,
gl_type,
data);
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
}
static CoglPixelFormat
_cogl_texture_rectangle_get_format (CoglTexture *tex)
{
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
return COGL_TEXTURE_RECTANGLE (tex)->internal_format;
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
}
static GLenum
_cogl_texture_rectangle_get_gl_format (CoglTexture *tex)
{
return COGL_TEXTURE_RECTANGLE (tex)->gl_format;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
static CoglBool
Support foreign textures in the texture-2d and rectangle backends This adds two new internal functions to create a foreign texture for the texture 2d and rectangle backends. cogl_texture_new_from_foreign will now use one of these backends directly if there is no waste instead of always using the sliced texture backend.
2010-10-04 10:27:38 -04:00
_cogl_texture_rectangle_is_foreign (CoglTexture *tex)
{
return COGL_TEXTURE_RECTANGLE (tex)->is_foreign;
}
Add _cogl_texture_get_type() This adds an internal function to get the type of the underlying hardware texture for any CoglTexture. It can return one of three values to represent 2D textures, 3D textures or rectangle textures. The idea is that this can be used as a replacement for cogl_texture_get_gl_texture when only the target is required to make it a bit less GL-centric. The implementation adds a new virtual function which all of the texture backends now implement. The enum is in a public header because a later patch will want to use it from the CoglPipeline API. We may want to consider making the function public too later. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 06:19:04 -05:00
static CoglTextureType
_cogl_texture_rectangle_get_type (CoglTexture *tex)
{
return COGL_TEXTURE_TYPE_RECTANGLE;
}
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
static const CoglTextureVtable
cogl_texture_rectangle_vtable =
{
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:09:43 -04:00
TRUE, /* primitive */
Allow lazy texture storage allocation Consistent with how we lazily allocate framebuffers this patch allows us to instantiate textures but still specify constraints and requirements before allocating storage so that we can be sure to allocate the most appropriate/efficient storage. This adds a cogl_texture_allocate() function that is analogous to cogl_framebuffer_allocate() which can optionally be called to explicitly allocate storage and catch any errors. If this function isn't used explicitly then Cogl will implicitly ensure textures are allocated before the storage is needed. It is generally recommended to rely on lazy storage allocation or at least perform explicit allocation as late as possible so Cogl can be fully informed about the best way to allocate storage. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 1fa7c0f10a8a03043e3c75cb079a49625df098b7) Note: This reverts the cogl_texture_rectangle_new_with_size API change that dropped the CoglError argument and keeps the semantics of allocating the texture immediately. This is because Mutter currently uses this API so we will probably look at updating this later once we have a corresponding Mutter patch prepared. The other API changes were kept since they only affected experimental api.
2012-11-22 18:01:08 -05:00
_cogl_texture_rectangle_allocate,
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
_cogl_texture_rectangle_set_region,
_cogl_texture_rectangle_get_data,
meta-texture: This publicly exposes CoglMetaTexture CoglMetaTexture is an interface for dealing with high level textures that may be comprised of one or more low-level textures internally. The interface allows the development of primitive drawing APIs that can draw with high-level textures (such as atlas textures) even though the GPU doesn't natively understand these texture types. There is currently just one function that's part of this interface: cogl_meta_texture_foreach_in_region() which allows an application to resolve the internal, low-level textures of a high-level texture. cogl_rectangle() uses this API for example so that it can easily emulate the _REPEAT wrap mode for textures that the hardware can't natively handle repeating of. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-08 09:13:03 -04:00
NULL, /* foreach_sub_texture_in_region */
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
_cogl_texture_rectangle_get_max_waste,
_cogl_texture_rectangle_is_sliced,
_cogl_texture_rectangle_can_hardware_repeat,
_cogl_texture_rectangle_transform_coords_to_gl,
_cogl_texture_rectangle_transform_quad_coords_to_gl,
_cogl_texture_rectangle_get_gl_texture,
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
_cogl_texture_rectangle_gl_flush_legacy_texobj_filters,
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
_cogl_texture_rectangle_pre_paint,
_cogl_texture_rectangle_ensure_non_quad_rendering,
texture: rename texobj flush code as gl specific This renames the set_filters and set_wrap_mode_parameters texture virtual functions to gl_flush_legacy_texobj_filters and gl_flush_legacy_texobj_wrap_modes respectively to clarify that they are opengl driver specific and that they are only used to support the legacy opengl apis for setting filters and wrap modes where the state is associated with texture objects instead of being associated with sampler objects. This part of an effort to clearly delimit our abstraction over opengl so that we can start to consider non-opengl backends for Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 6f78b8a613340d7c6b736e51a16c625f52154430)
2012-09-10 15:35:39 -04:00
_cogl_texture_rectangle_gl_flush_legacy_texobj_wrap_modes,
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
_cogl_texture_rectangle_get_format,
_cogl_texture_rectangle_get_gl_format,
Add _cogl_texture_get_type() This adds an internal function to get the type of the underlying hardware texture for any CoglTexture. It can return one of three values to represent 2D textures, 3D textures or rectangle textures. The idea is that this can be used as a replacement for cogl_texture_get_gl_texture when only the target is required to make it a bit less GL-centric. The implementation adds a new virtual function which all of the texture backends now implement. The enum is in a public header because a later patch will want to use it from the CoglPipeline API. We may want to consider making the function public too later. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 06:19:04 -05:00
_cogl_texture_rectangle_get_type,
Add a CoglPrimitiveTexture interface This interface represents any textures that are backed by a single texture in GL and that can be used directly with the cogl_framebuffer_draw_attributes family of functions. This currently equates to CoglTexture2D, CoglTexture3D and CoglTextureRectangle. The interface currently has only one method called cogl_primitive_set_auto_mipmap. This replaces the COGL_TEXTURE_NO_AUTO_MIPMAP flag from the CoglTextureFlags parameter in the constructors. None of the other flags in CoglTextureFlags make sense for primitive textures so it doesn't seem like a good idea to need them for primitive constructors. There is a boolean in the vtable to mark whether a texture type is primitive which the new cogl_is_primitive function uses. There is also a new texture virtual called set_auto_mipmap which is only required to be implemented for primitive textures. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-04 10:09:43 -04:00
_cogl_texture_rectangle_is_foreign,
_cogl_texture_rectangle_set_auto_mipmap
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
};
Reference in New Issue Copy Permalink