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;
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)
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);
pixels to the border */
if (atlas_tex->in_atlas)
{
- gint bpp;
+ int bpp;
CoglBitmap source_bmp;
CoglBitmap tmp_bmp;
gboolean tmp_bmp_owner = FALSE;
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);
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);
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);
} 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);
{
CoglAtlasTextureRepositionData *textures;
/* Number of textures found so far */
- guint n_textures;
+ unsigned int n_textures;
} CoglAtlasTextureGetRectanglesData;
static void
}
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 */
}
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;
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++)
{
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;
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);
{
CoglAtlasNode *root;
- guint space_remaining;
- guint n_rectangles;
+ unsigned int space_remaining;
+ unsigned int n_rectangles;
GDestroyNotify value_destroy_func;
};
}
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);
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
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
gboolean
_cogl_atlas_add_rectangle (CoglAtlas *atlas,
- guint width, guint height,
+ unsigned int width,
+ unsigned int height,
gpointer data,
CoglAtlasRectangle *rectangle)
{
#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;
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);
_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
/* 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];
}
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];
}
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];
}
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];
}
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];
}
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];
}
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];
/* 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];
}
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];
}
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];
}
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];
}
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];
/* (Un)Premultiplication */
inline static void
-_cogl_unpremult_alpha_0 (guchar *dst)
+_cogl_unpremult_alpha_0 (guint8 *dst)
{
dst[0] = 0;
dst[1] = 0;
}
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;
}
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;
} 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);
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))
/* 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++)
{
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))
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)
{
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))
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)
{
gboolean
_cogl_bitmap_fallback_from_file (CoglBitmap *bmp,
- const gchar *filename)
+ const char *filename)
{
/* FIXME: use jpeglib, libpng, etc. manually maybe */
return FALSE;
}
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;
/* 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);
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 */
}
/* allocate buffer big enough to hold pixel data */
- size_t rowstride;
+ gsize rowstride;
rowstride = 4 * width;
guint8 *out_data = g_malloc0 (height * rowstride);
#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);
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);
/* 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 */
#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;
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);
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
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,
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 */
g_free (bmp);
}
-gint
+int
_cogl_get_format_bpp (CoglPixelFormat format)
{
- gint bpp_lut[] = {
+ int bpp_lut[] = {
0, /* invalid */
1, /* A_8 */
3, /* 888 */
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);
}
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;
*
* 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:
*
* 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:
*
* Since: 1.0
*/
-gboolean cogl_is_bitmap (CoglHandle handle);
+gboolean
+cogl_is_bitmap (CoglHandle handle);
G_END_DECLS
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)
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)
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;
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)
{
{
CoglBlendStringColorSourceType type;
const char *name;
- size_t name_len;
+ gsize name_len;
} CoglBlendStringColorSourceInfo;
typedef struct _CoglBlendStringColorSource
{
enum _CoglBlendStringFunctionType type;
const char *name;
- size_t name_len;
+ gsize name_len;
int argc;
} CoglBlendStringFunctionInfo;
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
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);
void
_cogl_buffer_initialize (CoglBuffer *buffer,
- guint size,
+ unsigned int size,
CoglBufferUsageHint usage_hint,
CoglBufferUpdateHint update_hint)
{
ctx->current_pbo = buffer;
}
-guint
+unsigned int
cogl_buffer_get_size_EXP (CoglHandle handle)
{
if (!cogl_is_buffer (handle))
return COGL_BUFFER (handle)->update_hint;
}
-guchar *
+guint8 *
cogl_buffer_map_EXP (CoglHandle handle,
CoglBufferAccess access)
{
gboolean
cogl_buffer_set_data_EXP (CoglHandle handle,
gsize offset,
- const guchar *data,
+ const guint8 *data,
gsize size)
{
CoglBuffer *buffer;
* Since: 1.2
* Stability: Unstable
*/
-guint
+unsigned int
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;
/**
* Stability: Unstable
*/
void
-cogl_buffer_set_update_hint (CoglHandle handle,
+cogl_buffer_set_update_hint (CoglHandle handle,
CoglBufferUpdateHint hint);
/**
* Since: 1.2
* Stability: Unstable
*/
-guchar *
+guint8 *
cogl_buffer_map (CoglHandle handle,
CoglBufferAccess access);
*/
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
gboolean
cogl_is_buffer_EXP (CoglHandle handle);
-guint
+unsigned int
cogl_buffer_get_size_EXP (CoglHandle handle);
void
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);
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
#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);
floatVec2 path_nodes_min;
floatVec2 path_nodes_max;
- guint path_size;
+ unsigned int path_size;
CoglPathNode path[1];
};
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 ());
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 */
*
* Since: 1.0
*/
-CoglColor *cogl_color_new (void);
+CoglColor *
+cogl_color_new (void);
/**
* cogl_color_copy:
*
* Since: 1.0
*/
-CoglColor *cogl_color_copy (const CoglColor *color);
+CoglColor *
+cogl_color_copy (const CoglColor *color);
/**
* cogl_color_free:
*
* Since: 1.0
*/
-void cogl_color_free (CoglColor *color);
+void
+cogl_color_free (CoglColor *color);
/**
* cogl_color_set_from_4ub:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* Since: 1.0
*/
-float cogl_color_get_red (const CoglColor *color);
+float
+cogl_color_get_red (const CoglColor *color);
/**
* cogl_color_get_green:
*
* Since: 1.0
*/
-float cogl_color_get_green (const CoglColor *color);
+float
+cogl_color_get_green (const CoglColor *color);
/**
* cogl_color_get_blue:
*
* Since: 1.0
*/
-float cogl_color_get_blue (const CoglColor *color);
+float
+cogl_color_get_blue (const CoglColor *color);
/**
* cogl_color_get_alpha:
*
* Since: 1.0
*/
-float cogl_color_get_alpha (const CoglColor *color);
+float
+cogl_color_get_alpha (const CoglColor *color);
/**
* cogl_color_premultiply:
*
* Since: 1.0
*/
-void cogl_color_premultiply (CoglColor *color);
+void
+cogl_color_premultiply (CoglColor *color);
/**
* cogl_color_equal:
*
* Since: 1.0
*/
-gboolean cogl_color_equal (gconstpointer v1,
- gconstpointer v2);
+gboolean
+cogl_color_equal (gconstpointer v1,
+ gconstpointer v2);
G_END_DECLS
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)
CoglHandle default_material;
/* Enable cache */
- gulong enable_flags;
+ unsigned long enable_flags;
guint8 color_alpha;
gboolean enable_backface_culling;
/* 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 */
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;
/* 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;
{ "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
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,
#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
#endif /* COGL_ENABLE_DEBUG */
-extern guint cogl_debug_flags;
+extern unsigned int cogl_debug_flags;
G_END_DECLS
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);
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
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);
break;
/* Set the function pointer in the context */
- *(void **) ((guchar *) ctx +
+ *(void **) ((guint8 *) ctx +
data->functions[func_num].pointer_offset) = func;
}
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;
}
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;
/* 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
};
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 */
/* 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;
*
* 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;
#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;
*
* 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
*/
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.
return flt.i + y;
}
-guint
+unsigned int
cogl_fixed_pow2 (CoglFixed x)
{
/* Note: we could easily have a version that produces CoglFixed result,
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)));
}
*
* Since: 1.0
*/
-CoglFixed cogl_fixed_sin (CoglFixed angle);
+CoglFixed
+cogl_fixed_sin (CoglFixed angle);
/**
* cogl_fixed_tan:
*
* Since: 1.0
*/
-CoglFixed cogl_fixed_tan (CoglFixed angle);
+CoglFixed
+cogl_fixed_tan (CoglFixed angle);
/**
* cogl_fixed_cos:
*
* Since: 1.0
*/
-CoglFixed cogl_fixed_cos (CoglFixed angle);
+CoglFixed cogl_fixed_cos (CoglFixed angle);
/**
* cogl_fixed_atani:
*
* Since: 1.0
*/
-CoglFixed cogl_fixed_atani (CoglFixed a);
+CoglFixed
+cogl_fixed_atani (CoglFixed a);
/**
* cogl_fixed_atan2:
*
* 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:
*
* Since: 1.0
*/
-CoglFixed cogl_fixed_sqrt (CoglFixed x);
+CoglFixed
+cogl_fixed_sqrt (CoglFixed x);
/**
* cogl_fixed_log2:
*
* Since: 1.0
*/
-CoglFixed cogl_fixed_log2 (guint x);
+CoglFixed
+cogl_fixed_log2 (unsigned int x);
/**
* cogl_fixed_pow2:
*
* Since: 1.0
*/
-guint cogl_fixed_pow2 (CoglFixed x);
+unsigned int
+cogl_fixed_pow2 (CoglFixed x);
/**
* cogl_fixed_pow:
*
* Since: 1.0
*/
-guint cogl_fixed_pow (guint x,
- CoglFixed y);
+unsigned int
+cogl_fixed_pow (unsigned int x,
+ CoglFixed y);
/**
* cogl_sqrti:
*
* Since: 1.0
*/
-gint cogl_sqrti (gint x);
+int
+cogl_sqrti (int x);
/**
* COGL_ANGLE_FROM_DEG:
*
* Since: 1.0
*/
-CoglFixed cogl_angle_sin (CoglAngle angle);
+CoglFixed
+cogl_angle_sin (CoglAngle angle);
/**
* cogl_angle_tan:
*
* Since: 1.0
*/
-CoglFixed cogl_angle_tan (CoglAngle angle);
+CoglFixed
+cogl_angle_tan (CoglAngle angle);
/**
* cogl_angle_cos:
*
* Since: 1.0
*/
-CoglFixed cogl_angle_cos (CoglAngle angle);
+CoglFixed
+cogl_angle_cos (CoglAngle angle);
/*< private >*/
}
#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
*/
typedef struct _CoglHandleObject
{
- guint ref_count;
+ unsigned int ref_count;
CoglHandleClass *klass;
} CoglHandleObject;
*
* 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
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;
#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; \
#define COGL_ENABLE_COLOR_ARRAY (1<<4)
#define COGL_ENABLE_BACKFACE_CULLING (1<<5)
-void _cogl_features_init (void);
+void
+_cogl_features_init (void);
+
+int
+_cogl_get_format_bpp (CoglPixelFormat format);
-gint _cogl_get_format_bpp (CoglPixelFormat format);
+void
+cogl_enable (gulong flags);
-void cogl_enable (gulong flags);
-gulong cogl_get_enable (void);
+unsigned long
+cogl_get_enable (void);
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
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. */
GLuint vertex_offset;
#ifndef HAVE_COGL_GL
CoglJournalIndices *indices;
- size_t indices_type_size;
+ gsize indices_type_size;
#endif
CoglMatrixStack *modelview_stack;
} CoglJournalFlushState;
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);
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",
* 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);
static void
_cogl_journal_flush_texcoord_vbo_offsets_and_entries (
CoglJournalEntry *batch_start,
- gint batch_len,
+ int batch_len,
void *data)
{
CoglJournalFlushState *state = data;
* 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;
/* 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
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);
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;
/* 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;
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];
GLint blend_src_factor_rgb;
GLint blend_dst_factor_rgb;
- GList *layers;
- guint n_layers;
+ GList *layers;
+ unsigned int n_layers;
};
/*
* 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:
* 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:
-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 */
*/
static CoglMaterialLayer *
_cogl_material_get_layer (CoglMaterial *material,
- gint index_,
+ int index_,
gboolean create_if_not_found)
{
CoglMaterialLayer *layer;
void
cogl_material_set_layer (CoglHandle material_handle,
- gint layer_index,
+ int layer_index,
CoglHandle texture_handle)
{
CoglMaterial *material;
gboolean
cogl_material_set_layer_combine (CoglHandle handle,
- gint layer_index,
+ int layer_index,
const char *combine_description,
GError **error)
{
void
cogl_material_set_layer_combine_constant (CoglHandle handle,
- gint layer_index,
+ int layer_index,
CoglColor *constant_color)
{
CoglMaterial *material;
void
cogl_material_set_layer_matrix (CoglHandle material_handle,
- gint layer_index,
+ int layer_index,
CoglMatrix *matrix)
{
CoglMaterial *material;
void
cogl_material_remove_layer (CoglHandle material_handle,
- gint layer_index)
+ int layer_index)
{
CoglMaterial *material;
CoglMaterialLayer *layer;
/* 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);
return layer->texture;
}
-gulong
+unsigned long
_cogl_material_layer_get_flags (CoglHandle layer_handle)
{
CoglMaterialLayer *layer;
return _cogl_material_layer_handle_new (layer_copy);
}
-static guint
+static unsigned int
get_n_args_for_combine_func (GLint func)
{
switch (func)
void
cogl_material_set_layer_filters (CoglHandle handle,
- gint layer_index,
+ int layer_index,
CoglMaterialFilter min_filter,
CoglMaterialFilter mag_filter)
{
*
* Return value: a handle to the new material
*/
-CoglHandle cogl_material_new (void);
+CoglHandle
+cogl_material_new (void);
/**
* cogl_material_copy:
*
* Since: 1.2
*/
-CoglHandle cogl_material_copy (CoglHandle source);
+CoglHandle
+cogl_material_copy (CoglHandle source);
#ifndef COGL_DISABLE_DEPRECATED
*
* Deprecated: 1.2: Use cogl_handle_ref() instead
*/
-CoglHandle cogl_material_ref (CoglHandle handle);
+CoglHandle
+cogl_material_ref (CoglHandle handle);
/**
* cogl_material_unref:
*
* Deprecated: 1.2: Use cogl_handle_unref() instead
*/
-void cogl_material_unref (CoglHandle handle);
+void
+cogl_material_unref (CoglHandle handle);
#endif /* COGL_DISABLE_DEPRECATED */
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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
*
* Since: 1.0
*/
-float cogl_material_get_shininess (CoglHandle material);
+float
+cogl_material_get_shininess (CoglHandle material);
/**
* cogl_material_set_emission:
*
* 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:
*
* Since: 1.0
*/
-void cogl_material_get_emission (CoglHandle material,
- CoglColor *emission);
+void
+cogl_material_get_emission (CoglHandle material,
+ CoglColor *emission);
/**
* CoglMaterialAlphaFunc:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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);
/**
*/
gboolean
cogl_material_set_layer_combine (CoglHandle material,
- gint layer_index,
+ int layer_index,
const char *blend_string,
GError **error);
*
* 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:
* 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:
* 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:
*
* Since: 1.0
*/
-int cogl_material_get_n_layers (CoglHandle material);
+int
+cogl_material_get_n_layers (CoglHandle material);
/**
* CoglMaterialLayerType:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
* 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
/* 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;
};
/**
* .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:
* 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:
* 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:
* 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:
* 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:
*
* 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:
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
* 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
*
* 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:
* 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:
*
* Since: 1.0
**/
-void cogl_path_fill_preserve (void);
+void
+cogl_path_fill_preserve (void);
/**
* cogl_path_stroke:
* 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);
/**
*
* Since: 1.0
**/
-void cogl_path_stroke_preserve (void);
+void
+cogl_path_stroke_preserve (void);
/**
* cogl_path_new:
*
* Since: 1.0
*/
-void cogl_path_new (void);
+void
+cogl_path_new (void);
/**
* cogl_path_move_to:
* 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);
/**
* 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:
* 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:
* 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);
/**
* 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:
* 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:
* 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:
* 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:
* 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:
* 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);
/**
* 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);
/**
* 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:
* 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:
* 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
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
#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
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);
}
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))
}
#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);
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);
#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;
* Fallback path, buffer->data points to a malloc'ed buffer.
*/
-static guchar *
+static guint8 *
_cogl_malloc_pixel_buffer_map (CoglBuffer *buffer,
CoglBufferAccess access)
{
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;
* Stability: Unstable
*/
CoglHandle
-cogl_pixel_buffer_new (guint size);
+cogl_pixel_buffer_new (unsigned int size);
/**
* cogl_pixel_buffer_new_for_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:
*/
#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
* 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
*
* 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
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);
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;
{
CoglHandle layer = tmp->data;
CoglHandle tex_handle;
- gulong flags;
+ unsigned long flags;
if (cogl_material_layer_get_type (layer)
!= COGL_MATERIAL_LAYER_TYPE_TEXTURE)
void
cogl_rectangles (const float *verts,
- guint n_rects)
+ unsigned int n_rects)
{
struct _CoglMutiTexturedRect *rects;
int i;
void
cogl_rectangles_with_texture_coords (const float *verts,
- guint n_rects)
+ unsigned int n_rects)
{
struct _CoglMutiTexturedRect *rects;
int i;
float x_2,
float y_2,
const float *user_tex_coords,
- gint user_tex_coords_len)
+ int user_tex_coords_len)
{
struct _CoglMutiTexturedRect rect;
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)
{
void
cogl_polygon (const CoglTextureVertex *vertices,
- guint n_vertices,
+ unsigned int n_vertices,
gboolean use_color)
{
CoglHandle material;
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;
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) );
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));
cogl_handle_unref (prev_source);
}
-static gint
+static int
compare_ints (gconstpointer a,
gconstpointer b)
{
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],
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]);
void
cogl_path_polygon (float *coords,
- gint num_points)
+ int num_points)
{
cogl_path_polyline (coords, num_points);
cogl_path_close ();
float angle_1,
float angle_2,
float angle_step,
- guint move_first)
+ unsigned int move_first)
{
float a = 0x0;
float cosa = 0x0;
floatVec2 c3;
floatVec2 c4;
floatVec2 c5;
- gint cindex;
+ int cindex;
/* Put first curve on stack */
cubics[0] = *cubic;
floatVec2 c1;
floatVec2 c2;
floatVec2 c3;
- gint qindex;
+ int qindex;
/* Put first curve on stack */
quads[0] = *quad;
#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
{
{
float x;
float y;
- guint path_size;
+ unsigned int path_size;
};
struct _CoglBezQuad
floatVec2 p4;
};
-void _cogl_journal_flush (void);
+void
+_cogl_journal_flush (void);
#endif /* __COGL_PRIMITIVES_H */
*
* Returns: a new shader handle.
*/
-CoglHandle cogl_create_shader (CoglShaderType shader_type);
+CoglHandle
+cogl_create_shader (CoglShaderType shader_type);
/**
* cogl_shader_ref:
*
* Returns: @handle
*/
-CoglHandle cogl_shader_ref (CoglHandle handle);
+CoglHandle
+cogl_shader_ref (CoglHandle handle);
/**
* cogl_shader_unref:
* 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:
* 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:
* 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.
* 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:
* 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:
* 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:
*
* 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:
*
* Returns: a new cogl program.
*/
-CoglHandle cogl_create_program (void);
+CoglHandle
+cogl_create_program (void);
/**
* cogl_program_ref:
*
* Returns: @handle
*/
-CoglHandle cogl_program_ref (CoglHandle handle);
+CoglHandle
+cogl_program_ref (CoglHandle handle);
/**
* cogl_program_unref:
* 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:
* 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:
* 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);
/**
*
* Links a program making it ready for use.
*/
-void cogl_program_link (CoglHandle handle);
+void
+cogl_program_link (CoglHandle handle);
/**
* cogl_program_use:
* 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:
* 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:
* 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:
* 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:
* 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:
* 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:
* 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
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
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 */
*
* 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
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);
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,
/* 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);
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);
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);
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);
}
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;
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
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);
return sub_tex->sub_width;
}
-static gint
+static int
_cogl_sub_texture_get_height (CoglTexture *tex)
{
CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
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;
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 */
/* 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;
}
}
-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 */
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);
}
{
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);
/* 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);
/* 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++)
{
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++)
{
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);
_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)
&& 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)
&& 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)
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 */
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 */
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))
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;
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);
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;
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);
{
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);
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 (
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)
/* 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,
/* 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 */
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;
return _cogl_texture_2d_handle_new (tex_2d);
}
-static gint
+static int
_cogl_texture_2d_get_max_waste (CoglTexture *tex)
{
return -1;
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;
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);
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)
/* 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,
/* 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) );
/* 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)
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;
CoglTextureSliceCallback callback,
void *user_data);
- gint (* get_max_waste) (CoglTexture *tex);
+ int (* get_max_waste) (CoglTexture *tex);
gboolean (* is_sliced) (CoglTexture *tex);
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
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);
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)
{
}
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)
{
}
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;
/* 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;
}
CoglHandle
-cogl_texture_new_from_file (const gchar *filename,
+cogl_texture_new_from_file (const char *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
GError **error)
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;
return texture;
}
-guint
+unsigned int
cogl_texture_get_width (CoglHandle handle)
{
CoglTexture *tex;
return tex->vtable->get_width (tex);
}
-guint
+unsigned int
cogl_texture_get_height (CoglHandle handle)
{
CoglTexture *tex;
return tex->vtable->get_format (tex);
}
-guint
+unsigned int
cogl_texture_get_rowstride (CoglHandle handle)
{
CoglTexture *tex;
* cogl_texture_get_width (tex));
}
-gint
+int
cogl_texture_get_max_waste (CoglHandle handle)
{
CoglTexture *tex;
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;
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);
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);
GLuint target_gl_format,
GLuint target_gl_type)
{
- gint bpp;
+ int bpp;
CoglHandle framebuffer;
int viewport[4];
CoglBitmap alpha_bmp;
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,
return TRUE;
}
-gint
+int
cogl_texture_get_data (CoglHandle handle,
CoglPixelFormat format,
- guint rowstride,
- guchar *data)
+ unsigned int rowstride,
+ guint8 *data)
{
CoglTexture *tex;
*
* 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
*
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* 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:
* 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:
*
* 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:
*
* 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:
*
* Return value: the #CoglPixelFormat of the GPU side texture
*/
-CoglPixelFormat cogl_texture_get_format (CoglHandle handle);
+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:
*
* 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:
* 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:
* 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:
* 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:
* 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:
*
* 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)
* 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
*
* Return value: the @handle.
*/
-CoglHandle cogl_texture_ref (CoglHandle handle);
+CoglHandle
+cogl_texture_ref (CoglHandle handle);
/**
* cogl_texture_unref:
*
* Deprecated: 1.2: Use cogl_handle_unref() instead
*/
-void cogl_texture_unref (CoglHandle handle);
+void
+cogl_texture_unref (CoglHandle handle);
#endif /* COGL_DISABLE_DEPRECATED */
*
* 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:
*
* 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:
*
* 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:
*
* Since: 1.0
*/
-void cogl_rectangles (const float *verts,
- guint n_rects);
-
+void
+cogl_rectangles (const float *verts,
+ unsigned int n_rects);
/**
* cogl_polygon:
*
* 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
#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:
*
* Returns: the handle, with its reference count increased
*/
-CoglHandle cogl_handle_ref (CoglHandle handle);
+CoglHandle
+cogl_handle_ref (CoglHandle handle);
/**
* cogl_handle_unref:
* 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:
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:
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
*
* 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
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;
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);
}
* 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;
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));
return _cogl_vertex_buffer_handle_new (buffer);
}
-guint
+unsigned int
cogl_vertex_buffer_get_n_vertices (CoglHandle handle)
{
CoglVertexBuffer *buffer;
{
#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;
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;
#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;
{
gboolean fallback =
(cogl_get_features () & COGL_FEATURE_VBOS) ? FALSE : TRUE;
- size_t indices_bytes;
+ gsize indices_bytes;
CoglVertexBufferIndices *indices;
_COGL_GET_CONTEXT (ctx, 0);
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);
}
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);
* 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:
*
* Return value: the number of vertices
*/
-guint
+unsigned int
cogl_vertex_buffer_get_n_vertices (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:
/* 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" },
#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++)
{
#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;
}
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);
}
void
-cogl_clear (const CoglColor *color, gulong buffers)
+cogl_clear (const CoglColor *color, unsigned long buffers)
{
GLbitfield gl_buffers = 0;
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
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
}
void
-cogl_enable (gulong flags)
+cogl_enable (unsigned long flags)
{
/* This function essentially caches glEnable state() in the
* hope of lessening number GL traffic.
GL_COLOR_ARRAY);
}
-gulong
+unsigned long
cogl_get_enable ()
{
_COGL_GET_CONTEXT (ctx, 0);
/* 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,
}
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;
cogl_begin_gl (void)
{
CoglMaterialFlushOptions options;
- gulong enable_flags = 0;
+ unsigned long enable_flags = 0;
int i;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
* 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;
*
* Since: 1.0
*/
-GOptionGroup * cogl_get_option_group (void);
+GOptionGroup *
+cogl_get_option_group (void);
/* Misc */
/**
*
* Since: 0.8
*/
-CoglFeatureFlags cogl_get_features (void);
+CoglFeatureFlags
+cogl_get_features (void);
/**
* cogl_features_available:
*
* 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:
* 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
* 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 */
* 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:
* 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:
*
* 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:
*
* 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:
*
* 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
*
* 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 */
*
* 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:
* 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:
* 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:
* 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:
* 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:
*
* 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:
*
* 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:
*
* 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:
*
* Loads matrix as the new projection matrix.
*/
-void cogl_set_projection_matrix (CoglMatrix *matrix);
+void
+cogl_set_projection_matrix (CoglMatrix *matrix);
/**
* cogl_get_viewport:
* 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:
* 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:
*
* 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:
* 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:
*
* 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:
* 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:
* 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:
* 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:
*
* Since: 1.0
*/
-void cogl_set_source (CoglHandle material);
+void
+cogl_set_source (CoglHandle material);
/**
* cogl_set_source_color:
*
* Since: 1.0
*/
-void cogl_set_source_color (const CoglColor *color);
+void
+cogl_set_source_color (const CoglColor *color);
/**
* cogl_set_source_color4ub:
*
* 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:
*
* 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:
*
* Since: 1.0
*/
-void cogl_set_source_texture (CoglHandle texture_handle);
+void
+cogl_set_source_texture (CoglHandle texture_handle);
/**
* SECTION:cogl-clipping
*
* 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 */
*
* 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
* 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 */
*
* 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:
*
* Since: 1.0
*/
-void cogl_clip_push_from_path (void);
+void
+cogl_clip_push_from_path (void);
/**
* cogl_clip_push_from_path_preserve:
*
* Since: 1.0
*/
-void cogl_clip_push_from_path_preserve (void);
+void
+cogl_clip_push_from_path_preserve (void);
/**
* cogl_clip_pop:
* 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
*
* Since: 1.0
*/
-void cogl_clip_ensure (void) G_GNUC_DEPRECATED;
+void
+cogl_clip_ensure (void) G_GNUC_DEPRECATED;
/**
* cogl_clip_stack_save:
*
* 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:
*
* 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 */
*
* Since: 1.2
*/
-void cogl_set_framebuffer (CoglHandle buffer);
+void
+cogl_set_framebuffer (CoglHandle buffer);
/**
* cogl_push_framebuffer:
*
* Since: 1.2
*/
-void cogl_push_framebuffer (CoglHandle buffer);
+void
+cogl_push_framebuffer (CoglHandle buffer);
/**
* cogl_pop_framebuffer:
*
* Since: 1.2
*/
-void cogl_pop_framebuffer (void);
+void
+cogl_pop_framebuffer (void);
#ifndef COGL_DISABLE_DEPRECATED
* 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:
*
* 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:
*
* 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 */
* 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:
*
* Since: 1.0
*/
-void cogl_flush (void);
+void
+cogl_flush (void);
/**
* cogl_begin_gl:
*
* Since: 1.0
*/
-void cogl_begin_gl (void);
+void
+cogl_begin_gl (void);
/**
* cogl_end_gl:
*
* Since: 1.0
*/
-void cogl_end_gl (void);
+void
+cogl_end_gl (void);
/*
* Internal API available only to Clutter.
* 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 ())
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);
int
cogl_program_get_uniform_location (CoglHandle handle,
- const gchar *uniform_name)
+ const char *uniform_name)
{
CoglProgram *program;
_COGL_GET_CONTEXT (ctx, 0);
void
cogl_program_uniform_1f (int uniform_no,
- gfloat value)
+ float value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
glUniform1f (uniform_no, value);
void
cogl_program_uniform_1i (int uniform_no,
- gint value)
+ int value)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
glUniform1i (uniform_no, value);
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);
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);
void
cogl_program_uniform_matrix (int uniform_no,
- gint size,
- gint count,
+ int size,
+ int count,
gboolean transpose,
const GLfloat *value)
{
glCompileShader (shader->gl_handle);
}
-gchar *
+char *
cogl_shader_get_info_log (CoglHandle handle)
{
CoglShader *shader;
GLsizei n,
GLuint *textures)
{
- guint i;
+ unsigned int i;
GE (glGenTextures (n, textures));
_cogl_check_driver_valid (GError **error)
{
int major, minor;
- const gchar *gl_extensions;
+ const char *gl_extensions;
if (!_cogl_get_gl_version (&major, &minor))
{
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 */
_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;
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))
case COGL_BOXED_INT:
{
- gint *ptr;
+ int *ptr;
if (value->count == 1)
ptr = value->v.int_value;
case COGL_BOXED_FLOAT:
{
- gfloat *ptr;
+ float *ptr;
if (value->count == 1)
ptr = value->v.float_value;
case COGL_BOXED_MATRIX:
{
- gfloat *ptr;
+ float *ptr;
if (value->count == 1)
ptr = value->v.matrix;
/* 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
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
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];
int
cogl_program_get_uniform_location (CoglHandle handle,
- const gchar *uniform_name)
+ const char *uniform_name)
{
int i;
CoglProgram *program;
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);
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,
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)
{
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)
{
glCompileShader (shader->gl_handle);
}
-gchar *
+char *
cogl_shader_get_info_log (CoglHandle handle)
{
CoglShader *shader;
{
}
-gchar *
+char *
cogl_shader_get_info_log (CoglHandle handle)
{
return NULL;
GLsizei n,
GLuint *textures)
{
- guint i;
+ unsigned int i;
GE (glGenTextures (n, textures));
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,
--- /dev/null
+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.
+
projects / profile / ivi / clutter.git / commitdiff