isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-23 19:42:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

cogl: improves header and coding style consistency

Browse Source 
We've had complaints that our Cogl code/headers are a bit "special" so
this is a first pass at tidying things up by giving them some
consistency. These changes are all consistent with how new code in Cogl
is being written, but the style isn't consistently applied across all
code yet.

There are two parts to this patch; but since each one required a large
amount of effort to maintain tidy indenting it made sense to combine the
changes to reduce the time spent re indenting the same lines.

The first change is to use a consistent style for declaring function
prototypes in headers. Cogl headers now consistently use this style for
prototypes:

 return_type
 cogl_function_name (CoglType arg0,
                     CoglType arg1);

Not everyone likes this style, but it seems that most of the currently
active Cogl developers agree on it.

The second change is to constrain the use of redundant glib data types
in Cogl. Uses of gint, guint, gfloat, glong, gulong and gchar have all
been replaced with int, unsigned int, float, long, unsigned long and char
respectively. When talking about pixel data; use of guchar has been
replaced with guint8, otherwise unsigned char can be used.

The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize.

The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.
This commit is contained in:
Robert Bragg 2010-02-10 01:57:32 +00:00
parent 8c9472bc4c
commit 7edcbaa1f9
64 changed files with 1491 additions and 1184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
clutter/cogl/cogl/cogl-atlas-texture.c
View File

