/* cairo - a vector graphics library with display and print output
*
* Copyright © 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it either under the terms of the GNU Lesser General Public
* License version 2.1 as published by the Free Software Foundation
* (the "LGPL") or, at your option, under the terms of the Mozilla
* Public License Version 1.1 (the "MPL"). If you do not alter this
* notice, a recipient may use your version of this file under either
* the MPL or the LGPL.
*
* You should have received a copy of the LGPL along with this library
* in the file COPYING-LGPL-2.1; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
* You should have received a copy of the MPL along with this library
* in the file COPYING-MPL-1.1
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.og/MPL/
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
* OF ANY KIND, either express or implied. See the LGPL or the MPL for
* the specific language governing rights and limitations.
*
* Contributor(s):
* Robert Bragg <robert@linux.intel.com>
*/
#include "cairoint.h"
#include "cairo-cache-private.h"
#include "cairo-error-private.h"
#include "cairo-path-fixed-private.h"
#include "cairo-recording-surface-private.h"
#include "cairo-surface-clipper-private.h"
#include "cairo-fixed-private.h"
#include "cairo-device-private.h"
#include "cairo-composite-rectangles-private.h"
#include "cairo-image-surface-inline.h"
#include "cairo-cogl-private.h"
#include "cairo-cogl-gradient-private.h"
#include "cairo-arc-private.h"
#include "cairo-traps-private.h"
#include "cairo-cogl-context-private.h"
#include "cairo-cogl-utils-private.h"
#include "cairo-box-inline.h"
#include "cairo-surface-subsurface-inline.h"
#include "cairo-surface-fallback-private.h"
#include "cairo-surface-offset-private.h"
#include "cairo-cogl.h"
#include <cogl/cogl2-experimental.h>
#include <glib.h>
#define CAIRO_COGL_DEBUG 0
//#define FILL_WITH_COGL_PATH
//#define USE_CAIRO_PATH_FLATTENER
#define ENABLE_PATH_CACHE
//#define DISABLE_BATCHING
#define USE_COGL_RECTANGLE_API
#define ENABLE_RECTANGLES_FASTPATH
#if defined (USE_COGL_RECTANGLE_API) || defined (ENABLE_PATH_CACHE)
#define NEED_COGL_CONTEXT
#endif
#if CAIRO_COGL_DEBUG && __GNUC__
#define UNSUPPORTED(reason) ({ \
g_warning ("cairo-cogl: hit unsupported operation: %s", reason); \
CAIRO_INT_STATUS_UNSUPPORTED; \
})
#else
#define UNSUPPORTED(reason) CAIRO_INT_STATUS_UNSUPPORTED
#endif
#define CAIRO_COGL_PATH_META_CACHE_SIZE (1024 * 1024)
typedef struct _cairo_cogl_texture_attributes {
/* nabbed from cairo_surface_attributes_t... */
cairo_matrix_t matrix;
cairo_extend_t extend;
cairo_filter_t filter;
cairo_bool_t has_component_alpha;
CoglPipelineWrapMode s_wrap;
CoglPipelineWrapMode t_wrap;
} cairo_cogl_texture_attributes_t;
typedef enum _cairo_cogl_journal_entry_type {
CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE,
CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE,
CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH,
CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP
} cairo_cogl_journal_entry_type_t;
typedef struct _cairo_cogl_journal_entry {
cairo_cogl_journal_entry_type_t type;
} cairo_cogl_journal_entry_t;
typedef struct _cairo_cogl_journal_clip_entry {
cairo_cogl_journal_entry_t base;
cairo_clip_t *clip;
} cairo_cogl_journal_clip_entry_t;
typedef struct _cairo_cogl_journal_rect_entry {
cairo_cogl_journal_entry_t base;
CoglPipeline *pipeline;
float x;
float y;
float width;
float height;
int n_layers;
cairo_matrix_t ctm;
} cairo_cogl_journal_rect_entry_t;
typedef struct _cairo_cogl_journal_prim_entry {
cairo_cogl_journal_entry_t base;
CoglPipeline *pipeline;
CoglPrimitive *primitive;
gboolean has_transform;
cairo_matrix_t transform;
} cairo_cogl_journal_prim_entry_t;
typedef struct _cairo_cogl_journal_path_entry {
cairo_cogl_journal_entry_t base;
CoglPipeline *pipeline;
CoglPath *path;
} cairo_cogl_journal_path_entry_t;
typedef struct _cairo_cogl_path_fill_meta {
cairo_cache_entry_t cache_entry;
cairo_reference_count_t ref_count;
int counter;
cairo_path_fixed_t *user_path;
cairo_matrix_t ctm_inverse;
/* TODO */
#if 0
/* A cached path tessellation should be re-usable with different rotations
* and translations but not for different scales.
*
* one idea is to track the diagonal lenghts of a unit rectangle
* transformed through the original ctm use to tesselate the geometry
* so we can check what the lengths are for any new ctm to know if
* this geometry is compatible.
*/
#endif
CoglPrimitive *prim;
} cairo_cogl_path_fill_meta_t;
typedef struct _cairo_cogl_path_stroke_meta {
cairo_cache_entry_t cache_entry;
cairo_reference_count_t ref_count;
int counter;
cairo_path_fixed_t *user_path;
cairo_matrix_t ctm_inverse;
cairo_stroke_style_t style;
double tolerance;
/* TODO */
#if 0
/* A cached path tessellation should be re-usable with different rotations
* and translations but not for different scales.
*
* one idea is to track the diagonal lenghts of a unit rectangle
* transformed through the original ctm use to tesselate the geometry
* so we can check what the lengths are for any new ctm to know if
* this geometry is compatible.
*/
#endif
CoglPrimitive *prim;
} cairo_cogl_path_stroke_meta_t;
static cairo_surface_t *
_cairo_cogl_surface_create_full (cairo_cogl_device_t *dev,
cairo_bool_t ignore_alpha,
CoglFramebuffer *framebuffer,
CoglTexture *texture);
static cairo_int_status_t
_cairo_cogl_surface_fill (void *abstract_surface,
cairo_operator_t op,
const cairo_pattern_t *source,
const cairo_path_fixed_t *path,
cairo_fill_rule_t fill_rule,
double tolerance,
cairo_antialias_t antialias,
const cairo_clip_t *clip);
static void
_cairo_cogl_journal_flush (cairo_cogl_surface_t *surface);
cairo_private extern const cairo_surface_backend_t _cairo_cogl_surface_backend;
slim_hidden_proto (cairo_cogl_device_create);
slim_hidden_proto (cairo_cogl_surface_create);
slim_hidden_proto (cairo_cogl_surface_get_framebuffer);
slim_hidden_proto (cairo_cogl_surface_get_texture);
slim_hidden_proto (cairo_cogl_surface_end_frame);
static cairo_cogl_device_t *
to_device (cairo_device_t *device)
{
return (cairo_cogl_device_t *)device;
}
/* moves trap points such that they become the actual corners of the trapezoid */
static void
_sanitize_trap (cairo_trapezoid_t *t)
{
cairo_trapezoid_t s = *t;
#define FIX(lr, tb, p) \
if (t->lr.p.y != t->tb) { \
t->lr.p.x = s.lr.p2.x + _cairo_fixed_mul_div_floor (s.lr.p1.x - s.lr.p2.x, s.tb - s.lr.p2.y, s.lr.p1.y - s.lr.p2.y); \
t->lr.p.y = s.tb; \
}
FIX (left, top, p1);
FIX (left, bottom, p2);
FIX (right, top, p1);
FIX (right, bottom, p2);
}
static cairo_status_t
_cairo_cogl_surface_ensure_framebuffer (cairo_cogl_surface_t *surface)
{
GError *error = NULL;
if (surface->framebuffer)
return CAIRO_STATUS_SUCCESS;
surface->framebuffer = COGL_FRAMEBUFFER (cogl_offscreen_new_to_texture (surface->texture));
if (!cogl_framebuffer_allocate (surface->framebuffer, &error)) {
g_error_free (error);
cogl_object_unref (surface->framebuffer);
surface->framebuffer = NULL;
return CAIRO_STATUS_NO_MEMORY;
}
cogl_push_framebuffer (surface->framebuffer);
cogl_ortho (0, surface->width,
surface->height, 0,
-1, 100);
cogl_pop_framebuffer ();
return CAIRO_STATUS_SUCCESS;
}
static cairo_surface_t *
_cairo_cogl_surface_create_similar (void *abstract_surface,
cairo_content_t content,
int width,
int height)
{
cairo_cogl_surface_t *reference_surface = abstract_surface;
cairo_cogl_surface_t *surface;
CoglTexture *texture;
cairo_status_t status;
texture = cogl_texture_new_with_size (width, height,
COGL_TEXTURE_NO_SLICING,
(content & CAIRO_CONTENT_COLOR) ?
COGL_PIXEL_FORMAT_BGRA_8888_PRE :
COGL_PIXEL_FORMAT_A_8);
if (!texture)
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
surface = (cairo_cogl_surface_t *)
_cairo_cogl_surface_create_full (to_device(reference_surface->base.device),
(content & CAIRO_CONTENT_ALPHA) == 0,
NULL,
texture);
if (unlikely (surface->base.status))
return &surface->base;
status = _cairo_cogl_surface_ensure_framebuffer (surface);
if (unlikely (status)) {
cairo_surface_destroy (&surface->base);
return _cairo_surface_create_in_error (status);
}
return &surface->base;
}
static cairo_bool_t
_cairo_cogl_surface_get_extents (void *abstract_surface,
cairo_rectangle_int_t *extents)
{
cairo_cogl_surface_t *surface = abstract_surface;
extents->x = 0;
extents->y = 0;
extents->width = surface->width;
extents->height = surface->height;
return TRUE;
}
static void
_cairo_cogl_journal_free (cairo_cogl_surface_t *surface)
{
GList *l;
for (l = surface->journal->head; l; l = l->next) {
cairo_cogl_journal_entry_t *entry = l->data;
if (entry->type == CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE) {
cairo_cogl_journal_prim_entry_t *prim_entry =
(cairo_cogl_journal_prim_entry_t *)entry;
cogl_object_unref (prim_entry->primitive);
} else if (entry->type == CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH) {
cairo_cogl_journal_path_entry_t *path_entry =
(cairo_cogl_journal_path_entry_t *)entry;
cogl_object_unref (path_entry->path);
}
}
g_queue_free (surface->journal);
surface->journal = NULL;
}
#ifdef FILL_WITH_COGL_PATH
static void
_cairo_cogl_journal_log_path (cairo_cogl_surface_t *surface,
CoglPipeline *pipeline,
CoglPath *path)
{
cairo_cogl_journal_path_entry_t *entry;
if (unlikely (surface->journal == NULL))
surface->journal = g_queue_new ();
/* FIXME: Instead of a GList here we should stack allocate the journal
* entries so it would be cheaper to allocate and they can all be freed in
* one go after flushing! */
entry = g_slice_new (cairo_cogl_journal_path_entry_t);
entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH;
entry->pipeline = cogl_object_ref (pipeline);
entry->path = cogl_object_ref (path);
g_queue_push_tail (surface->journal, entry);
#ifdef DISABLE_BATCHING
_cairo_cogl_journal_flush (surface);
#endif
}
#endif /* FILL_WITH_COGL_PATH */
static void
_cairo_cogl_journal_log_primitive (cairo_cogl_surface_t *surface,
CoglPipeline *pipeline,
CoglPrimitive *primitive,
cairo_matrix_t *transform)
{
cairo_cogl_journal_prim_entry_t *entry;
if (unlikely (surface->journal == NULL))
surface->journal = g_queue_new ();
/* FIXME: Instead of a GList here we should stack allocate the journal
* entries so it would be cheaper to allocate and they can all be freed in
* one go after flushing! */
entry = g_slice_new (cairo_cogl_journal_prim_entry_t);
entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE;
entry->pipeline = cogl_object_ref (pipeline);
if (transform) {
entry->transform = *transform;
entry->has_transform = TRUE;
} else
entry->has_transform = FALSE;
entry->primitive = cogl_object_ref (primitive);
g_queue_push_tail (surface->journal, entry);
#ifdef DISABLE_BATCHING
_cairo_cogl_journal_flush (surface);
#endif
}
static void
_cairo_cogl_journal_log_rectangle (cairo_cogl_surface_t *surface,
CoglPipeline *pipeline,
float x,
float y,
float width,
float height,
int n_layers,
cairo_matrix_t *ctm)
{
cairo_cogl_journal_rect_entry_t *entry;
if (unlikely (surface->journal == NULL))
surface->journal = g_queue_new ();
/* FIXME: Instead of a GList here we should stack allocate the journal
* entries so it would be cheaper to allocate and they can all be freed in
* one go after flushing! */
entry = g_slice_new (cairo_cogl_journal_rect_entry_t);
entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE;
entry->pipeline = cogl_object_ref (pipeline);
entry->x = x;
entry->y = y;
entry->width = width;
entry->height = height;
entry->ctm = *ctm;
entry->n_layers = n_layers;
g_queue_push_tail (surface->journal, entry);
#ifdef DISABLE_BATCHING
_cairo_cogl_journal_flush (surface);
#endif
}
static void
_cairo_cogl_journal_log_clip (cairo_cogl_surface_t *surface,
const cairo_clip_t *clip)
{
cairo_cogl_journal_clip_entry_t *entry;
if (unlikely (surface->journal == NULL))
surface->journal = g_queue_new ();
/* FIXME: Instead of a GList here we should stack allocate the journal
* entries so it would be cheaper to allocate and they can all be freed in
* one go after flushing! */
entry = g_slice_new (cairo_cogl_journal_clip_entry_t);
entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP;
entry->clip = _cairo_clip_copy (clip);
g_queue_push_tail (surface->journal, entry);
}
static void
_cairo_cogl_journal_discard (cairo_cogl_surface_t *surface)
{
GList *l;
if (!surface->journal) {
assert (surface->last_clip == NULL);
return;
}
if (surface->buffer_stack && surface->buffer_stack_offset) {
cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack));
cogl_object_unref (surface->buffer_stack);
surface->buffer_stack = NULL;
}
for (l = surface->journal->head; l; l = l->next) {
cairo_cogl_journal_entry_t *entry = l->data;
gsize entry_size;
switch (entry->type)
{
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP: {
cairo_cogl_journal_clip_entry_t *clip_entry =
(cairo_cogl_journal_clip_entry_t *)entry;
_cairo_clip_destroy (clip_entry->clip);
entry_size = sizeof (cairo_cogl_journal_clip_entry_t);
break;
}
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE: {
cairo_cogl_journal_rect_entry_t *rect_entry =
(cairo_cogl_journal_rect_entry_t *)entry;
cogl_object_unref (rect_entry->pipeline);
entry_size = sizeof (cairo_cogl_journal_rect_entry_t);
break;
}
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE: {
cairo_cogl_journal_prim_entry_t *prim_entry =
(cairo_cogl_journal_prim_entry_t *)entry;
cogl_object_unref (prim_entry->pipeline);
cogl_object_unref (prim_entry->primitive);
entry_size = sizeof (cairo_cogl_journal_prim_entry_t);
break;
}
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH: {
cairo_cogl_journal_path_entry_t *path_entry =
(cairo_cogl_journal_path_entry_t *)entry;
cogl_object_unref (path_entry->pipeline);
cogl_object_unref (path_entry->path);
entry_size = sizeof (cairo_cogl_journal_path_entry_t);
break;
}
default:
assert (0); /* not reached! */
entry_size = 0; /* avoid compiler warning */
}
g_slice_free1 (entry_size, entry);
}
g_queue_clear (surface->journal);
if (surface->last_clip) {
_cairo_clip_destroy (surface->last_clip);
surface->last_clip = NULL;
}
}
static CoglAttributeBuffer *
_cairo_cogl_surface_allocate_buffer_space (cairo_cogl_surface_t *surface,
size_t size,
size_t *offset,
void **pointer)
{
/* XXX: In the Cogl journal we found it more efficient to have a pool of
* buffers that we re-cycle but for now we simply thow away our stack
* buffer each time we flush. */
if (unlikely (surface->buffer_stack &&
(surface->buffer_stack_size - surface->buffer_stack_offset) < size)) {
cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack));
cogl_object_unref (surface->buffer_stack);
surface->buffer_stack = NULL;
surface->buffer_stack_size *= 2;
}
if (unlikely (surface->buffer_stack_size < size))
surface->buffer_stack_size = size * 2;
if (unlikely (surface->buffer_stack == NULL)) {
surface->buffer_stack = cogl_attribute_buffer_new (surface->buffer_stack_size, NULL);
surface->buffer_stack_pointer =
cogl_buffer_map (COGL_BUFFER (surface->buffer_stack),
COGL_BUFFER_ACCESS_WRITE,
COGL_BUFFER_MAP_HINT_DISCARD);
surface->buffer_stack_offset = 0;
}
*pointer = surface->buffer_stack_pointer + surface->buffer_stack_offset;
*offset = surface->buffer_stack_offset;
surface->buffer_stack_offset += size;
return cogl_object_ref (surface->buffer_stack);
}
static CoglAttributeBuffer *
_cairo_cogl_traps_to_triangles_buffer (cairo_cogl_surface_t *surface,
cairo_traps_t *traps,
size_t *offset,
gboolean one_shot)
{
CoglAttributeBuffer *buffer;
int n_traps = traps->num_traps;
int i;
CoglVertexP2 *triangles;
if (one_shot) {
buffer = _cairo_cogl_surface_allocate_buffer_space (surface,
n_traps * sizeof (CoglVertexP2) * 6,
offset,
(void **)&triangles);
if (!buffer)
return NULL;
} else {
buffer = cogl_attribute_buffer_new (n_traps * sizeof (CoglVertexP2) * 6, NULL);
if (!buffer)
return NULL;
triangles = cogl_buffer_map (COGL_BUFFER (buffer),
COGL_BUFFER_ACCESS_WRITE,
COGL_BUFFER_MAP_HINT_DISCARD);
if (!triangles)
return NULL;
*offset = 0;
}
/* XXX: This is can be very expensive. I'm not sure a.t.m if it's
* predominantly the bandwidth required or the cost of the fixed_to_float
* conversions but either way we should try using an index buffer to
* reduce the amount we upload by 1/3 (offset by allocating and uploading
* indices though) sadly though my experience with the intel mesa drivers
* is that slow paths can easily be hit when starting to use indices.
*/
for (i = 0; i < n_traps; i++)
{
CoglVertexP2 *p = &triangles[i * 6];
cairo_trapezoid_t *trap = &traps->traps[i];
p[0].x = _cairo_cogl_util_fixed_to_float (trap->left.p1.x);
p[0].y = _cairo_cogl_util_fixed_to_float (trap->left.p1.y);
p[1].x = _cairo_cogl_util_fixed_to_float (trap->left.p2.x);
p[1].y = _cairo_cogl_util_fixed_to_float (trap->left.p2.y);
p[2].x = _cairo_cogl_util_fixed_to_float (trap->right.p2.x);
p[2].y = _cairo_cogl_util_fixed_to_float (trap->right.p2.y);
p[3].x = _cairo_cogl_util_fixed_to_float (trap->left.p1.x);
p[3].y = _cairo_cogl_util_fixed_to_float (trap->left.p1.y);
p[4].x = _cairo_cogl_util_fixed_to_float (trap->right.p2.x);
p[4].y = _cairo_cogl_util_fixed_to_float (trap->right.p2.y);
p[5].x = _cairo_cogl_util_fixed_to_float (trap->right.p1.x);
p[5].y = _cairo_cogl_util_fixed_to_float (trap->right.p1.y);
}
if (!one_shot)
cogl_buffer_unmap (COGL_BUFFER (buffer));
return buffer;
}
/* Used for solid fills, in this case we just need a mesh made of
* a single (2-component) position attribute. */
static CoglPrimitive *
_cairo_cogl_traps_to_composite_prim_p2 (cairo_cogl_surface_t *surface,
cairo_traps_t *traps,
gboolean one_shot)
{
size_t offset;
CoglAttributeBuffer *buffer = _cairo_cogl_traps_to_triangles_buffer (surface, traps, &offset, one_shot);
CoglAttribute *pos = cogl_attribute_new (buffer,
"cogl_position_in",
sizeof (CoglVertexP2),
offset,
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
CoglPrimitive *prim;
/* The attribute will have taken a reference on the buffer */
cogl_object_unref (buffer);
prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES,
traps->num_traps * 6, pos, NULL);
/* The primitive will now keep the attribute alive... */
cogl_object_unref (pos);
return prim;
}
/* Used for surface fills, in this case we need a mesh made of a single
* (2-component) position attribute + we also alias the same attribute as
* (2-component) texture coordinates */
static CoglPrimitive *
_cairo_cogl_traps_to_composite_prim_p2t2 (cairo_cogl_surface_t *surface,
cairo_traps_t *traps,
gboolean one_shot)
{
size_t offset;
CoglAttributeBuffer *buffer = _cairo_cogl_traps_to_triangles_buffer (surface, traps, &offset, one_shot);
CoglAttribute *pos = cogl_attribute_new (buffer,
"cogl_position_in",
sizeof (CoglVertexP2),
offset,
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
CoglAttribute *tex_coords = cogl_attribute_new (buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP2),
0,
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
CoglPrimitive *prim;
/* The attributes will have taken references on the buffer */
cogl_object_unref (buffer);
prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES,
traps->num_traps * 6, pos, tex_coords, NULL);
/* The primitive will now keep the attributes alive... */
cogl_object_unref (pos);
cogl_object_unref (tex_coords);
return prim;
}
static CoglPrimitive *
_cairo_cogl_traps_to_composite_prim (cairo_cogl_surface_t *surface,
cairo_traps_t *traps,
int n_layers,
gboolean one_shot)
{
int n_traps = traps->num_traps;
int i;
/* XXX: Ideally we would skip tessellating to traps entirely since
* given their representation, conversion to triangles is quite expensive.
*
* This simplifies the conversion to triangles by making the end points of
* the two side lines actually just correspond to the corners of the
* traps.
*/
for (i = 0; i < n_traps; i++)
_sanitize_trap (&traps->traps[i]);
if (n_layers == 0)
return _cairo_cogl_traps_to_composite_prim_p2 (surface, traps, one_shot);
else {
assert (n_layers == 1);
return _cairo_cogl_traps_to_composite_prim_p2t2 (surface, traps, one_shot);
}
}
static cairo_int_status_t
_cairo_cogl_fill_to_primitive (cairo_cogl_surface_t *surface,
const cairo_path_fixed_t *path,
cairo_fill_rule_t fill_rule,
double tolerance,
int n_layers,
cairo_bool_t one_shot,
CoglPrimitive **primitive,
size_t *size)
{
cairo_traps_t traps;
cairo_int_status_t status;
_cairo_traps_init (&traps);
status = _cairo_path_fixed_fill_to_traps (path, fill_rule, tolerance, &traps);
if (unlikely (status))
goto BAIL;
if (traps.num_traps == 0) {
status = CAIRO_INT_STATUS_NOTHING_TO_DO;
goto BAIL;
}
*size = traps.num_traps * sizeof (CoglVertexP2) * 6;
*primitive = _cairo_cogl_traps_to_composite_prim (surface, &traps, n_layers, one_shot);
if (!*primitive) {
status = CAIRO_INT_STATUS_NO_MEMORY;
goto BAIL;
}
BAIL:
_cairo_traps_fini (&traps);
return status;
}
static void
_cairo_cogl_clip_push_box (const cairo_box_t *box)
{
if (_cairo_box_is_pixel_aligned (box)) {
cairo_rectangle_int_t rect;
_cairo_box_round_to_rectangle (box, &rect);
cogl_clip_push_window_rectangle (rect.x, rect.y,
rect.width, rect.height);
} else {
double x1, y1, x2, y2;
_cairo_box_to_doubles (box, &x1, &y1, &x2, &y2);
cogl_clip_push_rectangle (x1, y1, x2, y2);
}
}
static void
_cairo_cogl_journal_flush (cairo_cogl_surface_t *surface)
{
GList *l;
int clip_stack_depth = 0;
int i;
if (!surface->journal)
return;
if (surface->buffer_stack && surface->buffer_stack_offset) {
cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack));
cogl_object_unref (surface->buffer_stack);
surface->buffer_stack = NULL;
}
cogl_set_framebuffer (surface->framebuffer);
cogl_push_matrix ();
for (l = surface->journal->head; l; l = l->next) {
cairo_cogl_journal_entry_t *entry = l->data;
switch (entry->type)
{
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP: {
cairo_cogl_journal_clip_entry_t *clip_entry =
(cairo_cogl_journal_clip_entry_t *)entry;
cairo_clip_path_t *path;
#if 0
cairo_bool_t checked_for_primitives = FALSE;
cairo_cogl_clip_primitives_t *clip_primitives;
#endif
for (i = 0; i < clip_stack_depth; i++)
cogl_clip_pop ();
clip_stack_depth = 0;
for (path = clip_entry->clip->path, i = 0; path; path = path->prev, i++) {
cairo_rectangle_int_t extents;
cairo_int_status_t status;
CoglPrimitive *prim;
size_t prim_size;
_cairo_path_fixed_approximate_clip_extents (&path->path, &extents);
/* TODO - maintain a fifo of the last 10 used clips with cached
* primitives to see if we can avoid tesselating the path and
* uploading the vertices...
*/
#if 0
if (!checked_for_primitives) {
clip_primitives = find_clip_primitives (clip);
checked_for_primitives = TRUE;
}
if (clip_primitives)
prim = clip_primitives->primitives[i];
#endif
status = _cairo_cogl_fill_to_primitive (surface,
&path->path,
path->fill_rule,
path->tolerance,
0,
TRUE,
&prim,
&prim_size);
if (unlikely (status)) {
g_warning ("Failed to get primitive for clip path while flushing journal");
continue;
}
clip_stack_depth++;
cogl_clip_push_primitive (prim,
extents.x, extents.y,
extents.x + extents.width,
extents.y + extents.height);
cogl_object_unref (prim);
}
for (i = 0; i < clip_entry->clip->num_boxes; i++) {
clip_stack_depth++;
_cairo_cogl_clip_push_box (&clip_entry->clip->boxes[i]);
}
surface->n_clip_updates_per_frame++;
break;
}
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE: {
cairo_cogl_journal_rect_entry_t *rect_entry =
(cairo_cogl_journal_rect_entry_t *)entry;
float tex_coords[8];
float x1 = rect_entry->x;
float y1 = rect_entry->y;
float x2 = rect_entry->x + rect_entry->width;
float y2 = rect_entry->y + rect_entry->height;
cairo_matrix_t *ctm = &rect_entry->ctm;
float ctmfv[16] = {
ctm->xx, ctm->yx, 0, 0,
ctm->xy, ctm->yy, 0, 0,
0, 0, 1, 0,
ctm->x0, ctm->y0, 0, 1
};
CoglMatrix transform;
cogl_matrix_init_from_array (&transform, ctmfv);
if (rect_entry->n_layers) {
g_assert (rect_entry->n_layers <= 2);
tex_coords[0] = x1;
tex_coords[1] = y1;
tex_coords[2] = x2;
tex_coords[3] = y2;
if (rect_entry->n_layers > 1)
memcpy (&tex_coords[4], tex_coords, sizeof (float) * 4);
}
cogl_set_source (rect_entry->pipeline);
cogl_push_matrix ();
cogl_transform (&transform);
cogl_rectangle_with_multitexture_coords (x1, y1, x2, y2,
tex_coords, 4 * rect_entry->n_layers);
cogl_pop_matrix ();
break;
}
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE: {
cairo_cogl_journal_prim_entry_t *prim_entry =
(cairo_cogl_journal_prim_entry_t *)entry;
CoglMatrix transform;
cogl_push_matrix ();
if (prim_entry->has_transform) {
cairo_matrix_t *ctm = &prim_entry->transform;
float ctmfv[16] = {
ctm->xx, ctm->yx, 0, 0,
ctm->xy, ctm->yy, 0, 0,
0, 0, 1, 0,
ctm->x0, ctm->y0, 0, 1
};
cogl_matrix_init_from_array (&transform, ctmfv);
cogl_transform (&transform);
} else {
cogl_matrix_init_identity (&transform);
cogl_set_modelview_matrix (&transform);
}
cogl_set_source (prim_entry->pipeline);
cogl_primitive_draw (prim_entry->primitive);
cogl_pop_matrix ();
break;
}
case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH: {
cairo_cogl_journal_path_entry_t *path_entry =
(cairo_cogl_journal_path_entry_t *)entry;
cogl_set_source (path_entry->pipeline);
cogl_path_fill (path_entry->path);
break;
}
default:
assert (0); /* not reached! */
}
}
cogl_pop_matrix ();
for (i = 0; i < clip_stack_depth; i++)
cogl_clip_pop ();
_cairo_cogl_journal_discard (surface);
}
static cairo_status_t
_cairo_cogl_surface_flush (void *abstract_surface,
unsigned flags)
{
cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
if (flags)
return CAIRO_STATUS_SUCCESS;
_cairo_cogl_journal_flush (surface);
return CAIRO_STATUS_SUCCESS;
}
static cairo_status_t
_cairo_cogl_surface_finish (void *abstract_surface)
{
cairo_cogl_surface_t *surface = abstract_surface;
if (surface->texture)
cogl_object_unref (surface->texture);
if (surface->framebuffer)
cogl_object_unref (surface->framebuffer);
if (surface->journal)
_cairo_cogl_journal_free (surface);
/*XXX wtf */
cairo_device_release (surface->base.device);
return CAIRO_STATUS_SUCCESS;
}
static CoglPixelFormat
get_cogl_format_from_cairo_format (cairo_format_t cairo_format);
/* XXX: We often use RGBA format for onscreen framebuffers so make sure
* to handle CAIRO_FORMAT_INVALID sensibly */
static cairo_format_t
get_cairo_format_from_cogl_format (CoglPixelFormat format)
{
switch ((int)format)
{
case COGL_PIXEL_FORMAT_A_8:
return CAIRO_FORMAT_A8;
case COGL_PIXEL_FORMAT_RGB_565:
return CAIRO_FORMAT_RGB16_565;
case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
case COGL_PIXEL_FORMAT_ARGB_8888_PRE:
case COGL_PIXEL_FORMAT_RGBA_8888_PRE:
/* Note: this is ambiguous since CAIRO_FORMAT_RGB24
* would also map to the same CoglPixelFormat */
return CAIRO_FORMAT_ARGB32;
default:
g_warning("bad format: %x a? %d, bgr? %d, pre %d, format: %d\n",
format,
format & COGL_A_BIT,
format & COGL_BGR_BIT,
format & COGL_PREMULT_BIT,
format & ~(COGL_A_BIT | COGL_BGR_BIT | COGL_PREMULT_BIT));
return CAIRO_FORMAT_INVALID;
}
}
static CoglPixelFormat
get_cogl_format_from_cairo_format (cairo_format_t cairo_format)
{
switch (cairo_format)
{
case CAIRO_FORMAT_ARGB32:
case CAIRO_FORMAT_RGB24:
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
return COGL_PIXEL_FORMAT_BGRA_8888_PRE;
#else
return COGL_PIXEL_FORMAT_ARGB_8888_PRE;
#endif
case CAIRO_FORMAT_A8:
return COGL_PIXEL_FORMAT_A_8;
case CAIRO_FORMAT_RGB16_565:
return COGL_PIXEL_FORMAT_RGB_565;
case CAIRO_FORMAT_INVALID:
case CAIRO_FORMAT_A1:
case CAIRO_FORMAT_RGB30:
return 0;
}
g_warn_if_reached ();
return 0;
}
static cairo_status_t
_cairo_cogl_surface_read_rect_to_image_surface (cairo_cogl_surface_t *surface,
cairo_rectangle_int_t *interest,
cairo_image_surface_t **image_out)
{
cairo_image_surface_t *image;
cairo_status_t status;
cairo_format_t cairo_format;
CoglPixelFormat cogl_format;
/* TODO: Add cogl_texture_get_region() API so we don't have to ensure the
* surface is bound to an fbo to read back pixels */
status = _cairo_cogl_surface_ensure_framebuffer (surface);
if (unlikely (status))
return status;
cairo_format = get_cairo_format_from_cogl_format (surface->cogl_format);
if (cairo_format == CAIRO_FORMAT_INVALID) {
cairo_format = CAIRO_FORMAT_ARGB32;
cogl_format = get_cogl_format_from_cairo_format (cairo_format);
} else {
cogl_format = cogl_framebuffer_get_color_format (surface->framebuffer);
}
image = (cairo_image_surface_t *)
cairo_image_surface_create (cairo_format, surface->width, surface->height);
if (image->base.status)
return image->base.status;
/* TODO: Add cogl_framebuffer_read_pixels() API */
cogl_push_framebuffer (surface->framebuffer);
cogl_read_pixels (0, 0, surface->width, surface->height,
COGL_READ_PIXELS_COLOR_BUFFER,
cogl_format,
image->data);
cogl_pop_framebuffer ();
*image_out = image;
return CAIRO_STATUS_SUCCESS;
}
static cairo_status_t
_cairo_cogl_surface_acquire_source_image (void *abstract_surface,
cairo_image_surface_t **image_out,
void **image_extra)
{
cairo_cogl_surface_t *surface = abstract_surface;
cairo_status_t status;
if (surface->texture) {
cairo_format_t format = get_cairo_format_from_cogl_format (surface->cogl_format);
cairo_image_surface_t *image = (cairo_image_surface_t *)
cairo_image_surface_create (format, surface->width, surface->height);
if (image->base.status)
return image->base.status;
cogl_texture_get_data (surface->texture,
cogl_texture_get_format (surface->texture),
0,
image->data);
image->base.is_clear = FALSE;
*image_out = image;
} else {
cairo_rectangle_int_t extents = {
0, 0, surface->width, surface->height
};
status = _cairo_cogl_surface_read_rect_to_image_surface (surface, &extents,
image_out);
if (unlikely (status))
return status;
}
*image_extra = NULL;
return CAIRO_STATUS_SUCCESS;
}
static void
_cairo_cogl_surface_release_source_image (void *abstract_surface,
cairo_image_surface_t *image,
void *image_extra)
{
cairo_surface_destroy (&image->base);
}
static cairo_status_t
_cairo_cogl_surface_clear (cairo_cogl_surface_t *surface,
const cairo_color_t *color)
{
/* Anything batched in the journal up until now is redundant... */
_cairo_cogl_journal_discard (surface);
/* XXX: we currently implicitly clear the depth and stencil buffer here
* but since we use the framebuffer_discard extension when available I
* suppose this doesn't matter too much.
*
* The main concern is that we want to avoid re-loading an external z
* buffer at the start of each frame, but also many gpu architectures have
* optimizations for how they handle the depth/stencil buffers and can get
* upset if they aren't cleared together at the start of the frame.
*
* FIXME: we need a way to assert that the clip stack currently isn't
* using the stencil buffer before clearing it here!
*/
cogl_framebuffer_clear4f (surface->framebuffer,
COGL_BUFFER_BIT_COLOR |
COGL_BUFFER_BIT_DEPTH |
COGL_BUFFER_BIT_STENCIL,
color->red * color->alpha,
color->green * color->alpha,
color->blue * color->alpha,
color->alpha);
return CAIRO_STATUS_SUCCESS;
}
cairo_status_t
_cairo_cogl_path_fixed_rectangle (cairo_path_fixed_t *path,
cairo_fixed_t x,
cairo_fixed_t y,
cairo_fixed_t width,
cairo_fixed_t height)
{
cairo_status_t status;
status = _cairo_path_fixed_move_to (path, x, y);
if (unlikely (status))
return status;
status = _cairo_path_fixed_rel_line_to (path, width, 0);
if (unlikely (status))
return status;
status = _cairo_path_fixed_rel_line_to (path, 0, height);
if (unlikely (status))
return status;
status = _cairo_path_fixed_rel_line_to (path, -width, 0);
if (unlikely (status))
return status;
status = _cairo_path_fixed_close_path (path);
if (unlikely (status))
return status;
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
_cairo_cogl_surface_paint (void *abstract_surface,
cairo_operator_t op,
const cairo_pattern_t *source,
const cairo_clip_t *clip)
{
cairo_cogl_surface_t *surface;
cairo_path_fixed_t path;
cairo_status_t status;
cairo_matrix_t identity;
if (clip == NULL) {
if (op == CAIRO_OPERATOR_CLEAR)
return _cairo_cogl_surface_clear (abstract_surface, CAIRO_COLOR_TRANSPARENT);
else if (source->type == CAIRO_PATTERN_TYPE_SOLID &&
(op == CAIRO_OPERATOR_SOURCE ||
(op == CAIRO_OPERATOR_OVER && (((cairo_surface_t *)abstract_surface)->is_clear || _cairo_pattern_is_opaque_solid (source))))) {
return _cairo_cogl_surface_clear (abstract_surface,
&((cairo_solid_pattern_t *) source)->color);
}
}
/* fallback to handling the paint in terms of a fill... */
surface = abstract_surface;
_cairo_path_fixed_init (&path);
status = _cairo_cogl_path_fixed_rectangle (&path, 0, 0, surface->width, surface->height);
if (unlikely (status))
goto BAIL;
#ifdef NEED_COGL_CONTEXT
/* XXX: in cairo-cogl-context.c we set some sideband data on the
* surface before issuing a fill so we need to do that here too... */
surface->user_path = &path;
cairo_matrix_init_identity (&identity);
surface->ctm = &identity;
surface->ctm_inverse = &identity;
surface->path_is_rectangle = TRUE;
surface->path_rectangle_x = 0;
surface->path_rectangle_y = 0;
surface->path_rectangle_width = surface->width;
surface->path_rectangle_height = surface->height;
#endif
status = _cairo_cogl_surface_fill (abstract_surface,
op,
source,
&path,
CAIRO_FILL_RULE_WINDING,
1,
CAIRO_ANTIALIAS_DEFAULT,
clip);
BAIL:
_cairo_path_fixed_fini (&path);
return status;
}
static CoglPipelineWrapMode
get_cogl_wrap_mode_for_extend (cairo_extend_t extend_mode)
{
switch (extend_mode)
{
case CAIRO_EXTEND_NONE:
return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
case CAIRO_EXTEND_PAD:
return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
case CAIRO_EXTEND_REPEAT:
return COGL_PIPELINE_WRAP_MODE_REPEAT;
case CAIRO_EXTEND_REFLECT:
/* TODO: return COGL_PIPELINE_WRAP_MODE_MIRROR; */
return CAIRO_EXTEND_REPEAT;
}
assert (0); /* not reached */
return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
}
#if 0
/* Given an arbitrary texture, check if it's already a pot texture and simply
* return it back if so. If not create a new pot texture, scale the old to
* fill it, unref the old and return a pointer to the new pot texture. */
static cairo_int_status_t
_cairo_cogl_get_pot_texture (CoglContext *context,
CoglTexture *texture,
CoglTexture **pot_texture)
{
int width = cogl_texture_get_width (texture);
int height = cogl_texture_get_height (texture);
int pot_width;
int pot_height;
CoglHandle offscreen = NULL;
CoglTexture2D *pot = NULL;
GError *error;
pot_width = _cairo_cogl_util_next_p2 (width);
pot_height = _cairo_cogl_util_next_p2 (height);
if (pot_width == width && pot_height == height)
return CAIRO_INT_STATUS_SUCCESS;
for (;;) {
error = NULL;
pot = cogl_texture_2d_new_with_size (context,
pot_width,
pot_height,
cogl_texture_get_format (texture),
&error);
if (pot)
break;
else
g_error_free (error);
if (pot_width > pot_height)
pot_width >>= 1;
else
pot_height >>= 1;
if (!pot_width || !pot_height)
break;
}
*pot_texture = COGL_TEXTURE (pot);
if (!pot)
return CAIRO_INT_STATUS_NO_MEMORY;
/* Use the GPU to do a bilinear filtered scale from npot to pot... */
offscreen = cogl_offscreen_new_to_texture (COGL_TEXTURE (pot));
error = NULL;
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen), &error)) {
/* NB: if we don't pass an error then Cogl is allowed to simply abort
* automatically. */
g_error_free (error);
cogl_object_unref (pot);
*pot_texture = NULL;
return CAIRO_INT_STATUS_NO_MEMORY;
}
cogl_push_framebuffer (COGL_FRAMEBUFFER (offscreen));
cogl_set_source_texture (texture);
cogl_rectangle (-1, 1, 1, -1);
cogl_pop_framebuffer ();
cogl_object_unref (offscreen);
}
#endif
/* NB: a reference for the texture is transferred to the caller which should
* be unrefed */
static CoglTexture *
_cairo_cogl_acquire_surface_texture (cairo_cogl_surface_t *reference_surface,
cairo_surface_t *abstract_surface)
{
cairo_image_surface_t *image;
cairo_image_surface_t *acquired_image = NULL;
void *image_extra;
CoglPixelFormat format;
cairo_image_surface_t *image_clone = NULL;
CoglTexture2D *texture;
GError *error = NULL;
cairo_surface_t *clone;
if (abstract_surface->device == reference_surface->base.device) {
cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
_cairo_cogl_surface_flush (surface, 0);
return surface->texture ? cogl_object_ref (surface->texture) : NULL;
}
if (abstract_surface->type == CAIRO_SURFACE_TYPE_COGL) {
if (_cairo_surface_is_subsurface (abstract_surface)) {
cairo_cogl_surface_t *surface;
surface = (cairo_cogl_surface_t *)
_cairo_surface_subsurface_get_target (abstract_surface);
if (surface->base.device == reference_surface->base.device)
return surface->texture ? cogl_object_ref (surface->texture) : NULL;
}
}
clone = _cairo_surface_has_snapshot (abstract_surface, &_cairo_cogl_surface_backend);
if (clone) {
cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)clone;
return surface->texture ? cogl_object_ref (surface->texture) : NULL;
}
g_warning ("Uploading image surface to texture");
if (_cairo_surface_is_image (abstract_surface)) {
image = (cairo_image_surface_t *)abstract_surface;
} else {
cairo_status_t status = _cairo_surface_acquire_source_image (abstract_surface,
&acquired_image, &image_extra);
if (unlikely (status)) {
g_warning ("acquire_source_image failed: %s [%d]\n",
cairo_status_to_string (status), status);
return NULL;
}
image = acquired_image;
}
format = get_cogl_format_from_cairo_format (image->format);
if (!format)
{
image_clone = _cairo_image_surface_coerce (image);
if (unlikely (image_clone->base.status)) {
g_warning ("image_surface_coerce failed");
texture = NULL;
goto BAIL;
}
format = get_cogl_format_from_cairo_format (image_clone->format);
assert (format);
}
texture = cogl_texture_2d_new_from_data (to_device(reference_surface->base.device)->cogl_context,
image->width,
image->height,
format, /* incoming */
format, /* desired */
image->stride,
image->data,
&error);
if (!texture) {
g_warning ("Failed to allocate texture: %s", error->message);
g_error_free (error);
goto BAIL;
}
clone = _cairo_cogl_surface_create_full (to_device(reference_surface->base.device),
reference_surface->ignore_alpha,
NULL, COGL_TEXTURE (texture));
_cairo_surface_attach_snapshot (abstract_surface, clone, NULL);
/* Attaching the snapshot will take a reference on the clone surface... */
cairo_surface_destroy (clone);
BAIL:
if (image_clone)
cairo_surface_destroy (&image_clone->base);
if (acquired_image)
_cairo_surface_release_source_image (abstract_surface, acquired_image, image_extra);
return COGL_TEXTURE (texture);
}
/* NB: a reference for the texture is transferred to the caller which should
* be unrefed */
static CoglTexture *
_cairo_cogl_acquire_pattern_texture (const cairo_pattern_t *pattern,
cairo_cogl_surface_t *destination,
const cairo_rectangle_int_t *extents,
const cairo_rectangle_int_t *sample,
cairo_cogl_texture_attributes_t *attributes)
{
CoglTexture *texture = NULL;
switch ((int)pattern->type)
{
case CAIRO_PATTERN_TYPE_SURFACE: {
cairo_surface_t *surface = ((cairo_surface_pattern_t *)pattern)->surface;
texture = _cairo_cogl_acquire_surface_texture (destination, surface);
if (!texture)
return NULL;
/* XXX: determine if it would have no effect to change the
* extend mode to EXTEND_PAD instead since we can simply map
* EXTEND_PAD to CLAMP_TO_EDGE without needing fragment shader
* tricks or extra border texels. */
#if 0
/* TODO: We still need to consider HW such as SGX which doesn't have
* full support for NPOT textures. */
if (pattern->extend == CAIRO_EXTEND_REPEAT || pattern->extend == CAIRO_EXTEND_REFLECT) {
_cairo_cogl_get_pot_texture ();
}
#endif
cairo_matrix_init_identity (&attributes->matrix);
/* Convert from un-normalized source coordinates in backend
* coordinates to normalized texture coordinates */
cairo_matrix_scale (&attributes->matrix,
1.0f / cogl_texture_get_width (texture),
1.0f / cogl_texture_get_height (texture));
/* XXX: need to multiply in the pattern->matrix */
attributes->extend = pattern->extend;
attributes->filter = CAIRO_FILTER_BILINEAR;
attributes->has_component_alpha = pattern->has_component_alpha;
attributes->s_wrap = get_cogl_wrap_mode_for_extend (pattern->extend);
attributes->t_wrap = attributes->s_wrap;
return texture;
}
case CAIRO_PATTERN_TYPE_RADIAL:
case CAIRO_PATTERN_TYPE_MESH: {
cairo_surface_t *surface;
cairo_matrix_t texture_matrix;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
extents->width, extents->height);
if (_cairo_surface_offset_paint (surface,
extents->x, extents->y,
CAIRO_OPERATOR_SOURCE,
pattern, NULL)) {
cairo_surface_destroy (surface);
return NULL;
}
texture = _cairo_cogl_acquire_surface_texture (destination, surface);
if (!texture)
goto BAIL;
cairo_matrix_init_identity (&texture_matrix);
/* Convert from un-normalized source coordinates in backend
* coordinates to normalized texture coordinates */
cairo_matrix_scale (&texture_matrix,
1.0f / cogl_texture_get_width (texture),
1.0f / cogl_texture_get_height (texture));
cairo_matrix_translate (&texture_matrix, -extents->x, -extents->y);
attributes->matrix = texture_matrix;
attributes->extend = pattern->extend;
attributes->filter = CAIRO_FILTER_NEAREST;
attributes->has_component_alpha = pattern->has_component_alpha;
/* any pattern extend modes have already been dealt with... */
attributes->s_wrap = COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
attributes->t_wrap = attributes->s_wrap;
BAIL:
cairo_surface_destroy (surface);
return texture;
}
case CAIRO_PATTERN_TYPE_LINEAR: {
cairo_linear_pattern_t *linear_pattern = (cairo_linear_pattern_t *)pattern;
cairo_cogl_linear_gradient_t *gradient;
cairo_cogl_linear_texture_entry_t *linear_texture;
cairo_int_status_t status;
float a, b;
float dist;
float scale;
float angle;
status = _cairo_cogl_get_linear_gradient (to_device(destination->base.device),
pattern->extend,
linear_pattern->base.n_stops,
linear_pattern->base.stops,
&gradient);
if (unlikely (status))
return NULL;
linear_texture = _cairo_cogl_linear_gradient_texture_for_extend (gradient, pattern->extend);
attributes->extend = pattern->extend;
attributes->filter = CAIRO_FILTER_BILINEAR;
attributes->has_component_alpha = pattern->has_component_alpha;
attributes->s_wrap = get_cogl_wrap_mode_for_extend (pattern->extend);
attributes->t_wrap = COGL_PIPELINE_WRAP_MODE_REPEAT;
cairo_matrix_init_identity (&attributes->matrix);
a = linear_pattern->pd2.x - linear_pattern->pd1.x;
b = linear_pattern->pd2.y - linear_pattern->pd1.y;
dist = sqrtf (a*a + b*b);
scale = 1.0f / dist;
angle = - atan2f (b, a);
cairo_matrix_rotate (&attributes->matrix, angle);
cairo_matrix_scale (&attributes->matrix, scale, scale);
cairo_matrix_translate (&attributes->matrix,
-linear_pattern->pd1.x,
-linear_pattern->pd1.y);
/* XXX: this caught me out: cairo doesn't follow the standard
* maths convention for multiplying two matrices A x B - cairo
* does B x A so the final matrix is as if A's transforms were
* applied first.
*/
cairo_matrix_multiply (&attributes->matrix,
&pattern->matrix,
&attributes->matrix);
return cogl_object_ref (linear_texture->texture);
}
default:
g_warning ("Un-supported source type");
return NULL;
}
}
static void
set_layer_texture_with_attributes (CoglPipeline *pipeline,
int layer_index,
CoglTexture *texture,
cairo_cogl_texture_attributes_t *attributes)
{
cogl_pipeline_set_layer_texture (pipeline, layer_index, texture);
if (!_cairo_matrix_is_identity (&attributes->matrix)) {
cairo_matrix_t *m = &attributes->matrix;
float texture_matrixfv[16] = {
m->xx, m->yx, 0, 0,
m->xy, m->yy, 0, 0,
0, 0, 1, 0,
m->x0, m->y0, 0, 1
};
CoglMatrix texture_matrix;
cogl_matrix_init_from_array (&texture_matrix, texture_matrixfv);
cogl_pipeline_set_layer_matrix (pipeline, layer_index, &texture_matrix);
}
if (attributes->s_wrap != attributes->t_wrap) {
cogl_pipeline_set_layer_wrap_mode_s (pipeline, layer_index, attributes->s_wrap);
cogl_pipeline_set_layer_wrap_mode_t (pipeline, layer_index, attributes->t_wrap);
} else
cogl_pipeline_set_layer_wrap_mode (pipeline, layer_index, attributes->s_wrap);
}
static CoglPipeline *
get_source_mask_operator_destination_pipeline (const cairo_pattern_t *mask,
const cairo_pattern_t *source,
cairo_operator_t op,
cairo_cogl_surface_t *destination,
cairo_composite_rectangles_t *extents)
{
cairo_cogl_template_type template_type;
CoglPipeline *pipeline;
switch ((int)source->type)
{
case CAIRO_PATTERN_TYPE_SOLID:
template_type = mask ?
CAIRO_COGL_TEMPLATE_TYPE_MASK_SOLID : CAIRO_COGL_TEMPLATE_TYPE_SOLID;
break;
case CAIRO_PATTERN_TYPE_SURFACE:
case CAIRO_PATTERN_TYPE_LINEAR:
case CAIRO_PATTERN_TYPE_RADIAL:
case CAIRO_PATTERN_TYPE_MESH:
template_type = mask ?
CAIRO_COGL_TEMPLATE_TYPE_MASK_TEXTURE : CAIRO_COGL_TEMPLATE_TYPE_TEXTURE;
break;
default:
g_warning ("Un-supported source type");
return NULL;
}
pipeline = cogl_pipeline_copy (to_device(destination->base.device)->template_pipelines[op][template_type]);
if (source->type == CAIRO_PATTERN_TYPE_SOLID) {
cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)source;
cogl_pipeline_set_color4f (pipeline,
solid_pattern->color.red * solid_pattern->color.alpha,
solid_pattern->color.green * solid_pattern->color.alpha,
solid_pattern->color.blue * solid_pattern->color.alpha,
solid_pattern->color.alpha);
} else {
cairo_cogl_texture_attributes_t attributes;
CoglTexture *texture =
_cairo_cogl_acquire_pattern_texture (source, destination,
&extents->bounded,
&extents->source_sample_area,
&attributes);
if (!texture)
goto BAIL;
set_layer_texture_with_attributes (pipeline, 0, texture, &attributes);
cogl_object_unref (texture);
}
if (mask) {
if (mask->type == CAIRO_PATTERN_TYPE_SOLID) {
cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)mask;
CoglColor color;
cogl_color_init_from_4f (&color,
solid_pattern->color.red * solid_pattern->color.alpha,
solid_pattern->color.green * solid_pattern->color.alpha,
solid_pattern->color.blue * solid_pattern->color.alpha,
solid_pattern->color.alpha);
cogl_pipeline_set_layer_combine_constant (pipeline, 1, &color);
} else {
cairo_cogl_texture_attributes_t attributes;
CoglTexture *texture =
_cairo_cogl_acquire_pattern_texture (mask, destination,
&extents->bounded,
&extents->mask_sample_area,
&attributes);
if (!texture)
goto BAIL;
set_layer_texture_with_attributes (pipeline, 1, texture, &attributes);
cogl_object_unref (texture);
}
}
return pipeline;
BAIL:
cogl_object_unref (pipeline);
return NULL;
}
#if 0
CoglPrimitive *
_cairo_cogl_rectangle_new_p2t2t2 (float x,
float y,
float width,
float height)
{
CoglVertexP2 vertices[] = {
{x, y}, {x, y + height}, {x + width, y + height},
{x, y}, {x + width, y + height}, {x + width, y}
};
CoglAttributeBuffer *buffer = cogl_attribute_buffer_new (sizeof (vertices));
CoglAttribute *pos = cogl_attribute_new (buffer,
"cogl_position_in",
sizeof (CoglVertexP2),
0,
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
CoglAttribute *tex_coords0 = cogl_attribute_new (buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP2),
0,
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
CoglAttribute *tex_coords0 = cogl_attribute_new (buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP2),
0,
2,
COGL_ATTRIBUTE_TYPE_FLOAT);
CoglPrimitive *prim;
cogl_buffer_set_data (COGL_BUFFER (buffer), 0, vertices, sizeof (vertices));
/* The attributes will now keep the buffer alive... */
cogl_object_unref (buffer);
prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES,
6, pos, tex_coords, NULL);
/* The primitive will now keep the attribute alive... */
cogl_object_unref (pos);
return prim;
}
#endif
static void
_cairo_cogl_log_clip (cairo_cogl_surface_t *surface,
const cairo_clip_t *clip)
{
if (!_cairo_clip_equal (clip, surface->last_clip)) {
_cairo_cogl_journal_log_clip (surface, clip);
_cairo_clip_destroy (surface->last_clip);
surface->last_clip = _cairo_clip_copy (clip);
}
}
static void
_cairo_cogl_maybe_log_clip (cairo_cogl_surface_t *surface,
cairo_composite_rectangles_t *composite)
{
cairo_clip_t *clip = composite->clip;
if (_cairo_composite_rectangles_can_reduce_clip (composite, clip))
clip = NULL;
if (clip == NULL) {
if (_cairo_composite_rectangles_can_reduce_clip (composite,
surface->last_clip))
return;
}
_cairo_cogl_log_clip (surface, clip);
}
static cairo_bool_t
is_operator_supported (cairo_operator_t op)
{
switch ((int)op) {
case CAIRO_OPERATOR_SOURCE:
case CAIRO_OPERATOR_OVER:
case CAIRO_OPERATOR_IN:
case CAIRO_OPERATOR_DEST_OVER:
case CAIRO_OPERATOR_DEST_IN:
case CAIRO_OPERATOR_ADD:
return TRUE;
default:
return FALSE;
}
}
static cairo_int_status_t
_cairo_cogl_surface_mask (void *abstract_surface,
cairo_operator_t op,
const cairo_pattern_t *source,
const cairo_pattern_t *mask,
const cairo_clip_t *clip)
{
cairo_cogl_surface_t *surface = abstract_surface;
cairo_composite_rectangles_t extents;
cairo_status_t status;
CoglPipeline *pipeline;
cairo_matrix_t identity;
/* XXX: Use this to smoke test the acquire_source/dest_image fallback
* paths... */
//return CAIRO_INT_STATUS_UNSUPPORTED;
if (!is_operator_supported (op))
return CAIRO_INT_STATUS_UNSUPPORTED;
status = _cairo_composite_rectangles_init_for_mask (&extents,
&surface->base,
op, source, mask, clip);
if (unlikely (status))
return status;
pipeline = get_source_mask_operator_destination_pipeline (mask, source,
op, surface, &extents);
if (!pipeline){
status = CAIRO_INT_STATUS_UNSUPPORTED;
goto BAIL;
}
_cairo_cogl_maybe_log_clip (surface, &extents);
cairo_matrix_init_identity (&identity);
_cairo_cogl_journal_log_rectangle (surface, pipeline,
extents.bounded.x,
extents.bounded.y,
extents.bounded.width,
extents.bounded.height,
2,
&identity);
/* The journal will take a reference on the pipeline and clip_path... */
cogl_object_unref (pipeline);
BAIL:
return status;
}
static int
_cairo_cogl_source_n_layers (const cairo_pattern_t *source)
{
switch ((int)source->type)
{
case CAIRO_PATTERN_TYPE_SOLID:
return 0;
case CAIRO_PATTERN_TYPE_LINEAR:
case CAIRO_PATTERN_TYPE_RADIAL:
case CAIRO_PATTERN_TYPE_MESH:
case CAIRO_PATTERN_TYPE_SURFACE:
return 1;
default:
g_warning ("Unsupported source type");
return 0;
}
}
static cairo_bool_t
_cairo_cogl_path_fill_meta_equal (const void *key_a, const void *key_b)
{
const cairo_cogl_path_fill_meta_t *meta0 = key_a;
const cairo_cogl_path_fill_meta_t *meta1 = key_b;
return _cairo_path_fixed_equal (meta0->user_path, meta1->user_path);
}
static cairo_bool_t
_cairo_cogl_stroke_style_equal (const cairo_stroke_style_t *a,
const cairo_stroke_style_t *b)
{
if (a->line_width == b->line_width &&
a->line_cap == b->line_cap &&
a->line_join == b->line_join &&
a->miter_limit == b->miter_limit &&
a->num_dashes == b->num_dashes &&
a->dash_offset == b->dash_offset)
{
unsigned int i;
for (i = 0; i < a->num_dashes; i++) {
if (a->dash[i] != b->dash[i])
return FALSE;
}
}
return TRUE;
}
static cairo_bool_t
_cairo_cogl_path_stroke_meta_equal (const void *key_a, const void *key_b)
{
const cairo_cogl_path_stroke_meta_t *meta0 = key_a;
const cairo_cogl_path_stroke_meta_t *meta1 = key_b;
return _cairo_cogl_stroke_style_equal (&meta0->style, &meta1->style) &&
_cairo_path_fixed_equal (meta0->user_path, meta1->user_path);
}
static cairo_cogl_path_stroke_meta_t *
_cairo_cogl_path_stroke_meta_reference (cairo_cogl_path_stroke_meta_t *meta)
{
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
_cairo_reference_count_inc (&meta->ref_count);
return meta;
}
static void
_cairo_cogl_path_stroke_meta_destroy (cairo_cogl_path_stroke_meta_t *meta)
{
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
if (! _cairo_reference_count_dec_and_test (&meta->ref_count))
return;
_cairo_path_fixed_fini (meta->user_path);
free (meta->user_path);
_cairo_stroke_style_fini (&meta->style);
if (meta->prim)
cogl_object_unref (meta->prim);
free (meta);
}
static cairo_cogl_path_stroke_meta_t *
_cairo_cogl_path_stroke_meta_lookup (cairo_cogl_device_t *ctx,
unsigned long hash,
cairo_path_fixed_t *user_path,
const cairo_stroke_style_t *style,
double tolerance)
{
cairo_cogl_path_stroke_meta_t *ret;
cairo_cogl_path_stroke_meta_t lookup;
lookup.cache_entry.hash = hash;
lookup.user_path = user_path;
lookup.style = *style;
lookup.tolerance = tolerance;
ret = _cairo_cache_lookup (&ctx->path_stroke_staging_cache, &lookup.cache_entry);
if (!ret)
ret = _cairo_cache_lookup (&ctx->path_stroke_prim_cache, &lookup.cache_entry);
return ret;
}
static void
_cairo_cogl_path_stroke_meta_set_prim_size (cairo_cogl_surface_t *surface,
cairo_cogl_path_stroke_meta_t *meta,
size_t size)
{
/* now that we know the meta structure is associated with a primitive
* we promote it from the staging cache into the primitive cache.
*/
/* XXX: _cairo_cache borks if you try and remove an entry that's already
* been evicted so we explicitly look it up first... */
if (_cairo_cache_lookup (&to_device(surface->base.device)->path_stroke_staging_cache, &meta->cache_entry)) {
_cairo_cogl_path_stroke_meta_reference (meta);
_cairo_cache_remove (&to_device(surface->base.device)->path_stroke_staging_cache, &meta->cache_entry);
}
meta->cache_entry.size = size;
if (_cairo_cache_insert (&to_device(surface->base.device)->path_stroke_prim_cache, &meta->cache_entry) !=
CAIRO_STATUS_SUCCESS)
_cairo_cogl_path_stroke_meta_destroy (meta);
}
static unsigned int
_cairo_cogl_stroke_style_hash (unsigned int hash,
const cairo_stroke_style_t *style)
{
unsigned int i;
hash = _cairo_hash_bytes (hash, &style->line_width, sizeof (style->line_width));
hash = _cairo_hash_bytes (hash, &style->line_cap, sizeof (style->line_cap));
hash = _cairo_hash_bytes (hash, &style->line_join, sizeof (style->line_join));
hash = _cairo_hash_bytes (hash, &style->miter_limit, sizeof (style->miter_limit));
hash = _cairo_hash_bytes (hash, &style->num_dashes, sizeof (style->num_dashes));
hash = _cairo_hash_bytes (hash, &style->dash_offset, sizeof (style->dash_offset));
for (i = 0; i < style->num_dashes; i++)
hash = _cairo_hash_bytes (hash, &style->dash[i], sizeof (double));
return hash;
}
static cairo_cogl_path_stroke_meta_t *
_cairo_cogl_get_path_stroke_meta (cairo_cogl_surface_t *surface,
const cairo_stroke_style_t *style,
double tolerance)
{
unsigned long hash;
cairo_cogl_path_stroke_meta_t *meta = NULL;
cairo_path_fixed_t *meta_path = NULL;
cairo_status_t status;
if (!surface->user_path)
return NULL;
hash = _cairo_path_fixed_hash (surface->user_path);
hash = _cairo_cogl_stroke_style_hash (hash, style);
hash = _cairo_hash_bytes (hash, &tolerance, sizeof (tolerance));
meta = _cairo_cogl_path_stroke_meta_lookup (to_device(surface->base.device), hash,
surface->user_path, style, tolerance);
if (meta)
return meta;
meta = calloc (1, sizeof (cairo_cogl_path_stroke_meta_t));
if (!meta)
goto BAIL;
CAIRO_REFERENCE_COUNT_INIT (&meta->ref_count, 1);
meta->cache_entry.hash = hash;
meta->counter = 0;
meta_path = malloc (sizeof (cairo_path_fixed_t));
if (!meta_path)
goto BAIL;
/* FIXME: we should add a ref-counted wrapper for our user_paths
* so we don't have to keep copying them here! */
status = _cairo_path_fixed_init_copy (meta_path, surface->user_path);
if (unlikely (status))
goto BAIL;
meta->user_path = meta_path;
meta->ctm_inverse = *surface->ctm_inverse;
status = _cairo_stroke_style_init_copy (&meta->style, style);
if (unlikely (status)) {
_cairo_path_fixed_fini (meta_path);
goto BAIL;
}
meta->tolerance = tolerance;
return meta;
BAIL:
free (meta_path);
free (meta);
return NULL;
}
static cairo_int_status_t
_cairo_cogl_stroke_to_primitive (cairo_cogl_surface_t *surface,
const cairo_path_fixed_t *path,
const cairo_stroke_style_t *style,
const cairo_matrix_t *ctm,
const cairo_matrix_t *ctm_inverse,
double tolerance,
int n_layers,
cairo_bool_t one_shot,
CoglPrimitive **primitive,
size_t *size)
{
cairo_traps_t traps;
cairo_int_status_t status;
_cairo_traps_init (&traps);
status = _cairo_path_fixed_stroke_to_traps (path, style, ctm, ctm_inverse, tolerance,
&traps);
if (unlikely (status))
goto BAIL;
if (traps.num_traps == 0) {
status = CAIRO_INT_STATUS_NOTHING_TO_DO;
goto BAIL;
}
*size = traps.num_traps * sizeof (CoglVertexP2) * 6;
//g_print ("new stroke prim\n");
*primitive = _cairo_cogl_traps_to_composite_prim (surface, &traps, n_layers, one_shot);
if (!*primitive) {
status = CAIRO_INT_STATUS_NO_MEMORY;
goto BAIL;
}
BAIL:
_cairo_traps_fini (&traps);
return status;
}
static cairo_int_status_t
_cairo_cogl_surface_stroke (void *abstract_surface,
cairo_operator_t op,
const cairo_pattern_t *source,
const cairo_path_fixed_t *path,
const cairo_stroke_style_t *style,
const cairo_matrix_t *ctm,
const cairo_matrix_t *ctm_inverse,
double tolerance,
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
cairo_composite_rectangles_t extents;
CoglPipeline *pipeline;
cairo_status_t status;
#ifdef ENABLE_PATH_CACHE
cairo_cogl_path_stroke_meta_t *meta = NULL;
cairo_matrix_t transform_matrix;
#endif
cairo_matrix_t *transform = NULL;
gboolean one_shot = TRUE;
CoglPrimitive *prim = NULL;
cairo_bool_t new_prim = FALSE;
if (! is_operator_supported (op))
return CAIRO_INT_STATUS_UNSUPPORTED;
/* FIXME - support unbounded operators */
if (!_cairo_operator_bounded_by_mask (op)) {
/* Currently IN this is the only unbounded operator we aim to support
* in cairo-cogl. */
assert (op == CAIRO_OPERATOR_IN);
g_warning ("FIXME: handle stroking with unbounded operators!");
return CAIRO_INT_STATUS_UNSUPPORTED;
}
status = _cairo_composite_rectangles_init_for_stroke (&extents,
&surface->base,
op, source, path,
style,
ctm,
clip);
if (unlikely (status))
return status;
#ifdef ENABLE_PATH_CACHE
/* FIXME: we are currently leaking the meta state if we don't reach
* the cache_insert at the end. */
meta = _cairo_cogl_get_path_stroke_meta (surface, style, tolerance);
if (meta) {
prim = meta->prim;
if (prim) {
cairo_matrix_multiply (&transform_matrix, &meta->ctm_inverse, surface->ctm);
transform = &transform_matrix;
} else if (meta->counter++ > 10)
one_shot = FALSE;
}
#endif
if (!prim) {
int n_layers = _cairo_cogl_source_n_layers (source);
size_t prim_size = 0;
status = _cairo_cogl_stroke_to_primitive (surface, path, style,
ctm, ctm_inverse, tolerance,
n_layers, one_shot,
&prim, &prim_size);
if (unlikely (status))
return status;
new_prim = TRUE;
#if defined (ENABLE_PATH_CACHE)
if (meta) {
meta->prim = cogl_object_ref (prim);
_cairo_cogl_path_stroke_meta_set_prim_size (surface, meta, prim_size);
}
#endif
}
pipeline = get_source_mask_operator_destination_pipeline (NULL, source,
op, surface, &extents);
if (!pipeline)
return CAIRO_INT_STATUS_UNSUPPORTED;
_cairo_cogl_maybe_log_clip (surface, &extents);
_cairo_cogl_journal_log_primitive (surface, pipeline, prim, transform);
/* The journal will take a reference on the pipeline and primitive... */
cogl_object_unref (pipeline);
if (new_prim)
cogl_object_unref (prim);
return CAIRO_INT_STATUS_SUCCESS;
}
static cairo_cogl_path_fill_meta_t *
_cairo_cogl_path_fill_meta_reference (cairo_cogl_path_fill_meta_t *meta)
{
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
_cairo_reference_count_inc (&meta->ref_count);
return meta;
}
static void
_cairo_cogl_path_fill_meta_destroy (cairo_cogl_path_fill_meta_t *meta)
{
assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
if (! _cairo_reference_count_dec_and_test (&meta->ref_count))
return;
_cairo_path_fixed_fini (meta->user_path);
free (meta->user_path);
if (meta->prim)
cogl_object_unref (meta->prim);
free (meta);
}
static cairo_cogl_path_fill_meta_t *
_cairo_cogl_path_fill_meta_lookup (cairo_cogl_device_t *ctx,
unsigned long hash,
cairo_path_fixed_t *user_path)
{
cairo_cogl_path_fill_meta_t *ret;
cairo_cogl_path_fill_meta_t lookup;
lookup.cache_entry.hash = hash;
lookup.user_path = user_path;
ret = _cairo_cache_lookup (&ctx->path_fill_staging_cache, &lookup.cache_entry);
if (!ret)
ret = _cairo_cache_lookup (&ctx->path_fill_prim_cache, &lookup.cache_entry);
return ret;
}
static void
_cairo_cogl_path_fill_meta_set_prim_size (cairo_cogl_surface_t *surface,
cairo_cogl_path_fill_meta_t *meta,
size_t size)
{
/* now that we know the meta structure is associated with a primitive
* we promote it from the staging cache into the primitive cache.
*/
/* XXX: _cairo_cache borks if you try and remove an entry that's already
* been evicted so we explicitly look it up first... */
if (_cairo_cache_lookup (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry)) {
_cairo_cogl_path_fill_meta_reference (meta);
_cairo_cache_remove (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry);
}
meta->cache_entry.size = size;
if (_cairo_cache_insert (&to_device(surface->base.device)->path_fill_prim_cache, &meta->cache_entry) !=
CAIRO_STATUS_SUCCESS)
_cairo_cogl_path_fill_meta_destroy (meta);
}
static cairo_cogl_path_fill_meta_t *
_cairo_cogl_get_path_fill_meta (cairo_cogl_surface_t *surface)
{
unsigned long hash;
cairo_cogl_path_fill_meta_t *meta = NULL;
cairo_path_fixed_t *meta_path = NULL;
cairo_status_t status;
if (!surface->user_path)
return NULL;
hash = _cairo_path_fixed_hash (surface->user_path);
meta = _cairo_cogl_path_fill_meta_lookup (to_device(surface->base.device),
hash, surface->user_path);
if (meta)
return meta;
meta = calloc (1, sizeof (cairo_cogl_path_fill_meta_t));
if (!meta)
goto BAIL;
meta->cache_entry.hash = hash;
meta->counter = 0;
CAIRO_REFERENCE_COUNT_INIT (&meta->ref_count, 1);
meta_path = malloc (sizeof (cairo_path_fixed_t));
if (!meta_path)
goto BAIL;
/* FIXME: we should add a ref-counted wrapper for our user_paths
* so we don't have to keep copying them here! */
status = _cairo_path_fixed_init_copy (meta_path, surface->user_path);
if (unlikely (status))
goto BAIL;
meta->user_path = meta_path;
meta->ctm_inverse = *surface->ctm_inverse;
/* To start with - until we associate a CoglPrimitive with the meta
* structure - we keep the meta in a staging structure until we
* see whether it actually gets re-used. */
meta->cache_entry.size = 1;
if (_cairo_cache_insert (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry) !=
CAIRO_STATUS_SUCCESS)
_cairo_cogl_path_fill_meta_destroy (meta);
return meta;
BAIL:
free (meta_path);
free (meta);
return NULL;
}
static cairo_int_status_t
_cairo_cogl_surface_fill (void *abstract_surface,
cairo_operator_t op,
const cairo_pattern_t *source,
const cairo_path_fixed_t *path,
cairo_fill_rule_t fill_rule,
double tolerance,
cairo_antialias_t antialias,
const cairo_clip_t *clip)
{
cairo_cogl_surface_t *surface = abstract_surface;
cairo_composite_rectangles_t extents;
cairo_status_t status;
#ifdef ENABLE_PATH_CACHE
cairo_cogl_path_fill_meta_t *meta = NULL;
cairo_matrix_t transform_matrix;
#endif
cairo_matrix_t *transform = NULL;
cairo_bool_t one_shot = TRUE;
CoglPrimitive *prim = NULL;
cairo_bool_t new_prim = FALSE;
CoglPipeline *pipeline;
if (! is_operator_supported (op))
return CAIRO_INT_STATUS_UNSUPPORTED;
/* FIXME - support unbounded operators */
if (!_cairo_operator_bounded_by_mask (op)) {
/* Currently IN this is the only unbounded operator we aim to support
* in cairo-cogl. */
assert (op == CAIRO_OPERATOR_IN);
g_warning ("FIXME: handle filling with unbounded operators!");
return CAIRO_INT_STATUS_UNSUPPORTED;
}
status = _cairo_composite_rectangles_init_for_fill (&extents,
&surface->base,
op, source, path,
clip);
if (unlikely (status))
return status;
#ifndef FILL_WITH_COGL_PATH
#ifdef ENABLE_PATH_CACHE
meta = _cairo_cogl_get_path_fill_meta (surface);
if (meta) {
prim = meta->prim;
if (prim) {
cairo_matrix_multiply (&transform_matrix, &meta->ctm_inverse, surface->ctm);
transform = &transform_matrix;
} else if (meta->counter++ > 10)
one_shot = FALSE;
}
#endif /* ENABLE_PATH_CACHE */
if (!prim) {
int n_layers = _cairo_cogl_source_n_layers (source);
size_t prim_size;
status = _cairo_cogl_fill_to_primitive (surface, path, fill_rule, tolerance,
one_shot, n_layers, &prim, &prim_size);
if (unlikely (status))
return status;
new_prim = TRUE;
#ifdef ENABLE_PATH_CACHE
if (meta) {
meta->prim = cogl_object_ref (prim);
_cairo_cogl_path_fill_meta_set_prim_size (surface, meta, prim_size);
}
#endif /* ENABLE_PATH_CACHE */
}
#endif /* !FILL_WITH_COGL_PATH */
pipeline = get_source_mask_operator_destination_pipeline (NULL, source,
op, surface, &extents);
if (!pipeline)
return CAIRO_INT_STATUS_UNSUPPORTED;
_cairo_cogl_maybe_log_clip (surface, &extents);
#ifndef FILL_WITH_COGL_PATH
_cairo_cogl_journal_log_primitive (surface, pipeline, prim, transform);
/* The journal will take a reference on the prim */
if (new_prim)
cogl_object_unref (prim);
#else
CoglPath * cogl_path = _cairo_cogl_util_path_from_cairo (path, fill_rule, tolerance);
_cairo_cogl_journal_log_path (surface, pipeline, cogl_path);
cogl_object_unref (cogl_path);
#endif
/* The journal will take a reference on the pipeline... */
cogl_object_unref (pipeline);
return CAIRO_INT_STATUS_SUCCESS;
}
cairo_int_status_t
_cairo_cogl_surface_fill_rectangle (void *abstract_surface,
cairo_operator_t op,
const cairo_pattern_t *source,
double x,
double y,
double width,
double height,
cairo_matrix_t *ctm,
const cairo_clip_t *clip)
{
cairo_cogl_surface_t *surface = abstract_surface;
CoglPipeline *pipeline;
if (! is_operator_supported (op))
return CAIRO_INT_STATUS_UNSUPPORTED;
/* FIXME - support unbounded operators */
if (!_cairo_operator_bounded_by_mask (op)) {
/* Currently IN this is the only unbounded operator we aim to support
* in cairo-cogl. */
assert (op == CAIRO_OPERATOR_IN);
g_warning ("FIXME: handle filling with unbounded operators!");
return CAIRO_INT_STATUS_UNSUPPORTED;
}
/* FIXME */
#if 0
status = _cairo_composite_rectangles_init_for_fill_rectangle (&extents,
&surface->base,
op, source, path,
clip);
if (unlikely (status))
return status;
#endif
if (source->type == CAIRO_PATTERN_TYPE_SOLID) {
double x1 = x;
double y1 = y;
double x2 = x1 + width;
double y2 = y1 + height;
pipeline = get_source_mask_operator_destination_pipeline (NULL, source,
op, surface, NULL);
if (!pipeline)
return CAIRO_INT_STATUS_UNSUPPORTED;
_cairo_cogl_log_clip (surface, clip);
_cairo_cogl_journal_log_rectangle (surface,
pipeline,
x1, y1, x2, y2,
0,
ctm);
return CAIRO_INT_STATUS_SUCCESS;
} else
return CAIRO_INT_STATUS_UNSUPPORTED;
/* TODO:
* We need to acquire the textures here, look at the corresponding
* attributes and see if this can be trivially handled by logging
* a textured rectangle only needing simple scaling or translation
* of texture coordinates.
*
* At this point we should also aim to remap the default
* EXTEND_NONE mode to EXTEND_PAD which is more efficient if we
* know it makes no difference either way since we can map that to
* CLAMP_TO_EDGE.
*/
}
static cairo_int_status_t
_cairo_cogl_surface_show_glyphs (void *surface,
cairo_operator_t op,
const cairo_pattern_t *source,
cairo_glyph_t *glyphs,
int num_glyphs,
cairo_scaled_font_t *scaled_font,
const cairo_clip_t *clip)
{
return CAIRO_INT_STATUS_UNSUPPORTED;
}
const cairo_surface_backend_t _cairo_cogl_surface_backend = {
CAIRO_SURFACE_TYPE_COGL,
_cairo_cogl_surface_finish,
#ifdef NEED_COGL_CONTEXT
_cairo_cogl_context_create,
#else
_cairo_default_context_create,
#endif
_cairo_cogl_surface_create_similar,
NULL, /* create similar image */
NULL, /* map to image */
NULL, /* unmap image */
_cairo_surface_default_source,
_cairo_cogl_surface_acquire_source_image,
_cairo_cogl_surface_release_source_image,
NULL, /* snapshot */
NULL, /* copy_page */
NULL, /* show_page */
_cairo_cogl_surface_get_extents,
NULL, /* get_font_options */
_cairo_cogl_surface_flush, /* flush */
NULL, /* mark_dirty_rectangle */
_cairo_cogl_surface_paint,
_cairo_cogl_surface_mask,
_cairo_cogl_surface_stroke,
_cairo_cogl_surface_fill,
NULL, /* fill_stroke*/
_cairo_surface_fallback_glyphs,
};
static cairo_surface_t *
_cairo_cogl_surface_create_full (cairo_cogl_device_t *dev,
cairo_bool_t ignore_alpha,
CoglFramebuffer *framebuffer,
CoglTexture *texture)
{
cairo_cogl_surface_t *surface;
cairo_status_t status;
status = cairo_device_acquire (&dev->base);
if (unlikely (status))
return _cairo_surface_create_in_error (status);
surface = malloc (sizeof (cairo_cogl_surface_t));
if (unlikely (surface == NULL))
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
surface->ignore_alpha = ignore_alpha;
surface->framebuffer = framebuffer;
if (framebuffer) {
surface->width = cogl_framebuffer_get_width (framebuffer);
surface->height = cogl_framebuffer_get_height (framebuffer);
surface->cogl_format = cogl_framebuffer_get_color_format (framebuffer);
cogl_object_ref (framebuffer);
}
/* FIXME: If texture == NULL and we are given an offscreen framebuffer
* then we want a way to poke inside the framebuffer to get a texture */
surface->texture = texture;
if (texture) {
if (!framebuffer) {
surface->width = cogl_texture_get_width (texture);
surface->height = cogl_texture_get_height (texture);
surface->cogl_format = cogl_texture_get_format (texture);
}
cogl_object_ref (texture);
}
assert(surface->width && surface->height);
surface->journal = NULL;
surface->buffer_stack = NULL;
surface->buffer_stack_size = 4096;
surface->last_clip = NULL;
surface->n_clip_updates_per_frame = 0;
_cairo_surface_init (&surface->base,
&_cairo_cogl_surface_backend,
&dev->base,
CAIRO_CONTENT_COLOR_ALPHA);
return &surface->base;
}
cairo_surface_t *
cairo_cogl_surface_create (cairo_device_t *abstract_device,
CoglFramebuffer *framebuffer)
{
cairo_cogl_device_t *dev = (cairo_cogl_device_t *)abstract_device;
if (abstract_device == NULL)
return _cairo_surface_create_in_error (CAIRO_STATUS_DEVICE_ERROR);
if (abstract_device->status)
return _cairo_surface_create_in_error (abstract_device->status);
if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_COGL)
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
return _cairo_cogl_surface_create_full (dev, FALSE, framebuffer, NULL);
}
slim_hidden_def (cairo_cogl_surface_create);
CoglFramebuffer *
cairo_cogl_surface_get_framebuffer (cairo_surface_t *abstract_surface)
{
cairo_cogl_surface_t *surface;
if (abstract_surface->backend != &_cairo_cogl_surface_backend) {
_cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
return NULL;
}
surface = (cairo_cogl_surface_t *) abstract_surface;
return surface->framebuffer;
}
slim_hidden_def (cairo_cogl_surface_get_framebuffer);
CoglTexture *
cairo_cogl_surface_get_texture (cairo_surface_t *abstract_surface)
{
cairo_cogl_surface_t *surface;
if (abstract_surface->backend != &_cairo_cogl_surface_backend) {
_cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
return NULL;
}
surface = (cairo_cogl_surface_t *) abstract_surface;
return surface->texture;
}
slim_hidden_def (cairo_cogl_surface_get_texture);
static cairo_status_t
_cairo_cogl_device_flush (void *device)
{
cairo_status_t status;
status = cairo_device_acquire (device);
if (unlikely (status))
return status;
/* XXX: we don't need to flush Cogl here, we just need to flush
* any batching we do of compositing primitives. */
cairo_device_release (device);
return CAIRO_STATUS_SUCCESS;
}
static void
_cairo_cogl_device_finish (void *device)
{
cairo_status_t status;
status = cairo_device_acquire (device);
if (unlikely (status))
return;
/* XXX: Drop references to external resources */
cairo_device_release (device);
}
static void
_cairo_cogl_device_destroy (void *device)
{
cairo_cogl_device_t *dev = device;
/* FIXME: Free stuff! */
g_free (dev);
}
static const cairo_device_backend_t _cairo_cogl_device_backend = {
CAIRO_DEVICE_TYPE_COGL,
NULL, /* lock */
NULL, /* unlock */
_cairo_cogl_device_flush,
_cairo_cogl_device_finish,
_cairo_cogl_device_destroy,
};
static cairo_bool_t
set_blend (CoglPipeline *pipeline, const char *blend_string)
{
GError *error = NULL;
if (!cogl_pipeline_set_blend (pipeline, blend_string, &error)) {
g_warning ("Unsupported blend string with current gpu/driver: %s", blend_string);
g_error_free (error);
return FALSE;
}
return TRUE;
}
static cairo_bool_t
_cairo_cogl_setup_op_state (CoglPipeline *pipeline, cairo_operator_t op)
{
cairo_bool_t status = FALSE;
switch ((int)op)
{
case CAIRO_OPERATOR_SOURCE:
status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, 0)");
break;
case CAIRO_OPERATOR_OVER:
status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, DST_COLOR * (1 - SRC_COLOR[A]))");
break;
case CAIRO_OPERATOR_IN:
status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR * DST_COLOR[A], 0)");
break;
case CAIRO_OPERATOR_DEST_OVER:
status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR * (1 - DST_COLOR[A]), DST_COLOR)");
break;
case CAIRO_OPERATOR_DEST_IN:
status = set_blend (pipeline, "RGBA = ADD (0, DST_COLOR * SRC_COLOR[A])");
break;
case CAIRO_OPERATOR_ADD:
status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, DST_COLOR)");
break;
}
return status;
}
static void
create_templates_for_op (cairo_cogl_device_t *dev, cairo_operator_t op)
{
CoglPipeline *base = cogl_pipeline_new ();
CoglPipeline *pipeline;
CoglColor color;
if (!_cairo_cogl_setup_op_state (base, op)) {
cogl_object_unref (base);
return;
}
dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_SOLID] = base;
pipeline = cogl_pipeline_copy (base);
cogl_pipeline_set_layer_texture (pipeline, 0, dev->dummy_texture);
dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_TEXTURE] = pipeline;
pipeline = cogl_pipeline_copy (base);
cogl_pipeline_set_layer_combine (pipeline, 1,
"RGBA = MODULATE (PREVIOUS, CONSTANT[A])",
NULL);
cogl_pipeline_set_layer_combine_constant (pipeline, 1, &color);
cogl_pipeline_set_layer_texture (pipeline, 1, dev->dummy_texture);
dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_MASK_SOLID] = pipeline;
pipeline = cogl_pipeline_copy (base);
cogl_pipeline_set_layer_combine (pipeline, 1,
"RGBA = MODULATE (PREVIOUS, TEXTURE[A])",
NULL);
cogl_pipeline_set_layer_texture (pipeline, 1, dev->dummy_texture);
dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_MASK_TEXTURE] = pipeline;
}
cairo_device_t *
cairo_cogl_device_create (CoglContext *cogl_context)
{
cairo_cogl_device_t *dev = g_new0 (cairo_cogl_device_t, 1);
cairo_status_t status;
dev->backend_vtable_initialized = FALSE;
dev->cogl_context = cogl_context;
dev->dummy_texture = cogl_texture_new_with_size (1, 1,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY);
if (!dev->dummy_texture)
goto ERROR;
memset (dev->template_pipelines, 0, sizeof (dev->template_pipelines));
create_templates_for_op (dev, CAIRO_OPERATOR_SOURCE);
create_templates_for_op (dev, CAIRO_OPERATOR_OVER);
create_templates_for_op (dev, CAIRO_OPERATOR_IN);
create_templates_for_op (dev, CAIRO_OPERATOR_DEST_OVER);
create_templates_for_op (dev, CAIRO_OPERATOR_DEST_IN);
create_templates_for_op (dev, CAIRO_OPERATOR_ADD);
status = _cairo_cache_init (&dev->linear_cache,
_cairo_cogl_linear_gradient_equal,
NULL,
(cairo_destroy_func_t) _cairo_cogl_linear_gradient_destroy,
CAIRO_COGL_LINEAR_GRADIENT_CACHE_SIZE);
if (unlikely (status))
return _cairo_device_create_in_error(status);
status = _cairo_cache_init (&dev->path_fill_staging_cache,
_cairo_cogl_path_fill_meta_equal,
NULL,
(cairo_destroy_func_t) _cairo_cogl_path_fill_meta_destroy,
1000);
status = _cairo_cache_init (&dev->path_stroke_staging_cache,
_cairo_cogl_path_stroke_meta_equal,
NULL,
(cairo_destroy_func_t) _cairo_cogl_path_stroke_meta_destroy,
1000);
status = _cairo_cache_init (&dev->path_fill_prim_cache,
_cairo_cogl_path_fill_meta_equal,
NULL,
(cairo_destroy_func_t) _cairo_cogl_path_fill_meta_destroy,
CAIRO_COGL_PATH_META_CACHE_SIZE);
status = _cairo_cache_init (&dev->path_stroke_prim_cache,
_cairo_cogl_path_stroke_meta_equal,
NULL,
(cairo_destroy_func_t) _cairo_cogl_path_stroke_meta_destroy,
CAIRO_COGL_PATH_META_CACHE_SIZE);
_cairo_device_init (&dev->base, &_cairo_cogl_device_backend);
return &dev->base;
ERROR:
g_free (dev);
return NULL;
}
slim_hidden_def (cairo_cogl_device_create);
void
cairo_cogl_surface_end_frame (cairo_surface_t *abstract_surface)
{
cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
cairo_surface_flush (abstract_surface);
//g_print ("n_clip_update_per_frame = %d\n", surface->n_clip_updates_per_frame);
surface->n_clip_updates_per_frame = 0;
}
slim_hidden_def (cairo_cogl_surface_end_frame);