CoglTexture *
cogl_texture_new_from_data (CoglContext *ctx,
int width,
int height,
CoglTextureFlags flags,
CoglPixelFormat format,
CoglPixelFormat internal_format,
int rowstride,
const uint8_t *data,
CoglError **error)
{
CoglBitmap *bmp;
CoglTexture *tex;
_COGL_RETURN_VAL_IF_FAIL (format != COGL_PIXEL_FORMAT_ANY, NULL);
_COGL_RETURN_VAL_IF_FAIL (data != NULL, NULL);
/* Rowstride from width if not given */
if (rowstride == 0)
rowstride = width * _cogl_pixel_format_get_bytes_per_pixel (format);
/* Wrap the data into a bitmap */
bmp = cogl_bitmap_new_for_data (ctx,
width, height,
format,
rowstride,
(uint8_t *) data);
tex = cogl_texture_new_from_bitmap (bmp, flags, internal_format, error);
cogl_object_unref (bmp);
return tex;
}
CoglHandle
cogl_texture_new_from_file (const char *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
GError **error)
{
CoglBitmap *bmp;
CoglHandle handle = COGL_INVALID_HANDLE;
CoglPixelFormat src_format;
g_return_val_if_fail (error == NULL || *error == NULL, COGL_INVALID_HANDLE);
bmp = cogl_bitmap_new_from_file (filename, error);
if (bmp == NULL)
return COGL_INVALID_HANDLE;
src_format = _cogl_bitmap_get_format (bmp);
/* We know that the bitmap data is solely owned by this function so
we can do the premult conversion in place. This avoids having to
copy the bitmap which will otherwise happen in
_cogl_texture_prepare_for_upload */
internal_format =
_cogl_texture_determine_internal_format (src_format, internal_format);
if (!_cogl_texture_needs_premult_conversion (src_format, internal_format) ||
_cogl_bitmap_convert_premult_status (bmp, src_format ^ COGL_PREMULT_BIT))
handle = cogl_texture_new_from_bitmap (bmp, flags, internal_format);
cogl_object_unref (bmp);
return handle;
}
static void
clutter_canvas_paint_content (ClutterContent *content,
ClutterActor *actor,
ClutterPaintNode *root)
{
ClutterCanvas *self = CLUTTER_CANVAS (content);
ClutterCanvasPrivate *priv = self->priv;
ClutterPaintNode *node;
if (priv->buffer == NULL)
return;
if (priv->dirty)
g_clear_pointer (&priv->texture, cogl_object_unref);
if (priv->texture == NULL)
priv->texture = cogl_texture_new_from_bitmap (priv->buffer,
COGL_TEXTURE_NO_SLICING,
CLUTTER_CAIRO_FORMAT_ARGB32);
if (priv->texture == NULL)
return;
node = clutter_actor_create_texture_paint_node (actor, priv->texture);
clutter_paint_node_set_name (node, "Canvas Content");
clutter_paint_node_add_child (root, node);
clutter_paint_node_unref (node);
priv->dirty = FALSE;
}
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,
const unsigned int offset)
{
CoglHandle texture;
CoglBuffer *cogl_buffer;
CoglPixelArray *pixel_array;
CoglBitmap *bmp;
g_return_val_if_fail (cogl_is_buffer (buffer), COGL_INVALID_HANDLE);
if (format == COGL_PIXEL_FORMAT_ANY)
return COGL_INVALID_HANDLE;
cogl_buffer = COGL_BUFFER (buffer);
pixel_array = COGL_PIXEL_ARRAY (buffer);
/* Rowstride from CoglBuffer or even width * bpp if not given */
if (rowstride == 0)
rowstride = pixel_array->stride;
if (rowstride == 0)
rowstride = width * _cogl_get_format_bpp (format);
/* use the CoglBuffer height and width as last resort */
if (width == 0)
width = pixel_array->width;
if (height == 0)
height = pixel_array->height;
if (width == 0 || height == 0)
{
/* no width or height specified, neither at creation time (because the
* array was created by cogl_pixel_array_new()) nor when calling this
* function */
return COGL_INVALID_HANDLE;
}
/* Wrap the buffer into a bitmap */
bmp = _cogl_bitmap_new_from_buffer (cogl_buffer,
format,
width, height,
rowstride,
offset);
texture = cogl_texture_new_from_bitmap (bmp, flags, internal_format);
cogl_object_unref (bmp);
return texture;
}
CoglTexture *
cogl_texture_new_from_file (CoglContext *ctx,
const char *filename,
CoglTextureFlags flags,
CoglPixelFormat internal_format,
CoglError **error)
{
CoglBitmap *bmp;
CoglTexture *texture = NULL;
CoglPixelFormat src_format;
_COGL_RETURN_VAL_IF_FAIL (error == NULL || *error == NULL, NULL);
bmp = cogl_bitmap_new_from_file (ctx, filename, error);
if (bmp == NULL)
return NULL;
src_format = cogl_bitmap_get_format (bmp);
/* We know that the bitmap data is solely owned by this function so
we can do the premult conversion in place. This avoids having to
copy the bitmap which will otherwise happen in
_cogl_texture_prepare_for_upload */
internal_format =
_cogl_texture_determine_internal_format (src_format, internal_format);
if (!_cogl_texture_needs_premult_conversion (src_format, internal_format) ||
_cogl_bitmap_convert_premult_status (bmp,
src_format ^ COGL_PREMULT_BIT,
error))
{
texture =
cogl_texture_new_from_bitmap (bmp, flags, internal_format, error);
}
cogl_object_unref (bmp);
return texture;
}
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)
{
CoglBitmap *bmp;
CoglHandle tex;
if (format == COGL_PIXEL_FORMAT_ANY)
return COGL_INVALID_HANDLE;
if (data == NULL)
return COGL_INVALID_HANDLE;
/* Rowstride from width if not given */
if (rowstride == 0)
rowstride = width * _cogl_get_format_bpp (format);
/* Wrap the data into a bitmap */
bmp = _cogl_bitmap_new_from_data ((guint8 *) data,
format,
width,
height,
rowstride,
NULL, NULL);
tex = cogl_texture_new_from_bitmap (bmp, flags, internal_format);
cogl_object_unref (bmp);
return tex;
}
