?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
beta-0.89.2
[luatex.git] / source / libs / cairo / cairo-src / src / cairo-cogl-surface.c
blobc57fd7f433c5ac1f97275c9012e08e0788797ae5
1 /* cairo - a vector graphics library with display and print output
2 *
3 * Copyright © 2011 Intel Corporation.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it either under the terms of the GNU Lesser General Public
7 * License version 2.1 as published by the Free Software Foundation
8 * (the "LGPL") or, at your option, under the terms of the Mozilla
9 * Public License Version 1.1 (the "MPL"). If you do not alter this
10 * notice, a recipient may use your version of this file under either
11 * the MPL or the LGPL.
12 *
13 * You should have received a copy of the LGPL along with this library
14 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
16 * You should have received a copy of the MPL along with this library
17 * in the file COPYING-MPL-1.1
18 *
19 * The contents of this file are subject to the Mozilla Public License
20 * Version 1.1 (the "License"); you may not use this file except in
21 * compliance with the License. You may obtain a copy of the License at
22 * http://www.mozilla.og/MPL/
23 *
24 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
25 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
26 * the specific language governing rights and limitations.
27 *
28 * Contributor(s):
29 * Robert Bragg <robert@linux.intel.com>
30 */
31 #include "cairoint.h"
32
33 #include "cairo-cache-private.h"
34 #include "cairo-error-private.h"
35 #include "cairo-path-fixed-private.h"
36 #include "cairo-recording-surface-private.h"
37 #include "cairo-surface-clipper-private.h"
38 #include "cairo-fixed-private.h"
39 #include "cairo-device-private.h"
40 #include "cairo-composite-rectangles-private.h"
41 #include "cairo-image-surface-inline.h"
42 #include "cairo-cogl-private.h"
43 #include "cairo-cogl-gradient-private.h"
44 #include "cairo-arc-private.h"
45 #include "cairo-traps-private.h"
46 #include "cairo-cogl-context-private.h"
47 #include "cairo-cogl-utils-private.h"
48 #include "cairo-box-inline.h"
49 #include "cairo-surface-subsurface-inline.h"
50 #include "cairo-surface-fallback-private.h"
51 #include "cairo-surface-offset-private.h"
52
53 #include "cairo-cogl.h"
54
55 #include <cogl/cogl2-experimental.h>
56 #include <glib.h>
57
58 #define CAIRO_COGL_DEBUG 0
59 //#define FILL_WITH_COGL_PATH
60 //#define USE_CAIRO_PATH_FLATTENER
61 #define ENABLE_PATH_CACHE
62 //#define DISABLE_BATCHING
63 #define USE_COGL_RECTANGLE_API
64 #define ENABLE_RECTANGLES_FASTPATH
65
66 #if defined (USE_COGL_RECTANGLE_API) || defined (ENABLE_PATH_CACHE)
67 #define NEED_COGL_CONTEXT
68 #endif
69
70 #if CAIRO_COGL_DEBUG && __GNUC__
71 #define UNSUPPORTED(reason) ({ \
72 g_warning ("cairo-cogl: hit unsupported operation: %s", reason); \
73 CAIRO_INT_STATUS_UNSUPPORTED; \
74 })
75 #else
76 #define UNSUPPORTED(reason) CAIRO_INT_STATUS_UNSUPPORTED
77 #endif
78
79 #define CAIRO_COGL_PATH_META_CACHE_SIZE (1024 * 1024)
80
81 typedef struct _cairo_cogl_texture_attributes {
82 /* nabbed from cairo_surface_attributes_t... */
83 cairo_matrix_t matrix;
84 cairo_extend_t extend;
85 cairo_filter_t filter;
86 cairo_bool_t has_component_alpha;
87
88 CoglPipelineWrapMode s_wrap;
89 CoglPipelineWrapMode t_wrap;
90 } cairo_cogl_texture_attributes_t;
91
92 typedef enum _cairo_cogl_journal_entry_type {
93 CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE,
94 CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE,
95 CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH,
96 CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP
97 } cairo_cogl_journal_entry_type_t;
98
99 typedef struct _cairo_cogl_journal_entry {
100 cairo_cogl_journal_entry_type_t type;
101 } cairo_cogl_journal_entry_t;
102
103 typedef struct _cairo_cogl_journal_clip_entry {
104 cairo_cogl_journal_entry_t base;
105 cairo_clip_t *clip;
106 } cairo_cogl_journal_clip_entry_t;
107
108 typedef struct _cairo_cogl_journal_rect_entry {
109 cairo_cogl_journal_entry_t base;
110 CoglPipeline *pipeline;
111 float x;
112 float y;
113 float width;
114 float height;
115 int n_layers;
116 cairo_matrix_t ctm;
117 } cairo_cogl_journal_rect_entry_t;
118
119 typedef struct _cairo_cogl_journal_prim_entry {
120 cairo_cogl_journal_entry_t base;
121 CoglPipeline *pipeline;
122 CoglPrimitive *primitive;
123 gboolean has_transform;
124 cairo_matrix_t transform;
125 } cairo_cogl_journal_prim_entry_t;
126
127 typedef struct _cairo_cogl_journal_path_entry {
128 cairo_cogl_journal_entry_t base;
129 CoglPipeline *pipeline;
130 CoglPath *path;
131 } cairo_cogl_journal_path_entry_t;
132
133 typedef struct _cairo_cogl_path_fill_meta {
134 cairo_cache_entry_t cache_entry;
135 cairo_reference_count_t ref_count;
136 int counter;
137 cairo_path_fixed_t *user_path;
138 cairo_matrix_t ctm_inverse;
139
140 /* TODO */
141 #if 0
142 /* A cached path tessellation should be re-usable with different rotations
143 * and translations but not for different scales.
144 *
145 * one idea is to track the diagonal lenghts of a unit rectangle
146 * transformed through the original ctm use to tessellate the geometry
147 * so we can check what the lengths are for any new ctm to know if
148 * this geometry is compatible.
149 */
150 #endif
151
152 CoglPrimitive *prim;
153 } cairo_cogl_path_fill_meta_t;
154
155 typedef struct _cairo_cogl_path_stroke_meta {
156 cairo_cache_entry_t cache_entry;
157 cairo_reference_count_t ref_count;
158 int counter;
159 cairo_path_fixed_t *user_path;
160 cairo_matrix_t ctm_inverse;
161 cairo_stroke_style_t style;
162 double tolerance;
163
164 /* TODO */
165 #if 0
166 /* A cached path tessellation should be re-usable with different rotations
167 * and translations but not for different scales.
168 *
169 * one idea is to track the diagonal lenghts of a unit rectangle
170 * transformed through the original ctm use to tessellate the geometry
171 * so we can check what the lengths are for any new ctm to know if
172 * this geometry is compatible.
173 */
174 #endif
175
176 CoglPrimitive *prim;
177 } cairo_cogl_path_stroke_meta_t;
178
179 static cairo_surface_t *
180 _cairo_cogl_surface_create_full (cairo_cogl_device_t *dev,
181 cairo_bool_t ignore_alpha,
182 CoglFramebuffer *framebuffer,
183 CoglTexture *texture);
184
185 static cairo_int_status_t
186 _cairo_cogl_surface_fill (void *abstract_surface,
187 cairo_operator_t op,
188 const cairo_pattern_t *source,
189 const cairo_path_fixed_t *path,
190 cairo_fill_rule_t fill_rule,
191 double tolerance,
192 cairo_antialias_t antialias,
193 const cairo_clip_t *clip);
194
195 static void
196 _cairo_cogl_journal_flush (cairo_cogl_surface_t *surface);
197
198 cairo_private extern const cairo_surface_backend_t _cairo_cogl_surface_backend;
199
200 slim_hidden_proto (cairo_cogl_device_create);
201 slim_hidden_proto (cairo_cogl_surface_create);
202 slim_hidden_proto (cairo_cogl_surface_get_framebuffer);
203 slim_hidden_proto (cairo_cogl_surface_get_texture);
204 slim_hidden_proto (cairo_cogl_surface_end_frame);
205
206 static cairo_cogl_device_t *
207 to_device (cairo_device_t *device)
208 {
209 return (cairo_cogl_device_t *)device;
210 }
211
212 /* moves trap points such that they become the actual corners of the trapezoid */
213 static void
214 _sanitize_trap (cairo_trapezoid_t *t)
215 {
216 cairo_trapezoid_t s = *t;
217
218 #define FIX(lr, tb, p) \
219 if (t->lr.p.y != t->tb) { \
220 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); \
221 t->lr.p.y = s.tb; \
222 }
223 FIX (left, top, p1);
224 FIX (left, bottom, p2);
225 FIX (right, top, p1);
226 FIX (right, bottom, p2);
227 }
228
229 static cairo_status_t
230 _cairo_cogl_surface_ensure_framebuffer (cairo_cogl_surface_t *surface)
231 {
232 GError *error = NULL;
233
234 if (surface->framebuffer)
235 return CAIRO_STATUS_SUCCESS;
236
237 surface->framebuffer = COGL_FRAMEBUFFER (cogl_offscreen_new_to_texture (surface->texture));
238 if (!cogl_framebuffer_allocate (surface->framebuffer, &error)) {
239 g_error_free (error);
240 cogl_object_unref (surface->framebuffer);
241 surface->framebuffer = NULL;
242 return CAIRO_STATUS_NO_MEMORY;
243 }
244
245 cogl_push_framebuffer (surface->framebuffer);
246 cogl_ortho (0, surface->width,
247 surface->height, 0,
248 -1, 100);
249 cogl_pop_framebuffer ();
250
251 return CAIRO_STATUS_SUCCESS;
252 }
253
254 static cairo_surface_t *
255 _cairo_cogl_surface_create_similar (void *abstract_surface,
256 cairo_content_t content,
257 int width,
258 int height)
259 {
260 cairo_cogl_surface_t *reference_surface = abstract_surface;
261 cairo_cogl_surface_t *surface;
262 CoglTexture *texture;
263 cairo_status_t status;
264
265 texture = cogl_texture_new_with_size (width, height,
266 COGL_TEXTURE_NO_SLICING,
267 (content & CAIRO_CONTENT_COLOR) ?
268 COGL_PIXEL_FORMAT_BGRA_8888_PRE :
269 COGL_PIXEL_FORMAT_A_8);
270 if (!texture)
271 return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
272
273 surface = (cairo_cogl_surface_t *)
274 _cairo_cogl_surface_create_full (to_device(reference_surface->base.device),
275 (content & CAIRO_CONTENT_ALPHA) == 0,
276 NULL,
277 texture);
278 if (unlikely (surface->base.status))
279 return &surface->base;
280
281 status = _cairo_cogl_surface_ensure_framebuffer (surface);
282 if (unlikely (status)) {
283 cairo_surface_destroy (&surface->base);
284 return _cairo_surface_create_in_error (status);
285 }
286
287 return &surface->base;
288 }
289
290 static cairo_bool_t
291 _cairo_cogl_surface_get_extents (void *abstract_surface,
292 cairo_rectangle_int_t *extents)
293 {
294 cairo_cogl_surface_t *surface = abstract_surface;
295
296 extents->x = 0;
297 extents->y = 0;
298 extents->width = surface->width;
299 extents->height = surface->height;
300
301 return TRUE;
302 }
303
304 static void
305 _cairo_cogl_journal_free (cairo_cogl_surface_t *surface)
306 {
307 GList *l;
308
309 for (l = surface->journal->head; l; l = l->next) {
310 cairo_cogl_journal_entry_t *entry = l->data;
311
312 if (entry->type == CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE) {
313 cairo_cogl_journal_prim_entry_t *prim_entry =
314 (cairo_cogl_journal_prim_entry_t *)entry;
315 cogl_object_unref (prim_entry->primitive);
316 } else if (entry->type == CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH) {
317 cairo_cogl_journal_path_entry_t *path_entry =
318 (cairo_cogl_journal_path_entry_t *)entry;
319 cogl_object_unref (path_entry->path);
320 }
321 }
322
323 g_queue_free (surface->journal);
324 surface->journal = NULL;
325 }
326
327 #ifdef FILL_WITH_COGL_PATH
328 static void
329 _cairo_cogl_journal_log_path (cairo_cogl_surface_t *surface,
330 CoglPipeline *pipeline,
331 CoglPath *path)
332 {
333 cairo_cogl_journal_path_entry_t *entry;
334
335 if (unlikely (surface->journal == NULL))
336 surface->journal = g_queue_new ();
337
338 /* FIXME: Instead of a GList here we should stack allocate the journal
339 * entries so it would be cheaper to allocate and they can all be freed in
340 * one go after flushing! */
341 entry = g_slice_new (cairo_cogl_journal_path_entry_t);
342 entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH;
343
344 entry->pipeline = cogl_object_ref (pipeline);
345 entry->path = cogl_object_ref (path);
346
347 g_queue_push_tail (surface->journal, entry);
348
349 #ifdef DISABLE_BATCHING
350 _cairo_cogl_journal_flush (surface);
351 #endif
352 }
353 #endif /* FILL_WITH_COGL_PATH */
354
355 static void
356 _cairo_cogl_journal_log_primitive (cairo_cogl_surface_t *surface,
357 CoglPipeline *pipeline,
358 CoglPrimitive *primitive,
359 cairo_matrix_t *transform)
360 {
361 cairo_cogl_journal_prim_entry_t *entry;
362
363 if (unlikely (surface->journal == NULL))
364 surface->journal = g_queue_new ();
365
366 /* FIXME: Instead of a GList here we should stack allocate the journal
367 * entries so it would be cheaper to allocate and they can all be freed in
368 * one go after flushing! */
369 entry = g_slice_new (cairo_cogl_journal_prim_entry_t);
370 entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE;
371
372 entry->pipeline = cogl_object_ref (pipeline);
373
374 if (transform) {
375 entry->transform = *transform;
376 entry->has_transform = TRUE;
377 } else
378 entry->has_transform = FALSE;
379
380 entry->primitive = cogl_object_ref (primitive);
381
382 g_queue_push_tail (surface->journal, entry);
383
384 #ifdef DISABLE_BATCHING
385 _cairo_cogl_journal_flush (surface);
386 #endif
387 }
388
389 static void
390 _cairo_cogl_journal_log_rectangle (cairo_cogl_surface_t *surface,
391 CoglPipeline *pipeline,
392 float x,
393 float y,
394 float width,
395 float height,
396 int n_layers,
397 cairo_matrix_t *ctm)
398 {
399 cairo_cogl_journal_rect_entry_t *entry;
400
401 if (unlikely (surface->journal == NULL))
402 surface->journal = g_queue_new ();
403
404 /* FIXME: Instead of a GList here we should stack allocate the journal
405 * entries so it would be cheaper to allocate and they can all be freed in
406 * one go after flushing! */
407 entry = g_slice_new (cairo_cogl_journal_rect_entry_t);
408 entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE;
409
410 entry->pipeline = cogl_object_ref (pipeline);
411
412 entry->x = x;
413 entry->y = y;
414 entry->width = width;
415 entry->height = height;
416 entry->ctm = *ctm;
417
418 entry->n_layers = n_layers;
419
420 g_queue_push_tail (surface->journal, entry);
421
422 #ifdef DISABLE_BATCHING
423 _cairo_cogl_journal_flush (surface);
424 #endif
425 }
426
427 static void
428 _cairo_cogl_journal_log_clip (cairo_cogl_surface_t *surface,
429 const cairo_clip_t *clip)
430 {
431 cairo_cogl_journal_clip_entry_t *entry;
432
433 if (unlikely (surface->journal == NULL))
434 surface->journal = g_queue_new ();
435
436 /* FIXME: Instead of a GList here we should stack allocate the journal
437 * entries so it would be cheaper to allocate and they can all be freed in
438 * one go after flushing! */
439 entry = g_slice_new (cairo_cogl_journal_clip_entry_t);
440 entry->base.type = CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP;
441 entry->clip = _cairo_clip_copy (clip);
442
443 g_queue_push_tail (surface->journal, entry);
444 }
445
446 static void
447 _cairo_cogl_journal_discard (cairo_cogl_surface_t *surface)
448 {
449 GList *l;
450
451 if (!surface->journal) {
452 assert (surface->last_clip == NULL);
453 return;
454 }
455
456 if (surface->buffer_stack && surface->buffer_stack_offset) {
457 cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack));
458 cogl_object_unref (surface->buffer_stack);
459 surface->buffer_stack = NULL;
460 }
461
462 for (l = surface->journal->head; l; l = l->next) {
463 cairo_cogl_journal_entry_t *entry = l->data;
464 gsize entry_size;
465
466 switch (entry->type)
467 {
468 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP: {
469 cairo_cogl_journal_clip_entry_t *clip_entry =
470 (cairo_cogl_journal_clip_entry_t *)entry;
471 _cairo_clip_destroy (clip_entry->clip);
472 entry_size = sizeof (cairo_cogl_journal_clip_entry_t);
473 break;
474 }
475 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE: {
476 cairo_cogl_journal_rect_entry_t *rect_entry =
477 (cairo_cogl_journal_rect_entry_t *)entry;
478 cogl_object_unref (rect_entry->pipeline);
479 entry_size = sizeof (cairo_cogl_journal_rect_entry_t);
480 break;
481 }
482 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE: {
483 cairo_cogl_journal_prim_entry_t *prim_entry =
484 (cairo_cogl_journal_prim_entry_t *)entry;
485 cogl_object_unref (prim_entry->pipeline);
486 cogl_object_unref (prim_entry->primitive);
487 entry_size = sizeof (cairo_cogl_journal_prim_entry_t);
488 break;
489 }
490 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH: {
491 cairo_cogl_journal_path_entry_t *path_entry =
492 (cairo_cogl_journal_path_entry_t *)entry;
493 cogl_object_unref (path_entry->pipeline);
494 cogl_object_unref (path_entry->path);
495 entry_size = sizeof (cairo_cogl_journal_path_entry_t);
496 break;
497 }
498 default:
499 assert (0); /* not reached! */
500 entry_size = 0; /* avoid compiler warning */
501 }
502 g_slice_free1 (entry_size, entry);
503 }
504
505 g_queue_clear (surface->journal);
506
507 if (surface->last_clip) {
508 _cairo_clip_destroy (surface->last_clip);
509 surface->last_clip = NULL;
510 }
511 }
512
513 static CoglAttributeBuffer *
514 _cairo_cogl_surface_allocate_buffer_space (cairo_cogl_surface_t *surface,
515 size_t size,
516 size_t *offset,
517 void **pointer)
518 {
519 /* XXX: In the Cogl journal we found it more efficient to have a pool of
520 * buffers that we re-cycle but for now we simply thow away our stack
521 * buffer each time we flush. */
522 if (unlikely (surface->buffer_stack &&
523 (surface->buffer_stack_size - surface->buffer_stack_offset) < size)) {
524 cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack));
525 cogl_object_unref (surface->buffer_stack);
526 surface->buffer_stack = NULL;
527 surface->buffer_stack_size *= 2;
528 }
529
530 if (unlikely (surface->buffer_stack_size < size))
531 surface->buffer_stack_size = size * 2;
532
533 if (unlikely (surface->buffer_stack == NULL)) {
534 surface->buffer_stack = cogl_attribute_buffer_new (surface->buffer_stack_size, NULL);
535 surface->buffer_stack_pointer =
536 cogl_buffer_map (COGL_BUFFER (surface->buffer_stack),
537 COGL_BUFFER_ACCESS_WRITE,
538 COGL_BUFFER_MAP_HINT_DISCARD);
539 surface->buffer_stack_offset = 0;
540 }
541
542 *pointer = surface->buffer_stack_pointer + surface->buffer_stack_offset;
543 *offset = surface->buffer_stack_offset;
544
545 surface->buffer_stack_offset += size;
546 return cogl_object_ref (surface->buffer_stack);
547 }
548
549
550 static CoglAttributeBuffer *
551 _cairo_cogl_traps_to_triangles_buffer (cairo_cogl_surface_t *surface,
552 cairo_traps_t *traps,
553 size_t *offset,
554 gboolean one_shot)
555 {
556 CoglAttributeBuffer *buffer;
557 int n_traps = traps->num_traps;
558 int i;
559 CoglVertexP2 *triangles;
560
561 if (one_shot) {
562 buffer = _cairo_cogl_surface_allocate_buffer_space (surface,
563 n_traps * sizeof (CoglVertexP2) * 6,
564 offset,
565 (void **)&triangles);
566 if (!buffer)
567 return NULL;
568 } else {
569 buffer = cogl_attribute_buffer_new (n_traps * sizeof (CoglVertexP2) * 6, NULL);
570 if (!buffer)
571 return NULL;
572 triangles = cogl_buffer_map (COGL_BUFFER (buffer),
573 COGL_BUFFER_ACCESS_WRITE,
574 COGL_BUFFER_MAP_HINT_DISCARD);
575 if (!triangles)
576 return NULL;
577 *offset = 0;
578 }
579
580 /* XXX: This is can be very expensive. I'm not sure a.t.m if it's
581 * predominantly the bandwidth required or the cost of the fixed_to_float
582 * conversions but either way we should try using an index buffer to
583 * reduce the amount we upload by 1/3 (offset by allocating and uploading
584 * indices though) sadly though my experience with the intel mesa drivers
585 * is that slow paths can easily be hit when starting to use indices.
586 */
587 for (i = 0; i < n_traps; i++)
588 {
589 CoglVertexP2 *p = &triangles[i * 6];
590 cairo_trapezoid_t *trap = &traps->traps[i];
591
592 p[0].x = _cairo_cogl_util_fixed_to_float (trap->left.p1.x);
593 p[0].y = _cairo_cogl_util_fixed_to_float (trap->left.p1.y);
594
595 p[1].x = _cairo_cogl_util_fixed_to_float (trap->left.p2.x);
596 p[1].y = _cairo_cogl_util_fixed_to_float (trap->left.p2.y);
597
598 p[2].x = _cairo_cogl_util_fixed_to_float (trap->right.p2.x);
599 p[2].y = _cairo_cogl_util_fixed_to_float (trap->right.p2.y);
600
601 p[3].x = _cairo_cogl_util_fixed_to_float (trap->left.p1.x);
602 p[3].y = _cairo_cogl_util_fixed_to_float (trap->left.p1.y);
603
604 p[4].x = _cairo_cogl_util_fixed_to_float (trap->right.p2.x);
605 p[4].y = _cairo_cogl_util_fixed_to_float (trap->right.p2.y);
606
607 p[5].x = _cairo_cogl_util_fixed_to_float (trap->right.p1.x);
608 p[5].y = _cairo_cogl_util_fixed_to_float (trap->right.p1.y);
609 }
610
611 if (!one_shot)
612 cogl_buffer_unmap (COGL_BUFFER (buffer));
613
614 return buffer;
615 }
616
617 /* Used for solid fills, in this case we just need a mesh made of
618 * a single (2-component) position attribute. */
619 static CoglPrimitive *
620 _cairo_cogl_traps_to_composite_prim_p2 (cairo_cogl_surface_t *surface,
621 cairo_traps_t *traps,
622 gboolean one_shot)
623 {
624 size_t offset;
625 CoglAttributeBuffer *buffer = _cairo_cogl_traps_to_triangles_buffer (surface, traps, &offset, one_shot);
626 CoglAttribute *pos = cogl_attribute_new (buffer,
627 "cogl_position_in",
628 sizeof (CoglVertexP2),
629 offset,
630 2,
631 COGL_ATTRIBUTE_TYPE_FLOAT);
632 CoglPrimitive *prim;
633
634 /* The attribute will have taken a reference on the buffer */
635 cogl_object_unref (buffer);
636
637 prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES,
638 traps->num_traps * 6, pos, NULL);
639
640 /* The primitive will now keep the attribute alive... */
641 cogl_object_unref (pos);
642
643 return prim;
644 }
645
646 /* Used for surface fills, in this case we need a mesh made of a single
647 * (2-component) position attribute + we also alias the same attribute as
648 * (2-component) texture coordinates */
649 static CoglPrimitive *
650 _cairo_cogl_traps_to_composite_prim_p2t2 (cairo_cogl_surface_t *surface,
651 cairo_traps_t *traps,
652 gboolean one_shot)
653 {
654 size_t offset;
655 CoglAttributeBuffer *buffer = _cairo_cogl_traps_to_triangles_buffer (surface, traps, &offset, one_shot);
656 CoglAttribute *pos = cogl_attribute_new (buffer,
657 "cogl_position_in",
658 sizeof (CoglVertexP2),
659 offset,
660 2,
661 COGL_ATTRIBUTE_TYPE_FLOAT);
662 CoglAttribute *tex_coords = cogl_attribute_new (buffer,
663 "cogl_tex_coord0_in",
664 sizeof (CoglVertexP2),
665 0,
666 2,
667 COGL_ATTRIBUTE_TYPE_FLOAT);
668 CoglPrimitive *prim;
669
670 /* The attributes will have taken references on the buffer */
671 cogl_object_unref (buffer);
672
673 prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES,
674 traps->num_traps * 6, pos, tex_coords, NULL);
675
676 /* The primitive will now keep the attributes alive... */
677 cogl_object_unref (pos);
678 cogl_object_unref (tex_coords);
679
680 return prim;
681 }
682
683 static CoglPrimitive *
684 _cairo_cogl_traps_to_composite_prim (cairo_cogl_surface_t *surface,
685 cairo_traps_t *traps,
686 int n_layers,
687 gboolean one_shot)
688 {
689 int n_traps = traps->num_traps;
690 int i;
691
692 /* XXX: Ideally we would skip tessellating to traps entirely since
693 * given their representation, conversion to triangles is quite expensive.
694 *
695 * This simplifies the conversion to triangles by making the end points of
696 * the two side lines actually just correspond to the corners of the
697 * traps.
698 */
699 for (i = 0; i < n_traps; i++)
700 _sanitize_trap (&traps->traps[i]);
701
702 if (n_layers == 0)
703 return _cairo_cogl_traps_to_composite_prim_p2 (surface, traps, one_shot);
704 else {
705 assert (n_layers == 1);
706 return _cairo_cogl_traps_to_composite_prim_p2t2 (surface, traps, one_shot);
707 }
708 }
709
710 static cairo_int_status_t
711 _cairo_cogl_fill_to_primitive (cairo_cogl_surface_t *surface,
712 const cairo_path_fixed_t *path,
713 cairo_fill_rule_t fill_rule,
714 double tolerance,
715 int n_layers,
716 cairo_bool_t one_shot,
717 CoglPrimitive **primitive,
718 size_t *size)
719 {
720 cairo_traps_t traps;
721 cairo_int_status_t status;
722
723 _cairo_traps_init (&traps);
724 status = _cairo_path_fixed_fill_to_traps (path, fill_rule, tolerance, &traps);
725 if (unlikely (status))
726 goto BAIL;
727
728 if (traps.num_traps == 0) {
729 status = CAIRO_INT_STATUS_NOTHING_TO_DO;
730 goto BAIL;
731 }
732
733 *size = traps.num_traps * sizeof (CoglVertexP2) * 6;
734
735 *primitive = _cairo_cogl_traps_to_composite_prim (surface, &traps, n_layers, one_shot);
736 if (!*primitive) {
737 status = CAIRO_INT_STATUS_NO_MEMORY;
738 goto BAIL;
739 }
740
741 BAIL:
742 _cairo_traps_fini (&traps);
743 return status;
744 }
745
746 static void
747 _cairo_cogl_clip_push_box (const cairo_box_t *box)
748 {
749 if (_cairo_box_is_pixel_aligned (box)) {
750 cairo_rectangle_int_t rect;
751 _cairo_box_round_to_rectangle (box, &rect);
752 cogl_clip_push_window_rectangle (rect.x, rect.y,
753 rect.width, rect.height);
754 } else {
755 double x1, y1, x2, y2;
756 _cairo_box_to_doubles (box, &x1, &y1, &x2, &y2);
757 cogl_clip_push_rectangle (x1, y1, x2, y2);
758 }
759 }
760
761 static void
762 _cairo_cogl_journal_flush (cairo_cogl_surface_t *surface)
763 {
764 GList *l;
765 int clip_stack_depth = 0;
766 int i;
767
768 if (!surface->journal)
769 return;
770
771 if (surface->buffer_stack && surface->buffer_stack_offset) {
772 cogl_buffer_unmap (COGL_BUFFER (surface->buffer_stack));
773 cogl_object_unref (surface->buffer_stack);
774 surface->buffer_stack = NULL;
775 }
776
777 cogl_set_framebuffer (surface->framebuffer);
778
779 cogl_push_matrix ();
780
781 for (l = surface->journal->head; l; l = l->next) {
782 cairo_cogl_journal_entry_t *entry = l->data;
783
784 switch (entry->type)
785 {
786 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_CLIP: {
787 cairo_cogl_journal_clip_entry_t *clip_entry =
788 (cairo_cogl_journal_clip_entry_t *)entry;
789 cairo_clip_path_t *path;
790 #if 0
791 cairo_bool_t checked_for_primitives = FALSE;
792 cairo_cogl_clip_primitives_t *clip_primitives;
793 #endif
794
795 for (i = 0; i < clip_stack_depth; i++)
796 cogl_clip_pop ();
797 clip_stack_depth = 0;
798
799 for (path = clip_entry->clip->path, i = 0; path; path = path->prev, i++) {
800 cairo_rectangle_int_t extents;
801 cairo_int_status_t status;
802 CoglPrimitive *prim;
803 size_t prim_size;
804
805 _cairo_path_fixed_approximate_clip_extents (&path->path, &extents);
806
807 /* TODO - maintain a fifo of the last 10 used clips with cached
808 * primitives to see if we can avoid tessellating the path and
809 * uploading the vertices...
810 */
811 #if 0
812 if (!checked_for_primitives) {
813 clip_primitives = find_clip_primitives (clip);
814 checked_for_primitives = TRUE;
815 }
816 if (clip_primitives)
817 prim = clip_primitives->primitives[i];
818 #endif
819 status = _cairo_cogl_fill_to_primitive (surface,
820 &path->path,
821 path->fill_rule,
822 path->tolerance,
823 0,
824 TRUE,
825 &prim,
826 &prim_size);
827 if (unlikely (status)) {
828 g_warning ("Failed to get primitive for clip path while flushing journal");
829 continue;
830 }
831 clip_stack_depth++;
832 cogl_clip_push_primitive (prim,
833 extents.x, extents.y,
834 extents.x + extents.width,
835 extents.y + extents.height);
836 cogl_object_unref (prim);
837 }
838
839 for (i = 0; i < clip_entry->clip->num_boxes; i++) {
840 clip_stack_depth++;
841 _cairo_cogl_clip_push_box (&clip_entry->clip->boxes[i]);
842 }
843
844 surface->n_clip_updates_per_frame++;
845 break;
846 }
847 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_RECTANGLE: {
848 cairo_cogl_journal_rect_entry_t *rect_entry =
849 (cairo_cogl_journal_rect_entry_t *)entry;
850 float tex_coords[8];
851 float x1 = rect_entry->x;
852 float y1 = rect_entry->y;
853 float x2 = rect_entry->x + rect_entry->width;
854 float y2 = rect_entry->y + rect_entry->height;
855 cairo_matrix_t *ctm = &rect_entry->ctm;
856 float ctmfv[16] = {
857 ctm->xx, ctm->yx, 0, 0,
858 ctm->xy, ctm->yy, 0, 0,
859 0, 0, 1, 0,
860 ctm->x0, ctm->y0, 0, 1
861 };
862 CoglMatrix transform;
863
864 cogl_matrix_init_from_array (&transform, ctmfv);
865
866 if (rect_entry->n_layers) {
867 g_assert (rect_entry->n_layers <= 2);
868 tex_coords[0] = x1;
869 tex_coords[1] = y1;
870 tex_coords[2] = x2;
871 tex_coords[3] = y2;
872 if (rect_entry->n_layers > 1)
873 memcpy (&tex_coords[4], tex_coords, sizeof (float) * 4);
874 }
875
876 cogl_set_source (rect_entry->pipeline);
877 cogl_push_matrix ();
878 cogl_transform (&transform);
879 cogl_rectangle_with_multitexture_coords (x1, y1, x2, y2,
880 tex_coords, 4 * rect_entry->n_layers);
881 cogl_pop_matrix ();
882 break;
883 }
884 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PRIMITIVE: {
885 cairo_cogl_journal_prim_entry_t *prim_entry =
886 (cairo_cogl_journal_prim_entry_t *)entry;
887 CoglMatrix transform;
888
889 cogl_push_matrix ();
890 if (prim_entry->has_transform) {
891 cairo_matrix_t *ctm = &prim_entry->transform;
892 float ctmfv[16] = {
893 ctm->xx, ctm->yx, 0, 0,
894 ctm->xy, ctm->yy, 0, 0,
895 0, 0, 1, 0,
896 ctm->x0, ctm->y0, 0, 1
897 };
898 cogl_matrix_init_from_array (&transform, ctmfv);
899 cogl_transform (&transform);
900 } else {
901 cogl_matrix_init_identity (&transform);
902 cogl_set_modelview_matrix (&transform);
903 }
904
905 cogl_set_source (prim_entry->pipeline);
906 cogl_primitive_draw (prim_entry->primitive);
907 cogl_pop_matrix ();
908 break;
909 }
910 case CAIRO_COGL_JOURNAL_ENTRY_TYPE_PATH: {
911 cairo_cogl_journal_path_entry_t *path_entry =
912 (cairo_cogl_journal_path_entry_t *)entry;
913
914 cogl_set_source (path_entry->pipeline);
915 cogl_path_fill (path_entry->path);
916 break;
917 }
918 default:
919 assert (0); /* not reached! */
920 }
921 }
922
923 cogl_pop_matrix ();
924
925 for (i = 0; i < clip_stack_depth; i++)
926 cogl_clip_pop ();
927
928 _cairo_cogl_journal_discard (surface);
929 }
930
931 static cairo_status_t
932 _cairo_cogl_surface_flush (void *abstract_surface,
933 unsigned flags)
934 {
935 cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
936
937 if (flags)
938 return CAIRO_STATUS_SUCCESS;
939
940 _cairo_cogl_journal_flush (surface);
941
942 return CAIRO_STATUS_SUCCESS;
943 }
944
945 static cairo_status_t
946 _cairo_cogl_surface_finish (void *abstract_surface)
947 {
948 cairo_cogl_surface_t *surface = abstract_surface;
949
950 if (surface->texture)
951 cogl_object_unref (surface->texture);
952
953 if (surface->framebuffer)
954 cogl_object_unref (surface->framebuffer);
955
956 if (surface->journal)
957 _cairo_cogl_journal_free (surface);
958
959 /*XXX wtf */
960 cairo_device_release (surface->base.device);
961
962 return CAIRO_STATUS_SUCCESS;
963 }
964
965 static CoglPixelFormat
966 get_cogl_format_from_cairo_format (cairo_format_t cairo_format);
967
968 /* XXX: We often use RGBA format for onscreen framebuffers so make sure
969 * to handle CAIRO_FORMAT_INVALID sensibly */
970 static cairo_format_t
971 get_cairo_format_from_cogl_format (CoglPixelFormat format)
972 {
973 switch ((int)format)
974 {
975 case COGL_PIXEL_FORMAT_A_8:
976 return CAIRO_FORMAT_A8;
977 case COGL_PIXEL_FORMAT_RGB_565:
978 return CAIRO_FORMAT_RGB16_565;
979
980 case COGL_PIXEL_FORMAT_BGRA_8888_PRE:
981 case COGL_PIXEL_FORMAT_ARGB_8888_PRE:
982 case COGL_PIXEL_FORMAT_RGBA_8888_PRE:
983 /* Note: this is ambiguous since CAIRO_FORMAT_RGB24
984 * would also map to the same CoglPixelFormat */
985 return CAIRO_FORMAT_ARGB32;
986
987 default:
988 g_warning("bad format: %x a? %d, bgr? %d, pre %d, format: %d\n",
989 format,
990 format & COGL_A_BIT,
991 format & COGL_BGR_BIT,
992 format & COGL_PREMULT_BIT,
993 format & ~(COGL_A_BIT | COGL_BGR_BIT | COGL_PREMULT_BIT));
994 return CAIRO_FORMAT_INVALID;
995 }
996 }
997
998 static CoglPixelFormat
999 get_cogl_format_from_cairo_format (cairo_format_t cairo_format)
1000 {
1001 switch (cairo_format)
1002 {
1003 case CAIRO_FORMAT_ARGB32:
1004 case CAIRO_FORMAT_RGB24:
1005 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
1006 return COGL_PIXEL_FORMAT_BGRA_8888_PRE;
1007 #else
1008 return COGL_PIXEL_FORMAT_ARGB_8888_PRE;
1009 #endif
1010 case CAIRO_FORMAT_A8:
1011 return COGL_PIXEL_FORMAT_A_8;
1012 case CAIRO_FORMAT_RGB16_565:
1013 return COGL_PIXEL_FORMAT_RGB_565;
1014 case CAIRO_FORMAT_INVALID:
1015 case CAIRO_FORMAT_A1:
1016 case CAIRO_FORMAT_RGB30:
1017 return 0;
1018 }
1019
1020 g_warn_if_reached ();
1021 return 0;
1022 }
1023
1024 static cairo_status_t
1025 _cairo_cogl_surface_read_rect_to_image_surface (cairo_cogl_surface_t *surface,
1026 cairo_rectangle_int_t *interest,
1027 cairo_image_surface_t **image_out)
1028 {
1029 cairo_image_surface_t *image;
1030 cairo_status_t status;
1031 cairo_format_t cairo_format;
1032 CoglPixelFormat cogl_format;
1033
1034 /* TODO: Add cogl_texture_get_region() API so we don't have to ensure the
1035 * surface is bound to an fbo to read back pixels */
1036 status = _cairo_cogl_surface_ensure_framebuffer (surface);
1037 if (unlikely (status))
1038 return status;
1039
1040 cairo_format = get_cairo_format_from_cogl_format (surface->cogl_format);
1041 if (cairo_format == CAIRO_FORMAT_INVALID) {
1042 cairo_format = CAIRO_FORMAT_ARGB32;
1043 cogl_format = get_cogl_format_from_cairo_format (cairo_format);
1044 } else {
1045 cogl_format = cogl_framebuffer_get_color_format (surface->framebuffer);
1046 }
1047
1048 image = (cairo_image_surface_t *)
1049 cairo_image_surface_create (cairo_format, surface->width, surface->height);
1050 if (image->base.status)
1051 return image->base.status;
1052
1053 /* TODO: Add cogl_framebuffer_read_pixels() API */
1054 cogl_push_framebuffer (surface->framebuffer);
1055 cogl_read_pixels (0, 0, surface->width, surface->height,
1056 COGL_READ_PIXELS_COLOR_BUFFER,
1057 cogl_format,
1058 image->data);
1059 cogl_pop_framebuffer ();
1060
1061 *image_out = image;
1062
1063 return CAIRO_STATUS_SUCCESS;
1064 }
1065
1066 static cairo_status_t
1067 _cairo_cogl_surface_acquire_source_image (void *abstract_surface,
1068 cairo_image_surface_t **image_out,
1069 void **image_extra)
1070 {
1071 cairo_cogl_surface_t *surface = abstract_surface;
1072 cairo_status_t status;
1073
1074 if (surface->texture) {
1075 cairo_format_t format = get_cairo_format_from_cogl_format (surface->cogl_format);
1076 cairo_image_surface_t *image = (cairo_image_surface_t *)
1077 cairo_image_surface_create (format, surface->width, surface->height);
1078 if (image->base.status)
1079 return image->base.status;
1080
1081 cogl_texture_get_data (surface->texture,
1082 cogl_texture_get_format (surface->texture),
1083 0,
1084 image->data);
1085
1086 image->base.is_clear = FALSE;
1087 *image_out = image;
1088 } else {
1089 cairo_rectangle_int_t extents = {
1090 0, 0, surface->width, surface->height
1091 };
1092 status = _cairo_cogl_surface_read_rect_to_image_surface (surface, &extents,
1093 image_out);
1094 if (unlikely (status))
1095 return status;
1096 }
1097
1098 *image_extra = NULL;
1099
1100 return CAIRO_STATUS_SUCCESS;
1101 }
1102
1103 static void
1104 _cairo_cogl_surface_release_source_image (void *abstract_surface,
1105 cairo_image_surface_t *image,
1106 void *image_extra)
1107 {
1108 cairo_surface_destroy (&image->base);
1109 }
1110
1111 static cairo_status_t
1112 _cairo_cogl_surface_clear (cairo_cogl_surface_t *surface,
1113 const cairo_color_t *color)
1114 {
1115 /* Anything batched in the journal up until now is redundant... */
1116 _cairo_cogl_journal_discard (surface);
1117
1118 /* XXX: we currently implicitly clear the depth and stencil buffer here
1119 * but since we use the framebuffer_discard extension when available I
1120 * suppose this doesn't matter too much.
1121 *
1122 * The main concern is that we want to avoid re-loading an external z
1123 * buffer at the start of each frame, but also many gpu architectures have
1124 * optimizations for how they handle the depth/stencil buffers and can get
1125 * upset if they aren't cleared together at the start of the frame.
1126 *
1127 * FIXME: we need a way to assert that the clip stack currently isn't
1128 * using the stencil buffer before clearing it here!
1129 */
1130 cogl_framebuffer_clear4f (surface->framebuffer,
1131 COGL_BUFFER_BIT_COLOR |
1132 COGL_BUFFER_BIT_DEPTH |
1133 COGL_BUFFER_BIT_STENCIL,
1134 color->red * color->alpha,
1135 color->green * color->alpha,
1136 color->blue * color->alpha,
1137 color->alpha);
1138 return CAIRO_STATUS_SUCCESS;
1139 }
1140
1141 cairo_status_t
1142 _cairo_cogl_path_fixed_rectangle (cairo_path_fixed_t *path,
1143 cairo_fixed_t x,
1144 cairo_fixed_t y,
1145 cairo_fixed_t width,
1146 cairo_fixed_t height)
1147 {
1148 cairo_status_t status;
1149
1150 status = _cairo_path_fixed_move_to (path, x, y);
1151 if (unlikely (status))
1152 return status;
1153
1154 status = _cairo_path_fixed_rel_line_to (path, width, 0);
1155 if (unlikely (status))
1156 return status;
1157
1158 status = _cairo_path_fixed_rel_line_to (path, 0, height);
1159 if (unlikely (status))
1160 return status;
1161
1162 status = _cairo_path_fixed_rel_line_to (path, -width, 0);
1163 if (unlikely (status))
1164 return status;
1165
1166 status = _cairo_path_fixed_close_path (path);
1167 if (unlikely (status))
1168 return status;
1169
1170 return CAIRO_STATUS_SUCCESS;
1171 }
1172
1173 static cairo_int_status_t
1174 _cairo_cogl_surface_paint (void *abstract_surface,
1175 cairo_operator_t op,
1176 const cairo_pattern_t *source,
1177 const cairo_clip_t *clip)
1178 {
1179 cairo_cogl_surface_t *surface;
1180 cairo_path_fixed_t path;
1181 cairo_status_t status;
1182 cairo_matrix_t identity;
1183
1184 if (clip == NULL) {
1185 if (op == CAIRO_OPERATOR_CLEAR)
1186 return _cairo_cogl_surface_clear (abstract_surface, CAIRO_COLOR_TRANSPARENT);
1187 else if (source->type == CAIRO_PATTERN_TYPE_SOLID &&
1188 (op == CAIRO_OPERATOR_SOURCE ||
1189 (op == CAIRO_OPERATOR_OVER && (((cairo_surface_t *)abstract_surface)->is_clear || _cairo_pattern_is_opaque_solid (source))))) {
1190 return _cairo_cogl_surface_clear (abstract_surface,
1191 &((cairo_solid_pattern_t *) source)->color);
1192 }
1193 }
1194
1195 /* fallback to handling the paint in terms of a fill... */
1196
1197 surface = abstract_surface;
1198
1199 _cairo_path_fixed_init (&path);
1200
1201 status = _cairo_cogl_path_fixed_rectangle (&path, 0, 0, surface->width, surface->height);
1202 if (unlikely (status))
1203 goto BAIL;
1204
1205 #ifdef NEED_COGL_CONTEXT
1206 /* XXX: in cairo-cogl-context.c we set some sideband data on the
1207 * surface before issuing a fill so we need to do that here too... */
1208 surface->user_path = &path;
1209 cairo_matrix_init_identity (&identity);
1210 surface->ctm = &identity;
1211 surface->ctm_inverse = &identity;
1212 surface->path_is_rectangle = TRUE;
1213 surface->path_rectangle_x = 0;
1214 surface->path_rectangle_y = 0;
1215 surface->path_rectangle_width = surface->width;
1216 surface->path_rectangle_height = surface->height;
1217 #endif
1218
1219 status = _cairo_cogl_surface_fill (abstract_surface,
1220 op,
1221 source,
1222 &path,
1223 CAIRO_FILL_RULE_WINDING,
1224 1,
1225 CAIRO_ANTIALIAS_DEFAULT,
1226 clip);
1227 BAIL:
1228 _cairo_path_fixed_fini (&path);
1229 return status;
1230 }
1231
1232 static CoglPipelineWrapMode
1233 get_cogl_wrap_mode_for_extend (cairo_extend_t extend_mode)
1234 {
1235 switch (extend_mode)
1236 {
1237 case CAIRO_EXTEND_NONE:
1238 return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
1239 case CAIRO_EXTEND_PAD:
1240 return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
1241 case CAIRO_EXTEND_REPEAT:
1242 return COGL_PIPELINE_WRAP_MODE_REPEAT;
1243 case CAIRO_EXTEND_REFLECT:
1244 /* TODO: return COGL_PIPELINE_WRAP_MODE_MIRROR; */
1245 return CAIRO_EXTEND_REPEAT;
1246 }
1247 assert (0); /* not reached */
1248 return COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
1249 }
1250
1251 #if 0
1252 /* Given an arbitrary texture, check if it's already a pot texture and simply
1253 * return it back if so. If not create a new pot texture, scale the old to
1254 * fill it, unref the old and return a pointer to the new pot texture. */
1255 static cairo_int_status_t
1256 _cairo_cogl_get_pot_texture (CoglContext *context,
1257 CoglTexture *texture,
1258 CoglTexture **pot_texture)
1259 {
1260 int width = cogl_texture_get_width (texture);
1261 int height = cogl_texture_get_height (texture);
1262 int pot_width;
1263 int pot_height;
1264 CoglHandle offscreen = NULL;
1265 CoglTexture2D *pot = NULL;
1266 GError *error;
1267
1268 pot_width = _cairo_cogl_util_next_p2 (width);
1269 pot_height = _cairo_cogl_util_next_p2 (height);
1270
1271 if (pot_width == width && pot_height == height)
1272 return CAIRO_INT_STATUS_SUCCESS;
1273
1274 for (;;) {
1275 error = NULL;
1276 pot = cogl_texture_2d_new_with_size (context,
1277 pot_width,
1278 pot_height,
1279 cogl_texture_get_format (texture),
1280 &error);
1281 if (pot)
1282 break;
1283 else
1284 g_error_free (error);
1285
1286 if (pot_width > pot_height)
1287 pot_width >>= 1;
1288 else
1289 pot_height >>= 1;
1290
1291 if (!pot_width || !pot_height)
1292 break;
1293 }
1294
1295 *pot_texture = COGL_TEXTURE (pot);
1296
1297 if (!pot)
1298 return CAIRO_INT_STATUS_NO_MEMORY;
1299
1300 /* Use the GPU to do a bilinear filtered scale from npot to pot... */
1301 offscreen = cogl_offscreen_new_to_texture (COGL_TEXTURE (pot));
1302 error = NULL;
1303 if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (offscreen), &error)) {
1304 /* NB: if we don't pass an error then Cogl is allowed to simply abort
1305 * automatically. */
1306 g_error_free (error);
1307 cogl_object_unref (pot);
1308 *pot_texture = NULL;
1309 return CAIRO_INT_STATUS_NO_MEMORY;
1310 }
1311
1312 cogl_push_framebuffer (COGL_FRAMEBUFFER (offscreen));
1313 cogl_set_source_texture (texture);
1314 cogl_rectangle (-1, 1, 1, -1);
1315 cogl_pop_framebuffer ();
1316
1317 cogl_object_unref (offscreen);
1318 }
1319 #endif
1320
1321 /* NB: a reference for the texture is transferred to the caller which should
1322 * be unrefed */
1323 static CoglTexture *
1324 _cairo_cogl_acquire_surface_texture (cairo_cogl_surface_t *reference_surface,
1325 cairo_surface_t *abstract_surface)
1326 {
1327 cairo_image_surface_t *image;
1328 cairo_image_surface_t *acquired_image = NULL;
1329 void *image_extra;
1330 CoglPixelFormat format;
1331 cairo_image_surface_t *image_clone = NULL;
1332 CoglTexture2D *texture;
1333 GError *error = NULL;
1334 cairo_surface_t *clone;
1335
1336 if (abstract_surface->device == reference_surface->base.device) {
1337 cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
1338 _cairo_cogl_surface_flush (surface, 0);
1339 return surface->texture ? cogl_object_ref (surface->texture) : NULL;
1340 }
1341
1342 if (abstract_surface->type == CAIRO_SURFACE_TYPE_COGL) {
1343 if (_cairo_surface_is_subsurface (abstract_surface)) {
1344 cairo_cogl_surface_t *surface;
1345
1346 surface = (cairo_cogl_surface_t *)
1347 _cairo_surface_subsurface_get_target (abstract_surface);
1348 if (surface->base.device == reference_surface->base.device)
1349 return surface->texture ? cogl_object_ref (surface->texture) : NULL;
1350 }
1351 }
1352
1353 clone = _cairo_surface_has_snapshot (abstract_surface, &_cairo_cogl_surface_backend);
1354 if (clone) {
1355 cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)clone;
1356 return surface->texture ? cogl_object_ref (surface->texture) : NULL;
1357 }
1358
1359 g_warning ("Uploading image surface to texture");
1360
1361 if (_cairo_surface_is_image (abstract_surface)) {
1362 image = (cairo_image_surface_t *)abstract_surface;
1363 } else {
1364 cairo_status_t status = _cairo_surface_acquire_source_image (abstract_surface,
1365 &acquired_image, &image_extra);
1366 if (unlikely (status)) {
1367 g_warning ("acquire_source_image failed: %s [%d]\n",
1368 cairo_status_to_string (status), status);
1369 return NULL;
1370 }
1371 image = acquired_image;
1372 }
1373
1374 format = get_cogl_format_from_cairo_format (image->format);
1375 if (!format)
1376 {
1377 image_clone = _cairo_image_surface_coerce (image);
1378 if (unlikely (image_clone->base.status)) {
1379 g_warning ("image_surface_coerce failed");
1380 texture = NULL;
1381 goto BAIL;
1382 }
1383
1384 format = get_cogl_format_from_cairo_format (image_clone->format);
1385 assert (format);
1386 }
1387
1388 texture = cogl_texture_2d_new_from_data (to_device(reference_surface->base.device)->cogl_context,
1389 image->width,
1390 image->height,
1391 format, /* incoming */
1392 format, /* desired */
1393 image->stride,
1394 image->data,
1395 &error);
1396 if (!texture) {
1397 g_warning ("Failed to allocate texture: %s", error->message);
1398 g_error_free (error);
1399 goto BAIL;
1400 }
1401
1402 clone = _cairo_cogl_surface_create_full (to_device(reference_surface->base.device),
1403 reference_surface->ignore_alpha,
1404 NULL, COGL_TEXTURE (texture));
1405
1406 _cairo_surface_attach_snapshot (abstract_surface, clone, NULL);
1407
1408 /* Attaching the snapshot will take a reference on the clone surface... */
1409 cairo_surface_destroy (clone);
1410
1411 BAIL:
1412 if (image_clone)
1413 cairo_surface_destroy (&image_clone->base);
1414 if (acquired_image)
1415 _cairo_surface_release_source_image (abstract_surface, acquired_image, image_extra);
1416
1417 return COGL_TEXTURE (texture);
1418 }
1419
1420 /* NB: a reference for the texture is transferred to the caller which should
1421 * be unrefed */
1422 static CoglTexture *
1423 _cairo_cogl_acquire_pattern_texture (const cairo_pattern_t *pattern,
1424 cairo_cogl_surface_t *destination,
1425 const cairo_rectangle_int_t *extents,
1426 const cairo_rectangle_int_t *sample,
1427 cairo_cogl_texture_attributes_t *attributes)
1428 {
1429 CoglTexture *texture = NULL;
1430
1431 switch ((int)pattern->type)
1432 {
1433 case CAIRO_PATTERN_TYPE_SURFACE: {
1434 cairo_surface_t *surface = ((cairo_surface_pattern_t *)pattern)->surface;
1435 texture = _cairo_cogl_acquire_surface_texture (destination, surface);
1436 if (!texture)
1437 return NULL;
1438
1439 /* XXX: determine if it would have no effect to change the
1440 * extend mode to EXTEND_PAD instead since we can simply map
1441 * EXTEND_PAD to CLAMP_TO_EDGE without needing fragment shader
1442 * tricks or extra border texels. */
1443 #if 0
1444 /* TODO: We still need to consider HW such as SGX which doesn't have
1445 * full support for NPOT textures. */
1446 if (pattern->extend == CAIRO_EXTEND_REPEAT || pattern->extend == CAIRO_EXTEND_REFLECT) {
1447 _cairo_cogl_get_pot_texture ();
1448 }
1449 #endif
1450
1451 cairo_matrix_init_identity (&attributes->matrix);
1452
1453 /* Convert from un-normalized source coordinates in backend
1454 * coordinates to normalized texture coordinates */
1455 cairo_matrix_scale (&attributes->matrix,
1456 1.0f / cogl_texture_get_width (texture),
1457 1.0f / cogl_texture_get_height (texture));
1458
1459 /* XXX: need to multiply in the pattern->matrix */
1460
1461 attributes->extend = pattern->extend;
1462 attributes->filter = CAIRO_FILTER_BILINEAR;
1463 attributes->has_component_alpha = pattern->has_component_alpha;
1464
1465 attributes->s_wrap = get_cogl_wrap_mode_for_extend (pattern->extend);
1466 attributes->t_wrap = attributes->s_wrap;
1467
1468 return texture;
1469 }
1470 case CAIRO_PATTERN_TYPE_RADIAL:
1471 case CAIRO_PATTERN_TYPE_MESH: {
1472 cairo_surface_t *surface;
1473 cairo_matrix_t texture_matrix;
1474
1475 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
1476 extents->width, extents->height);
1477 if (_cairo_surface_offset_paint (surface,
1478 extents->x, extents->y,
1479 CAIRO_OPERATOR_SOURCE,
1480 pattern, NULL)) {
1481 cairo_surface_destroy (surface);
1482 return NULL;
1483 }
1484
1485 texture = _cairo_cogl_acquire_surface_texture (destination, surface);
1486 if (!texture)
1487 goto BAIL;
1488
1489 cairo_matrix_init_identity (&texture_matrix);
1490
1491 /* Convert from un-normalized source coordinates in backend
1492 * coordinates to normalized texture coordinates */
1493 cairo_matrix_scale (&texture_matrix,
1494 1.0f / cogl_texture_get_width (texture),
1495 1.0f / cogl_texture_get_height (texture));
1496
1497 cairo_matrix_translate (&texture_matrix, -extents->x, -extents->y);
1498
1499 attributes->matrix = texture_matrix;
1500 attributes->extend = pattern->extend;
1501 attributes->filter = CAIRO_FILTER_NEAREST;
1502 attributes->has_component_alpha = pattern->has_component_alpha;
1503
1504 /* any pattern extend modes have already been dealt with... */
1505 attributes->s_wrap = COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE;
1506 attributes->t_wrap = attributes->s_wrap;
1507
1508 BAIL:
1509 cairo_surface_destroy (surface);
1510
1511 return texture;
1512 }
1513 case CAIRO_PATTERN_TYPE_LINEAR: {
1514 cairo_linear_pattern_t *linear_pattern = (cairo_linear_pattern_t *)pattern;
1515 cairo_cogl_linear_gradient_t *gradient;
1516 cairo_cogl_linear_texture_entry_t *linear_texture;
1517 cairo_int_status_t status;
1518 float a, b;
1519 float dist;
1520 float scale;
1521 float angle;
1522
1523 status = _cairo_cogl_get_linear_gradient (to_device(destination->base.device),
1524 pattern->extend,
1525 linear_pattern->base.n_stops,
1526 linear_pattern->base.stops,
1527 &gradient);
1528 if (unlikely (status))
1529 return NULL;
1530
1531 linear_texture = _cairo_cogl_linear_gradient_texture_for_extend (gradient, pattern->extend);
1532
1533 attributes->extend = pattern->extend;
1534 attributes->filter = CAIRO_FILTER_BILINEAR;
1535 attributes->has_component_alpha = pattern->has_component_alpha;
1536 attributes->s_wrap = get_cogl_wrap_mode_for_extend (pattern->extend);
1537 attributes->t_wrap = COGL_PIPELINE_WRAP_MODE_REPEAT;
1538
1539 cairo_matrix_init_identity (&attributes->matrix);
1540
1541 a = linear_pattern->pd2.x - linear_pattern->pd1.x;
1542 b = linear_pattern->pd2.y - linear_pattern->pd1.y;
1543 dist = sqrtf (a*a + b*b);
1544 scale = 1.0f / dist;
1545 angle = - atan2f (b, a);
1546
1547 cairo_matrix_rotate (&attributes->matrix, angle);
1548 cairo_matrix_scale (&attributes->matrix, scale, scale);
1549
1550 cairo_matrix_translate (&attributes->matrix,
1551 -linear_pattern->pd1.x,
1552 -linear_pattern->pd1.y);
1553
1554 /* XXX: this caught me out: cairo doesn't follow the standard
1555 * maths convention for multiplying two matrices A x B - cairo
1556 * does B x A so the final matrix is as if A's transforms were
1557 * applied first.
1558 */
1559 cairo_matrix_multiply (&attributes->matrix,
1560 &pattern->matrix,
1561 &attributes->matrix);
1562
1563 return cogl_object_ref (linear_texture->texture);
1564 }
1565 default:
1566 g_warning ("Un-supported source type");
1567 return NULL;
1568 }
1569 }
1570
1571 static void
1572 set_layer_texture_with_attributes (CoglPipeline *pipeline,
1573 int layer_index,
1574 CoglTexture *texture,
1575 cairo_cogl_texture_attributes_t *attributes)
1576 {
1577 cogl_pipeline_set_layer_texture (pipeline, layer_index, texture);
1578
1579 if (!_cairo_matrix_is_identity (&attributes->matrix)) {
1580 cairo_matrix_t *m = &attributes->matrix;
1581 float texture_matrixfv[16] = {
1582 m->xx, m->yx, 0, 0,
1583 m->xy, m->yy, 0, 0,
1584 0, 0, 1, 0,
1585 m->x0, m->y0, 0, 1
1586 };
1587 CoglMatrix texture_matrix;
1588 cogl_matrix_init_from_array (&texture_matrix, texture_matrixfv);
1589 cogl_pipeline_set_layer_matrix (pipeline, layer_index, &texture_matrix);
1590 }
1591
1592 if (attributes->s_wrap != attributes->t_wrap) {
1593 cogl_pipeline_set_layer_wrap_mode_s (pipeline, layer_index, attributes->s_wrap);
1594 cogl_pipeline_set_layer_wrap_mode_t (pipeline, layer_index, attributes->t_wrap);
1595 } else
1596 cogl_pipeline_set_layer_wrap_mode (pipeline, layer_index, attributes->s_wrap);
1597 }
1598
1599 static CoglPipeline *
1600 get_source_mask_operator_destination_pipeline (const cairo_pattern_t *mask,
1601 const cairo_pattern_t *source,
1602 cairo_operator_t op,
1603 cairo_cogl_surface_t *destination,
1604 cairo_composite_rectangles_t *extents)
1605 {
1606 cairo_cogl_template_type template_type;
1607 CoglPipeline *pipeline;
1608
1609 switch ((int)source->type)
1610 {
1611 case CAIRO_PATTERN_TYPE_SOLID:
1612 template_type = mask ?
1613 CAIRO_COGL_TEMPLATE_TYPE_MASK_SOLID : CAIRO_COGL_TEMPLATE_TYPE_SOLID;
1614 break;
1615 case CAIRO_PATTERN_TYPE_SURFACE:
1616 case CAIRO_PATTERN_TYPE_LINEAR:
1617 case CAIRO_PATTERN_TYPE_RADIAL:
1618 case CAIRO_PATTERN_TYPE_MESH:
1619 template_type = mask ?
1620 CAIRO_COGL_TEMPLATE_TYPE_MASK_TEXTURE : CAIRO_COGL_TEMPLATE_TYPE_TEXTURE;
1621 break;
1622 default:
1623 g_warning ("Un-supported source type");
1624 return NULL;
1625 }
1626
1627 pipeline = cogl_pipeline_copy (to_device(destination->base.device)->template_pipelines[op][template_type]);
1628
1629 if (source->type == CAIRO_PATTERN_TYPE_SOLID) {
1630 cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)source;
1631 cogl_pipeline_set_color4f (pipeline,
1632 solid_pattern->color.red * solid_pattern->color.alpha,
1633 solid_pattern->color.green * solid_pattern->color.alpha,
1634 solid_pattern->color.blue * solid_pattern->color.alpha,
1635 solid_pattern->color.alpha);
1636 } else {
1637 cairo_cogl_texture_attributes_t attributes;
1638 CoglTexture *texture =
1639 _cairo_cogl_acquire_pattern_texture (source, destination,
1640 &extents->bounded,
1641 &extents->source_sample_area,
1642 &attributes);
1643 if (!texture)
1644 goto BAIL;
1645 set_layer_texture_with_attributes (pipeline, 0, texture, &attributes);
1646 cogl_object_unref (texture);
1647 }
1648
1649 if (mask) {
1650 if (mask->type == CAIRO_PATTERN_TYPE_SOLID) {
1651 cairo_solid_pattern_t *solid_pattern = (cairo_solid_pattern_t *)mask;
1652 CoglColor color;
1653 cogl_color_init_from_4f (&color,
1654 solid_pattern->color.red * solid_pattern->color.alpha,
1655 solid_pattern->color.green * solid_pattern->color.alpha,
1656 solid_pattern->color.blue * solid_pattern->color.alpha,
1657 solid_pattern->color.alpha);
1658 cogl_pipeline_set_layer_combine_constant (pipeline, 1, &color);
1659 } else {
1660 cairo_cogl_texture_attributes_t attributes;
1661 CoglTexture *texture =
1662 _cairo_cogl_acquire_pattern_texture (mask, destination,
1663 &extents->bounded,
1664 &extents->mask_sample_area,
1665 &attributes);
1666 if (!texture)
1667 goto BAIL;
1668 set_layer_texture_with_attributes (pipeline, 1, texture, &attributes);
1669 cogl_object_unref (texture);
1670 }
1671 }
1672
1673 return pipeline;
1674
1675 BAIL:
1676 cogl_object_unref (pipeline);
1677 return NULL;
1678 }
1679
1680 #if 0
1681 CoglPrimitive *
1682 _cairo_cogl_rectangle_new_p2t2t2 (float x,
1683 float y,
1684 float width,
1685 float height)
1686 {
1687 CoglVertexP2 vertices[] = {
1688 {x, y}, {x, y + height}, {x + width, y + height},
1689 {x, y}, {x + width, y + height}, {x + width, y}
1690 };
1691 CoglAttributeBuffer *buffer = cogl_attribute_buffer_new (sizeof (vertices));
1692 CoglAttribute *pos = cogl_attribute_new (buffer,
1693 "cogl_position_in",
1694 sizeof (CoglVertexP2),
1695 0,
1696 2,
1697 COGL_ATTRIBUTE_TYPE_FLOAT);
1698 CoglAttribute *tex_coords0 = cogl_attribute_new (buffer,
1699 "cogl_tex_coord0_in",
1700 sizeof (CoglVertexP2),
1701 0,
1702 2,
1703 COGL_ATTRIBUTE_TYPE_FLOAT);
1704 CoglAttribute *tex_coords0 = cogl_attribute_new (buffer,
1705 "cogl_tex_coord0_in",
1706 sizeof (CoglVertexP2),
1707 0,
1708 2,
1709 COGL_ATTRIBUTE_TYPE_FLOAT);
1710 CoglPrimitive *prim;
1711
1712 cogl_buffer_set_data (COGL_BUFFER (buffer), 0, vertices, sizeof (vertices));
1713
1714 /* The attributes will now keep the buffer alive... */
1715 cogl_object_unref (buffer);
1716
1717 prim = cogl_primitive_new (COGL_VERTICES_MODE_TRIANGLES,
1718 6, pos, tex_coords, NULL);
1719
1720 /* The primitive will now keep the attribute alive... */
1721 cogl_object_unref (pos);
1722
1723 return prim;
1724 }
1725 #endif
1726
1727 static void
1728 _cairo_cogl_log_clip (cairo_cogl_surface_t *surface,
1729 const cairo_clip_t *clip)
1730 {
1731 if (!_cairo_clip_equal (clip, surface->last_clip)) {
1732 _cairo_cogl_journal_log_clip (surface, clip);
1733 _cairo_clip_destroy (surface->last_clip);
1734 surface->last_clip = _cairo_clip_copy (clip);
1735 }
1736 }
1737
1738 static void
1739 _cairo_cogl_maybe_log_clip (cairo_cogl_surface_t *surface,
1740 cairo_composite_rectangles_t *composite)
1741 {
1742 cairo_clip_t *clip = composite->clip;
1743
1744 if (_cairo_composite_rectangles_can_reduce_clip (composite, clip))
1745 clip = NULL;
1746
1747 if (clip == NULL) {
1748 if (_cairo_composite_rectangles_can_reduce_clip (composite,
1749 surface->last_clip))
1750 return;
1751 }
1752
1753 _cairo_cogl_log_clip (surface, clip);
1754 }
1755
1756 static cairo_bool_t
1757 is_operator_supported (cairo_operator_t op)
1758 {
1759 switch ((int)op) {
1760 case CAIRO_OPERATOR_SOURCE:
1761 case CAIRO_OPERATOR_OVER:
1762 case CAIRO_OPERATOR_IN:
1763 case CAIRO_OPERATOR_DEST_OVER:
1764 case CAIRO_OPERATOR_DEST_IN:
1765 case CAIRO_OPERATOR_ADD:
1766 return TRUE;
1767
1768 default:
1769 return FALSE;
1770 }
1771 }
1772
1773 static cairo_int_status_t
1774 _cairo_cogl_surface_mask (void *abstract_surface,
1775 cairo_operator_t op,
1776 const cairo_pattern_t *source,
1777 const cairo_pattern_t *mask,
1778 const cairo_clip_t *clip)
1779 {
1780 cairo_cogl_surface_t *surface = abstract_surface;
1781 cairo_composite_rectangles_t extents;
1782 cairo_status_t status;
1783 CoglPipeline *pipeline;
1784 cairo_matrix_t identity;
1785
1786 /* XXX: Use this to smoke test the acquire_source/dest_image fallback
1787 * paths... */
1788 //return CAIRO_INT_STATUS_UNSUPPORTED;
1789
1790 if (!is_operator_supported (op))
1791 return CAIRO_INT_STATUS_UNSUPPORTED;
1792
1793 status = _cairo_composite_rectangles_init_for_mask (&extents,
1794 &surface->base,
1795 op, source, mask, clip);
1796 if (unlikely (status))
1797 return status;
1798
1799 pipeline = get_source_mask_operator_destination_pipeline (mask, source,
1800 op, surface, &extents);
1801 if (!pipeline){
1802 status = CAIRO_INT_STATUS_UNSUPPORTED;
1803 goto BAIL;
1804 }
1805
1806 _cairo_cogl_maybe_log_clip (surface, &extents);
1807
1808 cairo_matrix_init_identity (&identity);
1809 _cairo_cogl_journal_log_rectangle (surface, pipeline,
1810 extents.bounded.x,
1811 extents.bounded.y,
1812 extents.bounded.width,
1813 extents.bounded.height,
1814 2,
1815 &identity);
1816
1817 /* The journal will take a reference on the pipeline and clip_path... */
1818 cogl_object_unref (pipeline);
1819
1820 BAIL:
1821 return status;
1822 }
1823
1824 static int
1825 _cairo_cogl_source_n_layers (const cairo_pattern_t *source)
1826 {
1827 switch ((int)source->type)
1828 {
1829 case CAIRO_PATTERN_TYPE_SOLID:
1830 return 0;
1831 case CAIRO_PATTERN_TYPE_LINEAR:
1832 case CAIRO_PATTERN_TYPE_RADIAL:
1833 case CAIRO_PATTERN_TYPE_MESH:
1834 case CAIRO_PATTERN_TYPE_SURFACE:
1835 return 1;
1836 default:
1837 g_warning ("Unsupported source type");
1838 return 0;
1839 }
1840 }
1841
1842 static cairo_bool_t
1843 _cairo_cogl_path_fill_meta_equal (const void *key_a, const void *key_b)
1844 {
1845 const cairo_cogl_path_fill_meta_t *meta0 = key_a;
1846 const cairo_cogl_path_fill_meta_t *meta1 = key_b;
1847
1848 return _cairo_path_fixed_equal (meta0->user_path, meta1->user_path);
1849 }
1850
1851 static cairo_bool_t
1852 _cairo_cogl_stroke_style_equal (const cairo_stroke_style_t *a,
1853 const cairo_stroke_style_t *b)
1854 {
1855 if (a->line_width == b->line_width &&
1856 a->line_cap == b->line_cap &&
1857 a->line_join == b->line_join &&
1858 a->miter_limit == b->miter_limit &&
1859 a->num_dashes == b->num_dashes &&
1860 a->dash_offset == b->dash_offset)
1861 {
1862 unsigned int i;
1863 for (i = 0; i < a->num_dashes; i++) {
1864 if (a->dash[i] != b->dash[i])
1865 return FALSE;
1866 }
1867 }
1868 return TRUE;
1869 }
1870
1871 static cairo_bool_t
1872 _cairo_cogl_path_stroke_meta_equal (const void *key_a, const void *key_b)
1873 {
1874 const cairo_cogl_path_stroke_meta_t *meta0 = key_a;
1875 const cairo_cogl_path_stroke_meta_t *meta1 = key_b;
1876
1877 return _cairo_cogl_stroke_style_equal (&meta0->style, &meta1->style) &&
1878 _cairo_path_fixed_equal (meta0->user_path, meta1->user_path);
1879 }
1880
1881 static cairo_cogl_path_stroke_meta_t *
1882 _cairo_cogl_path_stroke_meta_reference (cairo_cogl_path_stroke_meta_t *meta)
1883 {
1884 assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
1885
1886 _cairo_reference_count_inc (&meta->ref_count);
1887
1888 return meta;
1889 }
1890
1891 static void
1892 _cairo_cogl_path_stroke_meta_destroy (cairo_cogl_path_stroke_meta_t *meta)
1893 {
1894 assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
1895
1896 if (! _cairo_reference_count_dec_and_test (&meta->ref_count))
1897 return;
1898
1899 _cairo_path_fixed_fini (meta->user_path);
1900 free (meta->user_path);
1901
1902 _cairo_stroke_style_fini (&meta->style);
1903
1904 if (meta->prim)
1905 cogl_object_unref (meta->prim);
1906
1907 free (meta);
1908 }
1909
1910 static cairo_cogl_path_stroke_meta_t *
1911 _cairo_cogl_path_stroke_meta_lookup (cairo_cogl_device_t *ctx,
1912 unsigned long hash,
1913 cairo_path_fixed_t *user_path,
1914 const cairo_stroke_style_t *style,
1915 double tolerance)
1916 {
1917 cairo_cogl_path_stroke_meta_t *ret;
1918 cairo_cogl_path_stroke_meta_t lookup;
1919
1920 lookup.cache_entry.hash = hash;
1921 lookup.user_path = user_path;
1922 lookup.style = *style;
1923 lookup.tolerance = tolerance;
1924
1925 ret = _cairo_cache_lookup (&ctx->path_stroke_staging_cache, &lookup.cache_entry);
1926 if (!ret)
1927 ret = _cairo_cache_lookup (&ctx->path_stroke_prim_cache, &lookup.cache_entry);
1928 return ret;
1929 }
1930
1931 static void
1932 _cairo_cogl_path_stroke_meta_set_prim_size (cairo_cogl_surface_t *surface,
1933 cairo_cogl_path_stroke_meta_t *meta,
1934 size_t size)
1935 {
1936 /* now that we know the meta structure is associated with a primitive
1937 * we promote it from the staging cache into the primitive cache.
1938 */
1939
1940 /* XXX: _cairo_cache borks if you try and remove an entry that's already
1941 * been evicted so we explicitly look it up first... */
1942 if (_cairo_cache_lookup (&to_device(surface->base.device)->path_stroke_staging_cache, &meta->cache_entry)) {
1943 _cairo_cogl_path_stroke_meta_reference (meta);
1944 _cairo_cache_remove (&to_device(surface->base.device)->path_stroke_staging_cache, &meta->cache_entry);
1945 }
1946
1947 meta->cache_entry.size = size;
1948 if (_cairo_cache_insert (&to_device(surface->base.device)->path_stroke_prim_cache, &meta->cache_entry) !=
1949 CAIRO_STATUS_SUCCESS)
1950 _cairo_cogl_path_stroke_meta_destroy (meta);
1951 }
1952
1953 static unsigned int
1954 _cairo_cogl_stroke_style_hash (unsigned int hash,
1955 const cairo_stroke_style_t *style)
1956 {
1957 unsigned int i;
1958 hash = _cairo_hash_bytes (hash, &style->line_width, sizeof (style->line_width));
1959 hash = _cairo_hash_bytes (hash, &style->line_cap, sizeof (style->line_cap));
1960 hash = _cairo_hash_bytes (hash, &style->line_join, sizeof (style->line_join));
1961 hash = _cairo_hash_bytes (hash, &style->miter_limit, sizeof (style->miter_limit));
1962 hash = _cairo_hash_bytes (hash, &style->num_dashes, sizeof (style->num_dashes));
1963 hash = _cairo_hash_bytes (hash, &style->dash_offset, sizeof (style->dash_offset));
1964 for (i = 0; i < style->num_dashes; i++)
1965 hash = _cairo_hash_bytes (hash, &style->dash[i], sizeof (double));
1966 return hash;
1967 }
1968
1969 static cairo_cogl_path_stroke_meta_t *
1970 _cairo_cogl_get_path_stroke_meta (cairo_cogl_surface_t *surface,
1971 const cairo_stroke_style_t *style,
1972 double tolerance)
1973 {
1974 unsigned long hash;
1975 cairo_cogl_path_stroke_meta_t *meta = NULL;
1976 cairo_path_fixed_t *meta_path = NULL;
1977 cairo_status_t status;
1978
1979 if (!surface->user_path)
1980 return NULL;
1981
1982 hash = _cairo_path_fixed_hash (surface->user_path);
1983 hash = _cairo_cogl_stroke_style_hash (hash, style);
1984 hash = _cairo_hash_bytes (hash, &tolerance, sizeof (tolerance));
1985
1986 meta = _cairo_cogl_path_stroke_meta_lookup (to_device(surface->base.device), hash,
1987 surface->user_path, style, tolerance);
1988 if (meta)
1989 return meta;
1990
1991 meta = calloc (1, sizeof (cairo_cogl_path_stroke_meta_t));
1992 if (!meta)
1993 goto BAIL;
1994 CAIRO_REFERENCE_COUNT_INIT (&meta->ref_count, 1);
1995 meta->cache_entry.hash = hash;
1996 meta->counter = 0;
1997 meta_path = malloc (sizeof (cairo_path_fixed_t));
1998 if (!meta_path)
1999 goto BAIL;
2000 /* FIXME: we should add a ref-counted wrapper for our user_paths
2001 * so we don't have to keep copying them here! */
2002 status = _cairo_path_fixed_init_copy (meta_path, surface->user_path);
2003 if (unlikely (status))
2004 goto BAIL;
2005 meta->user_path = meta_path;
2006 meta->ctm_inverse = *surface->ctm_inverse;
2007
2008 status = _cairo_stroke_style_init_copy (&meta->style, style);
2009 if (unlikely (status)) {
2010 _cairo_path_fixed_fini (meta_path);
2011 goto BAIL;
2012 }
2013 meta->tolerance = tolerance;
2014
2015 return meta;
2016
2017 BAIL:
2018 free (meta_path);
2019 free (meta);
2020 return NULL;
2021 }
2022
2023 static cairo_int_status_t
2024 _cairo_cogl_stroke_to_primitive (cairo_cogl_surface_t *surface,
2025 const cairo_path_fixed_t *path,
2026 const cairo_stroke_style_t *style,
2027 const cairo_matrix_t *ctm,
2028 const cairo_matrix_t *ctm_inverse,
2029 double tolerance,
2030 int n_layers,
2031 cairo_bool_t one_shot,
2032 CoglPrimitive **primitive,
2033 size_t *size)
2034 {
2035 cairo_traps_t traps;
2036 cairo_int_status_t status;
2037
2038 _cairo_traps_init (&traps);
2039
2040 status = _cairo_path_fixed_stroke_polygon_to_traps (path, style,
2041 ctm, ctm_inverse,
2042 tolerance,
2043 &traps);
2044 if (unlikely (status))
2045 goto BAIL;
2046
2047 if (traps.num_traps == 0) {
2048 status = CAIRO_INT_STATUS_NOTHING_TO_DO;
2049 goto BAIL;
2050 }
2051
2052 *size = traps.num_traps * sizeof (CoglVertexP2) * 6;
2053
2054 //g_print ("new stroke prim\n");
2055 *primitive = _cairo_cogl_traps_to_composite_prim (surface, &traps, n_layers, one_shot);
2056 if (!*primitive) {
2057 status = CAIRO_INT_STATUS_NO_MEMORY;
2058 goto BAIL;
2059 }
2060
2061 BAIL:
2062 _cairo_traps_fini (&traps);
2063 return status;
2064 }
2065
2066 static cairo_int_status_t
2067 _cairo_cogl_surface_stroke (void *abstract_surface,
2068 cairo_operator_t op,
2069 const cairo_pattern_t *source,
2070 const cairo_path_fixed_t *path,
2071 const cairo_stroke_style_t *style,
2072 const cairo_matrix_t *ctm,
2073 const cairo_matrix_t *ctm_inverse,
2074 double tolerance,
2075 cairo_antialias_t antialias,
2076 const cairo_clip_t *clip)
2077 {
2078 cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
2079 cairo_composite_rectangles_t extents;
2080 CoglPipeline *pipeline;
2081 cairo_status_t status;
2082 #ifdef ENABLE_PATH_CACHE
2083 cairo_cogl_path_stroke_meta_t *meta = NULL;
2084 cairo_matrix_t transform_matrix;
2085 #endif
2086 cairo_matrix_t *transform = NULL;
2087 gboolean one_shot = TRUE;
2088 CoglPrimitive *prim = NULL;
2089 cairo_bool_t new_prim = FALSE;
2090
2091 if (! is_operator_supported (op))
2092 return CAIRO_INT_STATUS_UNSUPPORTED;
2093
2094 /* FIXME - support unbounded operators */
2095 if (!_cairo_operator_bounded_by_mask (op)) {
2096 /* Currently IN this is the only unbounded operator we aim to support
2097 * in cairo-cogl. */
2098 assert (op == CAIRO_OPERATOR_IN);
2099 g_warning ("FIXME: handle stroking with unbounded operators!");
2100 return CAIRO_INT_STATUS_UNSUPPORTED;
2101 }
2102
2103 status = _cairo_composite_rectangles_init_for_stroke (&extents,
2104 &surface->base,
2105 op, source, path,
2106 style,
2107 ctm,
2108 clip);
2109 if (unlikely (status))
2110 return status;
2111
2112 #ifdef ENABLE_PATH_CACHE
2113 /* FIXME: we are currently leaking the meta state if we don't reach
2114 * the cache_insert at the end. */
2115 meta = _cairo_cogl_get_path_stroke_meta (surface, style, tolerance);
2116 if (meta) {
2117 prim = meta->prim;
2118 if (prim) {
2119 cairo_matrix_multiply (&transform_matrix, &meta->ctm_inverse, surface->ctm);
2120 transform = &transform_matrix;
2121 } else if (meta->counter++ > 10)
2122 one_shot = FALSE;
2123 }
2124 #endif
2125
2126 if (!prim) {
2127 int n_layers = _cairo_cogl_source_n_layers (source);
2128 size_t prim_size = 0;
2129 status = _cairo_cogl_stroke_to_primitive (surface, path, style,
2130 ctm, ctm_inverse, tolerance,
2131 n_layers, one_shot,
2132 &prim, &prim_size);
2133 if (unlikely (status))
2134 return status;
2135 new_prim = TRUE;
2136 #if defined (ENABLE_PATH_CACHE)
2137 if (meta) {
2138 meta->prim = cogl_object_ref (prim);
2139 _cairo_cogl_path_stroke_meta_set_prim_size (surface, meta, prim_size);
2140 }
2141 #endif
2142 }
2143
2144 pipeline = get_source_mask_operator_destination_pipeline (NULL, source,
2145 op, surface, &extents);
2146 if (!pipeline)
2147 return CAIRO_INT_STATUS_UNSUPPORTED;
2148
2149 _cairo_cogl_maybe_log_clip (surface, &extents);
2150
2151 _cairo_cogl_journal_log_primitive (surface, pipeline, prim, transform);
2152
2153 /* The journal will take a reference on the pipeline and primitive... */
2154 cogl_object_unref (pipeline);
2155 if (new_prim)
2156 cogl_object_unref (prim);
2157
2158 return CAIRO_INT_STATUS_SUCCESS;
2159 }
2160
2161 static cairo_cogl_path_fill_meta_t *
2162 _cairo_cogl_path_fill_meta_reference (cairo_cogl_path_fill_meta_t *meta)
2163 {
2164 assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
2165
2166 _cairo_reference_count_inc (&meta->ref_count);
2167
2168 return meta;
2169 }
2170
2171 static void
2172 _cairo_cogl_path_fill_meta_destroy (cairo_cogl_path_fill_meta_t *meta)
2173 {
2174 assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&meta->ref_count));
2175
2176 if (! _cairo_reference_count_dec_and_test (&meta->ref_count))
2177 return;
2178
2179 _cairo_path_fixed_fini (meta->user_path);
2180 free (meta->user_path);
2181
2182 if (meta->prim)
2183 cogl_object_unref (meta->prim);
2184
2185 free (meta);
2186 }
2187
2188 static cairo_cogl_path_fill_meta_t *
2189 _cairo_cogl_path_fill_meta_lookup (cairo_cogl_device_t *ctx,
2190 unsigned long hash,
2191 cairo_path_fixed_t *user_path)
2192 {
2193 cairo_cogl_path_fill_meta_t *ret;
2194 cairo_cogl_path_fill_meta_t lookup;
2195
2196 lookup.cache_entry.hash = hash;
2197 lookup.user_path = user_path;
2198
2199 ret = _cairo_cache_lookup (&ctx->path_fill_staging_cache, &lookup.cache_entry);
2200 if (!ret)
2201 ret = _cairo_cache_lookup (&ctx->path_fill_prim_cache, &lookup.cache_entry);
2202 return ret;
2203 }
2204
2205 static void
2206 _cairo_cogl_path_fill_meta_set_prim_size (cairo_cogl_surface_t *surface,
2207 cairo_cogl_path_fill_meta_t *meta,
2208 size_t size)
2209 {
2210 /* now that we know the meta structure is associated with a primitive
2211 * we promote it from the staging cache into the primitive cache.
2212 */
2213
2214 /* XXX: _cairo_cache borks if you try and remove an entry that's already
2215 * been evicted so we explicitly look it up first... */
2216 if (_cairo_cache_lookup (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry)) {
2217 _cairo_cogl_path_fill_meta_reference (meta);
2218 _cairo_cache_remove (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry);
2219 }
2220
2221 meta->cache_entry.size = size;
2222 if (_cairo_cache_insert (&to_device(surface->base.device)->path_fill_prim_cache, &meta->cache_entry) !=
2223 CAIRO_STATUS_SUCCESS)
2224 _cairo_cogl_path_fill_meta_destroy (meta);
2225 }
2226
2227 static cairo_cogl_path_fill_meta_t *
2228 _cairo_cogl_get_path_fill_meta (cairo_cogl_surface_t *surface)
2229 {
2230 unsigned long hash;
2231 cairo_cogl_path_fill_meta_t *meta = NULL;
2232 cairo_path_fixed_t *meta_path = NULL;
2233 cairo_status_t status;
2234
2235 if (!surface->user_path)
2236 return NULL;
2237
2238 hash = _cairo_path_fixed_hash (surface->user_path);
2239
2240 meta = _cairo_cogl_path_fill_meta_lookup (to_device(surface->base.device),
2241 hash, surface->user_path);
2242 if (meta)
2243 return meta;
2244
2245 meta = calloc (1, sizeof (cairo_cogl_path_fill_meta_t));
2246 if (!meta)
2247 goto BAIL;
2248 meta->cache_entry.hash = hash;
2249 meta->counter = 0;
2250 CAIRO_REFERENCE_COUNT_INIT (&meta->ref_count, 1);
2251 meta_path = malloc (sizeof (cairo_path_fixed_t));
2252 if (!meta_path)
2253 goto BAIL;
2254 /* FIXME: we should add a ref-counted wrapper for our user_paths
2255 * so we don't have to keep copying them here! */
2256 status = _cairo_path_fixed_init_copy (meta_path, surface->user_path);
2257 if (unlikely (status))
2258 goto BAIL;
2259 meta->user_path = meta_path;
2260 meta->ctm_inverse = *surface->ctm_inverse;
2261
2262 /* To start with - until we associate a CoglPrimitive with the meta
2263 * structure - we keep the meta in a staging structure until we
2264 * see whether it actually gets re-used. */
2265 meta->cache_entry.size = 1;
2266 if (_cairo_cache_insert (&to_device(surface->base.device)->path_fill_staging_cache, &meta->cache_entry) !=
2267 CAIRO_STATUS_SUCCESS)
2268 _cairo_cogl_path_fill_meta_destroy (meta);
2269
2270 return meta;
2271
2272 BAIL:
2273 free (meta_path);
2274 free (meta);
2275 return NULL;
2276 }
2277
2278 static cairo_int_status_t
2279 _cairo_cogl_surface_fill (void *abstract_surface,
2280 cairo_operator_t op,
2281 const cairo_pattern_t *source,
2282 const cairo_path_fixed_t *path,
2283 cairo_fill_rule_t fill_rule,
2284 double tolerance,
2285 cairo_antialias_t antialias,
2286 const cairo_clip_t *clip)
2287 {
2288 cairo_cogl_surface_t *surface = abstract_surface;
2289 cairo_composite_rectangles_t extents;
2290 cairo_status_t status;
2291 #ifdef ENABLE_PATH_CACHE
2292 cairo_cogl_path_fill_meta_t *meta = NULL;
2293 cairo_matrix_t transform_matrix;
2294 #endif
2295 cairo_matrix_t *transform = NULL;
2296 cairo_bool_t one_shot = TRUE;
2297 CoglPrimitive *prim = NULL;
2298 cairo_bool_t new_prim = FALSE;
2299 CoglPipeline *pipeline;
2300
2301 if (! is_operator_supported (op))
2302 return CAIRO_INT_STATUS_UNSUPPORTED;
2303
2304 /* FIXME - support unbounded operators */
2305 if (!_cairo_operator_bounded_by_mask (op)) {
2306 /* Currently IN this is the only unbounded operator we aim to support
2307 * in cairo-cogl. */
2308 assert (op == CAIRO_OPERATOR_IN);
2309 g_warning ("FIXME: handle filling with unbounded operators!");
2310 return CAIRO_INT_STATUS_UNSUPPORTED;
2311 }
2312
2313 status = _cairo_composite_rectangles_init_for_fill (&extents,
2314 &surface->base,
2315 op, source, path,
2316 clip);
2317 if (unlikely (status))
2318 return status;
2319
2320 #ifndef FILL_WITH_COGL_PATH
2321 #ifdef ENABLE_PATH_CACHE
2322 meta = _cairo_cogl_get_path_fill_meta (surface);
2323 if (meta) {
2324 prim = meta->prim;
2325 if (prim) {
2326 cairo_matrix_multiply (&transform_matrix, &meta->ctm_inverse, surface->ctm);
2327 transform = &transform_matrix;
2328 } else if (meta->counter++ > 10)
2329 one_shot = FALSE;
2330 }
2331 #endif /* ENABLE_PATH_CACHE */
2332
2333 if (!prim) {
2334 int n_layers = _cairo_cogl_source_n_layers (source);
2335 size_t prim_size;
2336 status = _cairo_cogl_fill_to_primitive (surface, path, fill_rule, tolerance,
2337 one_shot, n_layers, &prim, &prim_size);
2338 if (unlikely (status))
2339 return status;
2340 new_prim = TRUE;
2341 #ifdef ENABLE_PATH_CACHE
2342 if (meta) {
2343 meta->prim = cogl_object_ref (prim);
2344 _cairo_cogl_path_fill_meta_set_prim_size (surface, meta, prim_size);
2345 }
2346 #endif /* ENABLE_PATH_CACHE */
2347 }
2348
2349 #endif /* !FILL_WITH_COGL_PATH */
2350
2351 pipeline = get_source_mask_operator_destination_pipeline (NULL, source,
2352 op, surface, &extents);
2353 if (!pipeline)
2354 return CAIRO_INT_STATUS_UNSUPPORTED;
2355
2356 _cairo_cogl_maybe_log_clip (surface, &extents);
2357
2358 #ifndef FILL_WITH_COGL_PATH
2359 _cairo_cogl_journal_log_primitive (surface, pipeline, prim, transform);
2360 /* The journal will take a reference on the prim */
2361 if (new_prim)
2362 cogl_object_unref (prim);
2363 #else
2364 CoglPath * cogl_path = _cairo_cogl_util_path_from_cairo (path, fill_rule, tolerance);
2365 _cairo_cogl_journal_log_path (surface, pipeline, cogl_path);
2366 cogl_object_unref (cogl_path);
2367 #endif
2368
2369 /* The journal will take a reference on the pipeline... */
2370 cogl_object_unref (pipeline);
2371
2372 return CAIRO_INT_STATUS_SUCCESS;
2373 }
2374
2375 cairo_int_status_t
2376 _cairo_cogl_surface_fill_rectangle (void *abstract_surface,
2377 cairo_operator_t op,
2378 const cairo_pattern_t *source,
2379 double x,
2380 double y,
2381 double width,
2382 double height,
2383 cairo_matrix_t *ctm,
2384 const cairo_clip_t *clip)
2385 {
2386 cairo_cogl_surface_t *surface = abstract_surface;
2387 CoglPipeline *pipeline;
2388
2389 if (! is_operator_supported (op))
2390 return CAIRO_INT_STATUS_UNSUPPORTED;
2391
2392 /* FIXME - support unbounded operators */
2393 if (!_cairo_operator_bounded_by_mask (op)) {
2394 /* Currently IN this is the only unbounded operator we aim to support
2395 * in cairo-cogl. */
2396 assert (op == CAIRO_OPERATOR_IN);
2397 g_warning ("FIXME: handle filling with unbounded operators!");
2398 return CAIRO_INT_STATUS_UNSUPPORTED;
2399 }
2400
2401 /* FIXME */
2402 #if 0
2403 status = _cairo_composite_rectangles_init_for_fill_rectangle (&extents,
2404 &surface->base,
2405 op, source, path,
2406 clip);
2407 if (unlikely (status))
2408 return status;
2409 #endif
2410
2411 if (source->type == CAIRO_PATTERN_TYPE_SOLID) {
2412 double x1 = x;
2413 double y1 = y;
2414 double x2 = x1 + width;
2415 double y2 = y1 + height;
2416
2417 pipeline = get_source_mask_operator_destination_pipeline (NULL, source,
2418 op, surface, NULL);
2419 if (!pipeline)
2420 return CAIRO_INT_STATUS_UNSUPPORTED;
2421
2422 _cairo_cogl_log_clip (surface, clip);
2423
2424 _cairo_cogl_journal_log_rectangle (surface,
2425 pipeline,
2426 x1, y1, x2, y2,
2427 0,
2428 ctm);
2429 return CAIRO_INT_STATUS_SUCCESS;
2430 } else
2431 return CAIRO_INT_STATUS_UNSUPPORTED;
2432
2433 /* TODO:
2434 * We need to acquire the textures here, look at the corresponding
2435 * attributes and see if this can be trivially handled by logging
2436 * a textured rectangle only needing simple scaling or translation
2437 * of texture coordinates.
2438 *
2439 * At this point we should also aim to remap the default
2440 * EXTEND_NONE mode to EXTEND_PAD which is more efficient if we
2441 * know it makes no difference either way since we can map that to
2442 * CLAMP_TO_EDGE.
2443 */
2444 }
2445
2446 static cairo_int_status_t
2447 _cairo_cogl_surface_show_glyphs (void *surface,
2448 cairo_operator_t op,
2449 const cairo_pattern_t *source,
2450 cairo_glyph_t *glyphs,
2451 int num_glyphs,
2452 cairo_scaled_font_t *scaled_font,
2453 const cairo_clip_t *clip)
2454 {
2455 return CAIRO_INT_STATUS_UNSUPPORTED;
2456 }
2457
2458 const cairo_surface_backend_t _cairo_cogl_surface_backend = {
2459 CAIRO_SURFACE_TYPE_COGL,
2460 _cairo_cogl_surface_finish,
2461 #ifdef NEED_COGL_CONTEXT
2462 _cairo_cogl_context_create,
2463 #else
2464 _cairo_default_context_create,
2465 #endif
2466
2467 _cairo_cogl_surface_create_similar,
2468 NULL, /* create similar image */
2469 NULL, /* map to image */
2470 NULL, /* unmap image */
2471
2472 _cairo_surface_default_source,
2473 _cairo_cogl_surface_acquire_source_image,
2474 _cairo_cogl_surface_release_source_image,
2475 NULL, /* snapshot */
2476
2477 NULL, /* copy_page */
2478 NULL, /* show_page */
2479
2480 _cairo_cogl_surface_get_extents,
2481 NULL, /* get_font_options */
2482
2483 _cairo_cogl_surface_flush, /* flush */
2484 NULL, /* mark_dirty_rectangle */
2485
2486 _cairo_cogl_surface_paint,
2487 _cairo_cogl_surface_mask,
2488 _cairo_cogl_surface_stroke,
2489 _cairo_cogl_surface_fill,
2490 NULL, /* fill_stroke*/
2491 _cairo_surface_fallback_glyphs,
2492 };
2493
2494 static cairo_surface_t *
2495 _cairo_cogl_surface_create_full (cairo_cogl_device_t *dev,
2496 cairo_bool_t ignore_alpha,
2497 CoglFramebuffer *framebuffer,
2498 CoglTexture *texture)
2499 {
2500 cairo_cogl_surface_t *surface;
2501 cairo_status_t status;
2502
2503 status = cairo_device_acquire (&dev->base);
2504 if (unlikely (status))
2505 return _cairo_surface_create_in_error (status);
2506
2507 surface = malloc (sizeof (cairo_cogl_surface_t));
2508 if (unlikely (surface == NULL))
2509 return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
2510
2511 surface->ignore_alpha = ignore_alpha;
2512
2513 surface->framebuffer = framebuffer;
2514 if (framebuffer) {
2515 surface->width = cogl_framebuffer_get_width (framebuffer);
2516 surface->height = cogl_framebuffer_get_height (framebuffer);
2517 surface->cogl_format = cogl_framebuffer_get_color_format (framebuffer);
2518 cogl_object_ref (framebuffer);
2519 }
2520
2521 /* FIXME: If texture == NULL and we are given an offscreen framebuffer
2522 * then we want a way to poke inside the framebuffer to get a texture */
2523 surface->texture = texture;
2524 if (texture) {
2525 if (!framebuffer) {
2526 surface->width = cogl_texture_get_width (texture);
2527 surface->height = cogl_texture_get_height (texture);
2528 surface->cogl_format = cogl_texture_get_format (texture);
2529 }
2530 cogl_object_ref (texture);
2531 }
2532
2533 assert(surface->width && surface->height);
2534
2535 surface->journal = NULL;
2536
2537 surface->buffer_stack = NULL;
2538 surface->buffer_stack_size = 4096;
2539
2540 surface->last_clip = NULL;
2541
2542 surface->n_clip_updates_per_frame = 0;
2543
2544 _cairo_surface_init (&surface->base,
2545 &_cairo_cogl_surface_backend,
2546 &dev->base,
2547 CAIRO_CONTENT_COLOR_ALPHA);
2548
2549 return &surface->base;
2550 }
2551
2552 cairo_surface_t *
2553 cairo_cogl_surface_create (cairo_device_t *abstract_device,
2554 CoglFramebuffer *framebuffer)
2555 {
2556 cairo_cogl_device_t *dev = (cairo_cogl_device_t *)abstract_device;
2557
2558 if (abstract_device == NULL)
2559 return _cairo_surface_create_in_error (CAIRO_STATUS_DEVICE_ERROR);
2560
2561 if (abstract_device->status)
2562 return _cairo_surface_create_in_error (abstract_device->status);
2563
2564 if (abstract_device->backend->type != CAIRO_DEVICE_TYPE_COGL)
2565 return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
2566
2567 return _cairo_cogl_surface_create_full (dev, FALSE, framebuffer, NULL);
2568 }
2569 slim_hidden_def (cairo_cogl_surface_create);
2570
2571 CoglFramebuffer *
2572 cairo_cogl_surface_get_framebuffer (cairo_surface_t *abstract_surface)
2573 {
2574 cairo_cogl_surface_t *surface;
2575
2576 if (abstract_surface->backend != &_cairo_cogl_surface_backend) {
2577 _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
2578 return NULL;
2579 }
2580
2581 surface = (cairo_cogl_surface_t *) abstract_surface;
2582
2583 return surface->framebuffer;
2584 }
2585 slim_hidden_def (cairo_cogl_surface_get_framebuffer);
2586
2587 CoglTexture *
2588 cairo_cogl_surface_get_texture (cairo_surface_t *abstract_surface)
2589 {
2590 cairo_cogl_surface_t *surface;
2591
2592 if (abstract_surface->backend != &_cairo_cogl_surface_backend) {
2593 _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
2594 return NULL;
2595 }
2596
2597 surface = (cairo_cogl_surface_t *) abstract_surface;
2598
2599 return surface->texture;
2600 }
2601 slim_hidden_def (cairo_cogl_surface_get_texture);
2602
2603 static cairo_status_t
2604 _cairo_cogl_device_flush (void *device)
2605 {
2606 cairo_status_t status;
2607
2608 status = cairo_device_acquire (device);
2609 if (unlikely (status))
2610 return status;
2611
2612 /* XXX: we don't need to flush Cogl here, we just need to flush
2613 * any batching we do of compositing primitives. */
2614
2615 cairo_device_release (device);
2616
2617 return CAIRO_STATUS_SUCCESS;
2618 }
2619
2620 static void
2621 _cairo_cogl_device_finish (void *device)
2622 {
2623 cairo_status_t status;
2624
2625 status = cairo_device_acquire (device);
2626 if (unlikely (status))
2627 return;
2628
2629 /* XXX: Drop references to external resources */
2630
2631 cairo_device_release (device);
2632 }
2633
2634 static void
2635 _cairo_cogl_device_destroy (void *device)
2636 {
2637 cairo_cogl_device_t *dev = device;
2638
2639 /* FIXME: Free stuff! */
2640
2641 g_free (dev);
2642 }
2643
2644 static const cairo_device_backend_t _cairo_cogl_device_backend = {
2645 CAIRO_DEVICE_TYPE_COGL,
2646
2647 NULL, /* lock */
2648 NULL, /* unlock */
2649
2650 _cairo_cogl_device_flush,
2651 _cairo_cogl_device_finish,
2652 _cairo_cogl_device_destroy,
2653 };
2654
2655 static cairo_bool_t
2656 set_blend (CoglPipeline *pipeline, const char *blend_string)
2657 {
2658 GError *error = NULL;
2659 if (!cogl_pipeline_set_blend (pipeline, blend_string, &error)) {
2660 g_warning ("Unsupported blend string with current gpu/driver: %s", blend_string);
2661 g_error_free (error);
2662 return FALSE;
2663 }
2664 return TRUE;
2665 }
2666
2667 static cairo_bool_t
2668 _cairo_cogl_setup_op_state (CoglPipeline *pipeline, cairo_operator_t op)
2669 {
2670 cairo_bool_t status = FALSE;
2671
2672 switch ((int)op)
2673 {
2674 case CAIRO_OPERATOR_SOURCE:
2675 status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, 0)");
2676 break;
2677 case CAIRO_OPERATOR_OVER:
2678 status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, DST_COLOR * (1 - SRC_COLOR[A]))");
2679 break;
2680 case CAIRO_OPERATOR_IN:
2681 status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR * DST_COLOR[A], 0)");
2682 break;
2683 case CAIRO_OPERATOR_DEST_OVER:
2684 status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR * (1 - DST_COLOR[A]), DST_COLOR)");
2685 break;
2686 case CAIRO_OPERATOR_DEST_IN:
2687 status = set_blend (pipeline, "RGBA = ADD (0, DST_COLOR * SRC_COLOR[A])");
2688 break;
2689 case CAIRO_OPERATOR_ADD:
2690 status = set_blend (pipeline, "RGBA = ADD (SRC_COLOR, DST_COLOR)");
2691 break;
2692 }
2693
2694 return status;
2695 }
2696
2697 static void
2698 create_templates_for_op (cairo_cogl_device_t *dev, cairo_operator_t op)
2699 {
2700 CoglPipeline *base = cogl_pipeline_new ();
2701 CoglPipeline *pipeline;
2702 CoglColor color;
2703
2704 if (!_cairo_cogl_setup_op_state (base, op)) {
2705 cogl_object_unref (base);
2706 return;
2707 }
2708
2709 dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_SOLID] = base;
2710
2711 pipeline = cogl_pipeline_copy (base);
2712 cogl_pipeline_set_layer_texture (pipeline, 0, dev->dummy_texture);
2713 dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_TEXTURE] = pipeline;
2714
2715 pipeline = cogl_pipeline_copy (base);
2716 cogl_pipeline_set_layer_combine (pipeline, 1,
2717 "RGBA = MODULATE (PREVIOUS, CONSTANT[A])",
2718 NULL);
2719 cogl_pipeline_set_layer_combine_constant (pipeline, 1, &color);
2720 cogl_pipeline_set_layer_texture (pipeline, 1, dev->dummy_texture);
2721 dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_MASK_SOLID] = pipeline;
2722
2723 pipeline = cogl_pipeline_copy (base);
2724 cogl_pipeline_set_layer_combine (pipeline, 1,
2725 "RGBA = MODULATE (PREVIOUS, TEXTURE[A])",
2726 NULL);
2727 cogl_pipeline_set_layer_texture (pipeline, 1, dev->dummy_texture);
2728 dev->template_pipelines[op][CAIRO_COGL_TEMPLATE_TYPE_MASK_TEXTURE] = pipeline;
2729 }
2730
2731 cairo_device_t *
2732 cairo_cogl_device_create (CoglContext *cogl_context)
2733 {
2734 cairo_cogl_device_t *dev = g_new0 (cairo_cogl_device_t, 1);
2735 cairo_status_t status;
2736
2737 dev->backend_vtable_initialized = FALSE;
2738
2739 dev->cogl_context = cogl_context;
2740
2741 dev->dummy_texture = cogl_texture_new_with_size (1, 1,
2742 COGL_TEXTURE_NO_SLICING,
2743 COGL_PIXEL_FORMAT_ANY);
2744 if (!dev->dummy_texture)
2745 goto ERROR;
2746
2747 memset (dev->template_pipelines, 0, sizeof (dev->template_pipelines));
2748 create_templates_for_op (dev, CAIRO_OPERATOR_SOURCE);
2749 create_templates_for_op (dev, CAIRO_OPERATOR_OVER);
2750 create_templates_for_op (dev, CAIRO_OPERATOR_IN);
2751 create_templates_for_op (dev, CAIRO_OPERATOR_DEST_OVER);
2752 create_templates_for_op (dev, CAIRO_OPERATOR_DEST_IN);
2753 create_templates_for_op (dev, CAIRO_OPERATOR_ADD);
2754
2755 status = _cairo_cache_init (&dev->linear_cache,
2756 _cairo_cogl_linear_gradient_equal,
2757 NULL,
2758 (cairo_destroy_func_t) _cairo_cogl_linear_gradient_destroy,
2759 CAIRO_COGL_LINEAR_GRADIENT_CACHE_SIZE);
2760 if (unlikely (status))
2761 return _cairo_device_create_in_error(status);
2762
2763 status = _cairo_cache_init (&dev->path_fill_staging_cache,
2764 _cairo_cogl_path_fill_meta_equal,
2765 NULL,
2766 (cairo_destroy_func_t) _cairo_cogl_path_fill_meta_destroy,
2767 1000);
2768
2769 status = _cairo_cache_init (&dev->path_stroke_staging_cache,
2770 _cairo_cogl_path_stroke_meta_equal,
2771 NULL,
2772 (cairo_destroy_func_t) _cairo_cogl_path_stroke_meta_destroy,
2773 1000);
2774
2775 status = _cairo_cache_init (&dev->path_fill_prim_cache,
2776 _cairo_cogl_path_fill_meta_equal,
2777 NULL,
2778 (cairo_destroy_func_t) _cairo_cogl_path_fill_meta_destroy,
2779 CAIRO_COGL_PATH_META_CACHE_SIZE);
2780
2781 status = _cairo_cache_init (&dev->path_stroke_prim_cache,
2782 _cairo_cogl_path_stroke_meta_equal,
2783 NULL,
2784 (cairo_destroy_func_t) _cairo_cogl_path_stroke_meta_destroy,
2785 CAIRO_COGL_PATH_META_CACHE_SIZE);
2786
2787 _cairo_device_init (&dev->base, &_cairo_cogl_device_backend);
2788 return &dev->base;
2789
2790 ERROR:
2791 g_free (dev);
2792 return _cairo_device_create_in_error (CAIRO_STATUS_DEVICE_ERROR);
2793 }
2794 slim_hidden_def (cairo_cogl_device_create);
2795
2796 void
2797 cairo_cogl_surface_end_frame (cairo_surface_t *abstract_surface)
2798 {
2799 cairo_cogl_surface_t *surface = (cairo_cogl_surface_t *)abstract_surface;
2800 cairo_surface_flush (abstract_surface);
2801
2802 //g_print ("n_clip_update_per_frame = %d\n", surface->n_clip_updates_per_frame);
2803 surface->n_clip_updates_per_frame = 0;
2804 }
2805 slim_hidden_def (cairo_cogl_surface_end_frame);
LuaTeX git mirror