@ -92,8 +92,8 @@ typedef struct _CoglAtlasTextureBlitData
complete texture data in */
unsigned char *image_data;
CoglPixelFormat format;
gint bpp;
guint src_height, src_width;
int bpp;
unsigned int src_height, src_width;
GLenum dst_gl_target;
} CoglAtlasTextureBlitData;
@ -169,12 +169,12 @@ _cogl_atlas_texture_blit_begin (CoglAtlasTextureBlitData *data,
static void
_cogl_atlas_texture_blit (CoglAtlasTextureBlitData *data,
guint src_x,
guint src_y,
guint dst_x,
guint dst_y,
guint width,
guint height)
unsigned int src_x,
unsigned int src_y,
unsigned int dst_x,
unsigned int dst_y,
unsigned int width,
unsigned int height)
{
/* If we have an FBO then we can do a fast blit */
if (data->fbo)
@ -269,7 +269,7 @@ _cogl_atlas_texture_free (CoglAtlasTexture *atlas_tex)
cogl_handle_unref (atlas_tex->sub_texture);
}
static gint
static int
_cogl_atlas_texture_get_max_waste (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
@ -506,7 +506,7 @@ _cogl_atlas_texture_set_region (CoglTexture *tex,
pixels to the border */
if (atlas_tex->in_atlas)
{
gint bpp;
int bpp;
CoglBitmap source_bmp;
CoglBitmap tmp_bmp;
gboolean tmp_bmp_owner = FALSE;
@ -524,7 +524,7 @@ _cogl_atlas_texture_set_region (CoglTexture *tex,
source_bmp.width = width;
source_bmp.height = height;
source_bmp.format = format;
source_bmp.data = (guchar*) data;
source_bmp.data = (guint8 *)data;
/* Rowstride from width if none specified */
bpp = _cogl_get_format_bpp (format);
@ -604,7 +604,7 @@ _cogl_atlas_texture_get_gl_format (CoglTexture *tex)
return _cogl_texture_get_gl_format (atlas_tex->sub_texture);
}
static gint
static int
_cogl_atlas_texture_get_width (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
@ -613,7 +613,7 @@ _cogl_atlas_texture_get_width (CoglTexture *tex)
return cogl_texture_get_width (atlas_tex->sub_texture);
}
static gint
static int
_cogl_atlas_texture_get_height (CoglTexture *tex)
{
CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
@ -644,13 +644,13 @@ typedef struct _CoglAtlasTextureRepositionData
} CoglAtlasTextureRepositionData;
static void
_cogl_atlas_texture_migrate (guint n_textures,
_cogl_atlas_texture_migrate (unsigned int n_textures,
CoglAtlasTextureRepositionData *textures,
CoglHandle old_texture,
CoglHandle new_texture,
CoglAtlasTexture *skip_texture)
{
guint i;
unsigned int i;
CoglAtlasTextureBlitData blit_data;
_cogl_atlas_texture_blit_begin (&blit_data, new_texture, old_texture);
@ -686,7 +686,7 @@ typedef struct _CoglAtlasTextureGetRectanglesData
{
CoglAtlasTextureRepositionData *textures;
/* Number of textures found so far */
guint n_textures;
unsigned int n_textures;
} CoglAtlasTextureGetRectanglesData;
static void
@ -700,8 +700,8 @@ _cogl_atlas_texture_get_rectangles_cb (const CoglAtlasRectangle *rectangle,
}
static void
_cogl_atlas_texture_get_next_size (guint *atlas_width,
guint *atlas_height)
_cogl_atlas_texture_get_next_size (unsigned int *atlas_width,
unsigned int *atlas_height)
{
/* Double the size of the texture by increasing whichever dimension
is smaller */
@ -712,9 +712,9 @@ _cogl_atlas_texture_get_next_size (guint *atlas_width,
}
static CoglAtlas *
_cogl_atlas_texture_create_atlas (guint atlas_width,
guint atlas_height,
guint n_textures,
_cogl_atlas_texture_create_atlas (unsigned int atlas_width,
unsigned int atlas_height,
unsigned int n_textures,
CoglAtlasTextureRepositionData *textures)
{
GLint max_texture_size = 1024;
@ -731,7 +731,7 @@ _cogl_atlas_texture_create_atlas (guint atlas_width,
while (atlas_width < max_texture_size && atlas_height < max_texture_size)
{
CoglAtlas *new_atlas = _cogl_atlas_new (atlas_width, atlas_height, NULL);
guint i;
unsigned int i;
/* Add all of the textures and keep track of the new position */
for (i = 0; i < n_textures; i++)
@ -763,7 +763,7 @@ _cogl_atlas_texture_compare_size_cb (const void *a,
{
const CoglAtlasTextureRepositionData *ta = a;
const CoglAtlasTextureRepositionData *tb = b;
guint a_size, b_size;
unsigned int a_size, b_size;
a_size = ta->texture->rectangle.width * ta->texture->rectangle.height;
b_size = tb->texture->rectangle.width * tb->texture->rectangle.height;
@ -773,13 +773,13 @@ _cogl_atlas_texture_compare_size_cb (const void *a,
static gboolean
_cogl_atlas_texture_reserve_space (CoglAtlasTexture *new_sub_tex,
guint width,
guint height)
unsigned int width,
unsigned int height)
{
CoglAtlasTextureGetRectanglesData data;
CoglAtlas *new_atlas;
CoglHandle new_tex;
guint atlas_width, atlas_height;
unsigned int atlas_width, atlas_height;
gboolean ret;
_COGL_GET_CONTEXT (ctx, FALSE);

22
clutter/cogl/cogl/cogl-atlas.c
View File

@ -67,8 +67,8 @@ struct _CoglAtlas
{
CoglAtlasNode *root;
guint space_remaining;
guint n_rectangles;
unsigned int space_remaining;
unsigned int n_rectangles;
GDestroyNotify value_destroy_func;
};
@ -119,7 +119,8 @@ _cogl_atlas_node_free (CoglAtlasNode *node)
}
CoglAtlas *
_cogl_atlas_new (guint width, guint height,
_cogl_atlas_new (unsigned int width,
unsigned int height,
GDestroyNotify value_destroy_func)
{
CoglAtlas *atlas = g_new (CoglAtlas, 1);
@ -166,7 +167,7 @@ _cogl_atlas_stack_pop (CoglAtlasStackEntry *stack)
static CoglAtlasNode *
_cogl_atlas_node_split_horizontally (CoglAtlasNode *node,
guint left_width)
unsigned int left_width)
{
/* Splits the node horizontally (according to emacs' definition, not
vim) by converting it to a branch and adding two new leaf
@ -204,7 +205,7 @@ _cogl_atlas_node_split_horizontally (CoglAtlasNode *node,
static CoglAtlasNode *
_cogl_atlas_node_split_vertically (CoglAtlasNode *node,
guint top_height)
unsigned int top_height)
{
/* Splits the node vertically (according to emacs' definition, not
vim) by converting it to a branch and adding two new leaf
@ -242,7 +243,8 @@ _cogl_atlas_node_split_vertically (CoglAtlasNode *node,
gboolean
_cogl_atlas_add_rectangle (CoglAtlas *atlas,
guint width, guint height,
unsigned int width,
unsigned int height,
gpointer data,
CoglAtlasRectangle *rectangle)
{
@ -411,25 +413,25 @@ _cogl_atlas_remove_rectangle (CoglAtlas *atlas,
#endif
}
guint
unsigned int
_cogl_atlas_get_width (CoglAtlas *atlas)
{
return atlas->root->rectangle.width;
}
guint
unsigned int
_cogl_atlas_get_height (CoglAtlas *atlas)
{
return atlas->root->rectangle.height;
}
guint
unsigned int
_cogl_atlas_get_remaining_space (CoglAtlas *atlas)
{
return atlas->space_remaining;
}
guint
unsigned int
_cogl_atlas_get_n_rectangles (CoglAtlas *atlas)
{
return atlas->n_rectangles;

18
clutter/cogl/cogl/cogl-atlas.h
View File

@ -35,17 +35,19 @@ typedef void (* CoglAtlasCallback) (const CoglAtlasRectangle *rectangle,
struct _CoglAtlasRectangle
{
guint x, y;
guint width, height;
unsigned int x, y;
unsigned int width, height;
};
CoglAtlas *
_cogl_atlas_new (guint width, guint height,
_cogl_atlas_new (unsigned int width,
unsigned int height,
GDestroyNotify value_destroy_func);
gboolean
_cogl_atlas_add_rectangle (CoglAtlas *atlas,
guint width, guint height,
unsigned int width,
unsigned int height,
gpointer data,
CoglAtlasRectangle *rectangle);
@ -53,16 +55,16 @@ void
_cogl_atlas_remove_rectangle (CoglAtlas *atlas,
const CoglAtlasRectangle *rectangle);
guint
unsigned int
_cogl_atlas_get_width (CoglAtlas *atlas);
guint
unsigned int
_cogl_atlas_get_height (CoglAtlas *atlas);
guint
unsigned int
_cogl_atlas_get_remaining_space (CoglAtlas *atlas);
guint
unsigned int
_cogl_atlas_get_n_rectangles (CoglAtlas *atlas);
void

82
clutter/cogl/cogl/cogl-bitmap-fallback.c
View File

@ -34,7 +34,7 @@
/* TO rgba */
inline static void
_cogl_g_to_rgba (const guchar *src, guchar *dst)
_cogl_g_to_rgba (const guint8 *src, guint8 *dst)
{
dst[0] = src[0];
dst[1] = src[0];
@ -43,7 +43,7 @@ _cogl_g_to_rgba (const guchar *src, guchar *dst)
}
inline static void
_cogl_rgb_to_rgba (const guchar *src, guchar *dst)
_cogl_rgb_to_rgba (const guint8 *src, guint8 *dst)
{
dst[0] = src[0];
dst[1] = src[1];
@ -52,7 +52,7 @@ _cogl_rgb_to_rgba (const guchar *src, guchar *dst)
}
inline static void
_cogl_bgr_to_rgba (const guchar *src, guchar *dst)
_cogl_bgr_to_rgba (const guint8 *src, guint8 *dst)
{
dst[0] = src[2];
dst[1] = src[1];
@ -61,7 +61,7 @@ _cogl_bgr_to_rgba (const guchar *src, guchar *dst)
}
inline static void
_cogl_bgra_to_rgba (const guchar *src, guchar *dst)
_cogl_bgra_to_rgba (const guint8 *src, guint8 *dst)
{
dst[0] = src[2];
dst[1] = src[1];
@ -70,7 +70,7 @@ _cogl_bgra_to_rgba (const guchar *src, guchar *dst)
}
inline static void
_cogl_argb_to_rgba (const guchar *src, guchar *dst)
_cogl_argb_to_rgba (const guint8 *src, guint8 *dst)
{
dst[0] = src[1];
dst[1] = src[2];
@ -79,7 +79,7 @@ _cogl_argb_to_rgba (const guchar *src, guchar *dst)
}
inline static void
_cogl_abgr_to_rgba (const guchar *src, guchar *dst)
_cogl_abgr_to_rgba (const guint8 *src, guint8 *dst)
{
dst[0] = src[3];
dst[1] = src[2];
@ -88,7 +88,7 @@ _cogl_abgr_to_rgba (const guchar *src, guchar *dst)
}
inline static void
_cogl_rgba_to_rgba (const guchar *src, guchar *dst)
_cogl_rgba_to_rgba (const guint8 *src, guint8 *dst)
{
dst[0] = src[0];
dst[1] = src[1];
@ -99,13 +99,13 @@ _cogl_rgba_to_rgba (const guchar *src, guchar *dst)
/* FROM rgba */
inline static void
_cogl_rgba_to_g (const guchar *src, guchar *dst)
_cogl_rgba_to_g (const guint8 *src, guint8 *dst)
{
dst[0] = (src[0] + src[1] + src[2]) / 3;
}
inline static void
_cogl_rgba_to_rgb (const guchar *src, guchar *dst)
_cogl_rgba_to_rgb (const guint8 *src, guint8 *dst)
{
dst[0] = src[0];
dst[1] = src[1];
@ -113,7 +113,7 @@ _cogl_rgba_to_rgb (const guchar *src, guchar *dst)
}
inline static void
_cogl_rgba_to_bgr (const guchar *src, guchar *dst)
_cogl_rgba_to_bgr (const guint8 *src, guint8 *dst)
{
dst[0] = src[2];
dst[1] = src[1];
@ -121,7 +121,7 @@ _cogl_rgba_to_bgr (const guchar *src, guchar *dst)
}
inline static void
_cogl_rgba_to_bgra (const guchar *src, guchar *dst)
_cogl_rgba_to_bgra (const guint8 *src, guint8 *dst)
{
dst[0] = src[2];
dst[1] = src[1];
@ -130,7 +130,7 @@ _cogl_rgba_to_bgra (const guchar *src, guchar *dst)
}
inline static void
_cogl_rgba_to_argb (const guchar *src, guchar *dst)
_cogl_rgba_to_argb (const guint8 *src, guint8 *dst)
{
dst[0] = src[3];
dst[1] = src[0];
@ -139,7 +139,7 @@ _cogl_rgba_to_argb (const guchar *src, guchar *dst)
}
inline static void
_cogl_rgba_to_abgr (const guchar *src, guchar *dst)
_cogl_rgba_to_abgr (const guint8 *src, guint8 *dst)
{
dst[0] = src[3];
dst[1] = src[2];
@ -150,7 +150,7 @@ _cogl_rgba_to_abgr (const guchar *src, guchar *dst)
/* (Un)Premultiplication */
inline static void
_cogl_unpremult_alpha_0 (guchar *dst)
_cogl_unpremult_alpha_0 (guint8 *dst)
{
dst[0] = 0;
dst[1] = 0;
@ -159,9 +159,9 @@ _cogl_unpremult_alpha_0 (guchar *dst)
}
inline static void
_cogl_unpremult_alpha_last (guchar *dst)
_cogl_unpremult_alpha_last (guint8 *dst)
{
guchar alpha = dst[3];
guint8 alpha = dst[3];
dst[0] = (dst[0] * 255) / alpha;
dst[1] = (dst[1] * 255) / alpha;
@ -169,9 +169,9 @@ _cogl_unpremult_alpha_last (guchar *dst)
}
inline static void
_cogl_unpremult_alpha_first (guchar *dst)
_cogl_unpremult_alpha_first (guint8 *dst)
{
guchar alpha = dst[0];
guint8 alpha = dst[0];
dst[1] = (dst[1] * 255) / alpha;
dst[2] = (dst[2] * 255) / alpha;
@ -189,24 +189,24 @@ _cogl_unpremult_alpha_first (guchar *dst)
} G_STMT_END
inline static void
_cogl_premult_alpha_last (guchar *dst)
_cogl_premult_alpha_last (guint8 *dst)
{
guchar alpha = dst[3];
guint8 alpha = dst[3];
/* Using a separate temporary per component has given slightly better
* code generation with GCC in the past; it shouldn't do any worse in
* any case.
*/
guint t1, t2, t3;
unsigned int t1, t2, t3;
MULT(dst[0], alpha, t1);
MULT(dst[1], alpha, t2);
MULT(dst[2], alpha, t3);
}
inline static void
_cogl_premult_alpha_first (guchar *dst)
_cogl_premult_alpha_first (guint8 *dst)
{
guchar alpha = dst[0];
guint t1, t2, t3;
guint8 alpha = dst[0];
unsigned int t1, t2, t3;
MULT(dst[1], alpha, t1);
MULT(dst[2], alpha, t2);
@ -342,12 +342,12 @@ _cogl_bitmap_fallback_convert (const CoglBitmap *bmp,
CoglBitmap *dst_bmp,
CoglPixelFormat dst_format)
{
guchar *src;
guchar *dst;
gint src_bpp;
gint dst_bpp;
gint x,y;
guchar temp_rgba[4] = {0,0,0,0};
guint8 *src;
guint8 *dst;
int src_bpp;
int dst_bpp;
int x,y;
guint8 temp_rgba[4] = {0,0,0,0};
/* Make sure conversion supported */
if (!_cogl_bitmap_fallback_can_convert (bmp->format, dst_format))
@ -358,20 +358,20 @@ _cogl_bitmap_fallback_convert (const CoglBitmap *bmp,
/* Initialize destination bitmap */
*dst_bmp = *bmp;
dst_bmp->rowstride = sizeof(guchar) * dst_bpp * dst_bmp->width;
dst_bmp->rowstride = sizeof(guint8) * dst_bpp * dst_bmp->width;
dst_bmp->format = ((bmp->format & COGL_PREMULT_BIT) |
(dst_format & COGL_UNPREMULT_MASK));
/* Allocate a new buffer to hold converted data */
dst_bmp->data = g_malloc (sizeof(guchar)
dst_bmp->data = g_malloc (sizeof(guint8)
* dst_bmp->height
* dst_bmp->rowstride);
/* FIXME: Optimize */
for (y = 0; y < bmp->height; y++)
{
src = (guchar*)bmp->data + y * bmp->rowstride;
dst = (guchar*)dst_bmp->data + y * dst_bmp->rowstride;
src = (guint8*)bmp->data + y * bmp->rowstride;
dst = (guint8*)dst_bmp->data + y * dst_bmp->rowstride;
for (x = 0; x < bmp->width; x++)
{
@ -429,8 +429,8 @@ _cogl_bitmap_fallback_convert (const CoglBitmap *bmp,
gboolean
_cogl_bitmap_fallback_unpremult (CoglBitmap *bmp)
{
guchar *p;
gint x,y;
guint8 *p;
int x,y;
/* Make sure format supported for un-premultiplication */
if (!_cogl_bitmap_fallback_can_unpremult (bmp->format))
@ -438,7 +438,7 @@ _cogl_bitmap_fallback_unpremult (CoglBitmap *bmp)
for (y = 0; y < bmp->height; y++)
{
p = (guchar*) bmp->data + y * bmp->rowstride;
p = (guint8*) bmp->data + y * bmp->rowstride;
if (bmp->format & COGL_AFIRST_BIT)
{
@ -472,8 +472,8 @@ _cogl_bitmap_fallback_unpremult (CoglBitmap *bmp)
gboolean
_cogl_bitmap_fallback_premult (CoglBitmap *bmp)
{
guchar *p;
gint x,y;
guint8 *p;
int x,y;
/* Make sure format supported for un-premultiplication */
if (!_cogl_bitmap_fallback_can_premult (bmp->format))
@ -481,7 +481,7 @@ _cogl_bitmap_fallback_premult (CoglBitmap *bmp)
for (y = 0; y < bmp->height; y++)
{
p = (guchar*) bmp->data + y * bmp->rowstride;
p = (guint8*) bmp->data + y * bmp->rowstride;
if (bmp->format & COGL_AFIRST_BIT)
{
@ -525,7 +525,7 @@ _cogl_bitmap_fallback_premult (CoglBitmap *bmp)
gboolean
_cogl_bitmap_fallback_from_file (CoglBitmap *bmp,
const gchar *filename)
const char *filename)
{
/* FIXME: use jpeglib, libpng, etc. manually maybe */
return FALSE;

60
clutter/cogl/cogl/cogl-bitmap-pixbuf.c
View File

@ -94,9 +94,9 @@ cogl_bitmap_error_quark (void)
}
gboolean
_cogl_bitmap_get_size_from_file (const gchar *filename,
gint *width,
gint *height)
_cogl_bitmap_get_size_from_file (const char *filename,
int *width,
int *height)
{
if (width)
*width = 0;
@ -110,7 +110,7 @@ _cogl_bitmap_get_size_from_file (const gchar *filename,
/* the error does not contain the filename as the caller already has it */
gboolean
_cogl_bitmap_from_file (CoglBitmap *bmp,
const gchar *filename,
const char *filename,
GError **error)
{
g_assert (bmp != NULL);
@ -145,8 +145,8 @@ _cogl_bitmap_from_file (CoglBitmap *bmp,
CGImageRef image = CGImageSourceCreateImageAtIndex (image_source, 0, NULL);
CFRelease (image_source);
size_t width = CGImageGetWidth (image);
size_t height = CGImageGetHeight (image);
gsize width = CGImageGetWidth (image);
gsize height = CGImageGetHeight (image);
if (width == 0 || height == 0)
{
/* incomplete or corrupt */
@ -157,7 +157,7 @@ _cogl_bitmap_from_file (CoglBitmap *bmp,
}
/* allocate buffer big enough to hold pixel data */
size_t rowstride;
gsize rowstride;
rowstride = 4 * width;
guint8 *out_data = g_malloc0 (height * rowstride);
@ -188,9 +188,9 @@ _cogl_bitmap_from_file (CoglBitmap *bmp,
#elif defined(USE_GDKPIXBUF)
gboolean
_cogl_bitmap_get_size_from_file (const gchar *filename,
gint *width,
gint *height)
_cogl_bitmap_get_size_from_file (const char *filename,
int *width,
int *height)
{
g_return_val_if_fail (filename != NULL, FALSE);
@ -202,23 +202,23 @@ _cogl_bitmap_get_size_from_file (const gchar *filename,
gboolean
_cogl_bitmap_from_file (CoglBitmap *bmp,
const gchar *filename,
const char *filename,
GError **error)
{
GdkPixbuf *pixbuf;
gboolean has_alpha;
GdkColorspace color_space;
CoglPixelFormat pixel_format;
gint width;
gint height;
gint rowstride;
gint bits_per_sample;
gint n_channels;
gint last_row_size;
guchar *pixels;
guchar *out_data;
guchar *out;
gint r;
int width;
int height;
int rowstride;
int bits_per_sample;
int n_channels;
int last_row_size;
guint8 *pixels;
guint8 *out_data;
guint8 *out;
int r;
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
@ -270,7 +270,7 @@ _cogl_bitmap_from_file (CoglBitmap *bmp,
/* FIXME: Any way to destroy pixbuf but retain pixel data? */
pixels = gdk_pixbuf_get_pixels (pixbuf);
out_data = (guchar*) g_malloc (height * rowstride);
out_data = g_malloc (height * rowstride);
out = out_data;
/* Copy up to last row */
@ -305,9 +305,9 @@ _cogl_bitmap_from_file (CoglBitmap *bmp,
#include "stb_image.c"
gboolean
_cogl_bitmap_get_size_from_file (const gchar *filename,
gint *width,
gint *height)
_cogl_bitmap_get_size_from_file (const char *filename,
int *width,
int *height)
{
if (width)
*width = 0;
@ -320,13 +320,13 @@ _cogl_bitmap_get_size_from_file (const gchar *filename,
gboolean
_cogl_bitmap_from_file (CoglBitmap *bmp,
const gchar *filename,
const char *filename,
GError **error)
{
gint stb_pixel_format;
gint width;
gint height;
guchar *pixels;
int stb_pixel_format;
int width;
int height;
guint8 *pixels;
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

30
clutter/cogl/cogl/cogl-bitmap-private.h
View File

@ -33,11 +33,11 @@
typedef struct _CoglBitmap
{
CoglHandleObject _parent;
guchar *data;
guint8 *data;
CoglPixelFormat format;
gint width;
gint height;
gint rowstride;
int width;
int height;
int rowstride;
} CoglBitmap;
gboolean
@ -81,12 +81,12 @@ _cogl_bitmap_fallback_premult (CoglBitmap *dst_bmp);
gboolean
_cogl_bitmap_from_file (CoglBitmap *bmp,
const gchar *filename,
const char *filename,
GError **error);
gboolean
_cogl_bitmap_fallback_from_file (CoglBitmap *bmp,
const gchar *filename);
const char *filename);
gboolean
_cogl_bitmap_convert_premult_status (CoglBitmap *bmp,
@ -100,16 +100,16 @@ _cogl_bitmap_convert_format_and_premult (const CoglBitmap *bmp,
void
_cogl_bitmap_copy_subregion (CoglBitmap *src,
CoglBitmap *dst,
gint src_x,
gint src_y,
gint dst_x,
gint dst_y,
gint width,
gint height);
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height);
gboolean
_cogl_bitmap_get_size_from_file (const gchar *filename,
gint *width,
gint *height);
_cogl_bitmap_get_size_from_file (const char *filename,
int *width,
int *height);
#endif /* __COGL_BITMAP_H */

34
clutter/cogl/cogl/cogl-bitmap.c
View File

@ -42,10 +42,10 @@ _cogl_bitmap_free (CoglBitmap *bmp)
g_free (bmp);
}
gint
int
_cogl_get_format_bpp (CoglPixelFormat format)
{
gint bpp_lut[] = {
int bpp_lut[] = {
0, /* invalid */
1, /* A_8 */
3, /* 888 */
@ -119,17 +119,17 @@ _cogl_bitmap_convert_format_and_premult (const CoglBitmap *bmp,
void
_cogl_bitmap_copy_subregion (CoglBitmap *src,
CoglBitmap *dst,
gint src_x,
gint src_y,
gint dst_x,
gint dst_y,
gint width,
gint height)
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height)
{
guchar *srcdata;
guchar *dstdata;
gint bpp;
gint line;
guint8 *srcdata;
guint8 *dstdata;
int bpp;
int line;
/* Intended only for fast copies when format is equal! */
g_assert (src->format == dst->format);
@ -147,16 +147,16 @@ _cogl_bitmap_copy_subregion (CoglBitmap *src,
}
gboolean
cogl_bitmap_get_size_from_file (const gchar *filename,
gint *width,
gint *height)
cogl_bitmap_get_size_from_file (const char *filename,
int *width,
int *height)
{
return _cogl_bitmap_get_size_from_file (filename, width, height);
}
CoglHandle
cogl_bitmap_new_from_file (const gchar *filename,
GError **error)
cogl_bitmap_new_from_file (const char *filename,
GError **error)
{
CoglBitmap bmp;
CoglBitmap *ret;

15
clutter/cogl/cogl/cogl-bitmap.h
View File

@ -56,8 +56,9 @@ G_BEGIN_DECLS
*
* Since: 1.0
*/
CoglHandle cogl_bitmap_new_from_file (const gchar *filename,
GError **error);
CoglHandle
cogl_bitmap_new_from_file (const char *filename,
GError **error);
/**
* cogl_bitmap_get_size_from_file:
@ -72,9 +73,10 @@ CoglHandle cogl_bitmap_new_from_file (const gchar *filename,
*
* Since: 1.0
*/
gboolean cogl_bitmap_get_size_from_file (const gchar *filename,
gint *width,
gint *height);
gboolean
cogl_bitmap_get_size_from_file (const char *filename,
int *width,
int *height);
/**
* cogl_is_bitmap:
@ -87,7 +89,8 @@ gboolean cogl_bitmap_get_size_from_file (const gchar *filename,
*
* Since: 1.0
*/
gboolean cogl_is_bitmap (CoglHandle handle);
gboolean
cogl_is_bitmap (CoglHandle handle);
G_END_DECLS

12
clutter/cogl/cogl/cogl-blend-string.c
View File

@ -413,9 +413,9 @@ get_function_info (const char *mark,
const char *p,
CoglBlendStringContext context)
{
size_t len = p - mark;
gsize len = p - mark;
CoglBlendStringFunctionInfo *functions;
size_t array_len;
gsize array_len;
int i;
if (context == COGL_BLEND_STRING_CONTEXT_BLENDING)
@ -443,9 +443,9 @@ get_color_src_info (const char *mark,
const char *p,
CoglBlendStringContext context)
{
size_t len = p - mark;
gsize len = p - mark;
CoglBlendStringColorSourceInfo *sources;
size_t array_len;
gsize array_len;
int i;
if (context == COGL_BLEND_STRING_CONTEXT_BLENDING)
@ -617,7 +617,7 @@ parse_argument (const char *string, /* original user string */
case PARSER_ARG_STATE_SCRAPING_MASK:
if (*p == ']')
{
size_t len = p - mark;
gsize len = p - mark;
CoglBlendStringColorSource *source =
parsing_factor ? &arg->factor.source : &arg->source;
@ -678,7 +678,7 @@ parse_argument (const char *string, /* original user string */
case PARSER_ARG_STATE_MAYBE_SRC_ALPHA_SATURATE:
if (!is_symbol_char (*p))
{
size_t len = p - mark;
gsize len = p - mark;
if (len >= strlen ("SRC_ALPHA_SATURATE") &&
strncmp (mark, "SRC_ALPHA_SATURATE", len) == 0)
{

4
clutter/cogl/cogl/cogl-blend-string.h
View File

@ -65,7 +65,7 @@ typedef struct _CoglBlendStringColorSourceInfo
{
CoglBlendStringColorSourceType type;
const char *name;
size_t name_len;
gsize name_len;
} CoglBlendStringColorSourceInfo;
typedef struct _CoglBlendStringColorSource
@ -111,7 +111,7 @@ typedef struct _CoglBlendStringFunctionInfo
{
enum _CoglBlendStringFunctionType type;
const char *name;
size_t name_len;
gsize name_len;
int argc;
} CoglBlendStringFunctionInfo;

14
clutter/cogl/cogl/cogl-buffer-private.h
View File

@ -50,15 +50,15 @@ typedef struct _CoglBufferVtable CoglBufferVtable;
struct _CoglBufferVtable
{
guchar * (* map) (CoglBuffer *buffer,
guint8 * (* map) (CoglBuffer *buffer,
CoglBufferAccess access);
void (* unmap) (CoglBuffer *buffer);
gboolean (* set_data) (CoglBuffer *buffer,
guint offset,
const guchar *data,
guint size);
unsigned int offset,
const guint8 *data,
unsigned int size);
};
typedef enum _CoglBufferFlags
@ -76,18 +76,18 @@ struct _CoglBuffer
CoglBufferFlags flags;
GLuint gl_handle; /* OpenGL handle */
guint size; /* size of the buffer, in bytes */
unsigned int size; /* size of the buffer, in bytes */
CoglBufferUsageHint usage_hint;
CoglBufferUpdateHint update_hint;
guchar *data; /* points to the mapped memory when
guint8 *data; /* points to the mapped memory when
* the CoglBuffer is a VBO, PBO, ... or
* points to allocated memory in the
* fallback paths */
};
void _cogl_buffer_initialize (CoglBuffer *buffer,
guint size,
unsigned int size,
CoglBufferUsageHint usage_hint,
CoglBufferUpdateHint update_hint);
void _cogl_buffer_fini (CoglBuffer *buffer);

8
clutter/cogl/cogl/cogl-buffer.c
View File

@ -85,7 +85,7 @@ cogl_is_buffer_EXP (CoglHandle handle)
void
_cogl_buffer_initialize (CoglBuffer *buffer,
guint size,
unsigned int size,
CoglBufferUsageHint usage_hint,
CoglBufferUpdateHint update_hint)
{
@ -183,7 +183,7 @@ _cogl_buffer_bind (CoglBuffer *buffer,
ctx->current_pbo = buffer;
}
guint
unsigned int
cogl_buffer_get_size_EXP (CoglHandle handle)
{
if (!cogl_is_buffer (handle))
@ -236,7 +236,7 @@ cogl_buffer_get_update_hint_EXP (CoglHandle handle)
return COGL_BUFFER (handle)->update_hint;
}
guchar *
guint8 *
cogl_buffer_map_EXP (CoglHandle handle,
CoglBufferAccess access)
{
@ -273,7 +273,7 @@ cogl_buffer_unmap_EXP (CoglHandle handle)
gboolean
cogl_buffer_set_data_EXP (CoglHandle handle,
gsize offset,
const guchar *data,
const guint8 *data,
gsize size)
{
CoglBuffer *buffer;

26
clutter/cogl/cogl/cogl-buffer.h
View File

@ -70,7 +70,7 @@ cogl_is_buffer (CoglHandle handle);
* Since: 1.2
* Stability: Unstable
*/
guint
unsigned int
cogl_buffer_get_size (CoglHandle handle);
/**
@ -85,7 +85,7 @@ cogl_buffer_get_size (CoglHandle handle);
* Stability: Unstable
*/
typedef enum { /*< prefix=COGL_BUFFER_USAGE_HINT >*/
COGL_BUFFER_USAGE_HINT_TEXTURE,
COGL_BUFFER_USAGE_HINT_TEXTURE,
} CoglBufferUsageHint;
/**
@ -148,7 +148,7 @@ typedef enum { /*< prefix=COGL_BUFFER_UPDATE_HINT >*/
* Stability: Unstable
*/
void
cogl_buffer_set_update_hint (CoglHandle handle,
cogl_buffer_set_update_hint (CoglHandle handle,
CoglBufferUpdateHint hint);
/**
@ -196,7 +196,7 @@ typedef enum { /*< prefix=COGL_BUFFER_ACCESS >*/
* Since: 1.2
* Stability: Unstable
*/
guchar *
guint8 *
cogl_buffer_map (CoglHandle handle,
CoglBufferAccess access);
@ -230,9 +230,9 @@ cogl_buffer_unmap (CoglHandle handle);
*/
gboolean
cogl_buffer_set_data (CoglHandle handle,
gsize offset,
const guchar *data,
gsize size);
gsize offset,
const guint8 *data,
gsize size);
/* the functions above are experimental, the actual symbols are suffixed by
* _EXP so we can ensure ABI compatibility and leave the cogl_buffer namespace
@ -242,7 +242,7 @@ cogl_buffer_set_data (CoglHandle handle,
gboolean
cogl_is_buffer_EXP (CoglHandle handle);
guint
unsigned int
cogl_buffer_get_size_EXP (CoglHandle handle);
void
@ -253,13 +253,13 @@ CoglBufferUsageHint
cogl_buffer_get_usage_hint_EXP (CoglHandle handle);
void
cogl_buffer_set_update_hint_EXP (CoglHandle handle,
cogl_buffer_set_update_hint_EXP (CoglHandle handle,
CoglBufferUpdateHint hint);
CoglBufferUpdateHint
cogl_buffer_get_update_hint_EXP (CoglHandle handle);
guchar *
guint8 *
cogl_buffer_map_EXP (CoglHandle handle,
CoglBufferAccess access);
@ -268,9 +268,9 @@ cogl_buffer_unmap_EXP (CoglHandle handle);
gboolean
cogl_buffer_set_data_EXP (CoglHandle handle,
gsize offset,
const guchar *data,
gsize size);
gsize offset,
const guint8 *data,
gsize size);
#define cogl_is_buffer cogl_is_buffer_EXP
#define cogl_buffer_get_size cogl_buffer_get_size_EXP

16
clutter/cogl/cogl/cogl-clip-stack.c
View File

@ -37,9 +37,9 @@
#include "cogl-internal.h"
#include "cogl-framebuffer-private.h"
void _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
floatVec2 nodes_max,
guint path_size,
void _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
floatVec2 nodes_max,
unsigned int path_size,
CoglPathNode *path,
gboolean merge,
gboolean need_clear);
@ -97,7 +97,7 @@ struct _CoglClipStackEntryPath
floatVec2 path_nodes_min;
floatVec2 path_nodes_max;
guint path_size;
unsigned int path_size;
CoglPathNode path[1];
};
@ -642,10 +642,10 @@ _cogl_flush_clip_state (CoglClipStackState *clip_state)
gboolean using_clip_planes = FALSE;
gboolean using_stencil_buffer = FALSE;
GList *node;
gint scissor_x0 = 0;
gint scissor_y0 = 0;
gint scissor_x1 = G_MAXINT;
gint scissor_y1 = G_MAXINT;
int scissor_x0 = 0;
int scissor_y0 = 0;
int scissor_x1 = G_MAXINT;
int scissor_y1 = G_MAXINT;
CoglMatrixStack *modelview_stack =
_cogl_framebuffer_get_modelview_stack (_cogl_get_framebuffer ());

14
clutter/cogl/cogl/cogl-clip-stack.h
View File

@ -35,10 +35,16 @@ struct _CoglClipStackState
gboolean stencil_used;
};
void _cogl_clip_stack_state_init (CoglClipStackState *state);
void _cogl_clip_stack_state_destroy (CoglClipStackState *state);
void _cogl_clip_stack_state_dirty (CoglClipStackState *state);
void
_cogl_clip_stack_state_init (CoglClipStackState *state);
void _cogl_flush_clip_state (CoglClipStackState *clip_state);
void
_cogl_clip_stack_state_destroy (CoglClipStackState *state);
void
_cogl_clip_stack_state_dirty (CoglClipStackState *state);
void
_cogl_flush_clip_state (CoglClipStackState *clip_state);
#endif /* __COGL_CLIP_STACK_H */

75
clutter/cogl/cogl/cogl-color.h
View File

@ -52,7 +52,8 @@ G_BEGIN_DECLS
*
* Since: 1.0
*/
CoglColor *cogl_color_new (void);
CoglColor *
cogl_color_new (void);
/**
* cogl_color_copy:
@ -65,7 +66,8 @@ CoglColor *cogl_color_new (void);
*
* Since: 1.0
*/
CoglColor *cogl_color_copy (const CoglColor *color);
CoglColor *
cogl_color_copy (const CoglColor *color);
/**
* cogl_color_free:
@ -75,7 +77,8 @@ CoglColor *cogl_color_copy (const CoglColor *color);
*
* Since: 1.0
*/
void cogl_color_free (CoglColor *color);
void
cogl_color_free (CoglColor *color);
/**
* cogl_color_set_from_4ub:
@ -89,11 +92,12 @@ void cogl_color_free (CoglColor *color);
*
* Since: 1.0
*/
void cogl_color_set_from_4ub (CoglColor *dest,
guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
void
cogl_color_set_from_4ub (CoglColor *dest,
guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
/**
* cogl_color_set_from_4f:
@ -107,11 +111,12 @@ void cogl_color_set_from_4ub (CoglColor *dest,
*
* Since: 1.0
*/
void cogl_color_set_from_4f (CoglColor *dest,
float red,
float green,
float blue,
float alpha);
void
cogl_color_set_from_4f (CoglColor *dest,
float red,
float green,
float blue,
float alpha);
/**
* cogl_color_get_red_byte:
@ -124,7 +129,8 @@ void cogl_color_set_from_4f (CoglColor *dest,
*
* Since: 1.0
*/
unsigned char cogl_color_get_red_byte (const CoglColor *color);
unsigned char
cogl_color_get_red_byte (const CoglColor *color);
/**
* cogl_color_get_green_byte:
@ -137,7 +143,8 @@ unsigned char cogl_color_get_red_byte (const CoglColor *color);
*
* Since: 1.0
*/
unsigned char cogl_color_get_green_byte (const CoglColor *color);
unsigned char
cogl_color_get_green_byte (const CoglColor *color);
/**
* cogl_color_get_blue_byte:
@ -150,7 +157,8 @@ unsigned char cogl_color_get_green_byte (const CoglColor *color);
*
* Since: 1.0
*/
unsigned char cogl_color_get_blue_byte (const CoglColor *color);
unsigned char
cogl_color_get_blue_byte (const CoglColor *color);
/**
* cogl_color_get_alpha_byte:
@ -163,7 +171,8 @@ unsigned char cogl_color_get_blue_byte (const CoglColor *color);
*
* Since: 1.0
*/
unsigned char cogl_color_get_alpha_byte (const CoglColor *color);
unsigned char
cogl_color_get_alpha_byte (const CoglColor *color);
/**
* cogl_color_get_red_float:
@ -176,7 +185,8 @@ unsigned char cogl_color_get_alpha_byte (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_red_float (const CoglColor *color);
float
cogl_color_get_red_float (const CoglColor *color);
/**
* cogl_color_get_green_float:
@ -189,7 +199,8 @@ float cogl_color_get_red_float (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_green_float (const CoglColor *color);
float
cogl_color_get_green_float (const CoglColor *color);
/**
* cogl_color_get_blue_float:
@ -202,7 +213,8 @@ float cogl_color_get_green_float (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_blue_float (const CoglColor *color);
float
cogl_color_get_blue_float (const CoglColor *color);
/**
* cogl_color_get_alpha_float:
@ -215,7 +227,8 @@ float cogl_color_get_blue_float (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_alpha_float (const CoglColor *color);
float
cogl_color_get_alpha_float (const CoglColor *color);
/**
* cogl_color_get_red:
@ -228,7 +241,8 @@ float cogl_color_get_alpha_float (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_red (const CoglColor *color);
float
cogl_color_get_red (const CoglColor *color);
/**
* cogl_color_get_green:
@ -241,7 +255,8 @@ float cogl_color_get_red (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_green (const CoglColor *color);
float
cogl_color_get_green (const CoglColor *color);
/**
* cogl_color_get_blue:
@ -254,7 +269,8 @@ float cogl_color_get_green (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_blue (const CoglColor *color);
float
cogl_color_get_blue (const CoglColor *color);
/**
* cogl_color_get_alpha:
@ -267,7 +283,8 @@ float cogl_color_get_blue (const CoglColor *color);
*
* Since: 1.0
*/
float cogl_color_get_alpha (const CoglColor *color);
float
cogl_color_get_alpha (const CoglColor *color);
/**
* cogl_color_premultiply:
@ -279,7 +296,8 @@ float cogl_color_get_alpha (const CoglColor *color);
*
* Since: 1.0
*/
void cogl_color_premultiply (CoglColor *color);
void
cogl_color_premultiply (CoglColor *color);
/**
* cogl_color_equal:
@ -295,8 +313,9 @@ void cogl_color_premultiply (CoglColor *color);
*
* Since: 1.0
*/
gboolean cogl_color_equal (gconstpointer v1,
gconstpointer v2);
gboolean
cogl_color_equal (gconstpointer v1,
gconstpointer v2);
G_END_DECLS

2
clutter/cogl/cogl/cogl-context.c
View File

@ -46,7 +46,7 @@ static gboolean
cogl_create_context (void)
{
GLubyte default_texture_data[] = { 0xff, 0xff, 0xff, 0x0 };
gulong enable_flags = 0;
unsigned long enable_flags = 0;
CoglHandle window_buffer;
if (_context != NULL)

10
clutter/cogl/cogl/cogl-context.h
View File

@ -49,7 +49,7 @@ typedef struct
CoglHandle default_material;
/* Enable cache */
gulong enable_flags;
unsigned long enable_flags;
guint8 color_alpha;
gboolean enable_backface_culling;
@ -83,10 +83,10 @@ typedef struct
/* Some simple caching, to minimize state changes... */
CoglHandle current_material;
gulong current_material_flags;
unsigned long current_material_flags;
CoglMaterialFlushOptions current_material_flush_options;
GArray *current_layers;
guint n_texcoord_arrays_enabled;
unsigned int n_texcoord_arrays_enabled;
/* PBOs */
/* This can be used to check if a pbo is bound */
@ -102,7 +102,7 @@ typedef struct
floatVec2 path_start;
floatVec2 path_pen;
GArray *path_nodes;
guint last_path;
unsigned int last_path;
floatVec2 path_nodes_min;
floatVec2 path_nodes_max;
CoglHandle stencil_material;
@ -110,7 +110,7 @@ typedef struct
/* Pre-generated VBOs containing indices to generate GL_TRIANGLES
out of a vertex array of quads */
CoglHandle quad_indices_byte;
guint quad_indices_short_len;
unsigned int quad_indices_short_len;
CoglHandle quad_indices_short;
gboolean in_begin_gl_block;

8
clutter/cogl/cogl/cogl-debug.c
View File

@ -53,10 +53,10 @@ static const GDebugKey cogl_debug_keys[] = {
{ "disable-atlas", COGL_DEBUG_DISABLE_ATLAS }
};
static const gint n_cogl_debug_keys = G_N_ELEMENTS (cogl_debug_keys);
static const int n_cogl_debug_keys = G_N_ELEMENTS (cogl_debug_keys);
#endif /* COGL_ENABLE_DEBUG */
guint cogl_debug_flags = 0;
unsigned int cogl_debug_flags = 0;
#ifdef COGL_ENABLE_DEBUG
static gboolean
@ -73,8 +73,8 @@ cogl_arg_debug_cb (const char *key,
static gboolean
cogl_arg_no_debug_cb (const char *key,
const char *value,
gpointer user_data)
const char *value,
gpointer user_data)
{
cogl_debug_flags &=
~g_parse_debug_string (value,

4
clutter/cogl/cogl/cogl-debug.h
View File

@ -62,7 +62,7 @@ typedef enum {
#else
#define COGL_NOTE(type,...) G_STMT_START { \
if (cogl_debug_flags & COGL_DEBUG_##type) { \
gchar *_fmt = g_strdup_printf (__VA_ARGS__); \
char *_fmt = g_strdup_printf (__VA_ARGS__); \
g_message ("[" #type "] " G_STRLOC ": %s", _fmt); \
g_free (_fmt); \
} } G_STMT_END
@ -75,7 +75,7 @@ typedef enum {
#endif /* COGL_ENABLE_DEBUG */
extern guint cogl_debug_flags;
extern unsigned int cogl_debug_flags;
G_END_DECLS

19
clutter/cogl/cogl/cogl-feature-private.c
View File

@ -34,11 +34,12 @@
gboolean
_cogl_feature_check (const CoglFeatureData *data,
guint gl_major, guint gl_minor,
const gchar *extensions_string)
unsigned int gl_major,
unsigned int gl_minor,
const char *extensions_string)
{
const gchar *suffix = NULL;
const char *suffix = NULL;
int func_num;
_COGL_GET_CONTEXT (ctx, FALSE);
@ -51,14 +52,14 @@ _cogl_feature_check (const CoglFeatureData *data,
else
{
/* Otherwise try all of the extensions */
const gchar *namespace, *namespace_suffix;
guint namespace_len;
const char *namespace, *namespace_suffix;
unsigned int namespace_len;
for (namespace = data->namespaces;
*namespace;
namespace += strlen (namespace) + 1)
{
const gchar *extension;
const char *extension;
GString *full_extension_name = g_string_new ("");
/* If the namespace part contains a ':' then the suffix for
@ -110,7 +111,7 @@ _cogl_feature_check (const CoglFeatureData *data,
for (func_num = 0; data->functions[func_num].name; func_num++)
{
void *func;
gchar *full_function_name;
char *full_function_name;
full_function_name = g_strconcat (data->functions[func_num].name,
suffix, NULL);
@ -121,7 +122,7 @@ _cogl_feature_check (const CoglFeatureData *data,
break;
/* Set the function pointer in the context */
*(void **) ((guchar *) ctx +
*(void **) ((guint8 *) ctx +
data->functions[func_num].pointer_offset) = func;
}
@ -132,7 +133,7 @@ _cogl_feature_check (const CoglFeatureData *data,
if (data->functions[func_num].name)
{
while (func_num-- > 0)
*(void **) ((guchar *) ctx +
*(void **) ((guint8 *) ctx +
data->functions[func_num].pointer_offset) = NULL;
return FALSE;
}

14
clutter/cogl/cogl/cogl-feature-private.h
View File

@ -36,9 +36,9 @@ typedef struct _CoglFeatureFunction CoglFeatureFunction;
struct _CoglFeatureFunction
{
/* The name of the function without the "EXT" or "ARB" suffix */
const gchar *name;
const char *name;
/* The offset in the context of where to store the function pointer */
guint pointer_offset;
unsigned int pointer_offset;
};
typedef struct _CoglFeatureData CoglFeatureData;
@ -48,15 +48,15 @@ struct _CoglFeatureData
/* A minimum GL version which the functions should be defined in
without needing an extension. Set to 255,255 if it's only
provided in an extension */
guchar min_gl_major, min_gl_minor;
guint8 min_gl_major, min_gl_minor;
/* \0 separated list of namespaces to try. Eg "EXT\0ARB\0" */
const gchar *namespaces;
const char *namespaces;
/* \0 separated list of required extension names without the GL_EXT
or GL_ARB prefix. All of the extensions must be available for the
feature to be considered available. If the suffix for an
extension is different from the namespace, you can specify it
with a ':' after the namespace */
const gchar *extension_names;
const char *extension_names;
/* A set of feature flags to enable if the extension is available */
CoglFeatureFlags feature_flags;
/* A list of functions required for this feature. Terminated with a
@ -65,7 +65,7 @@ struct _CoglFeatureData
};
gboolean _cogl_feature_check (const CoglFeatureData *data,
guint gl_major, guint gl_minor,
const gchar *extensions_string);
unsigned int gl_major, unsigned int gl_minor,
const char *extensions_string);
#endif /* __COGL_FEATURE_PRIVATE_H */

24
clutter/cogl/cogl/cogl-fixed.c
View File

@ -295,7 +295,7 @@ static const CoglFixed sqrt_tbl[] =
/* the difference of the angle for two adjacent values in the
* sin_tbl table, expressed as CoglFixed number
*/
static const gint sin_tbl_size = G_N_ELEMENTS (sin_tbl) - 1;
static const int sin_tbl_size = G_N_ELEMENTS (sin_tbl) - 1;
static const double _magic = 68719476736.0 * 1.5;
@ -346,11 +346,11 @@ cogl_double_to_fixed (double val)
*
* Return value: Integer part of the double
*/
gint
int
cogl_double_to_int (double val)
{
#ifdef COGL_NO_FAST_CONVERSIONS
return (gint) (val);
return (int) (val);
#else
union {
double d;
@ -364,11 +364,11 @@ cogl_double_to_int (double val)
#endif
}
guint
unsigned int
cogl_double_to_uint (double val)
{
#ifdef COGL_NO_FAST_CONVERSIONS
return (guint)(val);
return (unsigned int)(val);
#else
union {
double d;
@ -716,8 +716,8 @@ cogl_fixed_sqrt (CoglFixed x)
*
* Since: 0.2
*/
gint
cogl_sqrti (gint number)
int
cogl_sqrti (int number)
{
#if defined __SSE2__
/* The GCC built-in with SSE2 (sqrtsd) is up to twice as fast as
@ -859,7 +859,7 @@ cogl_fixed_mul_div (CoglFixed a,
*/
CoglFixed
cogl_fixed_log2 (guint x)
cogl_fixed_log2 (unsigned int x)
{
/* Note: we could easily have a version for CoglFixed x, but the int
* precision is enough for the current purposes.
@ -889,7 +889,7 @@ cogl_fixed_log2 (guint x)
return flt.i + y;
}
guint
unsigned int
cogl_fixed_pow2 (CoglFixed x)
{
/* Note: we could easily have a version that produces CoglFixed result,
@ -926,9 +926,9 @@ cogl_fixed_pow2 (CoglFixed x)
return COGL_FLOAT_TO_UINT (flt.f);
}
guint
cogl_fixed_pow (guint x,
CoglFixed y)
unsigned int
cogl_fixed_pow (unsigned int x,
CoglFixed y)
{
return cogl_fixed_pow2 (COGL_FIXED_MUL (y, cogl_fixed_log2 (x)));
}

72
clutter/cogl/cogl/cogl-fixed.h
View File

@ -468,7 +468,8 @@ G_BEGIN_DECLS
*
* Since: 1.0
*/
CoglFixed cogl_fixed_sin (CoglFixed angle);
CoglFixed
cogl_fixed_sin (CoglFixed angle);
/**
* cogl_fixed_tan:
@ -480,7 +481,8 @@ CoglFixed cogl_fixed_sin (CoglFixed angle);
*
* Since: 1.0
*/
CoglFixed cogl_fixed_tan (CoglFixed angle);
CoglFixed
cogl_fixed_tan (CoglFixed angle);
/**
* cogl_fixed_cos:
@ -492,7 +494,7 @@ CoglFixed cogl_fixed_tan (CoglFixed angle);
*
* Since: 1.0
*/
CoglFixed cogl_fixed_cos (CoglFixed angle);
CoglFixed cogl_fixed_cos (CoglFixed angle);
/**
* cogl_fixed_atani:
@ -504,7 +506,8 @@ CoglFixed cogl_fixed_cos (CoglFixed angle);
*
* Since: 1.0
*/
CoglFixed cogl_fixed_atani (CoglFixed a);
CoglFixed
cogl_fixed_atani (CoglFixed a);
/**
* cogl_fixed_atan2:
@ -519,19 +522,25 @@ CoglFixed cogl_fixed_atani (CoglFixed a);
*
* Since: 1.0
*/
CoglFixed cogl_fixed_atan2 (CoglFixed a,
CoglFixed b);
CoglFixed
cogl_fixed_atan2 (CoglFixed a,
CoglFixed b);
/*< public >*/
/* Fixed point math routines */
G_INLINE_FUNC CoglFixed cogl_fixed_mul (CoglFixed a,
CoglFixed b);
G_INLINE_FUNC CoglFixed cogl_fixed_div (CoglFixed a,
CoglFixed b);
G_INLINE_FUNC CoglFixed cogl_fixed_mul_div (CoglFixed a,
CoglFixed b,
CoglFixed c);
G_INLINE_FUNC CoglFixed
cogl_fixed_mul (CoglFixed a,
CoglFixed b);
G_INLINE_FUNC CoglFixed
cogl_fixed_div (CoglFixed a,
CoglFixed b);
G_INLINE_FUNC CoglFixed
cogl_fixed_mul_div (CoglFixed a,
CoglFixed b,
CoglFixed c);
/**
* COGL_SQRTI_ARG_MAX:
@ -585,7 +594,8 @@ G_INLINE_FUNC CoglFixed cogl_fixed_mul_div (CoglFixed a,
*
* Since: 1.0
*/
CoglFixed cogl_fixed_sqrt (CoglFixed x);
CoglFixed
cogl_fixed_sqrt (CoglFixed x);
/**
* cogl_fixed_log2:
@ -600,7 +610,8 @@ CoglFixed cogl_fixed_sqrt (CoglFixed x);
*
* Since: 1.0
*/
CoglFixed cogl_fixed_log2 (guint x);
CoglFixed
cogl_fixed_log2 (unsigned int x);
/**
* cogl_fixed_pow2:
@ -615,7 +626,8 @@ CoglFixed cogl_fixed_log2 (guint x);
*
* Since: 1.0
*/
guint cogl_fixed_pow2 (CoglFixed x);
unsigned int
cogl_fixed_pow2 (CoglFixed x);
/**
* cogl_fixed_pow:
@ -628,8 +640,9 @@ guint cogl_fixed_pow2 (CoglFixed x);
*
* Since: 1.0
*/
guint cogl_fixed_pow (guint x,
CoglFixed y);
unsigned int
cogl_fixed_pow (unsigned int x,
CoglFixed y);
/**
* cogl_sqrti:
@ -647,7 +660,8 @@ guint cogl_fixed_pow (guint x,
*
* Since: 1.0
*/
gint cogl_sqrti (gint x);
int
cogl_sqrti (int x);
/**
* COGL_ANGLE_FROM_DEG:
@ -700,7 +714,8 @@ gint cogl_sqrti (gint x);
*
* Since: 1.0
*/
CoglFixed cogl_angle_sin (CoglAngle angle);
CoglFixed
cogl_angle_sin (CoglAngle angle);
/**
* cogl_angle_tan:
@ -712,7 +727,8 @@ CoglFixed cogl_angle_sin (CoglAngle angle);
*
* Since: 1.0
*/
CoglFixed cogl_angle_tan (CoglAngle angle);
CoglFixed
cogl_angle_tan (CoglAngle angle);
/**
* cogl_angle_cos:
@ -724,7 +740,8 @@ CoglFixed cogl_angle_tan (CoglAngle angle);
*
* Since: 1.0
*/
CoglFixed cogl_angle_cos (CoglAngle angle);
CoglFixed
cogl_angle_cos (CoglAngle angle);
/*< private >*/
@ -773,9 +790,14 @@ cogl_fixed_mul_div (CoglFixed a,
}
#endif
extern CoglFixed cogl_double_to_fixed (double value);
extern gint cogl_double_to_int (double value);
extern guint cogl_double_to_unit (double value);
CoglFixed
cogl_double_to_fixed (double value);
int
cogl_double_to_int (double value);
unsigned int
cogl_double_to_unit (double value);
G_END_DECLS

2
clutter/cogl/cogl/cogl-handle.h
View File

@ -39,7 +39,7 @@ typedef struct _CoglHandleClass
*/
typedef struct _CoglHandleObject
{
guint ref_count;
unsigned int ref_count;
CoglHandleClass *klass;
} CoglHandleObject;

32
clutter/cogl/cogl/cogl-internal.h
View File

@ -3,7 +3,7 @@
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2007,2008,2009 Intel Corporation.
* Copyright (C) 2007,2008,2009,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
@ -48,11 +48,11 @@ typedef struct _CoglBoxedValue
gboolean transpose;
union {
gfloat float_value[4];
gint int_value[4];
gfloat matrix[16];
gfloat *float_array;
gint *int_array;
float float_value[4];
int int_value[4];
float matrix[16];
float *float_array;
int *int_array;
gpointer array;
} v;
} CoglBoxedValue;
@ -60,7 +60,8 @@ typedef struct _CoglBoxedValue
#ifdef COGL_GL_DEBUG
const gchar *cogl_gl_error_to_string (GLenum error_code);
const char *
cogl_gl_error_to_string (GLenum error_code);
#define GE(x) G_STMT_START { \
GLenum __err; \
@ -97,12 +98,17 @@ const gchar *cogl_gl_error_to_string (GLenum error_code);
#define COGL_ENABLE_COLOR_ARRAY (1<<4)
#define COGL_ENABLE_BACKFACE_CULLING (1<<5)
void _cogl_features_init (void);
void
_cogl_features_init (void);
gint _cogl_get_format_bpp (CoglPixelFormat format);
int
_cogl_get_format_bpp (CoglPixelFormat format);
void cogl_enable (gulong flags);
gulong cogl_get_enable (void);
void
cogl_enable (gulong flags);
unsigned long
cogl_get_enable (void);
typedef struct _CoglTextureUnit
{
@ -112,9 +118,11 @@ typedef struct _CoglTextureUnit
CoglTextureUnit *
_cogl_get_texture_unit (int index_);
void
_cogl_destroy_texture_units (void);
guint
unsigned int
_cogl_get_max_texture_image_units (void);
void

26
clutter/cogl/cogl/cogl-journal.c
View File

@ -88,7 +88,7 @@ typedef CoglVertexBufferIndices CoglJournalIndices;
typedef struct _CoglJournalFlushState
{
size_t stride;
gsize stride;
/* Note: this is a pointer to handle fallbacks. It normally holds a VBO
* offset, but when the driver doesn't support VBOs then this points into
* our GArray of logged vertices. */
@ -96,7 +96,7 @@ typedef struct _CoglJournalFlushState
GLuint vertex_offset;
#ifndef HAVE_COGL_GL
CoglJournalIndices *indices;
size_t indices_type_size;
gsize indices_type_size;
#endif
CoglMatrixStack *modelview_stack;
} CoglJournalFlushState;
@ -110,7 +110,7 @@ typedef gboolean (*CoglJournalBatchTest) (CoglJournalEntry *entry0,
void
_cogl_journal_dump_quad_vertices (guint8 *data, int n_layers)
{
size_t stride = GET_JOURNAL_VB_STRIDE_FOR_N_LAYERS (n_layers);
gsize stride = GET_JOURNAL_VB_STRIDE_FOR_N_LAYERS (n_layers);
int i;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -144,7 +144,7 @@ _cogl_journal_dump_quad_vertices (guint8 *data, int n_layers)
void
_cogl_journal_dump_quad_batch (guint8 *data, int n_layers, int n_quads)
{
size_t byte_stride = GET_JOURNAL_VB_STRIDE_FOR_N_LAYERS (n_layers) * 4;
gsize byte_stride = GET_JOURNAL_VB_STRIDE_FOR_N_LAYERS (n_layers) * 4;
int i;
g_print ("_cogl_journal_dump_quad_batch: n_layers = %d, n_quads = %d\n",
@ -304,10 +304,10 @@ compare_entry_modelviews (CoglJournalEntry *entry0,
* materials, but they may not all have the same modelview matrix */
static void
_cogl_journal_flush_material_and_entries (CoglJournalEntry *batch_start,
gint batch_len,
int batch_len,
void *data)
{
gulong enable_flags = 0;
unsigned long enable_flags = 0;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -367,7 +367,7 @@ compare_entry_materials (CoglJournalEntry *entry0, CoglJournalEntry *entry1)
static void
_cogl_journal_flush_texcoord_vbo_offsets_and_entries (
CoglJournalEntry *batch_start,
gint batch_len,
int batch_len,
void *data)
{
CoglJournalFlushState *state = data;
@ -423,11 +423,11 @@ compare_entry_n_layers (CoglJournalEntry *entry0, CoglJournalEntry *entry1)
* of journal entries */
static void
_cogl_journal_flush_vbo_offsets_and_entries (CoglJournalEntry *batch_start,
gint batch_len,
int batch_len,
void *data)
{
CoglJournalFlushState *state = data;
size_t stride;
gsize stride;
#ifndef HAVE_COGL_GL
int needed_indices = batch_len * 6;
CoglHandle indices_handle;
@ -502,7 +502,7 @@ _cogl_journal_flush_vbo_offsets_and_entries (CoglJournalEntry *batch_start,
/* progress forward through the VBO containing all our vertices */
state->vbo_offset += (stride * 4 * batch_len);
if (G_UNLIKELY (cogl_debug_flags & COGL_DEBUG_JOURNAL))
g_print ("new vbo offset = %lu\n", (gulong)state->vbo_offset);
g_print ("new vbo offset = %lu\n", (unsigned long)state->vbo_offset);
}
static gboolean
@ -524,7 +524,7 @@ compare_entry_strides (CoglJournalEntry *entry0, CoglJournalEntry *entry1)
static GLuint
upload_vertices_to_vbo (GArray *vertices, CoglJournalFlushState *state)
{
size_t needed_vbo_len;
gsize needed_vbo_len;
GLuint journal_vbo;
_COGL_GET_CONTEXT (ctx, 0);
@ -668,8 +668,8 @@ _cogl_journal_log_quad (float x_1,
const float *tex_coords,
unsigned int tex_coords_len)
{
size_t stride;
size_t byte_stride;
gsize stride;
gsize byte_stride;
int next_vert;
GLfloat *v;
GLubyte *c;

67
clutter/cogl/cogl/cogl-material-private.h
View File

@ -60,23 +60,23 @@ typedef enum _CoglMaterialLayerPrivFlags
/* For tracking the state of a layer that's been flushed to OpenGL */
typedef struct _CoglLayerInfo
{
CoglHandle handle;
gulong flags;
GLenum gl_target;
GLuint gl_texture;
gboolean fallback;
gboolean disabled;
gboolean layer0_overridden;
CoglHandle handle;
unsigned long flags;
GLenum gl_target;
GLuint gl_texture;
gboolean fallback;
gboolean disabled;
gboolean layer0_overridden;
} CoglLayerInfo;
struct _CoglMaterialLayer
{
CoglHandleObject _parent;
guint index; /*!< lowest index is blended first then others
on top */
gulong flags;
CoglHandle texture; /*!< The texture for this layer, or COGL_INVALID_HANDLE
for an empty layer */
unsigned int index; /*!< lowest index is blended first then others on
top */
unsigned long flags;
CoglHandle texture; /*!< The texture for this layer, or
COGL_INVALID_HANDLE for an empty layer */
CoglMaterialFilter mag_filter;
CoglMaterialFilter min_filter;
@ -112,9 +112,9 @@ typedef enum _CoglMaterialFlags
struct _CoglMaterial
{
CoglHandleObject _parent;
gulong journal_ref_count;
unsigned long journal_ref_count;
gulong flags;
unsigned long flags;
/* If no lighting is enabled; this is the basic material color */
GLubyte unlit[4];
@ -141,8 +141,8 @@ struct _CoglMaterial
GLint blend_src_factor_rgb;
GLint blend_dst_factor_rgb;
GList *layers;
guint n_layers;
GList *layers;
unsigned int n_layers;
};
/*
@ -179,7 +179,8 @@ _cogl_material_init_default_material (void);
* will be replaced.
*/
/* TODO: find a nicer solution! */
gulong _cogl_material_get_cogl_enable_flags (CoglHandle handle);
unsigned long
_cogl_material_get_cogl_enable_flags (CoglHandle handle);
/*
* CoglMaterialLayerFlags:
@ -202,13 +203,15 @@ typedef enum _CoglMaterialLayerFlags
* internally, but if you are developing custom primitives directly with
* OpenGL you may need this.
*/
gulong _cogl_material_layer_get_flags (CoglHandle layer_handle);
unsigned long
_cogl_material_layer_get_flags (CoglHandle layer_handle);
/*
* Ensures the mipmaps are available for the texture in the layer if
* the filter settings would require it
*/
void _cogl_material_layer_ensure_mipmaps (CoglHandle layer_handler);
void
_cogl_material_layer_ensure_mipmaps (CoglHandle layer_handler);
/*
* CoglMaterialFlushFlag:
@ -251,19 +254,25 @@ typedef struct _CoglMaterialFlushOptions
void _cogl_material_get_colorubv (CoglHandle handle,
guint8 *color);
void
_cogl_material_get_colorubv (CoglHandle handle,
guint8 *color);
void _cogl_material_flush_gl_state (CoglHandle material,
CoglMaterialFlushOptions *options);
void
_cogl_material_flush_gl_state (CoglHandle material,
CoglMaterialFlushOptions *options);
gboolean _cogl_material_equal (CoglHandle material0_handle,
CoglMaterialFlushOptions *material0_flush_options,
CoglHandle material1_handle,
CoglMaterialFlushOptions *material1_flush_options);
gboolean
_cogl_material_equal (CoglHandle material0_handle,
CoglMaterialFlushOptions *material0_flush_options,
CoglHandle material1_handle,
CoglMaterialFlushOptions *material1_flush_options);
CoglHandle _cogl_material_journal_ref (CoglHandle material_handle);
void _cogl_material_journal_unref (CoglHandle material_handle);
CoglHandle
_cogl_material_journal_ref (CoglHandle material_handle);
void
_cogl_material_journal_unref (CoglHandle material_handle);
#endif /* __COGL_MATERIAL_PRIVATE_H */

22
clutter/cogl/cogl/cogl-material.c
View File

@ -740,7 +740,7 @@ cogl_material_set_blend_constant (CoglHandle handle,
*/
static CoglMaterialLayer *
_cogl_material_get_layer (CoglMaterial *material,
gint index_,
int index_,
gboolean create_if_not_found)
{
CoglMaterialLayer *layer;
@ -801,7 +801,7 @@ _cogl_material_get_layer (CoglMaterial *material,
void
cogl_material_set_layer (CoglHandle material_handle,
gint layer_index,
int layer_index,
CoglHandle texture_handle)
{
CoglMaterial *material;
@ -934,7 +934,7 @@ setup_texture_combine_state (CoglBlendStringStatement *statement,
gboolean
cogl_material_set_layer_combine (CoglHandle handle,
gint layer_index,
int layer_index,
const char *combine_description,
GError **error)
{
@ -1004,7 +1004,7 @@ cogl_material_set_layer_combine (CoglHandle handle,
void
cogl_material_set_layer_combine_constant (CoglHandle handle,
gint layer_index,
int layer_index,
CoglColor *constant_color)
{
CoglMaterial *material;
@ -1031,7 +1031,7 @@ cogl_material_set_layer_combine_constant (CoglHandle handle,
void
cogl_material_set_layer_matrix (CoglHandle material_handle,
gint layer_index,
int layer_index,
CoglMatrix *matrix)
{
CoglMaterial *material;
@ -1062,7 +1062,7 @@ _cogl_material_layer_free (CoglMaterialLayer *layer)
void
cogl_material_remove_layer (CoglHandle material_handle,
gint layer_index)
int layer_index)
{
CoglMaterial *material;
CoglMaterialLayer *layer;
@ -1099,11 +1099,11 @@ cogl_material_remove_layer (CoglHandle material_handle,
/* XXX: This API is hopfully just a stop-gap solution. Ideally cogl_enable
* will be replaced. */
gulong
unsigned long
_cogl_material_get_cogl_enable_flags (CoglHandle material_handle)
{
CoglMaterial *material;
gulong enable_flags = 0;
unsigned long enable_flags = 0;
_COGL_GET_CONTEXT (ctx, 0);
@ -1169,7 +1169,7 @@ cogl_material_layer_get_texture (CoglHandle layer_handle)
return layer->texture;
}
gulong
unsigned long
_cogl_material_layer_get_flags (CoglHandle layer_handle)
{
CoglMaterialLayer *layer;
@ -1196,7 +1196,7 @@ _cogl_material_layer_copy (CoglHandle layer_handle)
return _cogl_material_layer_handle_new (layer_copy);
}
static guint
static unsigned int
get_n_args_for_combine_func (GLint func)
{
switch (func)
@ -2056,7 +2056,7 @@ cogl_material_layer_get_mag_filter (CoglHandle layer_handle)
void
cogl_material_set_layer_filters (CoglHandle handle,
gint layer_index,
int layer_index,
CoglMaterialFilter min_filter,
CoglMaterialFilter mag_filter)
{

175
clutter/cogl/cogl/cogl-material.h
View File

@ -86,7 +86,8 @@ typedef enum {
*
* Return value: a handle to the new material
*/
CoglHandle cogl_material_new (void);
CoglHandle
cogl_material_new (void);
/**
* cogl_material_copy:
@ -104,7 +105,8 @@ CoglHandle cogl_material_new (void);
*
* Since: 1.2
*/
CoglHandle cogl_material_copy (CoglHandle source);
CoglHandle
cogl_material_copy (CoglHandle source);
#ifndef COGL_DISABLE_DEPRECATED
@ -120,7 +122,8 @@ CoglHandle cogl_material_copy (CoglHandle source);
*
* Deprecated: 1.2: Use cogl_handle_ref() instead
*/
CoglHandle cogl_material_ref (CoglHandle handle);
CoglHandle
cogl_material_ref (CoglHandle handle);
/**
* cogl_material_unref:
@ -132,7 +135,8 @@ CoglHandle cogl_material_ref (CoglHandle handle);
*
* Deprecated: 1.2: Use cogl_handle_unref() instead
*/
void cogl_material_unref (CoglHandle handle);
void
cogl_material_unref (CoglHandle handle);
#endif /* COGL_DISABLE_DEPRECATED */
@ -145,7 +149,8 @@ void cogl_material_unref (CoglHandle handle);
* Return value: %TRUE if the handle references a #CoglMaterial,
* %FALSE otherwise
*/
gboolean cogl_is_material (CoglHandle handle);
gboolean
cogl_is_material (CoglHandle handle);
/**
* cogl_material_set_color:
@ -163,8 +168,9 @@ gboolean cogl_is_material (CoglHandle handle);
*
* Since: 1.0
*/
void cogl_material_set_color (CoglHandle material,
const CoglColor *color);
void
cogl_material_set_color (CoglHandle material,
const CoglColor *color);
/**
* cogl_material_set_color4ub:
@ -180,11 +186,12 @@ void cogl_material_set_color (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_color4ub (CoglHandle material,
guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
void
cogl_material_set_color4ub (CoglHandle material,
guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
/**
* cogl_material_set_color4f:
@ -200,11 +207,12 @@ void cogl_material_set_color4ub (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_color4f (CoglHandle material,
float red,
float green,
float blue,
float alpha);
void
cogl_material_set_color4f (CoglHandle material,
float red,
float green,
float blue,
float alpha);
/**
* cogl_material_get_color:
@ -215,8 +223,9 @@ void cogl_material_set_color4f (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_get_color (CoglHandle material,
CoglColor *color);
void
cogl_material_get_color (CoglHandle material,
CoglColor *color);
/**
* cogl_material_set_ambient:
@ -234,8 +243,9 @@ void cogl_material_get_color (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_ambient (CoglHandle material,
const CoglColor *ambient);
void
cogl_material_set_ambient (CoglHandle material,
const CoglColor *ambient);
/**
* cogl_material_get_ambient:
@ -246,8 +256,9 @@ void cogl_material_set_ambient (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_get_ambient (CoglHandle material,
CoglColor *ambient);
void
cogl_material_get_ambient (CoglHandle material,
CoglColor *ambient);
/**
* cogl_material_set_diffuse:
@ -262,8 +273,9 @@ void cogl_material_get_ambient (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_diffuse (CoglHandle material,
const CoglColor *diffuse);
void
cogl_material_set_diffuse (CoglHandle material,
const CoglColor *diffuse);
/**
* cogl_material_get_diffuse:
@ -274,8 +286,9 @@ void cogl_material_set_diffuse (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_get_diffuse (CoglHandle material,
CoglColor *diffuse);
void
cogl_material_get_diffuse (CoglHandle material,
CoglColor *diffuse);
/**
* cogl_material_set_ambient_and_diffuse:
@ -291,8 +304,9 @@ void cogl_material_get_diffuse (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_ambient_and_diffuse (CoglHandle material,
const CoglColor *color);
void
cogl_material_set_ambient_and_diffuse (CoglHandle material,
const CoglColor *color);
/**
* cogl_material_set_specular:
@ -307,8 +321,9 @@ void cogl_material_set_ambient_and_diffuse (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_specular (CoglHandle material,
const CoglColor *specular);
void
cogl_material_set_specular (CoglHandle material,
const CoglColor *specular);
/**
* cogl_material_get_specular:
@ -319,8 +334,9 @@ void cogl_material_set_specular (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_get_specular (CoglHandle material,
CoglColor *specular);
void
cogl_material_get_specular (CoglHandle material,
CoglColor *specular);
/**
* cogl_material_set_shininess:
@ -335,8 +351,10 @@ void cogl_material_get_specular (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_shininess (CoglHandle material,
float shininess);
void
cogl_material_set_shininess (CoglHandle material,
float shininess);
/**
* cogl_material_get_shininess:
* @material: A CoglMaterial object
@ -347,7 +365,8 @@ void cogl_material_set_shininess (CoglHandle material,
*
* Since: 1.0
*/
float cogl_material_get_shininess (CoglHandle material);
float
cogl_material_get_shininess (CoglHandle material);
/**
* cogl_material_set_emission:
@ -362,8 +381,9 @@ float cogl_material_get_shininess (CoglHandle material);
*
* Since: 1.0
*/
void cogl_material_set_emission (CoglHandle material,
const CoglColor *emission);
void
cogl_material_set_emission (CoglHandle material,
const CoglColor *emission);
/**
* cogl_material_get_emission:
@ -374,8 +394,9 @@ void cogl_material_set_emission (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_get_emission (CoglHandle material,
CoglColor *emission);
void
cogl_material_get_emission (CoglHandle material,
CoglColor *emission);
/**
* CoglMaterialAlphaFunc:
@ -427,9 +448,10 @@ typedef enum {
*
* Since: 1.0
*/
void cogl_material_set_alpha_test_function (CoglHandle material,
CoglMaterialAlphaFunc alpha_func,
float alpha_reference);
void
cogl_material_set_alpha_test_function (CoglHandle material,
CoglMaterialAlphaFunc alpha_func,
float alpha_reference);
/**
* cogl_material_set_blend:
@ -515,9 +537,10 @@ void cogl_material_set_alpha_test_function (CoglHandle material,
*
* Since: 1.0
*/
gboolean cogl_material_set_blend (CoglHandle material,
const char *blend_string,
GError **error);
gboolean
cogl_material_set_blend (CoglHandle material,
const char *blend_string,
GError **error);
/**
* cogl_material_set_blend_constant:
@ -529,8 +552,9 @@ gboolean cogl_material_set_blend (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_blend_constant (CoglHandle material,
CoglColor *constant_color);
void
cogl_material_set_blend_constant (CoglHandle material,
CoglColor *constant_color);
/**
* cogl_material_set_layer:
@ -551,9 +575,10 @@ void cogl_material_set_blend_constant (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_layer (CoglHandle material,
int layer_index,
CoglHandle texture);
void
cogl_material_set_layer (CoglHandle material,
int layer_index,
CoglHandle texture);
/**
* cogl_material_remove_layer:
@ -562,8 +587,9 @@ void cogl_material_set_layer (CoglHandle material,
*
* This function removes a layer from your material
*/
void cogl_material_remove_layer (CoglHandle material,
gint layer_index);
void
cogl_material_remove_layer (CoglHandle material,
int layer_index);
/**
@ -660,7 +686,7 @@ void cogl_material_remove_layer (CoglHandle material,
*/
gboolean
cogl_material_set_layer_combine (CoglHandle material,
gint layer_index,
int layer_index,
const char *blend_string,
GError **error);
@ -676,9 +702,10 @@ cogl_material_set_layer_combine (CoglHandle material,
*
* Since: 1.0
*/
void cogl_material_set_layer_combine_constant (CoglHandle material,
int layer_index,
CoglColor *constant);
void
cogl_material_set_layer_combine_constant (CoglHandle material,
int layer_index,
CoglColor *constant);
/**
* cogl_material_set_layer_matrix:
@ -689,9 +716,10 @@ void cogl_material_set_layer_combine_constant (CoglHandle material,
* This function lets you set a matrix that can be used to e.g. translate
* and rotate a single layer of a material used to fill your geometry.
*/
void cogl_material_set_layer_matrix (CoglHandle material,
int layer_index,
CoglMatrix *matrix);
void
cogl_material_set_layer_matrix (CoglHandle material,
int layer_index,
CoglMatrix *matrix);
/**
* cogl_material_get_layers:
@ -705,7 +733,8 @@ void cogl_material_set_layer_matrix (CoglHandle material,
* functions. The list is owned by COGL and it should not be modified or
* freed
*/
G_CONST_RETURN GList *cogl_material_get_layers (CoglHandle material);
G_CONST_RETURN GList *
cogl_material_get_layers (CoglHandle material);
/**
* cogl_material_get_n_layers:
@ -717,7 +746,8 @@ G_CONST_RETURN GList *cogl_material_get_layers (CoglHandle material);
*
* Since: 1.0
*/
int cogl_material_get_n_layers (CoglHandle material);
int
cogl_material_get_n_layers (CoglHandle material);
/**
* CoglMaterialLayerType:
@ -747,7 +777,8 @@ typedef enum {
*
* Return value: the type of the layer
*/
CoglMaterialLayerType cogl_material_layer_get_type (CoglHandle layer);
CoglMaterialLayerType
cogl_material_layer_get_type (CoglHandle layer);
/**
* cogl_material_layer_get_texture:
@ -763,7 +794,8 @@ CoglMaterialLayerType cogl_material_layer_get_type (CoglHandle layer);
*
* Return value: a #CoglHandle for the texture inside the layer
*/
CoglHandle cogl_material_layer_get_texture (CoglHandle layer);
CoglHandle
cogl_material_layer_get_texture (CoglHandle layer);
/**
* cogl_material_layer_get_min_filter:
@ -773,7 +805,8 @@ CoglHandle cogl_material_layer_get_texture (CoglHandle layer);
*
* Return value: the current downscaling filter
*/
CoglMaterialFilter cogl_material_layer_get_min_filter (CoglHandle layer);
CoglMaterialFilter
cogl_material_layer_get_min_filter (CoglHandle layer);
/**
* cogl_material_layer_get_mag_filter:
@ -783,7 +816,8 @@ CoglMaterialFilter cogl_material_layer_get_min_filter (CoglHandle layer);
*
* Return value: the current downscaling filter
*/
CoglMaterialFilter cogl_material_layer_get_mag_filter (CoglHandle layer);
CoglMaterialFilter
cogl_material_layer_get_mag_filter (CoglHandle layer);
/**
* cogl_material_set_layer_filters:
@ -795,10 +829,11 @@ CoglMaterialFilter cogl_material_layer_get_mag_filter (CoglHandle layer);
* Changes the decimation and interpolation filters used when a texture is
* drawn at other scales than 100%.
*/
void cogl_material_set_layer_filters (CoglHandle material,
gint layer_index,
CoglMaterialFilter min_filter,
CoglMaterialFilter mag_filter);
void
cogl_material_set_layer_filters (CoglHandle material,
int layer_index,
CoglMaterialFilter min_filter,
CoglMaterialFilter mag_filter);
G_END_DECLS

110
clutter/cogl/cogl/cogl-matrix.h
View File

@ -101,9 +101,9 @@ struct _CoglMatrix
/* Note: we may want to extend this later with private flags
* and a cache of the inverse transform matrix. */
float inv[16];
gulong type;
gulong flags;
gulong _padding3;
unsigned long type;
unsigned long flags;
unsigned long _padding3;
};
/**
@ -119,7 +119,8 @@ struct _CoglMatrix
* .wx=0; .wy=0; .wz=0; .ww=1;
* ]|
*/
void cogl_matrix_init_identity (CoglMatrix *matrix);
void
cogl_matrix_init_identity (CoglMatrix *matrix);
/**
* cogl_matrix_multiply:
@ -130,9 +131,10 @@ void cogl_matrix_init_identity (CoglMatrix *matrix);
* Multiplies the two supplied matrices together and stores
* the resulting matrix inside @result
*/
void cogl_matrix_multiply (CoglMatrix *result,
const CoglMatrix *a,
const CoglMatrix *b);
void
cogl_matrix_multiply (CoglMatrix *result,
const CoglMatrix *a,
const CoglMatrix *b);
/**
* cogl_matrix_rotate:
@ -145,11 +147,12 @@ void cogl_matrix_multiply (CoglMatrix *result,
* Multiplies @matrix with a rotation matrix that applies a rotation
* of @angle degrees around the specified 3D vector.
*/
void cogl_matrix_rotate (CoglMatrix *matrix,
float angle,
float x,
float y,
float z);
void
cogl_matrix_rotate (CoglMatrix *matrix,
float angle,
float x,
float y,
float z);
/**
* cogl_matrix_translate:
@ -161,10 +164,11 @@ void cogl_matrix_rotate (CoglMatrix *matrix,
* Multiplies @matrix with a transform matrix that translates along
* the X, Y and Z axis.
*/
void cogl_matrix_translate (CoglMatrix *matrix,
float x,
float y,
float z);
void
cogl_matrix_translate (CoglMatrix *matrix,
float x,
float y,
float z);
/**
* cogl_matrix_scale:
@ -176,10 +180,11 @@ void cogl_matrix_translate (CoglMatrix *matrix,
* Multiplies @matrix with a transform matrix that scales along the X,
* Y and Z axis.
*/
void cogl_matrix_scale (CoglMatrix *matrix,
float sx,
float sy,
float sz);
void
cogl_matrix_scale (CoglMatrix *matrix,
float sx,
float sy,
float sz);
/**
* cogl_matrix_frustum:
@ -193,13 +198,14 @@ void cogl_matrix_scale (CoglMatrix *matrix,
*
* Multiplies @matrix by the given frustum perspective matrix.
*/
void cogl_matrix_frustum (CoglMatrix *matrix,
float left,
float right,
float bottom,
float top,
float z_near,
float z_far);
void
cogl_matrix_frustum (CoglMatrix *matrix,
float left,
float right,
float bottom,
float top,
float z_near,
float z_far);
/**
* cogl_matrix_perspective:
@ -218,11 +224,12 @@ void cogl_matrix_frustum (CoglMatrix *matrix,
* be enough precision to identify the depth of objects near to each
* other.</note>
*/
void cogl_matrix_perspective (CoglMatrix *matrix,
float fov_y,
float aspect,
float z_near,
float z_far);
void
cogl_matrix_perspective (CoglMatrix *matrix,
float fov_y,
float aspect,
float z_near,
float z_far);
/**
* cogl_matrix_ortho:
@ -238,13 +245,14 @@ void cogl_matrix_perspective (CoglMatrix *matrix,
*
* Multiplies @matrix by a parallel projection matrix.
*/
void cogl_matrix_ortho (CoglMatrix *matrix,
float left,
float right,
float bottom,
float top,
float z_near,
float z_far);
void
cogl_matrix_ortho (CoglMatrix *matrix,
float left,
float right,
float bottom,
float top,
float z_near,
float z_far);
/**
* cogl_matrix_init_from_array:
@ -253,8 +261,9 @@ void cogl_matrix_ortho (CoglMatrix *matrix,
*
* Initializes @matrix with the contents of @array
*/
void cogl_matrix_init_from_array (CoglMatrix *matrix,
const float *array);
void
cogl_matrix_init_from_array (CoglMatrix *matrix,
const float *array);
/**
* cogl_matrix_get_array:
@ -264,7 +273,8 @@ void cogl_matrix_init_from_array (CoglMatrix *matrix,
*
* Return value: a pointer to the float array
*/
G_CONST_RETURN float *cogl_matrix_get_array (const CoglMatrix *matrix);
G_CONST_RETURN float *
cogl_matrix_get_array (const CoglMatrix *matrix);
/**
* cogl_matrix_get_inverse:
@ -286,8 +296,9 @@ G_CONST_RETURN float *cogl_matrix_get_array (const CoglMatrix *matrix);
*
* Since: 1.2
*/
gboolean cogl_matrix_get_inverse (const CoglMatrix *matrix,
CoglMatrix *inverse);
gboolean
cogl_matrix_get_inverse (const CoglMatrix *matrix,
CoglMatrix *inverse);
/**
* cogl_matrix_transform_point:
@ -300,11 +311,12 @@ gboolean cogl_matrix_get_inverse (const CoglMatrix *matrix,
* Transforms a point whos position is given and returned as four float
* components.
*/
void cogl_matrix_transform_point (const CoglMatrix *matrix,
float *x,
float *y,
float *z,
float *w);
void
cogl_matrix_transform_point (const CoglMatrix *matrix,
float *x,
float *y,
float *z,
float *w);
G_END_DECLS

138
clutter/cogl/cogl/cogl-path.h
View File

@ -63,10 +63,11 @@ G_BEGIN_DECLS
*
* Fills a rectangle at the given coordinates with the current source material
**/
void cogl_rectangle (float x_1,
float y_1,
float x_2,
float y_2);
void
cogl_rectangle (float x_1,
float y_1,
float x_2,
float y_2);
/**
* cogl_path_fill:
@ -75,7 +76,8 @@ void cogl_rectangle (float x_1,
* current path is then cleared. To use the path again, call
* cogl_path_fill_preserve() instead.
**/
void cogl_path_fill (void);
void
cogl_path_fill (void);
/**
* cogl_path_fill_preserve:
@ -85,7 +87,8 @@ void cogl_path_fill (void);
*
* Since: 1.0
**/
void cogl_path_fill_preserve (void);
void
cogl_path_fill_preserve (void);
/**
* cogl_path_stroke:
@ -95,7 +98,8 @@ void cogl_path_fill_preserve (void);
* matrix). To current path is then cleared. To use the path again,
* call cogl_path_stroke_preserve() instead.
**/
void cogl_path_stroke (void);
void
cogl_path_stroke (void);
/**
@ -106,7 +110,8 @@ void cogl_path_stroke (void);
*
* Since: 1.0
**/
void cogl_path_stroke_preserve (void);
void
cogl_path_stroke_preserve (void);
/**
* cogl_path_new:
@ -115,7 +120,8 @@ void cogl_path_stroke_preserve (void);
*
* Since: 1.0
*/
void cogl_path_new (void);
void
cogl_path_new (void);
/**
* cogl_path_move_to:
@ -125,8 +131,9 @@ void cogl_path_new (void);
* Moves the pen to the given location. If there is an existing path
* this will start a new disjoint subpath.
**/
void cogl_path_move_to (float x,
float y);
void
cogl_path_move_to (float x,
float y);
/**
@ -138,8 +145,9 @@ void cogl_path_move_to (float x,
* location. If there is an existing path this will start a new
* disjoint subpath.
**/
void cogl_path_rel_move_to (float x,
float y);
void
cogl_path_rel_move_to (float x,
float y);
/**
* cogl_path_line_to:
@ -149,8 +157,9 @@ void cogl_path_rel_move_to (float x,
* Adds a straight line segment to the current path that ends at the
* given coordinates.
**/
void cogl_path_line_to (float x,
float y);
void
cogl_path_line_to (float x,
float y);
/**
* cogl_path_rel_line_to:
@ -160,8 +169,9 @@ void cogl_path_line_to (float x,
* Adds a straight line segment to the current path that ends at the
* given coordinates relative to the current pen location.
**/
void cogl_path_rel_line_to (float x,
float y);
void
cogl_path_rel_line_to (float x,
float y);
/**
@ -178,14 +188,13 @@ void cogl_path_rel_line_to (float x,
* of the arc. If you perform a move_to to the arcs start just before
* drawing it you create a free standing arc.
**/
void cogl_path_arc (float center_x,
float center_y,
float radius_x,
float radius_y,
float angle_1,
float angle_2);
void
cogl_path_arc (float center_x,
float center_y,
float radius_x,
float radius_y,
float angle_1,
float angle_2);
/**
* cogl_path_curve_to:
@ -200,12 +209,13 @@ void cogl_path_arc (float center_x,
* second, third and fourth control points and using current pen location
* as the first control point.
**/
void cogl_path_curve_to (float x_1,
float y_1,
float x_2,
float y_2,
float x_3,
float y_3);
void
cogl_path_curve_to (float x_1,
float y_1,
float x_2,
float y_2,
float x_3,
float y_3);
/**
* cogl_path_rel_curve_to:
@ -221,12 +231,13 @@ void cogl_path_curve_to (float x_1,
* as the first control point. The given coordinates are relative to the
* current pen location.
*/
void cogl_path_rel_curve_to (float x_1,
float y_1,
float x_2,
float y_2,
float x_3,
float y_3);
void
cogl_path_rel_curve_to (float x_1,
float y_1,
float x_2,
float y_2,
float x_3,
float y_3);
/**
* cogl_path_close:
@ -234,7 +245,8 @@ void cogl_path_rel_curve_to (float x_1,
* Closes the path being constructed by adding a straight line segment
* to it that ends at the first vertex of the path.
**/
void cogl_path_close (void);
void
cogl_path_close (void);
/**
* cogl_path_line:
@ -247,10 +259,11 @@ void cogl_path_close (void);
* coordinates. If there is an existing path this will start a new
* disjoint sub-path.
**/
void cogl_path_line (float x_1,
float y_1,
float x_2,
float y_2);
void
cogl_path_line (float x_1,
float y_1,
float x_2,
float y_2);
/**
* cogl_path_polyline:
@ -270,8 +283,9 @@ void cogl_path_line (float x_1,
* fashion for the rest of the vertices. (num_points - 1) segments will
* be constructed.
**/
void cogl_path_polyline (float *coords,
gint num_points);
void
cogl_path_polyline (float *coords,
int num_points);
/**
@ -288,8 +302,9 @@ void cogl_path_polyline (float *coords,
* represents the Y coordinate of the first vertex, continuing in the same
* fashion for the rest of the vertices.
**/
void cogl_path_polygon (float *coords,
gint num_points);
void
cogl_path_polygon (float *coords,
int num_points);
/**
@ -302,10 +317,11 @@ void cogl_path_polygon (float *coords,
* Constructs a rectangular shape at the given coordinates. If there
* is an existing path this will start a new disjoint sub-path.
**/
void cogl_path_rectangle (float x_1,
float y_1,
float x_2,
float y_2);
void
cogl_path_rectangle (float x_1,
float y_1,
float x_2,
float y_2);
/**
* cogl_path_ellipse:
@ -317,10 +333,11 @@ void cogl_path_rectangle (float x_1,
* Constructs an ellipse shape. If there is an existing path this will
* start a new disjoint sub-path.
**/
void cogl_path_ellipse (float center_x,
float center_y,
float radius_x,
float radius_y);
void
cogl_path_ellipse (float center_x,
float center_y,
float radius_x,
float radius_y);
/**
* cogl_path_round_rectangle:
@ -335,12 +352,13 @@ void cogl_path_ellipse (float center_x,
* Constructs a rectangular shape with rounded corners. If there is an
* existing path this will start a new disjoint sub-path.
**/
void cogl_path_round_rectangle (float x_1,
float y_1,
float x_2,
float y_2,
float radius,
float arc_step);
void
cogl_path_round_rectangle (float x_1,
float y_1,
float x_2,
float y_2,
float radius,
float arc_step);
G_END_DECLS

9
clutter/cogl/cogl/cogl-pixel-buffer-private.h
View File

@ -59,13 +59,14 @@ typedef struct _CoglPixelBuffer
GLenum gl_target;
CoglPixelFormat format;
guint width;
guint height;
guint stride;
unsigned int width;
unsigned int height;
unsigned int stride;
} CoglPixelBuffer;
GQuark _cogl_handle_pixel_buffer_get_type (void);
GQuark
_cogl_handle_pixel_buffer_get_type (void);
G_END_DECLS

53
clutter/cogl/cogl/cogl-pixel-buffer.c
View File

@ -76,12 +76,15 @@
#endif
static void _cogl_pixel_buffer_free (CoglPixelBuffer *buffer);
static void
_cogl_pixel_buffer_free (CoglPixelBuffer *buffer);
#if !defined (COGL_HAS_GLES)
static const CoglBufferVtable cogl_pixel_buffer_vtable;
static const CoglBufferVtable
cogl_pixel_buffer_vtable;
#endif
static const CoglBufferVtable cogl_malloc_pixel_buffer_vtable;
static const CoglBufferVtable
cogl_malloc_pixel_buffer_vtable;
/* we don't want to use the stock COGL_HANDLE_DEFINE * for 2 reasons:
* - it defines already deprecated symbols
@ -138,7 +141,7 @@ cogl_is_##type_name##_EXP (CoglHandle handle) \
COGL_HANDLE_DEFINE_EXP(PixelBuffer, pixel_buffer)
CoglHandle
cogl_pixel_buffer_new_EXP (guint size)
cogl_pixel_buffer_new_EXP (unsigned int size)
{
CoglPixelBuffer *pixel_buffer = g_slice_new0 (CoglPixelBuffer);
CoglBuffer *buffer = COGL_BUFFER (pixel_buffer);
@ -179,14 +182,14 @@ cogl_pixel_buffer_new_EXP (guint size)
}
CoglHandle
cogl_pixel_buffer_new_for_size_EXP (guint width,
guint height,
CoglPixelFormat format,
guint *rowstride)
cogl_pixel_buffer_new_for_size_EXP (unsigned int width,
unsigned int height,
CoglPixelFormat format,
unsigned int *rowstride)
{
CoglHandle buffer;
CoglPixelBuffer *pixel_buffer;
guint stride;
unsigned int stride;
/* creating a buffer to store "any" format does not make sense */
if (G_UNLIKELY (format == COGL_PIXEL_FORMAT_ANY))
@ -225,13 +228,13 @@ _cogl_pixel_buffer_free (CoglPixelBuffer *buffer)
}
#if !defined (COGL_HAS_GLES)
static guchar *
static guint8 *
_cogl_pixel_buffer_map (CoglBuffer *buffer,
CoglBufferAccess access)
{
CoglPixelBuffer *pixel_buffer = COGL_PIXEL_BUFFER (buffer);
GLenum gl_target;
guchar *data;
guint8 *data;
_COGL_GET_CONTEXT (ctx, NULL);
@ -281,9 +284,9 @@ _cogl_pixel_buffer_unmap (CoglBuffer *buffer)
static gboolean
_cogl_pixel_buffer_set_data (CoglBuffer *buffer,
guint offset,
const guchar *data,
guint size)
unsigned int offset,
const guint8 *data,
unsigned int size)
{
CoglPixelBuffer *pixel_buffer = COGL_PIXEL_BUFFER (buffer);
@ -315,13 +318,13 @@ _cogl_pixel_buffer_set_data (CoglBuffer *buffer,
#if 0
gboolean
cogl_pixel_buffer_set_region_EXP (CoglHandle buffer,
guchar *data,
guint src_width,
guint src_height,
guint src_rowstride,
guint dst_x,
guint dst_y)
cogl_pixel_buffer_set_region_EXP (CoglHandle buffer,
guint8 *data,
unsigned int src_width,
unsigned int src_height,
unsigned int src_rowstride,
unsigned int dst_x,
unsigned int dst_y)
{
if (!cogl_is_pixel_buffer (buffer))
return FALSE;
@ -342,7 +345,7 @@ static const CoglBufferVtable cogl_pixel_buffer_vtable =
* Fallback path, buffer->data points to a malloc'ed buffer.
*/
static guchar *
static guint8 *
_cogl_malloc_pixel_buffer_map (CoglBuffer *buffer,
CoglBufferAccess access)
{
@ -358,9 +361,9 @@ _cogl_malloc_pixel_buffer_unmap (CoglBuffer *buffer)
static gboolean
_cogl_malloc_pixel_buffer_set_data (CoglBuffer *buffer,
guint offset,
const guchar *data,
guint size)
unsigned int offset,
const guint8 *data,
unsigned int size)
{
memcpy (buffer->data + offset, data, size);
return TRUE;

46
clutter/cogl/cogl/cogl-pixel-buffer.h
View File

@ -50,7 +50,7 @@ G_BEGIN_DECLS
* Stability: Unstable
*/
CoglHandle
cogl_pixel_buffer_new (guint size);
cogl_pixel_buffer_new (unsigned int size);
/**
* cogl_pixel_buffer_new_for_size:
@ -75,10 +75,10 @@ cogl_pixel_buffer_new (guint size);
* Stability: Unstable
*/
CoglHandle
cogl_pixel_buffer_new_for_size (guint width,
guint height,
cogl_pixel_buffer_new_for_size (unsigned int width,
unsigned int height,
CoglPixelFormat format,
guint *stride);
unsigned int *stride);
/**
* cogl_is_pixel_buffer:
@ -117,13 +117,13 @@ cogl_is_pixel_buffer (CoglHandle handle);
*/
#if 0
gboolean
cogl_pixel_buffer_set_region (CoglHandle buffer,
guchar *data,
guint src_width,
guint src_height,
guint src_rowstride,
guint dst_x,
guint dst_y);
cogl_pixel_buffer_set_region (CoglHandle buffer,
guint8 *data,
unsigned int src_width,
unsigned int src_height,
unsigned int src_rowstride,
unsigned int dst_x,
unsigned int dst_y);
#endif
/* the functions above are experimental, the actual symbols are suffixed by
@ -132,25 +132,25 @@ cogl_pixel_buffer_set_region (CoglHandle buffer,
* above into the real symbols */
CoglHandle
cogl_pixel_buffer_new_EXP (guint size);
cogl_pixel_buffer_new_EXP (unsigned int size);
CoglHandle
cogl_pixel_buffer_new_for_size_EXP (guint width,
guint height,
CoglPixelFormat format,
guint *stride);
cogl_pixel_buffer_new_for_size_EXP (unsigned int width,
unsigned int height,
CoglPixelFormat format,
unsigned int *stride);
gboolean
cogl_is_pixel_buffer_EXP (CoglHandle handle);
#if 0
gboolean
cogl_pixel_buffer_set_region_EXP (CoglHandle buffer,
guchar *data,
guint src_width,
guint src_height,
guint src_rowstride,
guint dst_x,
guint dst_y);
cogl_pixel_buffer_set_region_EXP (CoglHandle buffer,
guint8 *data,
unsigned int src_width,
unsigned int src_height,
unsigned int src_rowstride,
unsigned int dst_x,
unsigned int dst_y);
#endif
#define cogl_pixel_buffer_new cogl_pixel_buffer_new_EXP

48
clutter/cogl/cogl/cogl-primitives.c
View File

@ -3,7 +3,7 @@
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2007,2008,2009 Intel Corporation.
* Copyright (C) 2007,2008,2009,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
@ -250,7 +250,7 @@ _cogl_multitexture_quad_single_primitive (float x_1,
float *out_tex_coords;
float default_tex_coords[4] = {0.0, 0.0, 1.0, 1.0};
gboolean need_repeat = FALSE;
gint coord_num;
int coord_num;
GLenum wrap_mode;
tex_handle = cogl_material_layer_get_texture (layer);
@ -364,13 +364,13 @@ struct _CoglMutiTexturedRect
float x_2;
float y_2;
const float *tex_coords;
gint tex_coords_len;
int tex_coords_len;
};
static void
_cogl_rectangles_with_multitexture_coords (
struct _CoglMutiTexturedRect *rects,
gint n_rects)
int n_rects)
{
CoglHandle material;
const GList *layers;
@ -395,7 +395,7 @@ _cogl_rectangles_with_multitexture_coords (
{
CoglHandle layer = tmp->data;
CoglHandle tex_handle;
gulong flags;
unsigned long flags;
if (cogl_material_layer_get_type (layer)
!= COGL_MATERIAL_LAYER_TYPE_TEXTURE)
@ -542,7 +542,7 @@ _cogl_rectangles_with_multitexture_coords (
void
cogl_rectangles (const float *verts,
guint n_rects)
unsigned int n_rects)
{
struct _CoglMutiTexturedRect *rects;
int i;
@ -564,7 +564,7 @@ cogl_rectangles (const float *verts,
void
cogl_rectangles_with_texture_coords (const float *verts,
guint n_rects)
unsigned int n_rects)
{
struct _CoglMutiTexturedRect *rects;
int i;
@ -617,7 +617,7 @@ cogl_rectangle_with_multitexture_coords (float x_1,
float x_2,
float y_2,
const float *user_tex_coords,
gint user_tex_coords_len)
int user_tex_coords_len)
{
struct _CoglMutiTexturedRect rect;
@ -756,9 +756,9 @@ _cogl_texture_polygon_multiple_primitives (const CoglTextureVertex *vertices,
static void
_cogl_multitexture_polygon_single_primitive (const CoglTextureVertex *vertices,
guint n_vertices,
guint n_layers,
guint stride,
unsigned int n_vertices,
unsigned int n_layers,
unsigned int stride,
gboolean use_color,
guint32 fallback_layers)
{
@ -835,7 +835,7 @@ _cogl_multitexture_polygon_single_primitive (const CoglTextureVertex *vertices,
void
cogl_polygon (const CoglTextureVertex *vertices,
guint n_vertices,
unsigned int n_vertices,
gboolean use_color)
{
CoglHandle material;
@ -844,8 +844,8 @@ cogl_polygon (const CoglTextureVertex *vertices,
gboolean use_sliced_polygon_fallback = FALSE;
guint32 fallback_layers = 0;
int i;
gulong enable_flags;
guint stride;
unsigned long enable_flags;
unsigned int stride;
gsize stride_bytes;
GLfloat *v;
int prev_n_texcoord_arrays_enabled;
@ -1081,7 +1081,7 @@ _cogl_path_stroke_nodes (void)
path_start);
GE( glVertexPointer (2, GL_FLOAT, sizeof (CoglPathNode),
(guchar *) path
(guint8 *) path
+ G_STRUCT_OFFSET (CoglPathNode, x)) );
GE( glDrawArrays (GL_LINE_STRIP, 0, path->path_size) );
@ -1200,7 +1200,7 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
while (path_start < path_size)
{
GE (glVertexPointer (2, GL_FLOAT, sizeof (CoglPathNode),
(guchar *) path
(guint8 *) path
+ G_STRUCT_OFFSET (CoglPathNode, x)));
GE (glDrawArrays (GL_TRIANGLE_FAN, 0, path->path_size));
@ -1273,7 +1273,7 @@ _cogl_add_path_to_stencil_buffer (floatVec2 nodes_min,
cogl_handle_unref (prev_source);
}
static gint
static int
compare_ints (gconstpointer a,
gconstpointer b)
{
@ -1359,7 +1359,7 @@ _cogl_path_fill_nodes_scanlines (CoglPathNode *path,
y - bounds_y < bounds_h &&
lastline != y)
{
gint x = prev_x + (dx * (y-prev_y)) / dy;
int x = prev_x + (dx * (y-prev_y)) / dy;
scanlines[ y - bounds_y ]=
g_slist_insert_sorted (scanlines[ y - bounds_y],
@ -1640,9 +1640,9 @@ cogl_path_line (float x_1,
void
cogl_path_polyline (float *coords,
gint num_points)
int num_points)
{
gint c = 0;
int c = 0;
cogl_path_move_to (coords[0], coords[1]);
@ -1652,7 +1652,7 @@ cogl_path_polyline (float *coords,
void
cogl_path_polygon (float *coords,
gint num_points)
int num_points)
{
cogl_path_polyline (coords, num_points);
cogl_path_close ();
@ -1679,7 +1679,7 @@ _cogl_path_arc (float center_x,
float angle_1,
float angle_2,
float angle_step,
guint move_first)
unsigned int move_first)
{
float a = 0x0;
float cosa = 0x0;
@ -1856,7 +1856,7 @@ _cogl_path_bezier3_sub (CoglBezCubic *cubic)
floatVec2 c3;
floatVec2 c4;
floatVec2 c5;
gint cindex;
int cindex;
/* Put first curve on stack */
cubics[0] = *cubic;
@ -2001,7 +2001,7 @@ _cogl_path_bezier2_sub (CoglBezQuad *quad)
floatVec2 c1;
floatVec2 c2;
floatVec2 c3;
gint qindex;
int qindex;
/* Put first curve on stack */
quads[0] = *quad;

13
clutter/cogl/cogl/cogl-primitives.h
View File

@ -24,10 +24,10 @@
#ifndef __COGL_PRIMITIVES_H
#define __COGL_PRIMITIVES_H
typedef struct _floatVec2 floatVec2;
typedef struct _CoglBezQuad CoglBezQuad;
typedef struct _CoglBezCubic CoglBezCubic;
typedef struct _CoglPathNode CoglPathNode;
typedef struct _floatVec2 floatVec2;
typedef struct _CoglBezQuad CoglBezQuad;
typedef struct _CoglBezCubic CoglBezCubic;
typedef struct _CoglPathNode CoglPathNode;
struct _floatVec2
{
@ -39,7 +39,7 @@ struct _CoglPathNode
{
float x;
float y;
guint path_size;
unsigned int path_size;
};
struct _CoglBezQuad
@ -57,6 +57,7 @@ struct _CoglBezCubic
floatVec2 p4;
};
void _cogl_journal_flush (void);
void
_cogl_journal_flush (void);
#endif /* __COGL_PRIMITIVES_H */

96
clutter/cogl/cogl/cogl-shader.h
View File

@ -66,7 +66,8 @@ typedef enum {
*
* Returns: a new shader handle.
*/
CoglHandle cogl_create_shader (CoglShaderType shader_type);
CoglHandle
cogl_create_shader (CoglShaderType shader_type);
/**
* cogl_shader_ref:
@ -76,7 +77,8 @@ CoglHandle cogl_create_shader (CoglShaderType shader_type);
*
* Returns: @handle
*/
CoglHandle cogl_shader_ref (CoglHandle handle);
CoglHandle
cogl_shader_ref (CoglHandle handle);
/**
* cogl_shader_unref:
@ -85,7 +87,8 @@ CoglHandle cogl_shader_ref (CoglHandle handle);
* Removes a reference to a shader. If it was the last reference the
* shader object will be destroyed.
*/
void cogl_shader_unref (CoglHandle handle);
void
cogl_shader_unref (CoglHandle handle);
/**
* cogl_is_shader:
@ -96,7 +99,7 @@ void cogl_shader_unref (CoglHandle handle);
* Returns: %TRUE if the handle references a shader,
* %FALSE otherwise
*/
gboolean cogl_is_shader (CoglHandle handle);
gboolean cogl_is_shader (CoglHandle handle);
/**
* cogl_shader_source:
@ -106,8 +109,9 @@ gboolean cogl_is_shader (CoglHandle handle);
* Replaces the current GLSL source associated with a shader with a new
* one.
*/
void cogl_shader_source (CoglHandle shader,
const gchar *source);
void
cogl_shader_source (CoglHandle shader,
const char *source);
/**
* cogl_shader_compile:
* @handle: #CoglHandle for a shader.
@ -115,7 +119,8 @@ void cogl_shader_source (CoglHandle shader,
* Compiles the shader, no return value, but the shader is now ready for
* linking into a program.
*/
void cogl_shader_compile (CoglHandle handle);
void
cogl_shader_compile (CoglHandle handle);
/**
* cogl_shader_get_info_log:
@ -129,7 +134,8 @@ void cogl_shader_compile (CoglHandle handle);
* Return value: a newly allocated string containing the info log. Use
* g_free() to free it
*/
gchar * cogl_shader_get_info_log (CoglHandle handle);
char *
cogl_shader_get_info_log (CoglHandle handle);
/**
* cogl_shader_get_type:
@ -140,7 +146,8 @@ gchar * cogl_shader_get_info_log (CoglHandle handle);
* Return value: %COGL_SHADER_TYPE_VERTEX if the shader is a vertex processor
* or %COGL_SHADER_TYPE_FRAGMENT if the shader is a frament processor
*/
CoglShaderType cogl_shader_get_type (CoglHandle handle);
CoglShaderType
cogl_shader_get_type (CoglHandle handle);
/**
* cogl_shader_is_compiled:
@ -150,7 +157,8 @@ CoglShaderType cogl_shader_get_type (CoglHandle handle);
*
* Return value: %TRUE if the shader object has sucessfully be compiled
*/
gboolean cogl_shader_is_compiled (CoglHandle handle);
gboolean
cogl_shader_is_compiled (CoglHandle handle);
/**
* cogl_create_program:
@ -160,7 +168,8 @@ gboolean cogl_shader_is_compiled (CoglHandle handle);
*
* Returns: a new cogl program.
*/
CoglHandle cogl_create_program (void);
CoglHandle
cogl_create_program (void);
/**
* cogl_program_ref:
@ -170,7 +179,8 @@ CoglHandle cogl_create_program (void);
*
* Returns: @handle
*/
CoglHandle cogl_program_ref (CoglHandle handle);
CoglHandle
cogl_program_ref (CoglHandle handle);
/**
* cogl_program_unref:
@ -179,7 +189,8 @@ CoglHandle cogl_program_ref (CoglHandle handle);
* Removes a reference to a program. If it was the last reference the
* program object will be destroyed.
*/
void cogl_program_unref (CoglHandle handle);
void
cogl_program_unref (CoglHandle handle);
/**
* cogl_is_program:
@ -190,7 +201,8 @@ void cogl_program_unref (CoglHandle handle);
* Returns: %TRUE if the handle references a program,
* %FALSE otherwise
*/
gboolean cogl_is_program (CoglHandle handle);
gboolean
cogl_is_program (CoglHandle handle);
/**
* cogl_program_attach_shader:
@ -200,8 +212,9 @@ gboolean cogl_is_program (CoglHandle handle);
* Attaches a shader to a program object, a program can have one vertex shader
* and one fragment shader attached.
*/
void cogl_program_attach_shader (CoglHandle program_handle,
CoglHandle shader_handle);
void
cogl_program_attach_shader (CoglHandle program_handle,
CoglHandle shader_handle);
/**
@ -210,7 +223,8 @@ void cogl_program_attach_shader (CoglHandle program_handle,
*
* Links a program making it ready for use.
*/
void cogl_program_link (CoglHandle handle);
void
cogl_program_link (CoglHandle handle);
/**
* cogl_program_use:
@ -220,7 +234,8 @@ void cogl_program_link (CoglHandle handle);
* rendering pipeline, if passed in %COGL_INVALID_HANDLE the default
* behavior of GL is reinstated.
*/
void cogl_program_use (CoglHandle handle);
void
cogl_program_use (CoglHandle handle);
/**
* cogl_program_get_uniform_location:
@ -235,9 +250,9 @@ void cogl_program_use (CoglHandle handle);
* This uniform can be set using cogl_program_uniform_1f() when the
* program is in use.
*/
int cogl_program_get_uniform_location
(CoglHandle handle,
const char *uniform_name);
int
cogl_program_get_uniform_location (CoglHandle handle,
const char *uniform_name);
/**
* cogl_program_uniform_1f:
@ -247,8 +262,9 @@ int cogl_program_get_uniform_location
* Changes the value of a floating point uniform in the currently
* used (see cogl_program_use()) shader program.
*/
void cogl_program_uniform_1f (int uniform_no,
float value);
void
cogl_program_uniform_1f (int uniform_no,
float value);
/**
* cogl_program_uniform_1i:
@ -258,8 +274,9 @@ void cogl_program_uniform_1f (int uniform_no,
* Changes the value of an integer uniform in the currently
* used (see cogl_program_use()) shader program.
*/
void cogl_program_uniform_1i (int uniform_no,
int value);
void
cogl_program_uniform_1i (int uniform_no,
int value);
/**
* cogl_program_uniform_float:
@ -271,10 +288,11 @@ void cogl_program_uniform_1i (int uniform_no,
* Changes the value of a float vector uniform, or uniform array in the
* currently used (see cogl_program_use()) shader program.
*/
void cogl_program_uniform_float (int uniform_no,
int size,
int count,
const GLfloat *value);
void
cogl_program_uniform_float (int uniform_no,
int size,
int count,
const GLfloat *value);
/**
* cogl_program_uniform_int:
@ -286,10 +304,11 @@ void cogl_program_uniform_float (int uniform_no,
* Changes the value of a int vector uniform, or uniform array in the
* currently used (see cogl_program_use()) shader program.
*/
void cogl_program_uniform_int (int uniform_no,
int size,
int count,
const int *value);
void
cogl_program_uniform_int (int uniform_no,
int size,
int count,
const int *value);
/**
* cogl_program_uniform_matrix:
@ -303,11 +322,12 @@ void cogl_program_uniform_int (int uniform_no,
* currently used (see cogl_program_use()) shader program. The @size
* parameter is used to determine the square size of the matrix.
*/
void cogl_program_uniform_matrix (int uniform_no,
int size,
int count,
gboolean transpose,
const float *value);
void
cogl_program_uniform_matrix (int uniform_no,
int size,
int count,
gboolean transpose,
const float *value);
G_END_DECLS

14
clutter/cogl/cogl/cogl-sub-texture-private.h
View File

@ -38,10 +38,10 @@ struct _CoglSubTexture
CoglHandle full_texture;
/* The region represented by this sub-texture */
gint sub_x;
gint sub_y;
gint sub_width;
gint sub_height;
int sub_x;
int sub_y;
int sub_width;
int sub_height;
};
GQuark
@ -49,7 +49,9 @@ _cogl_handle_sub_texture_get_type (void);
CoglHandle
_cogl_sub_texture_new (CoglHandle full_texture,
gint sub_x, gint sub_y,
gint sub_width, gint sub_height);
int sub_x,
int sub_y,
int sub_width,
int sub_height);
#endif /* __COGL_SUB_TEXTURE_H */

70
clutter/cogl/cogl/cogl-sub-texture.c
View File

@ -3,7 +3,7 @@
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2009 Intel Corporation.
* Copyright (C) 2009,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
@ -47,12 +47,12 @@ COGL_HANDLE_DEFINE (SubTexture, sub_texture);
static const CoglTextureVtable cogl_sub_texture_vtable;
static void
_cogl_sub_texture_map_range (gfloat *t1, gfloat *t2,
gint sub_offset,
gint sub_size,
gint full_size)
_cogl_sub_texture_map_range (float *t1, float *t2,
int sub_offset,
int sub_size,
int full_size)
{
gfloat t1_frac, t1_int, t2_frac, t2_int;
float t1_frac, t1_int, t2_frac, t2_int;
t1_frac = modff (*t1, &t1_int);
t2_frac = modff (*t2, &t2_int);
@ -98,10 +98,10 @@ _cogl_sub_texture_map_range (gfloat *t1, gfloat *t2,
static void
_cogl_sub_texture_map_quad (CoglSubTexture *sub_tex,
gfloat *coords)
float *coords)
{
guint full_width = cogl_texture_get_width (sub_tex->full_texture);
guint full_height = cogl_texture_get_height (sub_tex->full_texture);
unsigned int full_width = cogl_texture_get_width (sub_tex->full_texture);
unsigned int full_height = cogl_texture_get_height (sub_tex->full_texture);
_cogl_sub_texture_map_range (coords + 0, coords + 2,
sub_tex->sub_x, sub_tex->sub_width,
@ -113,13 +113,13 @@ _cogl_sub_texture_map_quad (CoglSubTexture *sub_tex,
/* Maps from the texture coordinates of the full texture to the
texture coordinates of the sub texture */
static gfloat
_cogl_sub_texture_unmap_coord (gfloat t,
gint sub_offset,
gint sub_size,
gint full_size)
static float
_cogl_sub_texture_unmap_coord (float t,
int sub_offset,
int sub_size,
int full_size)
{
gfloat frac_part, int_part;
float frac_part, int_part;
/* Convert the fractional part leaving the integer part in tact */
frac_part = modff (t, &int_part);
@ -135,11 +135,11 @@ _cogl_sub_texture_unmap_coord (gfloat t,
static void
_cogl_sub_texture_unmap_coords (CoglSubTexture *sub_tex,
gfloat *s,
gfloat *t)
float *s,
float *t)
{
guint full_width = cogl_texture_get_width (sub_tex->full_texture);
guint full_height = cogl_texture_get_height (sub_tex->full_texture);
unsigned int full_width = cogl_texture_get_width (sub_tex->full_texture);
unsigned int full_height = cogl_texture_get_height (sub_tex->full_texture);
*s = _cogl_sub_texture_unmap_coord (*s, sub_tex->sub_x, sub_tex->sub_width,
full_width);
@ -242,12 +242,12 @@ _cogl_sub_texture_free (CoglSubTexture *sub_tex)
CoglHandle
_cogl_sub_texture_new (CoglHandle full_texture,
gint sub_x, gint sub_y,
gint sub_width, gint sub_height)
int sub_x, int sub_y,
int sub_width, int sub_height)
{
CoglSubTexture *sub_tex;
CoglTexture *tex;
guint full_width, full_height;
unsigned int full_width, full_height;
full_width = cogl_texture_get_width (full_texture);
full_height = cogl_texture_get_height (full_texture);
@ -273,7 +273,7 @@ _cogl_sub_texture_new (CoglHandle full_texture,
return _cogl_sub_texture_handle_new (sub_tex);
}
static gint
static int
_cogl_sub_texture_get_max_waste (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
@ -403,14 +403,14 @@ _cogl_sub_texture_set_region (CoglTexture *tex,
}
static void
_cogl_sub_texture_copy_region (guchar *dst,
const guchar *src,
gint dst_x, gint dst_y,
gint src_x, gint src_y,
gint width, gint height,
gint dst_rowstride,
gint src_rowstride,
gint bpp)
_cogl_sub_texture_copy_region (guint8 *dst,
const guint8 *src,
int dst_x, int dst_y,
int src_x, int src_y,
int width, int height,
int dst_rowstride,
int src_rowstride,
int bpp)
{
int y;
@ -435,8 +435,8 @@ _cogl_sub_texture_get_data (CoglTexture *tex,
unsigned int full_rowstride;
guint8 *full_data;
int byte_size, full_size;
gint bpp;
gint full_tex_width, full_tex_height;
int bpp;
int full_tex_width, full_tex_height;
/* FIXME: This gets the full data from the full texture and then
copies a subregion of that. It would be better if there was a
@ -500,7 +500,7 @@ _cogl_sub_texture_get_gl_format (CoglTexture *tex)
return _cogl_texture_get_gl_format (sub_tex->full_texture);
}
static gint
static int
_cogl_sub_texture_get_width (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
@ -508,7 +508,7 @@ _cogl_sub_texture_get_width (CoglTexture *tex)
return sub_tex->sub_width;
}
static gint
static int
_cogl_sub_texture_get_height (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);

4
clutter/cogl/cogl/cogl-texture-2d-private.h
View File

@ -43,8 +43,8 @@ struct _CoglTexture2D
GLenum gl_format;
/* The texture object number */
GLuint gl_texture;
gint width;
gint height;
int width;
int height;
GLenum min_filter;
GLenum mag_filter;
GLint wrap_mode;

6
clutter/cogl/cogl/cogl-texture-2d-sliced-private.h
View File

@ -52,7 +52,7 @@ struct _CoglTexture2DSliced
GArray *slice_x_spans;
GArray *slice_y_spans;
GArray *slice_gl_handles;
gint max_waste;
int max_waste;
/* The internal format of the GL texture represented as a
CoglPixelFormat */
@ -60,8 +60,8 @@ struct _CoglTexture2DSliced
/* The internal format of the GL texture represented as a GL enum */
GLenum gl_format;
GLenum gl_target;
gint width;
gint height;
int width;
int height;
GLenum min_filter;
GLenum mag_filter;
gboolean is_foreign;

163
clutter/cogl/cogl/cogl-texture-2d-sliced.c
View File

@ -181,13 +181,13 @@ _cogl_texture_2d_sliced_foreach_sub_texture_in_region (
}
}
static guchar *
static guint8 *
_cogl_texture_2d_sliced_allocate_waste_buffer (CoglTexture2DSliced *tex_2ds,
CoglPixelFormat format)
{
CoglSpan *last_x_span;
CoglSpan *last_y_span;
guchar *waste_buf = NULL;
guint8 *waste_buf = NULL;
/* If the texture has any waste then allocate a buffer big enough to
fill the gaps */
@ -197,13 +197,13 @@ _cogl_texture_2d_sliced_allocate_waste_buffer (CoglTexture2DSliced *tex_2ds,
tex_2ds->slice_y_spans->len - 1);
if (last_x_span->waste > 0 || last_y_span->waste > 0)
{
gint bpp = _cogl_get_format_bpp (format);
int bpp = _cogl_get_format_bpp (format);
CoglSpan *first_x_span
= &g_array_index (tex_2ds->slice_x_spans, CoglSpan, 0);
CoglSpan *first_y_span
= &g_array_index (tex_2ds->slice_y_spans, CoglSpan, 0);
guint right_size = first_y_span->size * last_x_span->waste;
guint bottom_size = first_x_span->size * last_y_span->waste;
unsigned int right_size = first_y_span->size * last_x_span->waste;
unsigned int bottom_size = first_x_span->size * last_y_span->waste;
waste_buf = g_malloc (MAX (right_size, bottom_size) * bpp);
}
@ -220,10 +220,10 @@ _cogl_texture_2d_sliced_upload_to_gl (CoglTexture2DSliced *tex_2ds,
{
CoglSpan *x_span;
CoglSpan *y_span;
GLuint gl_handle;
gint bpp;
gint x,y;
guchar *waste_buf;
GLuint gl_handle;
int bpp;
int x, y;
guint8 *waste_buf;
bpp = _cogl_get_format_bpp (bmp->format);
@ -238,7 +238,7 @@ _cogl_texture_2d_sliced_upload_to_gl (CoglTexture2DSliced *tex_2ds,
/* Iterate horizontal slices */
for (x = 0; x < tex_2ds->slice_x_spans->len; ++x)
{
gint slice_num = y * tex_2ds->slice_x_spans->len + x;
int slice_num = y * tex_2ds->slice_x_spans->len + x;
x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan, x);
@ -272,11 +272,11 @@ _cogl_texture_2d_sliced_upload_to_gl (CoglTexture2DSliced *tex_2ds,
/* Fill the waste with a copies of the rightmost pixels */
if (x_span->waste > 0)
{
const guchar *src = bmp->data
const guint8 *src = bmp->data
+ y_span->start * bmp->rowstride
+ (x_span->start + x_span->size - x_span->waste - 1) * bpp;
guchar *dst = waste_buf;
guint wx, wy;
guint8 *dst = waste_buf;
unsigned int wx, wy;
for (wy = 0; wy < y_span->size - y_span->waste; wy++)
{
@ -303,12 +303,12 @@ _cogl_texture_2d_sliced_upload_to_gl (CoglTexture2DSliced *tex_2ds,
if (y_span->waste > 0)
{
const guchar *src = bmp->data
const guint8 *src = bmp->data
+ ((y_span->start + y_span->size - y_span->waste - 1)
* bmp->rowstride)
+ x_span->start * bpp;
guchar *dst = waste_buf;
guint wy, wx;
guint8 *dst = waste_buf;
unsigned int wy, wx;
for (wy = 0; wy < y_span->waste; wy++)
{
@ -347,26 +347,26 @@ _cogl_texture_2d_sliced_upload_to_gl (CoglTexture2DSliced *tex_2ds,
static gboolean
_cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
gint src_x,
gint src_y,
gint dst_x,
gint dst_y,
gint width,
gint height,
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height,
CoglBitmap *source_bmp,
GLuint source_gl_format,
GLuint source_gl_type)
{
CoglSpan *x_span;
CoglSpan *y_span;
gint bpp;
int bpp;
CoglSpanIter x_iter;
CoglSpanIter y_iter;
GLuint gl_handle;
gint source_x = 0, source_y = 0;
gint inter_w = 0, inter_h = 0;
gint local_x = 0, local_y = 0;
guchar *waste_buf;
int source_x = 0, source_y = 0;
int inter_w = 0, inter_h = 0;
int local_x = 0, local_y = 0;
guint8 *waste_buf;
bpp = _cogl_get_format_bpp (source_bmp->format);
@ -409,7 +409,7 @@ _cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
_cogl_span_iter_next (&x_iter),
source_x += inter_w )
{
gint slice_num;
int slice_num;
/* Discard slices out of the subregion early */
if (!x_iter.intersects)
@ -464,9 +464,9 @@ _cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
&& local_x < x_span->size - x_span->waste
&& local_x + inter_w >= x_span->size - x_span->waste)
{
const guchar *src;
guchar *dst;
guint wx, wy;
const guint8 *src;
guint8 *dst;
unsigned int wx, wy;
src = source_bmp->data
+ (src_y + ((int)y_iter.intersect_start)
@ -507,10 +507,10 @@ _cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
&& local_y < y_span->size - y_span->waste
&& local_y + inter_h >= y_span->size - y_span->waste)
{
const guchar *src;
guchar *dst;
guint wy, wx;
guint copy_width;
const guint8 *src;
guint8 *dst;
unsigned int wy, wx;
unsigned int copy_width;
src = source_bmp->data
+ (src_x + ((int)x_iter.intersect_start)
@ -563,13 +563,13 @@ _cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
return TRUE;
}
static gint
static int
_cogl_rect_slices_for_size (int size_to_fill,
int max_span_size,
int max_waste,
GArray *out_spans)
{
int n_spans = 0;
int n_spans = 0;
CoglSpan span;
/* Init first slice span */
@ -600,13 +600,13 @@ _cogl_rect_slices_for_size (int size_to_fill,
return n_spans;
}
static gint
_cogl_pot_slices_for_size (gint size_to_fill,
gint max_span_size,
gint max_waste,
static int
_cogl_pot_slices_for_size (int size_to_fill,
int max_span_size,
int max_waste,
GArray *out_spans)
{
gint n_spans = 0;
int n_spans = 0;
CoglSpan span;
/* Init first slice span */
@ -686,23 +686,23 @@ _cogl_texture_2d_sliced_set_wrap_mode_parameter (CoglTexture *tex,
static gboolean
_cogl_texture_2d_sliced_slices_create (CoglTexture2DSliced *tex_2ds,
gint width, gint height,
int width, int height,
GLenum gl_intformat,
GLenum gl_format,
GLenum gl_type)
{
gint max_width;
gint max_height;
GLuint *gl_handles;
gint n_x_slices;
gint n_y_slices;
gint n_slices;
gint x, y;
int max_width;
int max_height;
GLuint *gl_handles;
int n_x_slices;
int n_y_slices;
int n_slices;
int x, y;
CoglSpan *x_span;
CoglSpan *y_span;
const GLfloat transparent_color[4] = { 0x00, 0x00, 0x00, 0x00 };
const GLfloat transparent_color[4] = { 0x00, 0x00, 0x00, 0x00 };
gint (*slices_for_size) (gint, gint, gint, GArray*);
int (*slices_for_size) (int, int, int, GArray*);
/* Initialize size of largest slice according to supported features */
if (cogl_features_available (COGL_FEATURE_TEXTURE_NPOT))
@ -1096,8 +1096,8 @@ _cogl_texture_2d_sliced_new_from_foreign (GLuint gl_handle,
GLint gl_gen_mipmap;
CoglTexture2DSliced *tex_2ds;
CoglTexture *tex;
CoglSpan x_span;
CoglSpan y_span;
CoglSpan x_span;
CoglSpan y_span;
if (!_cogl_texture_driver_allows_foreign_gl_target (gl_target))
return COGL_INVALID_HANDLE;
@ -1228,7 +1228,7 @@ _cogl_texture_2d_sliced_new_from_foreign (GLuint gl_handle,
return _cogl_texture_2d_sliced_handle_new (tex_2ds);
}
static gint
static int
_cogl_texture_2d_sliced_get_max_waste (CoglTexture *tex)
{
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
@ -1427,7 +1427,7 @@ _cogl_texture_2d_sliced_set_region (CoglTexture *tex,
const guint8 *data)
{
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
gint bpp;
int bpp;
CoglBitmap source_bmp;
CoglBitmap tmp_bmp;
gboolean tmp_bmp_owner = FALSE;
@ -1446,7 +1446,7 @@ _cogl_texture_2d_sliced_set_region (CoglTexture *tex,
source_bmp.width = width;
source_bmp.height = height;
source_bmp.format = format;
source_bmp.data = (guchar*)data;
source_bmp.data = (guint8 *)data;
/* Rowstride from width if none specified */
bpp = _cogl_get_format_bpp (format);
@ -1489,10 +1489,10 @@ _cogl_texture_2d_sliced_download_from_gl (
{
CoglSpan *x_span;
CoglSpan *y_span;
GLuint gl_handle;
gint bpp;
gint x,y;
CoglBitmap slice_bmp;
GLuint gl_handle;
int bpp;
int x, y;
CoglBitmap slice_bmp;
bpp = _cogl_get_format_bpp (target_bmp->format);
@ -1521,8 +1521,8 @@ _cogl_texture_2d_sliced_download_from_gl (
slice_bmp.width = x_span->size;
slice_bmp.height = y_span->size;
slice_bmp.rowstride = bpp * slice_bmp.width;
slice_bmp.data = (guchar*) g_malloc (slice_bmp.rowstride *
slice_bmp.height);
slice_bmp.data = g_malloc (slice_bmp.rowstride *
slice_bmp.height);
/* Setup gl alignment to 0,0 top-left corner */
_cogl_texture_driver_prep_gl_for_pixels_download (
@ -1587,18 +1587,18 @@ _cogl_texture_2d_sliced_get_data (CoglTexture *tex,
guint8 *data)
{
CoglTexture2DSliced *tex_2ds = COGL_TEXTURE_2D_SLICED (tex);
gint bpp;
gint byte_size;
CoglPixelFormat closest_format;
gint closest_bpp;
GLenum closest_gl_format;
GLenum closest_gl_type;
CoglBitmap target_bmp;
CoglBitmap new_bmp;
gboolean success;
guchar *src;
guchar *dst;
gint y;
int bpp;
int byte_size;
CoglPixelFormat closest_format;
int closest_bpp;
GLenum closest_gl_format;
GLenum closest_gl_type;
CoglBitmap target_bmp;
CoglBitmap new_bmp;
gboolean success;
guint8 *src;
guint8 *dst;
int y;
/* Default to internal format if none specified */
if (format == COGL_PIXEL_FORMAT_ANY)
@ -1606,11 +1606,13 @@ _cogl_texture_2d_sliced_get_data (CoglTexture *tex,
/* Rowstride from texture width if none specified */
bpp = _cogl_get_format_bpp (format);
if (rowstride == 0) rowstride = tex_2ds->width * bpp;
if (rowstride == 0)
rowstride = tex_2ds->width * bpp;
/* Return byte size if only that requested */
byte_size = tex_2ds->height * rowstride;
if (data == NULL) return byte_size;
if (data == NULL)
return byte_size;
closest_format =
_cogl_texture_driver_find_best_gl_get_data_format (format,
@ -1634,8 +1636,7 @@ _cogl_texture_2d_sliced_get_data (CoglTexture *tex,
/* Target intermediate buffer */
target_bmp.format = closest_format;
target_bmp.rowstride = target_bmp.width * closest_bpp;
target_bmp.data = (guchar*) g_malloc (target_bmp.height
* target_bmp.rowstride);
target_bmp.data = g_malloc (target_bmp.height * target_bmp.rowstride);
}
/* Retrieve data from slices */
@ -1691,13 +1692,13 @@ _cogl_texture_2d_sliced_get_gl_format (CoglTexture *tex)
return COGL_TEXTURE_2D_SLICED (tex)->gl_format;
}
static gint
static int
_cogl_texture_2d_sliced_get_width (CoglTexture *tex)
{
return COGL_TEXTURE_2D_SLICED (tex)->width;
}
static gint
static int
_cogl_texture_2d_sliced_get_height (CoglTexture *tex)
{
return COGL_TEXTURE_2D_SLICED (tex)->height;

34
clutter/cogl/cogl/cogl-texture-2d.c
View File

@ -316,7 +316,7 @@ _cogl_texture_2d_new_from_bitmap (CoglHandle bmp_handle,
return _cogl_texture_2d_handle_new (tex_2d);
}
static gint
static int
_cogl_texture_2d_get_max_waste (CoglTexture *tex)
{
return -1;
@ -430,7 +430,7 @@ _cogl_texture_2d_set_region (CoglTexture *tex,
const guint8 *data)
{
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
gint bpp;
int bpp;
CoglBitmap source_bmp;
CoglBitmap tmp_bmp;
gboolean tmp_bmp_owner = FALSE;
@ -449,7 +449,7 @@ _cogl_texture_2d_set_region (CoglTexture *tex,
source_bmp.width = width;
source_bmp.height = height;
source_bmp.format = format;
source_bmp.data = (guchar*) data;
source_bmp.data = (guint8 *)data;
/* Rowstride from width if none specified */
bpp = _cogl_get_format_bpp (format);
@ -490,18 +490,18 @@ _cogl_texture_2d_get_data (CoglTexture *tex,
guint8 *data)
{
CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
gint bpp;
gint byte_size;
int bpp;
int byte_size;
CoglPixelFormat closest_format;
gint closest_bpp;
int closest_bpp;
GLenum closest_gl_format;
GLenum closest_gl_type;
CoglBitmap target_bmp;
CoglBitmap new_bmp;
gboolean success;
guchar *src;
guchar *dst;
gint y;
guint8 *src;
guint8 *dst;
int y;
/* Default to internal format if none specified */
if (format == COGL_PIXEL_FORMAT_ANY)
@ -509,11 +509,13 @@ _cogl_texture_2d_get_data (CoglTexture *tex,
/* Rowstride from texture width if none specified */
bpp = _cogl_get_format_bpp (format);
if (rowstride == 0) rowstride = tex_2d->width * bpp;
if (rowstride == 0)
rowstride = tex_2d->width * bpp;
/* Return byte size if only that requested */
byte_size = tex_2d->height * rowstride;
if (data == NULL) return byte_size;
if (data == NULL)
return byte_size;
closest_format =
_cogl_texture_driver_find_best_gl_get_data_format (format,
@ -537,8 +539,7 @@ _cogl_texture_2d_get_data (CoglTexture *tex,
/* Target intermediate buffer */
target_bmp.format = closest_format;
target_bmp.rowstride = target_bmp.width * closest_bpp;
target_bmp.data = (guchar*) g_malloc (target_bmp.height
* target_bmp.rowstride);
target_bmp.data = g_malloc (target_bmp.height * target_bmp.rowstride);
}
GE( glBindTexture (GL_TEXTURE_2D, tex_2d->gl_texture) );
@ -566,7 +567,8 @@ _cogl_texture_2d_get_data (CoglTexture *tex,
/* Free intermediate data and return if failed */
g_free (target_bmp.data);
if (!success) return 0;
if (!success)
return 0;
/* Copy to user buffer */
for (y = 0; y < new_bmp.height; ++y)
@ -595,13 +597,13 @@ _cogl_texture_2d_get_gl_format (CoglTexture *tex)
return COGL_TEXTURE_2D (tex)->gl_format;
}
static gint
static int
_cogl_texture_2d_get_width (CoglTexture *tex)
{
return COGL_TEXTURE_2D (tex)->width;
}
static gint
static int
_cogl_texture_2d_get_height (CoglTexture *tex)
{
return COGL_TEXTURE_2D (tex)->height;

6
clutter/cogl/cogl/cogl-texture-private.h
View File

@ -74,7 +74,7 @@ struct _CoglTextureVtable
CoglTextureSliceCallback callback,
void *user_data);
gint (* get_max_waste) (CoglTexture *tex);
int (* get_max_waste) (CoglTexture *tex);
gboolean (* is_sliced) (CoglTexture *tex);
@ -102,8 +102,8 @@ struct _CoglTextureVtable
CoglPixelFormat (* get_format) (CoglTexture *tex);
GLenum (* get_gl_format) (CoglTexture *tex);
gint (* get_width) (CoglTexture *tex);
gint (* get_height) (CoglTexture *tex);
int (* get_width) (CoglTexture *tex);
int (* get_height) (CoglTexture *tex);
};
struct _CoglTexture

106
clutter/cogl/cogl/cogl-texture.c
View File

@ -224,15 +224,15 @@ _cogl_texture_set_wrap_mode_parameter (CoglHandle handle,
effectively assumes there is only one span from 0.0 to 1.0 */
typedef struct _CoglTextureIter
{
gfloat pos, end, next_pos;
float pos, end, next_pos;
gboolean flipped;
gfloat t_1, t_2;
float t_1, t_2;
} CoglTextureIter;
static void
_cogl_texture_iter_update (CoglTextureIter *iter)
{
gfloat t_2;
float t_2;
float frac_part;
frac_part = modff (iter->pos, &iter->next_pos);
@ -261,7 +261,7 @@ _cogl_texture_iter_update (CoglTextureIter *iter)
static void
_cogl_texture_iter_begin (CoglTextureIter *iter,
gfloat t_1, gfloat t_2)
float t_1, float t_2)
{
if (t_1 <= t_2)
{
@ -316,8 +316,8 @@ _cogl_texture_iterate_manual_repeats (CoglTextureManualRepeatCallback callback,
}
CoglHandle
cogl_texture_new_with_size (guint width,
guint height,
cogl_texture_new_with_size (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat internal_format)
{
@ -337,13 +337,13 @@ cogl_texture_new_with_size (guint width,
}
CoglHandle
cogl_texture_new_from_data (guint width,
guint height,
cogl_texture_new_from_data (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
guint rowstride,
const guchar *data)
unsigned int rowstride,
const guint8 *data)
{
CoglBitmap bitmap;
@ -360,7 +360,7 @@ cogl_texture_new_from_data (guint width,
/* Wrap the data into a bitmap */
bitmap.width = width;
bitmap.height = height;
bitmap.data = (guchar *) data;
bitmap.data = (guint8 *) data;
bitmap.format = format;
bitmap.rowstride = rowstride;
@ -393,7 +393,7 @@ cogl_texture_new_from_bitmap (CoglHandle bmp_handle,
}
CoglHandle
cogl_texture_new_from_file (const gchar *filename,
cogl_texture_new_from_file (const char *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
GError **error)
@ -445,24 +445,24 @@ cogl_texture_new_from_foreign (GLuint gl_handle,
CoglHandle
cogl_texture_new_from_sub_texture (CoglHandle full_texture,
gint sub_x,
gint sub_y,
gint sub_width,
gint sub_height)
int sub_x,
int sub_y,
int sub_width,
int sub_height)
{
return _cogl_sub_texture_new (full_texture, sub_x, sub_y,
sub_width, sub_height);
}
CoglHandle
cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
guint width,
guint height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
guint rowstride,
const guint offset)
cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
unsigned int rowstride,
const unsigned int offset)
{
CoglHandle texture;
CoglBuffer *cogl_buffer;
@ -526,7 +526,7 @@ cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
return texture;
}
guint
unsigned int
cogl_texture_get_width (CoglHandle handle)
{
CoglTexture *tex;
@ -539,7 +539,7 @@ cogl_texture_get_width (CoglHandle handle)
return tex->vtable->get_width (tex);
}
guint
unsigned int
cogl_texture_get_height (CoglHandle handle)
{
CoglTexture *tex;
@ -565,7 +565,7 @@ cogl_texture_get_format (CoglHandle handle)
return tex->vtable->get_format (tex);
}
guint
unsigned int
cogl_texture_get_rowstride (CoglHandle handle)
{
CoglTexture *tex;
@ -584,7 +584,7 @@ cogl_texture_get_rowstride (CoglHandle handle)
* cogl_texture_get_width (tex));
}
gint
int
cogl_texture_get_max_waste (CoglHandle handle)
{
CoglTexture *tex;
@ -739,17 +739,17 @@ _cogl_texture_ensure_non_quad_rendering (CoglHandle handle)
gboolean
cogl_texture_set_region (CoglHandle handle,
gint src_x,
gint src_y,
gint dst_x,
gint dst_y,
guint dst_width,
guint dst_height,
gint width,
gint height,
int src_x,
int src_y,
int dst_x,
int dst_y,
unsigned int dst_width,
unsigned int dst_height,
int width,
int height,
CoglPixelFormat format,
guint rowstride,
const guchar *data)
unsigned int rowstride,
const guint8 *data)
{
CoglTexture *tex;
@ -786,14 +786,14 @@ do_texture_draw_and_read (CoglHandle handle,
CoglBitmap *target_bmp,
GLint *viewport)
{
gint bpp;
int bpp;
float rx1, ry1;
float rx2, ry2;
float tx1, ty1;
float tx2, ty2;
int bw, bh;
CoglBitmap rect_bmp;
guint tex_width, tex_height;
unsigned int tex_width, tex_height;
bpp = _cogl_get_format_bpp (COGL_PIXEL_FORMAT_RGBA_8888);
@ -840,8 +840,8 @@ do_texture_draw_and_read (CoglHandle handle,
rect_bmp.width = rx2 - rx1;
rect_bmp.height = ry2 - ry1;
rect_bmp.rowstride = bpp * rect_bmp.width;
rect_bmp.data = (guchar*) g_malloc (rect_bmp.rowstride *
rect_bmp.height);
rect_bmp.data = g_malloc (rect_bmp.rowstride *
rect_bmp.height);
_cogl_texture_driver_prep_gl_for_pixels_download (rect_bmp.rowstride,
bpp);
@ -877,7 +877,7 @@ _cogl_texture_draw_and_read (CoglHandle handle,
GLuint target_gl_format,
GLuint target_gl_type)
{
gint bpp;
int bpp;
CoglHandle framebuffer;
int viewport[4];
CoglBitmap alpha_bmp;
@ -951,19 +951,19 @@ _cogl_texture_draw_and_read (CoglHandle handle,
printf ("A bits: %d\n", a_bits); */
if ((cogl_texture_get_format (handle) & COGL_A_BIT)/* && a_bits == 0*/)
{
guchar *srcdata;
guchar *dstdata;
guchar *srcpixel;
guchar *dstpixel;
gint x,y;
guint8 *srcdata;
guint8 *dstdata;
guint8 *srcpixel;
guint8 *dstpixel;
int x,y;
/* Create temp bitmap for alpha values */
alpha_bmp.format = COGL_PIXEL_FORMAT_RGBA_8888;
alpha_bmp.width = target_bmp->width;
alpha_bmp.height = target_bmp->height;
alpha_bmp.rowstride = bpp * alpha_bmp.width;
alpha_bmp.data = (guchar*) g_malloc (alpha_bmp.rowstride *
alpha_bmp.height);
alpha_bmp.data = g_malloc (alpha_bmp.rowstride *
alpha_bmp.height);
/* Draw alpha values into RGB channels */
cogl_material_set_layer_combine (ctx->texture_download_material,
@ -1003,11 +1003,11 @@ _cogl_texture_draw_and_read (CoglHandle handle,
return TRUE;
}
gint
int
cogl_texture_get_data (CoglHandle handle,
CoglPixelFormat format,
guint rowstride,
guchar *data)
unsigned int rowstride,
guint8 *data)
{
CoglTexture *tex;

220
clutter/cogl/cogl/cogl-texture.h
View File

@ -3,7 +3,7 @@
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2007,2008,2009 Intel Corporation.
* Copyright (C) 2007,2008,2009,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
@ -59,10 +59,11 @@ G_BEGIN_DECLS
*
* Since: 0.8
*/
CoglHandle cogl_texture_new_with_size (guint width,
guint height,
CoglTextureFlags flags,
CoglPixelFormat internal_format);
CoglHandle
cogl_texture_new_with_size (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat internal_format);
/**
* cogl_texture_new_from_file:
@ -85,10 +86,11 @@ CoglHandle cogl_texture_new_with_size (guint width,
*
* Since: 0.8
*/
CoglHandle cogl_texture_new_from_file (const gchar *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
GError **error);
CoglHandle
cogl_texture_new_from_file (const char *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
GError **error);
/**
* cogl_texture_new_from_data:
@ -115,13 +117,14 @@ CoglHandle cogl_texture_new_from_file (const gchar *filename,
*
* Since: 0.8
*/
CoglHandle cogl_texture_new_from_data (guint width,
guint height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
guint rowstride,
const guchar *data);
CoglHandle
cogl_texture_new_from_data (unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
unsigned int rowstride,
const guint8 *data);
/**
* cogl_texture_new_from_foreign:
@ -142,13 +145,14 @@ CoglHandle cogl_texture_new_from_data (guint width,
*
* Since: 0.8
*/
CoglHandle cogl_texture_new_from_foreign (GLuint gl_handle,
GLenum gl_target,
GLuint width,
GLuint height,
GLuint x_pot_waste,
GLuint y_pot_waste,
CoglPixelFormat format);
CoglHandle
cogl_texture_new_from_foreign (GLuint gl_handle,
GLenum gl_target,
GLuint width,
GLuint height,
GLuint x_pot_waste,
GLuint y_pot_waste,
CoglPixelFormat format);
/**
* cogl_texture_new_from_bitmap:
@ -164,9 +168,10 @@ CoglHandle cogl_texture_new_from_foreign (GLuint gl_handle,
*
* Since: 1.0
*/
CoglHandle cogl_texture_new_from_bitmap (CoglHandle bmp_handle,
CoglTextureFlags flags,
CoglPixelFormat internal_format);
CoglHandle
cogl_texture_new_from_bitmap (CoglHandle bmp_handle,
CoglTextureFlags flags,
CoglPixelFormat internal_format);
/**
* cogl_is_texture:
@ -177,7 +182,8 @@ CoglHandle cogl_texture_new_from_bitmap (CoglHandle bmp_handle,
* Return value: %TRUE if the handle references a texture, and
* %FALSE otherwise
*/
gboolean cogl_is_texture (CoglHandle handle);
gboolean
cogl_is_texture (CoglHandle handle);
/**
* cogl_texture_get_width:
@ -187,7 +193,8 @@ gboolean cogl_is_texture (CoglHandle handle);
*
* Return value: the width of the GPU side texture in pixels
*/
guint cogl_texture_get_width (CoglHandle handle);
unsigned int
cogl_texture_get_width (CoglHandle handle);
/**
* cogl_texture_get_height:
@ -197,7 +204,8 @@ guint cogl_texture_get_width (CoglHandle handle);
*
* Return value: the height of the GPU side texture in pixels
*/
guint cogl_texture_get_height (CoglHandle handle);
unsigned int
cogl_texture_get_height (CoglHandle handle);
/**
* cogl_texture_get_format:
@ -207,7 +215,8 @@ guint cogl_texture_get_height (CoglHandle handle);
*
* Return value: the #CoglPixelFormat of the GPU side texture
*/
CoglPixelFormat cogl_texture_get_format (CoglHandle handle);
CoglPixelFormat
cogl_texture_get_format (CoglHandle handle);
/**
@ -218,7 +227,8 @@ CoglPixelFormat cogl_texture_get_format (CoglHandle handle);
*
* Return value: the offset in bytes between each consequetive row of pixels
*/
guint cogl_texture_get_rowstride (CoglHandle handle);
unsigned int
cogl_texture_get_rowstride (CoglHandle handle);
/**
* cogl_texture_get_max_waste:
@ -229,7 +239,8 @@ guint cogl_texture_get_rowstride (CoglHandle handle);
*
* Return value: the maximum waste
*/
gint cogl_texture_get_max_waste (CoglHandle handle);
int
cogl_texture_get_max_waste (CoglHandle handle);
/**
* cogl_texture_is_sliced:
@ -241,7 +252,8 @@ gint cogl_texture_get_max_waste (CoglHandle handle);
* Return value: %TRUE if the texture is sliced, %FALSE if the texture
* is stored as a single GPU texture
*/
gboolean cogl_texture_is_sliced (CoglHandle handle);
gboolean
cogl_texture_is_sliced (CoglHandle handle);
/**
* cogl_texture_get_gl_texture:
@ -259,9 +271,10 @@ gboolean cogl_texture_is_sliced (CoglHandle handle);
* Return value: %TRUE if the handle was successfully retrieved, %FALSE
* if the handle was invalid
*/
gboolean cogl_texture_get_gl_texture (CoglHandle handle,
GLuint *out_gl_handle,
GLenum *out_gl_target);
gboolean
cogl_texture_get_gl_texture (CoglHandle handle,
GLuint *out_gl_handle,
GLenum *out_gl_target);
/**
* cogl_texture_get_data:
@ -277,10 +290,11 @@ gboolean cogl_texture_get_gl_texture (CoglHandle handle,
* Return value: the size of the texture data in bytes, or 0 if the texture
* is not valid
*/
gint cogl_texture_get_data (CoglHandle handle,
CoglPixelFormat format,
guint rowstride,
guchar *data);
int
cogl_texture_get_data (CoglHandle handle,
CoglPixelFormat format,
unsigned int rowstride,
guint8 *data);
/**
* cogl_texture_set_region:
@ -304,18 +318,19 @@ gint cogl_texture_get_data (CoglHandle handle,
* Return value: %TRUE if the subregion upload was successful, and
* %FALSE otherwise
*/
gboolean cogl_texture_set_region (CoglHandle handle,
gint src_x,
gint src_y,
gint dst_x,
gint dst_y,
guint dst_width,
guint dst_height,
gint width,
gint height,
CoglPixelFormat format,
guint rowstride,
const guchar *data);
gboolean
cogl_texture_set_region (CoglHandle handle,
int src_x,
int src_y,
int dst_x,
int dst_y,
unsigned int dst_width,
unsigned int dst_height,
int width,
int height,
CoglPixelFormat format,
unsigned int rowstride,
const guint8 *data);
/**
* cogl_texture_new_from_sub_texture:
@ -337,12 +352,12 @@ gboolean cogl_texture_set_region (CoglHandle handle,
*
* Since: 1.2
*/
CoglHandle cogl_texture_new_from_sub_texture
(CoglHandle full_texture,
gint sub_x,
gint sub_y,
gint sub_width,
gint sub_height);
CoglHandle
cogl_texture_new_from_sub_texture (CoglHandle full_texture,
int sub_x,
int sub_y,
int sub_width,
int sub_height);
#if defined (COGL_ENABLE_EXPERIMENTAL_API)
@ -376,29 +391,30 @@ CoglHandle cogl_texture_new_from_sub_texture
* Since: 1.2
* Stability: Unstable
*/
CoglHandle cogl_texture_new_from_buffer (CoglHandle buffer,
guint width,
guint height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
guint rowstride,
guint offset);
CoglHandle
cogl_texture_new_from_buffer (CoglHandle buffer,
unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
unsigned int rowstride,
unsigned int offset);
/* the function above is experimental, the actual symbol is suffixed by _EXP so
* we can ensure ABI compatibility and leave the cogl_buffer namespace free for
* future use. A bunch of defines translates the symbols documented above into
* the real symbols */
CoglHandle cogl_texture_new_from_buffer_EXP
(CoglHandle buffer,
guint width,
guint height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
guint rowstride,
guint offset);
CoglHandle
cogl_texture_new_from_buffer_EXP (CoglHandle buffer,
unsigned int width,
unsigned int height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
unsigned int rowstride,
unsigned int offset);
#define cogl_texture_new_from_buffer cogl_texture_new_from_buffer_EXP
@ -416,7 +432,8 @@ CoglHandle cogl_texture_new_from_buffer_EXP
*
* Return value: the @handle.
*/
CoglHandle cogl_texture_ref (CoglHandle handle);
CoglHandle
cogl_texture_ref (CoglHandle handle);
/**
* cogl_texture_unref:
@ -426,7 +443,8 @@ CoglHandle cogl_texture_ref (CoglHandle handle);
*
* Deprecated: 1.2: Use cogl_handle_unref() instead
*/
void cogl_texture_unref (CoglHandle handle);
void
cogl_texture_unref (CoglHandle handle);
#endif /* COGL_DISABLE_DEPRECATED */
@ -447,14 +465,15 @@ void cogl_texture_unref (CoglHandle handle);
*
* Since: 1.0
*/
void cogl_rectangle_with_texture_coords (float x1,
float y1,
float x2,
float y2,
float tx1,
float ty1,
float tx2,
float ty2);
void
cogl_rectangle_with_texture_coords (float x1,
float y1,
float x2,
float y2,
float tx1,
float ty1,
float tx2,
float ty2);
/**
* cogl_rectangle_with_multitexture_coords:
@ -483,12 +502,13 @@ void cogl_rectangle_with_texture_coords (float x1,
*
* Since: 1.0
*/
void cogl_rectangle_with_multitexture_coords (float x1,
float y1,
float x2,
float y2,
const float *tex_coords,
gint tex_coords_len);
void
cogl_rectangle_with_multitexture_coords (float x1,
float y1,
float x2,
float y2,
const float *tex_coords,
int tex_coords_len);
/**
* cogl_rectangles_with_texture_coords:
@ -507,8 +527,9 @@ void cogl_rectangle_with_multitexture_coords (float x1,
*
* Since: 0.8.6
*/
void cogl_rectangles_with_texture_coords (const float *verts,
guint n_rects);
void
cogl_rectangles_with_texture_coords (const float *verts,
unsigned int n_rects);
/**
* cogl_rectangles:
@ -527,9 +548,9 @@ void cogl_rectangles_with_texture_coords (const float *verts,
*
* Since: 1.0
*/
void cogl_rectangles (const float *verts,
guint n_rects);
void
cogl_rectangles (const float *verts,
unsigned int n_rects);
/**
* cogl_polygon:
@ -555,9 +576,10 @@ void cogl_rectangles (const float *verts,
*
* Since: 1.0
*/
void cogl_polygon (const CoglTextureVertex *vertices,
guint n_vertices,
gboolean use_color);
void
cogl_polygon (const CoglTextureVertex *vertices,
unsigned int n_vertices,
gboolean use_color);
G_END_DECLS

15
clutter/cogl/cogl/cogl-types.h
View File

@ -49,7 +49,8 @@ typedef gpointer CoglHandle;
#define COGL_INVALID_HANDLE NULL
#define COGL_TYPE_HANDLE (cogl_handle_get_type ())
GType cogl_handle_get_type (void) G_GNUC_CONST;
GType
cogl_handle_get_type (void) G_GNUC_CONST;
/**
* cogl_handle_ref:
@ -59,7 +60,8 @@ GType cogl_handle_get_type (void) G_GNUC_CONST;
*
* Returns: the handle, with its reference count increased
*/
CoglHandle cogl_handle_ref (CoglHandle handle);
CoglHandle
cogl_handle_ref (CoglHandle handle);
/**
* cogl_handle_unref:
@ -68,7 +70,8 @@ CoglHandle cogl_handle_ref (CoglHandle handle);
* Drecreases the reference count of @handle by 1; if the reference
* count reaches 0, the resources allocated by @handle will be freed
*/
void cogl_handle_unref (CoglHandle Handle);
void
cogl_handle_unref (CoglHandle Handle);
/**
* CoglFuncPtr:
@ -87,7 +90,8 @@ typedef void (* CoglFuncPtr) (void);
typedef gint32 CoglFixed;
#define COGL_TYPE_FIXED (cogl_fixed_get_type ())
GType cogl_fixed_get_type (void) G_GNUC_CONST;
GType
cogl_fixed_get_type (void) G_GNUC_CONST;
/**
* CoglAngle:
@ -361,7 +365,8 @@ typedef enum { /*< prefix=COGL_BLEND_STRING_ERROR >*/
COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR
} CoglBlendStringError;
GQuark cogl_blend_string_error_quark (void);
GQuark
cogl_blend_string_error_quark (void);
G_END_DECLS

30
clutter/cogl/cogl/cogl-util.c
View File

@ -3,7 +3,7 @@
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2007,2008,2009 Intel Corporation.
* Copyright (C) 2007,2008,2009,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
@ -129,27 +129,27 @@ cogl_value_init_fixed (GValue *value)
static void
cogl_value_copy_fixed (const GValue *src,
GValue *dest)
GValue *dest)
{
dest->data[0].v_int = src->data[0].v_int;
}
static gchar *
cogl_value_collect_fixed (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
static char *
cogl_value_collect_fixed (GValue *value,
unsigned int n_collect_values,
GTypeCValue *collect_values,
unsigned int collect_flags)
{
value->data[0].v_int = collect_values[0].v_int;
return NULL;
}
static gchar *
static char *
cogl_value_lcopy_fixed (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
unsigned int n_collect_values,
GTypeCValue *collect_values,
unsigned int collect_flags)
{
gint32 *fixed_p = collect_values[0].v_pointer;
@ -178,28 +178,28 @@ cogl_value_transform_fixed_double (const GValue *src,
static void
cogl_value_transform_fixed_float (const GValue *src,
GValue *dest)
GValue *dest)
{
dest->data[0].v_float = COGL_FIXED_TO_FLOAT (src->data[0].v_int);
}
static void
cogl_value_transform_int_fixed (const GValue *src,
GValue *dest)
GValue *dest)
{
dest->data[0].v_int = COGL_FIXED_FROM_INT (src->data[0].v_int);
}
static void
cogl_value_transform_double_fixed (const GValue *src,
GValue *dest)
GValue *dest)
{
dest->data[0].v_int = COGL_FIXED_FROM_DOUBLE (src->data[0].v_double);
}
static void
cogl_value_transform_float_fixed (const GValue *src,
GValue *dest)
GValue *dest)
{
dest->data[0].v_int = COGL_FIXED_FROM_FLOAT (src->data[0].v_float);
}

2
clutter/cogl/cogl/cogl-vertex-buffer-private.h
View File

@ -133,7 +133,7 @@ typedef struct _CoglVertexBufferVBO
* a GLuint VBO name, but when the driver doesn't support VBOs then
* this simply points to an malloc'd buffer. */
void *vbo_name; /*!< The name of the corresponding buffer object */
size_t vbo_bytes; /*!< The lengh of the allocated buffer object in bytes */
gsize vbo_bytes; /*!< The lengh of the allocated buffer object in bytes */
GList *attributes;
} CoglVertexBufferVBO;

18
clutter/cogl/cogl/cogl-vertex-buffer.c
View File

@ -210,7 +210,7 @@ COGL_HANDLE_DEFINE (VertexBuffer, vertex_buffer);
COGL_HANDLE_DEFINE (VertexBufferIndices, vertex_buffer_indices);
CoglHandle
cogl_vertex_buffer_new (guint n_vertices)
cogl_vertex_buffer_new (unsigned int n_vertices)
{
CoglVertexBuffer *buffer = g_slice_alloc (sizeof (CoglVertexBuffer));
@ -223,7 +223,7 @@ cogl_vertex_buffer_new (guint n_vertices)
return _cogl_vertex_buffer_handle_new (buffer);
}
guint
unsigned int
cogl_vertex_buffer_get_n_vertices (CoglHandle handle)
{
CoglVertexBuffer *buffer;
@ -958,7 +958,7 @@ upload_multipack_vbo_via_map_buffer (CoglVertexBufferVBO *cogl_vbo)
{
#if HAVE_COGL_GL
GList *tmp;
guint offset = 0;
unsigned int offset = 0;
char *buf;
gboolean fallback =
(cogl_get_features () & COGL_FEATURE_VBOS) ? FALSE : TRUE;
@ -1004,7 +1004,7 @@ static void
upload_multipack_vbo_via_buffer_sub_data (CoglVertexBufferVBO *cogl_vbo)
{
GList *tmp;
guint offset = 0;
unsigned int offset = 0;
gboolean fallback =
(cogl_get_features () & COGL_FEATURE_VBOS) ? FALSE : TRUE;
@ -1511,8 +1511,8 @@ enable_state_for_drawing_buffer (CoglVertexBuffer *buffer)
#ifdef MAY_HAVE_PROGRAMABLE_GL
GLuint generic_index = 0;
#endif
gulong enable_flags = 0;
gint max_texcoord_attrib_unit = -1;
unsigned long enable_flags = 0;
int max_texcoord_attrib_unit = -1;
const GList *layers;
guint32 fallback_layers = 0;
guint32 disable_layers = ~0;
@ -1797,7 +1797,7 @@ cogl_vertex_buffer_indices_new (CoglIndicesType indices_type,
{
gboolean fallback =
(cogl_get_features () & COGL_FEATURE_VBOS) ? FALSE : TRUE;
size_t indices_bytes;
gsize indices_bytes;
CoglVertexBufferIndices *indices;
_COGL_GET_CONTEXT (ctx, 0);
@ -1885,7 +1885,7 @@ cogl_vertex_buffer_draw_elements (CoglHandle handle,
CoglVertexBuffer *buffer;
gboolean fallback =
(cogl_get_features () & COGL_FEATURE_VBOS) ? FALSE : TRUE;
size_t byte_offset;
gsize byte_offset;
CoglVertexBufferIndices *indices = NULL;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -1936,7 +1936,7 @@ _cogl_vertex_buffer_free (CoglVertexBuffer *buffer)
}
CoglHandle
cogl_vertex_buffer_indices_get_for_quads (guint n_indices)
cogl_vertex_buffer_indices_get_for_quads (unsigned int n_indices)
{
_COGL_GET_CONTEXT (ctx, COGL_INVALID_HANDLE);

6
clutter/cogl/cogl/cogl-vertex-buffer.h
View File

@ -83,7 +83,7 @@ G_BEGIN_DECLS
* Return value: a new #CoglHandle
*/
CoglHandle
cogl_vertex_buffer_new (guint n_vertices);
cogl_vertex_buffer_new (unsigned int n_vertices);
/**
* cogl_vertex_buffer_get_n_vertices:
@ -93,7 +93,7 @@ cogl_vertex_buffer_new (guint n_vertices);
*
* Return value: the number of vertices
*/
guint
unsigned int
cogl_vertex_buffer_get_n_vertices (CoglHandle handle);
/**
@ -439,7 +439,7 @@ cogl_vertex_buffer_unref (CoglHandle handle);
* owned by Cogl and should not be modified or unref'd.
*/
CoglHandle
cogl_vertex_buffer_indices_get_for_quads (guint n_indices);
cogl_vertex_buffer_indices_get_for_quads (unsigned int n_indices);
/**
* cogl_is_vertex_buffer:

52
clutter/cogl/cogl/cogl.c
View File

@ -54,7 +54,7 @@
/* GL error to string conversion */
static const struct {
GLuint error_code;
const gchar *error_string;
const char *error_string;
} gl_errors[] = {
{ GL_NO_ERROR, "No error" },
{ GL_INVALID_ENUM, "Invalid enumeration value" },
@ -69,12 +69,12 @@ static const struct {
#endif
};
static const guint n_gl_errors = G_N_ELEMENTS (gl_errors);
static const unsigned int n_gl_errors = G_N_ELEMENTS (gl_errors);
const gchar *
const char *
cogl_gl_error_to_string (GLenum error_code)
{
gint i;
int i;
for (i = 0; i < n_gl_errors; i++)
{
@ -87,7 +87,7 @@ cogl_gl_error_to_string (GLenum error_code)
#endif /* COGL_GL_DEBUG */
CoglFuncPtr
cogl_get_proc_address (const gchar* name)
cogl_get_proc_address (const char* name)
{
void *address;
static GModule *module = NULL;
@ -113,15 +113,15 @@ cogl_get_proc_address (const gchar* name)
}
gboolean
_cogl_check_extension (const gchar *name, const gchar *ext)
_cogl_check_extension (const char *name, const gchar *ext)
{
gchar *end;
gint name_len, n;
char *end;
int name_len, n;
if (name == NULL || ext == NULL)
return FALSE;
end = (gchar*)(ext + strlen(ext));
end = (char*)(ext + strlen(ext));
name_len = strlen(name);
@ -145,7 +145,7 @@ cogl_check_extension (const char *name, const char *ext)
}
void
cogl_clear (const CoglColor *color, gulong buffers)
cogl_clear (const CoglColor *color, unsigned long buffers)
{
GLbitfield gl_buffers = 0;
@ -203,8 +203,8 @@ cogl_clear (const CoglColor *color, gulong buffers)
static inline gboolean
cogl_toggle_flag (CoglContext *ctx,
gulong new_flags,
gulong flag,
unsigned long new_flags,
unsigned long flag,
GLenum gl_flag)
{
/* Toggles and caches a single enable flag on or off
@ -230,8 +230,8 @@ cogl_toggle_flag (CoglContext *ctx,
static inline gboolean
cogl_toggle_client_flag (CoglContext *ctx,
gulong new_flags,
gulong flag,
unsigned long new_flags,
unsigned long flag,
GLenum gl_flag)
{
/* Toggles and caches a single client-side enable flag
@ -256,7 +256,7 @@ cogl_toggle_client_flag (CoglContext *ctx,
}
void
cogl_enable (gulong flags)
cogl_enable (unsigned long flags)
{
/* This function essentially caches glEnable state() in the
* hope of lessening number GL traffic.
@ -280,7 +280,7 @@ cogl_enable (gulong flags)
GL_COLOR_ARRAY);
}
gulong
unsigned long
cogl_get_enable ()
{
_COGL_GET_CONTEXT (ctx, 0);
@ -402,15 +402,15 @@ cogl_set_viewport (int x,
/* XXX: This should be deprecated, and we should expose a way to also
* specify an x and y viewport offset */
void
cogl_viewport (guint width,
guint height)
cogl_viewport (unsigned int width,
unsigned int height)
{
cogl_set_viewport (0, 0, width, height);
}
void
_cogl_setup_viewport (guint width,
guint height,
_cogl_setup_viewport (unsigned int width,
unsigned int height,
float fovy,
float aspect,
float z_near,
@ -525,10 +525,10 @@ cogl_get_viewport (float v[4])
}
void
cogl_get_bitmasks (gint *red,
gint *green,
gint *blue,
gint *alpha)
cogl_get_bitmasks (int *red,
int *green,
int *blue,
int *alpha)
{
GLint value;
@ -698,7 +698,7 @@ void
cogl_begin_gl (void)
{
CoglMaterialFlushOptions options;
gulong enable_flags = 0;
unsigned long enable_flags = 0;
int i;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -851,7 +851,7 @@ _cogl_destroy_texture_units (void)
* Note that, for now, we use GL_MAX_TEXTURE_UNITS as we are exposing the
* fixed function pipeline.
*/
guint
unsigned int
_cogl_get_max_texture_image_units (void)
{
GLint nb_texture_image_units;

310
clutter/cogl/cogl/cogl.h
View File

@ -73,7 +73,8 @@ G_BEGIN_DECLS
*
* Since: 1.0
*/
GOptionGroup * cogl_get_option_group (void);
GOptionGroup *
cogl_get_option_group (void);
/* Misc */
/**
@ -85,7 +86,8 @@ GOptionGroup * cogl_get_option_group (void);
*
* Since: 0.8
*/
CoglFeatureFlags cogl_get_features (void);
CoglFeatureFlags
cogl_get_features (void);
/**
* cogl_features_available:
@ -98,7 +100,8 @@ CoglFeatureFlags cogl_get_features (void);
*
* Return value: %TRUE if the features are available, %FALSE otherwise.
*/
gboolean cogl_features_available (CoglFeatureFlags features);
gboolean
cogl_features_available (CoglFeatureFlags features);
/**
* cogl_get_proc_address:
@ -111,7 +114,8 @@ gboolean cogl_features_available (CoglFeatureFlags features);
* Return value: a pointer to the requested function or %NULL if the
* function is not available.
*/
CoglFuncPtr cogl_get_proc_address (const gchar *name);
CoglFuncPtr
cogl_get_proc_address (const char *name);
#ifndef COGL_DISABLE_DEPRECATED
@ -128,8 +132,9 @@ CoglFuncPtr cogl_get_proc_address (const gchar *name);
* appropriate to expose OpenGL extensions through the Cogl
* API.
*/
gboolean cogl_check_extension (const gchar *name,
const gchar *ext) G_GNUC_DEPRECATED;
gboolean
cogl_check_extension (const char *name,
const char *ext) G_GNUC_DEPRECATED;
#endif /* COGL_DISABLE_DEPRECATED */
@ -144,10 +149,11 @@ gboolean cogl_check_extension (const gchar *name,
* in the color buffer. Pass %NULL for any of the arguments if the
* value is not required.
*/
void cogl_get_bitmasks (gint *red,
gint *green,
gint *blue,
gint *alpha);
void
cogl_get_bitmasks (int *red,
int *green,
int *blue,
int *alpha);
/**
* cogl_perspective:
@ -159,10 +165,11 @@ void cogl_get_bitmasks (gint *red,
* Replaces the current projection matrix with a perspective matrix
* based on the provided values.
*/
void cogl_perspective (float fovy,
float aspect,
float z_near,
float z_far);
void
cogl_perspective (float fovy,
float aspect,
float z_near,
float z_far);
/**
* cogl_frustum:
@ -178,12 +185,13 @@ void cogl_perspective (float fovy,
*
* Since: 0.8.2
*/
void cogl_frustum (float left,
float right,
float bottom,
float top,
float z_near,
float z_far);
void
cogl_frustum (float left,
float right,
float bottom,
float top,
float z_near,
float z_far);
/**
* cogl_ortho:
@ -201,12 +209,13 @@ void cogl_frustum (float left,
*
* Since: 1.0
*/
void cogl_ortho (float left,
float right,
float bottom,
float top,
float near,
float far);
void
cogl_ortho (float left,
float right,
float bottom,
float top,
float near,
float far);
/*
* _cogl_setup_viewport:
@ -226,12 +235,13 @@ void cogl_ortho (float left,
*
* This function is used only by Clutter.
*/
void _cogl_setup_viewport (guint width,
guint height,
float fovy,
float aspect,
float z_near,
float z_far);
void
_cogl_setup_viewport (unsigned int width,
unsigned int height,
float fovy,
float aspect,
float z_near,
float z_far);
#ifndef COGL_DISABLE_DEPRECATED
@ -246,8 +256,9 @@ void _cogl_setup_viewport (guint width,
*
* Deprecated: 1.2: Use cogl_set_viewport() instead
*/
void cogl_viewport (guint width,
guint height) G_GNUC_DEPRECATED;
void
cogl_viewport (unsigned int width,
unsigned int height) G_GNUC_DEPRECATED;
#endif /* COGL_DISABLE_DEPRECATED */
@ -262,10 +273,11 @@ void cogl_viewport (guint width,
*
* Since: 1.2
*/
void cogl_set_viewport (int x,
int y,
int width,
int height);
void
cogl_set_viewport (int x,
int y,
int width,
int height);
/**
* cogl_push_matrix:
@ -273,14 +285,16 @@ void cogl_set_viewport (int x,
* Stores the current model-view matrix on the matrix stack. The matrix
* can later be restored with cogl_pop_matrix().
*/
void cogl_push_matrix (void);
void
cogl_push_matrix (void);
/**
* cogl_pop_matrix:
*
* Restores the current model-view matrix from the matrix stack.
*/
void cogl_pop_matrix (void);
void
cogl_pop_matrix (void);
/**
* cogl_scale:
@ -291,9 +305,10 @@ void cogl_pop_matrix (void);
* Multiplies the current model-view matrix by one that scales the x,
* y and z axes by the given values.
*/
void cogl_scale (float x,
float y,
float z);
void
cogl_scale (float x,
float y,
float z);
/**
* cogl_translate:
@ -304,9 +319,10 @@ void cogl_scale (float x,
* Multiplies the current model-view matrix by one that translates the
* model along all three axes according to the given values.
*/
void cogl_translate (float x,
float y,
float z);
void
cogl_translate (float x,
float y,
float z);
/**
* cogl_rotate:
@ -321,10 +337,11 @@ void cogl_translate (float x,
* degrees about the vertex (0, 0, 1) causes a small counter-clockwise
* rotation.
*/
void cogl_rotate (float angle,
float x,
float y,
float z);
void
cogl_rotate (float angle,
float x,
float y,
float z);
/**
* cogl_get_modelview_matrix:
@ -332,7 +349,8 @@ void cogl_rotate (float angle,
*
* Stores the current model-view matrix in @matrix.
*/
void cogl_get_modelview_matrix (CoglMatrix *matrix);
void
cogl_get_modelview_matrix (CoglMatrix *matrix);
/**
* cogl_set_modelview_matrix:
@ -340,7 +358,8 @@ void cogl_get_modelview_matrix (CoglMatrix *matrix);
*
* Loads @matrix as the new model-view matrix.
*/
void cogl_set_modelview_matrix (CoglMatrix *matrix);
void
cogl_set_modelview_matrix (CoglMatrix *matrix);
/**
* cogl_get_projection_matrix:
@ -348,7 +367,8 @@ void cogl_set_modelview_matrix (CoglMatrix *matrix);
*
* Stores the current projection matrix in @matrix.
*/
void cogl_get_projection_matrix (CoglMatrix *matrix);
void
cogl_get_projection_matrix (CoglMatrix *matrix);
/**
* cogl_set_projection_matrix:
@ -356,7 +376,8 @@ void cogl_get_projection_matrix (CoglMatrix *matrix);
*
* Loads matrix as the new projection matrix.
*/
void cogl_set_projection_matrix (CoglMatrix *matrix);
void
cogl_set_projection_matrix (CoglMatrix *matrix);
/**
* cogl_get_viewport:
@ -367,7 +388,8 @@ void cogl_set_projection_matrix (CoglMatrix *matrix);
* position of the viewport and @v[2] and @v[3] get the width and
* height.
*/
void cogl_get_viewport (float v[4]);
void
cogl_get_viewport (float v[4]);
/**
* cogl_set_depth_test_enabled:
@ -379,7 +401,8 @@ void cogl_get_viewport (float v[4]);
* clutter_actor_lower(), otherwise it will also take into account the
* actor's depth. Depth testing is disabled by default.
*/
void cogl_set_depth_test_enabled (gboolean setting);
void
cogl_set_depth_test_enabled (gboolean setting);
/**
* cogl_get_depth_test_enabled:
@ -388,7 +411,8 @@ void cogl_set_depth_test_enabled (gboolean setting);
*
* Return value: %TRUE if depth testing is enabled, and %FALSE otherwise
*/
gboolean cogl_get_depth_test_enabled (void);
gboolean
cogl_get_depth_test_enabled (void);
/**
* cogl_set_backface_culling_enabled:
@ -400,7 +424,8 @@ gboolean cogl_get_depth_test_enabled (void);
* only affects calls to the cogl_rectangle* family of functions and
* cogl_vertex_buffer_draw*. Backface culling is disabled by default.
*/
void cogl_set_backface_culling_enabled (gboolean setting);
void
cogl_set_backface_culling_enabled (gboolean setting);
/**
* cogl_get_backface_culling_enabled:
@ -410,7 +435,8 @@ void cogl_set_backface_culling_enabled (gboolean setting);
*
* Return value: %TRUE if backface culling is enabled, and %FALSE otherwise
*/
gboolean cogl_get_backface_culling_enabled (void);
gboolean
cogl_get_backface_culling_enabled (void);
/**
* cogl_set_fog:
@ -437,11 +463,12 @@ gboolean cogl_get_backface_culling_enabled (void);
* opaque primitives. This might improve in the future when we can depend
* on fragment shaders.</note>
*/
void cogl_set_fog (const CoglColor *fog_color,
CoglFogMode mode,
float density,
float z_near,
float z_far);
void
cogl_set_fog (const CoglColor *fog_color,
CoglFogMode mode,
float density,
float z_near,
float z_far);
/**
* cogl_disable_fog:
@ -449,7 +476,8 @@ void cogl_set_fog (const CoglColor *fog_color,
* This function disables fogging, so primitives drawn afterwards will not be
* blended with any previously set fog color.
*/
void cogl_disable_fog (void);
void
cogl_disable_fog (void);
/**
* CoglBufferBit:
@ -476,8 +504,9 @@ typedef enum {
* Clears all the auxiliary buffers identified in the @buffers mask, and if
* that includes the color buffer then the specified @color is used.
*/
void cogl_clear (const CoglColor *color,
gulong buffers);
void
cogl_clear (const CoglColor *color,
unsigned long buffers);
/**
* cogl_set_source:
@ -492,7 +521,8 @@ void cogl_clear (const CoglColor *color,
*
* Since: 1.0
*/
void cogl_set_source (CoglHandle material);
void
cogl_set_source (CoglHandle material);
/**
* cogl_set_source_color:
@ -511,7 +541,8 @@ void cogl_set_source (CoglHandle material);
*
* Since: 1.0
*/
void cogl_set_source_color (const CoglColor *color);
void
cogl_set_source_color (const CoglColor *color);
/**
* cogl_set_source_color4ub:
@ -529,10 +560,11 @@ void cogl_set_source_color (const CoglColor *color);
*
* Since: 1.0
*/
void cogl_set_source_color4ub (guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
void
cogl_set_source_color4ub (guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
/**
* cogl_set_source_color4f:
@ -551,10 +583,11 @@ void cogl_set_source_color4ub (guint8 red,
*
* Since: 1.0
*/
void cogl_set_source_color4f (float red,
float green,
float blue,
float alpha);
void
cogl_set_source_color4f (float red,
float green,
float blue,
float alpha);
/**
* cogl_set_source_texture:
@ -576,7 +609,8 @@ void cogl_set_source_color4f (float red,
*
* Since: 1.0
*/
void cogl_set_source_texture (CoglHandle texture_handle);
void
cogl_set_source_texture (CoglHandle texture_handle);
/**
* SECTION:cogl-clipping
@ -607,10 +641,11 @@ void cogl_set_source_texture (CoglHandle texture_handle);
*
* Deprecated: 1.2: Use cogl_clip_push_window_rectangle() instead
*/
void cogl_clip_push_window_rect (float x_offset,
float y_offset,
float width,
float height) G_GNUC_DEPRECATED;
void
cogl_clip_push_window_rect (float x_offset,
float y_offset,
float width,
float height) G_GNUC_DEPRECATED;
#endif /* COGL_DISABLE_DEPRECATED */
@ -632,10 +667,11 @@ void cogl_clip_push_window_rect (float x_offset,
*
* Since: 1.2
*/
void cogl_clip_push_window_rectangle (int x_offset,
int y_offset,
int width,
int height);
void
cogl_clip_push_window_rectangle (int x_offset,
int y_offset,
int width,
int height);
#ifndef COGL_DISABLE_DEPRECATED
@ -661,10 +697,11 @@ void cogl_clip_push_window_rectangle (int x_offset,
* extending up, it's awkward to use. Please use cogl_clip_push_rectangle()
* instead
*/
void cogl_clip_push (float x_offset,
float y_offset,
float width,
float height) G_GNUC_DEPRECATED;
void
cogl_clip_push (float x_offset,
float y_offset,
float width,
float height) G_GNUC_DEPRECATED;
#endif /* COGL_DISABLE_DEPRECATED */
@ -686,10 +723,11 @@ void cogl_clip_push (float x_offset,
*
* Since: 1.2
*/
void cogl_clip_push_rectangle (float x0,
float y0,
float x1,
float y1);
void
cogl_clip_push_rectangle (float x0,
float y0,
float x1,
float y1);
/**
* cogl_clip_push_from_path:
@ -701,7 +739,8 @@ void cogl_clip_push_rectangle (float x0,
*
* Since: 1.0
*/
void cogl_clip_push_from_path (void);
void
cogl_clip_push_from_path (void);
/**
* cogl_clip_push_from_path_preserve:
@ -713,7 +752,8 @@ void cogl_clip_push_from_path (void);
*
* Since: 1.0
*/
void cogl_clip_push_from_path_preserve (void);
void
cogl_clip_push_from_path_preserve (void);
/**
* cogl_clip_pop:
@ -721,7 +761,8 @@ void cogl_clip_push_from_path_preserve (void);
* Reverts the clipping region to the state before the last call to
* cogl_clip_push().
*/
void cogl_clip_pop (void);
void
cogl_clip_pop (void);
#ifndef COGL_DISABLE_DEPRECATED
@ -737,7 +778,8 @@ void cogl_clip_pop (void);
*
* Since: 1.0
*/
void cogl_clip_ensure (void) G_GNUC_DEPRECATED;
void
cogl_clip_ensure (void) G_GNUC_DEPRECATED;
/**
* cogl_clip_stack_save:
@ -756,7 +798,8 @@ void cogl_clip_ensure (void) G_GNUC_DEPRECATED;
*
* Since: 0.8.2
*/
void cogl_clip_stack_save (void) G_GNUC_DEPRECATED;
void
cogl_clip_stack_save (void) G_GNUC_DEPRECATED;
/**
* cogl_clip_stack_restore:
@ -772,7 +815,8 @@ void cogl_clip_stack_save (void) G_GNUC_DEPRECATED;
*
* Since: 0.8.2
*/
void cogl_clip_stack_restore (void) G_GNUC_DEPRECATED;
void
cogl_clip_stack_restore (void) G_GNUC_DEPRECATED;
#endif /* COGL_DISABLE_DEPRECATED */
@ -788,7 +832,8 @@ void cogl_clip_stack_restore (void) G_GNUC_DEPRECATED;
*
* Since: 1.2
*/
void cogl_set_framebuffer (CoglHandle buffer);
void
cogl_set_framebuffer (CoglHandle buffer);
/**
* cogl_push_framebuffer:
@ -804,7 +849,8 @@ void cogl_set_framebuffer (CoglHandle buffer);
*
* Since: 1.2
*/
void cogl_push_framebuffer (CoglHandle buffer);
void
cogl_push_framebuffer (CoglHandle buffer);
/**
* cogl_pop_framebuffer:
@ -814,7 +860,8 @@ void cogl_push_framebuffer (CoglHandle buffer);
*
* Since: 1.2
*/
void cogl_pop_framebuffer (void);
void
cogl_pop_framebuffer (void);
#ifndef COGL_DISABLE_DEPRECATED
@ -833,8 +880,9 @@ void cogl_pop_framebuffer (void);
* Deprecated: 1.2: The target argument was redundant since we could look at
* the type of CoglHandle given instead.
*/
void cogl_set_draw_buffer (CoglBufferTarget target,
CoglHandle offscreen) G_GNUC_DEPRECATED;
void
cogl_set_draw_buffer (CoglBufferTarget target,
CoglHandle offscreen) G_GNUC_DEPRECATED;
/**
* cogl_push_draw_buffer:
@ -843,7 +891,8 @@ void cogl_set_draw_buffer (CoglBufferTarget target,
*
* Deprecated: 1.2: The draw buffer API was replaced with a framebuffer API
*/
void cogl_push_draw_buffer (void) G_GNUC_DEPRECATED;
void
cogl_push_draw_buffer (void) G_GNUC_DEPRECATED;
/**
* cogl_pop_draw_buffer:
@ -852,7 +901,8 @@ void cogl_push_draw_buffer (void) G_GNUC_DEPRECATED;
*
* Deprecated: 1.2: The draw buffer API was replaced with a framebuffer API
*/
void cogl_pop_draw_buffer (void) G_GNUC_DEPRECATED;
void
cogl_pop_draw_buffer (void) G_GNUC_DEPRECATED;
#endif /* COGL_DISABLE_DEPRECATED */
@ -884,13 +934,14 @@ typedef enum { /*< prefix=COGL_READ_PIXELS >*/
* position (0, 0) is the top left. The pixel at (x, y) is the first
* read, and the data is returned with a rowstride of (width * 4)
*/
void cogl_read_pixels (int x,
int y,
int width,
int height,
CoglReadPixelsFlags source,
CoglPixelFormat format,
guint8 *pixels);
void
cogl_read_pixels (int x,
int y,
int width,
int height,
CoglReadPixelsFlags source,
CoglPixelFormat format,
guint8 *pixels);
/**
* cogl_flush:
@ -918,7 +969,8 @@ void cogl_read_pixels (int x,
*
* Since: 1.0
*/
void cogl_flush (void);
void
cogl_flush (void);
/**
* cogl_begin_gl:
@ -993,7 +1045,8 @@ void cogl_flush (void);
*
* Since: 1.0
*/
void cogl_begin_gl (void);
void
cogl_begin_gl (void);
/**
* cogl_end_gl:
@ -1003,7 +1056,8 @@ void cogl_begin_gl (void);
*
* Since: 1.0
*/
void cogl_end_gl (void);
void
cogl_end_gl (void);
/*
* Internal API available only to Clutter.
@ -1014,7 +1068,8 @@ void cogl_end_gl (void);
* move down into Cogl and these functions will be removed.
*/
void _cogl_destroy_context (void);
void
_cogl_destroy_context (void);
/*< private >*/
#define COGL_DRIVER_ERROR (_cogl_driver_error_quark ())
@ -1024,11 +1079,20 @@ typedef enum { /*< prefix=COGL_DRIVER_ERROR >*/
COGL_DRIVER_ERROR_INVALID_VERSION
} CoglDriverError;
gboolean _cogl_check_extension (const char *name, const char *ext);
void _cogl_set_indirect_context (gboolean indirect);
void _cogl_set_viewport (int x, int y, int width, int height);
gboolean _cogl_check_driver_valid (GError **error);
GQuark _cogl_driver_error_quark (void);
gboolean
_cogl_check_extension (const char *name, const char *ext);
void
_cogl_set_indirect_context (gboolean indirect);
void
_cogl_set_viewport (int x, int y, int width, int height);
gboolean
_cogl_check_driver_valid (GError **error);
GQuark
_cogl_driver_error_quark (void);
void
_cogl_onscreen_clutter_backend_set_size (int width, int height);

18
clutter/cogl/cogl/driver/gl/cogl-program.c
View File

@ -145,7 +145,7 @@ cogl_program_use (CoglHandle handle)
int
cogl_program_get_uniform_location (CoglHandle handle,
const gchar *uniform_name)
const char *uniform_name)
{
CoglProgram *program;
_COGL_GET_CONTEXT (ctx, 0);
@ -160,7 +160,7 @@ cogl_program_get_uniform_location (CoglHandle handle,
void
cogl_program_uniform_1f (int uniform_no,
gfloat value)
float value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
glUniform1f (uniform_no, value);
@ -168,7 +168,7 @@ cogl_program_uniform_1f (int uniform_no,
void
cogl_program_uniform_1i (int uniform_no,
gint value)
int value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
glUniform1i (uniform_no, value);
@ -176,8 +176,8 @@ cogl_program_uniform_1i (int uniform_no,
void
cogl_program_uniform_float (int uniform_no,
gint size,
gint count,
int size,
int count,
const GLfloat *value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -203,8 +203,8 @@ cogl_program_uniform_float (int uniform_no,
void
cogl_program_uniform_int (int uniform_no,
gint size,
gint count,
int size,
int count,
const int *value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -230,8 +230,8 @@ cogl_program_uniform_int (int uniform_no,
void
cogl_program_uniform_matrix (int uniform_no,
gint size,
gint count,
int size,
int count,
gboolean transpose,
const GLfloat *value)
{

2
clutter/cogl/cogl/driver/gl/cogl-shader.c
View File

@ -107,7 +107,7 @@ cogl_shader_compile (CoglHandle handle)
glCompileShader (shader->gl_handle);
}
gchar *
char *
cogl_shader_get_info_log (CoglHandle handle)
{
CoglShader *shader;

2
clutter/cogl/cogl/driver/gl/cogl-texture-driver.c
View File

@ -52,7 +52,7 @@ _cogl_texture_driver_gen (GLenum gl_target,
GLsizei n,
GLuint *textures)
{
guint i;
unsigned int i;
GE (glGenTextures (n, textures));

8
clutter/cogl/cogl/driver/gl/cogl.c
View File

@ -98,7 +98,7 @@ gboolean
_cogl_check_driver_valid (GError **error)
{
int major, minor;
const gchar *gl_extensions;
const char *gl_extensions;
if (!_cogl_get_gl_version (&major, &minor))
{
@ -113,7 +113,7 @@ _cogl_check_driver_valid (GError **error)
if (COGL_CHECK_GL_VERSION (major, minor, 1, 3))
return TRUE;
gl_extensions = (const gchar*) glGetString (GL_EXTENSIONS);
gl_extensions = (const char*) glGetString (GL_EXTENSIONS);
/* OpenGL 1.2 is only supported if we have the multitexturing
extension */
@ -175,7 +175,7 @@ void
_cogl_features_init (void)
{
CoglFeatureFlags flags = 0;
const gchar *gl_extensions;
const char *gl_extensions;
GLint max_clip_planes = 0;
GLint num_stencil_bits = 0;
int gl_major = 0, gl_minor = 0;
@ -187,7 +187,7 @@ _cogl_features_init (void)
flags = COGL_FEATURE_TEXTURE_READ_PIXELS;
gl_extensions = (const gchar*) glGetString (GL_EXTENSIONS);
gl_extensions = (const char*) glGetString (GL_EXTENSIONS);
if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 0) ||
_cogl_check_extension ("GL_ARB_texture_non_power_of_two", gl_extensions))

6
clutter/cogl/cogl/driver/gles/cogl-gles2-wrapper.c
View File

@ -788,7 +788,7 @@ cogl_gles2_do_set_uniform (GLint location, CoglBoxedValue *value)
case COGL_BOXED_INT:
{
gint *ptr;
int *ptr;
if (value->count == 1)
ptr = value->v.int_value;
@ -807,7 +807,7 @@ cogl_gles2_do_set_uniform (GLint location, CoglBoxedValue *value)
case COGL_BOXED_FLOAT:
{
gfloat *ptr;
float *ptr;
if (value->count == 1)
ptr = value->v.float_value;
@ -826,7 +826,7 @@ cogl_gles2_do_set_uniform (GLint location, CoglBoxedValue *value)
case COGL_BOXED_MATRIX:
{
gfloat *ptr;
float *ptr;
if (value->count == 1)
ptr = value->v.matrix;

12
clutter/cogl/cogl/driver/gles/cogl-gles2-wrapper.h
View File

@ -128,8 +128,8 @@ struct _CoglGles2WrapperSettings
/* The current in-use user program */
CoglHandle user_program;
guint alpha_test_enabled:1;
guint fog_enabled:1;
unsigned int alpha_test_enabled:1;
unsigned int fog_enabled:1;
};
struct _CoglGles2WrapperTextureUnit
@ -141,8 +141,8 @@ struct _CoglGles2WrapperTextureUnit
GLsizei texture_coords_stride;
const void *texture_coords_pointer;
guint texture_coords_enabled:1;
guint dirty_matrix:1; /*!< shader uniform needs updating */
unsigned int texture_coords_enabled:1;
unsigned int dirty_matrix:1; /*!< shader uniform needs updating */
};
struct _CoglGles2Wrapper
@ -150,8 +150,8 @@ struct _CoglGles2Wrapper
GLuint matrix_mode;
CoglMatrix modelview_matrix;
CoglMatrix projection_matrix;
guint active_texture_unit;
guint active_client_texture_unit;
unsigned int active_texture_unit;
unsigned int active_client_texture_unit;
CoglGles2WrapperTextureUnit texture_units[COGL_GLES2_MAX_TEXTURE_UNITS];

42
clutter/cogl/cogl/driver/gles/cogl-program.c
View File

@ -124,7 +124,7 @@ cogl_program_use (CoglHandle handle)
int
cogl_program_get_uniform_location (CoglHandle handle,
const gchar *uniform_name)
const char *uniform_name)
{
int i;
CoglProgram *program;
@ -156,24 +156,24 @@ cogl_program_get_uniform_location (CoglHandle handle,
void
cogl_program_uniform_1f (int uniform_no,
gfloat value)
float value)
{
cogl_program_uniform_float (uniform_no, 1, 1, &value);
}
void
cogl_program_uniform_1i (int uniform_no,
gint value)
int value)
{
cogl_program_uniform_int (uniform_no, 1, 1, &value);
}
static void
cogl_program_uniform_x (int uniform_no,
gint size,
gint count,
int size,
int count,
CoglBoxedType type,
size_t value_size,
gsize value_size,
gconstpointer value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
@ -216,8 +216,8 @@ cogl_program_uniform_x (int uniform_no,
void
cogl_program_uniform_float (int uniform_no,
gint size,
gint count,
int size,
int count,
const GLfloat *value)
{
cogl_program_uniform_x (uniform_no, size, count, COGL_BOXED_FLOAT,
@ -226,18 +226,18 @@ cogl_program_uniform_float (int uniform_no,
void
cogl_program_uniform_int (int uniform_no,
gint size,
gint count,
int size,
int count,
const GLint *value)
{
cogl_program_uniform_x (uniform_no, size, count, COGL_BOXED_INT,
sizeof (gint) * size, value);
sizeof (int) * size, value);
}
void
cogl_program_uniform_matrix (int uniform_no,
gint size,
gint count,
int size,
int count,
gboolean transpose,
const GLfloat *value)
{
@ -298,37 +298,37 @@ cogl_program_use (CoglHandle program_handle)
int
cogl_program_get_uniform_location (CoglHandle program_handle,
const gchar *uniform_name)
const char *uniform_name)
{
return 0;
}
void
cogl_program_uniform_1f (int uniform_no,
gfloat value)
float value)
{
}
void
cogl_program_uniform_float (int uniform_no,
gint size,
gint count,
int size,
int count,
const GLfloat *value)
{
}
void
cogl_program_uniform_int (int uniform_no,
gint size,
gint count,
int size,
int count,
const int *value)
{
}
void
cogl_program_uniform_matrix (int uniform_no,
gint size,
gint count,
int size,
int count,
gboolean transpose,
const GLfloat *value)
{

4
clutter/cogl/cogl/driver/gles/cogl-shader.c
View File

@ -99,7 +99,7 @@ cogl_shader_compile (CoglHandle handle)
glCompileShader (shader->gl_handle);
}
gchar *
char *
cogl_shader_get_info_log (CoglHandle handle)
{
CoglShader *shader;
@ -200,7 +200,7 @@ cogl_shader_compile (CoglHandle shader_handle)
{
}
gchar *
char *
cogl_shader_get_info_log (CoglHandle handle)
{
return NULL;

4
clutter/cogl/cogl/driver/gles/cogl-texture-driver.c
View File

@ -52,7 +52,7 @@ _cogl_texture_driver_gen (GLenum gl_target,
GLsizei n,
GLuint *textures)
{
guint i;
unsigned int i;
GE (glGenTextures (n, textures));
@ -125,7 +125,7 @@ _cogl_texture_driver_upload_subregion_to_gl (GLenum gl_target,
slice_bmp.width = width;
slice_bmp.height = height;
slice_bmp.rowstride = bpp * slice_bmp.width;
slice_bmp.data = (guchar*) g_malloc (slice_bmp.rowstride * slice_bmp.height);
slice_bmp.data = g_malloc (slice_bmp.rowstride * slice_bmp.height);
/* Setup gl alignment to match rowstride and top-left corner */
_cogl_texture_driver_prep_gl_for_pixels_upload (slice_bmp.rowstride,

49
clutter/cogl/doc/CODING_STYLE Normal file
View File

@ -0,0 +1,49 @@
Cogl Coding Style
--------------------
This document is intended to be a short description of the preferred
coding style to be used for the Cogl source code.
Coding style is a matter of consistency, readability and maintainance;
coding style is also completely arbitrary and a matter of taste. This
document will use examples at the very least to provide authoritative
and consistent answers to common questions regarding the coding style,
and will also try to identify the allowed exceptions.
The Cogl coding style is currently defined relative to the Clutter
coding style, so please first read clutter/docs/CODING_STYLE.
Differences to the Clutter coding style:
+ Headers
Cogl headers are not exempt from the 80 characters limit as they are in
Clutter. Function prototypes should not be arranged into vertical
columns but should instead follow the "+ Functions" section of the
Clutter CODING_STYLE like:
void
my_function (CoglType type,
CoglType *a_pointer,
CoglType another_type);
+ Types
Avoid the use of redundant glib typedefs and wherever possible simply
use ANSI C types.
The following types should not be used:
gint, guint, gfloat, gdouble, glong, gulong, gchar and guchar
Instead use:
int, unsigned int, float, double, long, unsigned long, char, and
guint8/unsigned char
The glib types that we continue to use for portability are gboolean,
gint{8,16,32,64}, guint{8,16,32,64} and gsize. When ever you need a
byte size type for dealing with pixel data then guint8 should be used.
The general intention is that Cogl should look palatable to the widest
range of C programmers including those outside the Gnome community so
- especially for the public API - we want to minimize the number of
foreign looking typedefs.