summaryrefslogtreecommitdiff
path: root/src/cairo-gl-operand.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/cairo-gl-operand.c')
-rwxr-xr-xsrc/cairo-gl-operand.c1500
1 files changed, 1500 insertions, 0 deletions
diff --git a/src/cairo-gl-operand.c b/src/cairo-gl-operand.c
new file mode 100755
index 000000000..8c21e6985
--- /dev/null
+++ b/src/cairo-gl-operand.c
@@ -0,0 +1,1500 @@
+/* cairo - a vector graphics library with display and print output
+ *
+ * Copyright © 2009 Eric Anholt
+ * Copyright © 2009 Chris Wilson
+ * Copyright © 2005,2010 Red Hat, Inc
+ * 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.org/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.
+ *
+ * The Original Code is the cairo graphics library.
+ *
+ * The Initial Developer of the Original Code is Red Hat, Inc.
+ *
+ * Contributor(s):
+ * Benjamin Otte <otte@gnome.org>
+ * Carl Worth <cworth@cworth.org>
+ * Chris Wilson <chris@chris-wilson.co.uk>
+ * Eric Anholt <eric@anholt.net>
+ */
+
+#include "cairoint.h"
+
+#include "cairo-gl-private.h"
+
+#include "cairo-composite-rectangles-private.h"
+#include "cairo-compositor-private.h"
+#include "cairo-default-context-private.h"
+#include "cairo-error-private.h"
+#include "cairo-image-surface-private.h"
+#include "cairo-surface-backend-private.h"
+#include "cairo-surface-offset-private.h"
+#include "cairo-surface-subsurface-inline.h"
+#include "cairo-rtree-private.h"
+
+static cairo_int_status_t
+_cairo_gl_create_gradient_texture (cairo_gl_surface_t *dst,
+ const cairo_gradient_pattern_t *pattern,
+ cairo_gl_gradient_t **gradient)
+{
+ cairo_gl_context_t *ctx;
+ cairo_status_t status;
+
+ status = _cairo_gl_context_acquire (dst->base.device, &ctx);
+ if (unlikely (status))
+ return status;
+
+ status = _cairo_gl_gradient_create (ctx, pattern->n_stops, pattern->stops, gradient);
+
+ return _cairo_gl_context_release (ctx, status);
+}
+
+static void
+_cairo_gl_image_cache_lock (cairo_gl_context_t *ctx,
+ cairo_gl_image_t *image_node)
+{
+ if (ctx->image_cache && ctx->image_cache->surface)
+ _cairo_rtree_pin (&ctx->image_cache->rtree, &image_node->node);
+}
+
+void
+_cairo_gl_image_cache_unlock (cairo_gl_context_t *ctx)
+{
+ if (ctx->image_cache && ctx->image_cache->surface)
+ _cairo_rtree_unpin (&(ctx->image_cache->rtree));
+}
+
+static cairo_int_status_t
+_cairo_gl_copy_texture (cairo_gl_surface_t *surface,
+ cairo_gl_surface_t *dst,
+ cairo_gl_surface_t *image,
+ int dst_x, int dst_y,
+ int src_x, int src_y,
+ int width, int height,
+ cairo_bool_t replace,
+ cairo_gl_context_t **ctx)
+{
+ cairo_int_status_t status;
+ cairo_gl_context_t *ctx_out;
+ cairo_gl_dispatch_t *dispatch;
+ cairo_gl_surface_t *target;
+ cairo_surface_pattern_t pattern;
+ cairo_rectangle_int_t rect;
+ cairo_clip_t *clip;
+
+ if (! _cairo_gl_surface_is_texture (image))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ status = _cairo_gl_context_acquire (surface->base.device, &ctx_out);
+ if(unlikely (status))
+ return status;
+
+ if (replace)
+ _cairo_gl_composite_flush (ctx_out);
+
+ image->needs_to_cache = FALSE;
+ dispatch = &ctx_out->dispatch;
+ target = ctx_out->current_target;
+
+ /* paint image to dst */
+ _cairo_pattern_init_for_surface (&pattern, &image->base);
+ cairo_matrix_init_translate (&pattern.base.matrix,
+ -dst_x + src_x, -dst_y + src_y);
+
+ rect.x = dst_x;
+ rect.y = dst_y;
+ rect.width = width;
+ rect.height = height;
+ clip = _cairo_clip_intersect_rectangle (NULL, &rect);
+
+ status = _cairo_surface_paint (&dst->base,
+ CAIRO_OPERATOR_SOURCE,
+ &pattern.base, clip);
+
+ _cairo_clip_destroy (clip);
+
+ _cairo_gl_composite_flush (ctx_out);
+ _cairo_pattern_fini (&pattern.base);
+ image->needs_to_cache = TRUE;
+
+ if (unlikely (status))
+ goto finish;
+
+ status = _cairo_gl_surface_resolve_multisampling (dst);
+
+finish:
+ /* restore ctx status */
+ if (target)
+ _cairo_gl_context_set_destination (ctx_out, target,
+ target->msaa_active);
+
+ *ctx = ctx_out;
+
+ if (unlikely (status))
+ return _cairo_gl_context_release (ctx_out, status);
+ return status;
+
+}
+
+static void
+_cairo_gl_copy_image_cache (cairo_rtree_node_t *node, void *data)
+{
+ cairo_gl_image_cache_t *new_cache = (cairo_gl_image_cache_t *)data;
+ cairo_gl_image_t *image_node = (cairo_gl_image_t *)node;
+ cairo_gl_image_t *new_image_node;
+ cairo_int_status_t status;
+ cairo_rtree_node_t *new_node = NULL;
+ int width, height;
+ cairo_gl_surface_t *image = (cairo_gl_surface_t *)image_node->original_surface;
+ cairo_gl_context_t *ctx = image_node->ctx;
+
+ if (node->state != CAIRO_RTREE_NODE_OCCUPIED || !image)
+ return;
+
+ width = image->width;
+ height = image->height;
+
+ status = _cairo_rtree_insert (&new_cache->rtree, width,
+ height, &new_node);
+
+ /* because new_cache has larger size, eviction will not happen */
+ if (unlikely (status))
+ {
+ new_cache->copy_success = FALSE;
+ return;
+ }
+
+ /* Paint image to cache. */
+ status = _cairo_gl_copy_texture (new_cache->surface,
+ new_cache->surface,
+ ctx->image_cache->surface,
+ new_node->x, new_node->y,
+ node->x, node->y,
+ width, height,
+ FALSE, &ctx);
+ if (unlikely (status)) {
+ new_cache->copy_success = FALSE;
+ return;
+ }
+
+ new_image_node = (cairo_gl_image_t *)new_node;
+ new_image_node->ctx = ctx;
+ new_image_node->original_surface = &image->base;
+ /* Coordinate. */
+ new_image_node->p1.x = new_node->x;
+ new_image_node->p1.y = new_node->y;
+ new_image_node->p2.x = new_node->x + image->width;
+ new_image_node->p2.y = new_node->y + image->height;
+ if (! _cairo_gl_device_requires_power_of_two_textures (&ctx->base)) {
+ new_image_node->p1.x /= new_cache->surface->width;
+ new_image_node->p2.x /= new_cache->surface->width;
+ new_image_node->p1.y /= new_cache->surface->height;
+ new_image_node->p2.y /= new_cache->surface->height;
+ }
+ image->content_changed = FALSE;
+
+ image_node->original_surface = NULL;
+
+ image->image_node = new_image_node;
+
+ _cairo_gl_image_cache_lock (ctx, new_image_node);
+ status = _cairo_gl_context_release (ctx, status);
+}
+
+static cairo_int_status_t
+_cairo_gl_image_cache_replace_image (cairo_gl_image_t *image_node,
+ cairo_gl_surface_t *dst,
+ cairo_gl_surface_t *cache_surface,
+ cairo_gl_surface_t *image,
+ cairo_gl_context_t **ctx)
+{
+ cairo_int_status_t status;
+ /* Paint image to cache. */
+ status = _cairo_gl_copy_texture (dst, cache_surface,
+ image, image_node->node.x,
+ image_node->node.y,
+ 0, 0,
+ image->width, image->height,
+ TRUE,
+ ctx);
+ image->content_changed = FALSE;
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_gl_image_cache_add_image (cairo_gl_context_t *ctx,
+ cairo_gl_surface_t *dst,
+ cairo_gl_surface_t *image,
+ cairo_gl_image_t **image_node)
+{
+ cairo_int_status_t status;
+ cairo_rtree_node_t *node = NULL;
+ int width, height;
+ cairo_bool_t replaced = FALSE;
+ int image_cache_size;
+
+ if (! image->base.device ||
+ (image->width >= IMAGE_CACHE_MAX_SIZE ||
+ image->height >= IMAGE_CACHE_MAX_SIZE))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ else if (! _cairo_gl_surface_is_texture (image))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ width = image->width;
+ height = image->height;
+
+ *image_node = image->image_node;
+
+ if (*image_node) {
+ if (image->content_changed) {
+ status = _cairo_gl_image_cache_replace_image (*image_node,
+ dst,
+ ctx->image_cache->surface,
+ image, &ctx);
+
+ if (unlikely (status))
+ return status;
+
+ replaced = TRUE;
+ }
+
+ _cairo_gl_image_cache_lock (ctx, *image_node);
+
+ image->content_changed = FALSE;
+ if (replaced)
+ return _cairo_gl_context_release (ctx, status);
+ return CAIRO_INT_STATUS_SUCCESS;
+ }
+
+ if (! ctx->image_cache) {
+ status = _cairo_gl_image_cache_init (ctx,
+ MIN_IMAGE_CACHE_WIDTH,
+ MIN_IMAGE_CACHE_HEIGHT,
+ &ctx->image_cache);
+ if (unlikely (status))
+ return status;
+ }
+
+ status = _cairo_rtree_insert (&ctx->image_cache->rtree, width,
+ height, &node);
+ /* Search for an unlocked slot. */
+ if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
+ cairo_gl_image_cache_t *new_cache = NULL;
+
+ _cairo_gl_composite_flush (ctx);
+
+ image_cache_size = ((cairo_gl_surface_t *)(ctx->image_cache->surface))->width;
+ if (image_cache_size < MAX_IMAGE_CACHE_WIDTH) {
+ image_cache_size *= 2;
+ status = _cairo_gl_image_cache_init (ctx,
+ image_cache_size,
+ image_cache_size,
+ &new_cache);
+ if (status == CAIRO_INT_STATUS_SUCCESS) {
+ /* copy existing image cache to new image cache */
+ _cairo_rtree_foreach (&ctx->image_cache->rtree,
+ _cairo_gl_copy_image_cache,
+ (void *)new_cache);
+ if (new_cache->copy_success) {
+ _cairo_gl_image_cache_fini (ctx);
+ ctx->image_cache = new_cache;
+ }
+ else {
+ _cairo_rtree_fini (&new_cache->rtree);
+ cairo_surface_destroy (&new_cache->surface->base);
+ free (new_cache);
+ new_cache = NULL;
+ status = CAIRO_INT_STATUS_UNSUPPORTED;
+ }
+ }
+ }
+ if (!new_cache)
+ status = _cairo_rtree_evict_random (&ctx->image_cache->rtree,
+ width, height, &node);
+
+ if (status == CAIRO_INT_STATUS_SUCCESS) {
+ if (! node)
+ status = _cairo_rtree_insert (&ctx->image_cache->rtree,
+ width, height, &node);
+ else
+ status = _cairo_rtree_node_insert (&ctx->image_cache->rtree,
+ node, width, height, &node);
+ }
+ }
+
+ if (unlikely (status))
+ return status;
+
+ /* Paint image to cache. */
+ status = _cairo_gl_copy_texture (dst, ctx->image_cache->surface,
+ image, node->x, node->y,
+ 0, 0,
+ image->width, image->height,
+ FALSE, &ctx);
+ if (unlikely (status))
+ return status;
+
+ *image_node = (cairo_gl_image_t *)node;
+ (*image_node)->ctx = ctx;
+ (*image_node)->original_surface = &image->base;
+ /* Coordinate. */
+ (*image_node)->p1.x = node->x;
+ (*image_node)->p1.y = node->y;
+ (*image_node)->p2.x = node->x + image->width;
+ (*image_node)->p2.y = node->y + image->height;
+ if (! _cairo_gl_device_requires_power_of_two_textures (&ctx->base)) {
+ (*image_node)->p1.x /= ctx->image_cache->surface->width;
+ (*image_node)->p2.x /= ctx->image_cache->surface->width;
+ (*image_node)->p1.y /= ctx->image_cache->surface->height;
+ (*image_node)->p2.y /= ctx->image_cache->surface->height;
+ }
+ image->content_changed = FALSE;
+
+ image->image_node = *image_node;
+
+ _cairo_gl_image_cache_lock (ctx, *image_node);
+
+ return _cairo_gl_context_release (ctx, status);
+}
+
+static cairo_status_t
+_cairo_gl_subsurface_clone_operand_init (cairo_gl_operand_t *operand,
+ const cairo_pattern_t *_src,
+ cairo_gl_surface_t *dst,
+ const cairo_rectangle_int_t *sample,
+ const cairo_rectangle_int_t *extents,
+ cairo_bool_t use_texgen)
+{
+ const cairo_surface_pattern_t *src = (cairo_surface_pattern_t *)_src;
+ cairo_surface_pattern_t local_pattern;
+ cairo_surface_subsurface_t *sub;
+ cairo_gl_surface_t *surface;
+ cairo_gl_context_t *ctx;
+ cairo_surface_attributes_t *attributes;
+ cairo_status_t status;
+
+ sub = (cairo_surface_subsurface_t *) src->surface;
+
+ if (sub->snapshot &&
+ sub->snapshot->type == CAIRO_SURFACE_TYPE_GL &&
+ sub->snapshot->device == dst->base.device)
+ {
+ surface = (cairo_gl_surface_t *)
+ cairo_surface_reference (sub->snapshot);
+ }
+ else
+ {
+ status = _cairo_gl_context_acquire (dst->base.device, &ctx);
+ if (unlikely (status))
+ return status;
+
+ /* XXX Trim surface to the sample area within the subsurface? */
+ surface = (cairo_gl_surface_t *)
+ _cairo_gl_surface_create_scratch (ctx,
+ sub->target->content,
+ sub->extents.width,
+ sub->extents.height);
+ if (surface->base.status)
+ return _cairo_gl_context_release (ctx, surface->base.status);
+
+ _cairo_pattern_init_for_surface (&local_pattern, sub->target);
+ cairo_matrix_init_translate (&local_pattern.base.matrix,
+ sub->extents.x, sub->extents.y);
+ local_pattern.base.filter = CAIRO_FILTER_NEAREST;
+ status = _cairo_surface_paint (&surface->base,
+ CAIRO_OPERATOR_SOURCE,
+ &local_pattern.base,
+ NULL);
+ _cairo_pattern_fini (&local_pattern.base);
+
+ status = _cairo_gl_context_release (ctx, status);
+ if (unlikely (status)) {
+ cairo_surface_destroy (&surface->base);
+ return status;
+ }
+
+ _cairo_surface_subsurface_set_snapshot (&sub->base, &surface->base);
+ }
+
+ status = _cairo_gl_surface_resolve_multisampling (surface);
+ if (unlikely (status))
+ return status;
+
+ attributes = &operand->texture.attributes;
+
+ operand->type = CAIRO_GL_OPERAND_TEXTURE;
+ operand->texture.surface = surface;
+ operand->texture.owns_surface = surface;
+ operand->texture.tex = surface->tex;
+ operand->texture.use_atlas = FALSE;
+
+ if (_cairo_gl_device_requires_power_of_two_textures (dst->base.device)) {
+ attributes->matrix = src->base.matrix;
+ } else {
+ cairo_matrix_t m;
+
+ cairo_matrix_init_scale (&m,
+ 1.0 / surface->width,
+ 1.0 / surface->height);
+ cairo_matrix_multiply (&attributes->matrix, &src->base.matrix, &m);
+ }
+
+ attributes->extend = src->base.extend;
+ attributes->filter = src->base.filter;
+ attributes->has_component_alpha = src->base.has_component_alpha;
+
+ operand->texture.texgen = use_texgen;
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_gl_subsurface_operand_init (cairo_gl_operand_t *operand,
+ const cairo_pattern_t *_src,
+ cairo_gl_surface_t *dst,
+ const cairo_rectangle_int_t *sample,
+ const cairo_rectangle_int_t *extents,
+ cairo_bool_t use_texgen)
+{
+ const cairo_surface_pattern_t *src = (cairo_surface_pattern_t *)_src;
+ cairo_surface_subsurface_t *sub;
+ cairo_gl_surface_t *surface, *blur_surface;
+ cairo_surface_attributes_t *attributes;
+ cairo_int_status_t status;
+ cairo_gl_image_t *image_node = NULL;
+ cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
+ cairo_bool_t ctx_acquired = FALSE;
+ cairo_rectangle_int_t blur_extents;
+
+ sub = (cairo_surface_subsurface_t *) src->surface;
+
+ if (sample->x < 0 || sample->y < 0 ||
+ sample->x + sample->width > sub->extents.width ||
+ sample->y + sample->height > sub->extents.height)
+ {
+ return _cairo_gl_subsurface_clone_operand_init (operand, _src,
+ dst, sample, extents,
+ use_texgen);
+ }
+
+ surface = (cairo_gl_surface_t *) sub->target;
+ if (surface->base.device && (surface->base.device != dst->base.device ||
+ (! _cairo_gl_surface_is_texture (surface) && ! surface->bounded_tex)))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ status = _cairo_gl_surface_resolve_multisampling (surface);
+ if (unlikely (status))
+ return status;
+
+ blur_extents.x = blur_extents.y = 0;
+ blur_extents.width = cairo_gl_surface_get_width (&surface->base);
+ blur_extents.height = cairo_gl_surface_get_height (&surface->base);
+
+ blur_surface = _cairo_gl_gaussian_filter (dst, src, surface, &blur_extents);
+
+ _cairo_gl_operand_copy(operand, &surface->operand);
+ *operand = surface->operand;
+ operand->texture.use_atlas = FALSE;
+
+ attributes = &operand->texture.attributes;
+ attributes->extend = src->base.extend;
+ attributes->filter = src->base.filter;
+ attributes->has_component_alpha = src->base.has_component_alpha;
+
+ attributes->matrix = src->base.matrix;
+ attributes->matrix.x0 += sub->extents.x;
+ attributes->matrix.y0 += sub->extents.y;
+
+ operand->texture.texgen = use_texgen;
+
+
+ if (blur_surface == surface &&
+ surface->needs_to_cache &&
+ surface->base.device) {
+ status = _cairo_gl_context_acquire (dst->base.device, &ctx);
+ if (status == CAIRO_INT_STATUS_SUCCESS) {
+ ctx_acquired = TRUE;
+ status = _cairo_gl_image_cache_add_image (ctx, dst, surface,
+ &image_node);
+ }
+ }
+
+ /* Translate the matrix from
+ * (unnormalized src -> unnormalized src) to
+ * (unnormalized dst -> unnormalized src)
+ */
+
+ if (unlikely (status) || ! image_node) {
+ if (blur_surface == surface &&
+ blur_surface->operand.type != CAIRO_GL_OPERAND_GAUSSIAN) {
+ cairo_matrix_multiply (&attributes->matrix,
+ &attributes->matrix,
+ &surface->operand.texture.attributes.matrix);
+ }
+ else {
+ cairo_matrix_t matrix = src->base.matrix;
+ operand->texture.use_atlas = TRUE;
+ attributes->extend = CAIRO_EXTEND_NONE;
+ operand->texture.extend = src->base.extend;
+
+ operand->texture.p1.x = 0;
+ operand->texture.p1.y = 0;
+ operand->texture.p2.x = (double) blur_extents.width / (double) blur_surface->width;
+ operand->texture.p2.y = (double) blur_extents.height / (double) blur_surface->height;
+
+ operand->texture.p1.x += 0.5 / blur_surface->width;
+ operand->texture.p1.y += 0.5 / blur_surface->height;
+ operand->texture.p2.x -= 0.5 / blur_surface->width;
+ operand->texture.p2.y -= 0.5 / blur_surface->height;
+
+
+ operand->texture.surface = blur_surface;
+ operand->texture.owns_surface = NULL;
+ operand->texture.tex = blur_surface->tex;
+ if (blur_surface->blur_stage == CAIRO_GL_BLUR_STAGE_2)
+ cairo_matrix_scale (&attributes->matrix,
+ (double)blur_extents.width/(double)surface->width,
+ (double)blur_extents.height/(double)surface->height);
+ cairo_matrix_multiply (&attributes->matrix,
+ &matrix,
+ &attributes->matrix);
+
+ }
+ }
+ else {
+ cairo_matrix_t matrix = src->base.matrix;
+ operand->texture.surface = ctx->image_cache->surface;
+ operand->texture.owns_surface = NULL;
+ operand->texture.tex = ctx->image_cache->surface->tex;
+ attributes->extend = CAIRO_EXTEND_NONE;
+ operand->texture.extend = src->base.extend;
+ attributes->matrix.x0 = image_node->node.x + sub->extents.x;
+ attributes->matrix.y0 = image_node->node.y + sub->extents.y;
+ operand->texture.use_atlas = TRUE;
+
+ operand->texture.p1.x = image_node->p1.x;
+ operand->texture.p1.y = image_node->p1.y;
+ operand->texture.p2.x = image_node->p2.x;
+ operand->texture.p2.y = image_node->p2.y;
+
+ operand->texture.p1.x += 0.5 / ctx->image_cache->surface->width;
+ operand->texture.p1.y += 0.5 / ctx->image_cache->surface->height;
+ operand->texture.p2.x -= 0.5 / ctx->image_cache->surface->width;
+ operand->texture.p2.y -= 0.5 / ctx->image_cache->surface->height;
+
+
+ cairo_matrix_multiply (&attributes->matrix,
+ &matrix,
+ &ctx->image_cache->surface->operand.texture.attributes.matrix);
+ }
+
+ status = CAIRO_STATUS_SUCCESS;
+ cairo_surface_destroy (&blur_surface->base);
+
+ if (ctx_acquired)
+ return _cairo_gl_context_release (ctx, status);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_gl_surface_operand_init (cairo_gl_operand_t *operand,
+ const cairo_pattern_t *_src,
+ cairo_gl_surface_t *dst,
+ const cairo_rectangle_int_t *sample,
+ const cairo_rectangle_int_t *extents,
+ cairo_bool_t use_texgen)
+{
+ const cairo_surface_pattern_t *src = (cairo_surface_pattern_t *)_src;
+ cairo_gl_surface_t *surface, *blur_surface;
+ cairo_surface_attributes_t *attributes;
+ cairo_int_status_t status;
+ cairo_gl_image_t *image_node = NULL;
+ cairo_gl_context_t *ctx = (cairo_gl_context_t *)dst->base.device;
+ cairo_bool_t ctx_acquired = FALSE;
+ cairo_rectangle_int_t blur_extents;
+
+ surface = (cairo_gl_surface_t *) src->surface;
+ if (surface->base.type != CAIRO_SURFACE_TYPE_GL)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ if (surface->base.backend->type != CAIRO_SURFACE_TYPE_GL) {
+ if (_cairo_surface_is_subsurface (&surface->base))
+ return _cairo_gl_subsurface_operand_init (operand, _src, dst,
+ sample, extents,
+ use_texgen);
+
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
+
+ if (surface->base.device && surface->base.device != dst->base.device)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ if (surface->base.device && ! _cairo_gl_surface_is_texture (surface) &&
+ ! surface->bounded_tex)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ status = _cairo_gl_surface_resolve_multisampling (surface);
+ if (unlikely (status))
+ return status;
+
+ blur_extents.x = blur_extents.y = 0;
+ blur_extents.width = cairo_gl_surface_get_width (&surface->base);
+ blur_extents.height = cairo_gl_surface_get_height (&surface->base);
+
+ blur_surface = _cairo_gl_gaussian_filter (dst, src, surface, &blur_extents);
+
+ _cairo_gl_operand_copy(operand, &blur_surface->operand);
+ operand->texture.use_atlas = FALSE;
+
+ attributes = &operand->texture.attributes;
+ attributes->extend = src->base.extend;
+ attributes->filter = src->base.filter;
+ attributes->has_component_alpha = src->base.has_component_alpha;
+
+ operand->texture.texgen = use_texgen;
+
+ if (surface->base.device &&
+ blur_surface == surface &&
+ surface->needs_to_cache) {
+ status = _cairo_gl_context_acquire (dst->base.device, &ctx);
+ if (status == CAIRO_INT_STATUS_SUCCESS) {
+ ctx_acquired = TRUE;
+ status = _cairo_gl_image_cache_add_image (ctx, dst, surface,
+ &image_node);
+ }
+ }
+
+ if (unlikely (status) || ! image_node) {
+ if (blur_surface == surface &&
+ blur_surface->operand.type != CAIRO_GL_OPERAND_GAUSSIAN) {
+ cairo_matrix_multiply (&attributes->matrix,
+ &src->base.matrix,
+ &attributes->matrix);
+ }
+ else {
+ cairo_matrix_t matrix = src->base.matrix;
+ operand->texture.use_atlas = TRUE;
+ attributes->extend = CAIRO_EXTEND_NONE;
+ operand->texture.extend = src->base.extend;
+
+ operand->texture.p1.x = 0;
+ operand->texture.p1.y = 0;
+ operand->texture.p2.x = (double) blur_extents.width / (double) blur_surface->width;
+ operand->texture.p2.y = (double) blur_extents.height / (double) blur_surface->height;
+
+ operand->texture.p1.x += 0.5 / blur_surface->width;
+ operand->texture.p1.y += 0.5 / blur_surface->height;
+ operand->texture.p2.x -= 0.5 / blur_surface->width;
+ operand->texture.p2.y -= 0.5 / blur_surface->height;
+
+
+ operand->texture.surface = blur_surface;
+ operand->texture.owns_surface = NULL;
+ operand->texture.tex = blur_surface->tex;
+ if (blur_surface->blur_stage == CAIRO_GL_BLUR_STAGE_2)
+ cairo_matrix_scale (&attributes->matrix,
+ (double)blur_extents.width/(double)surface->width,
+ (double)blur_extents.height/(double)surface->height);
+ cairo_matrix_multiply (&attributes->matrix,
+ &matrix,
+ &attributes->matrix);
+
+ }
+ }
+ else {
+ cairo_matrix_t matrix = src->base.matrix;
+ operand->texture.use_atlas = TRUE;
+ attributes->extend = CAIRO_EXTEND_NONE;
+ operand->texture.extend = src->base.extend;
+
+ operand->texture.p1.x = image_node->p1.x;
+ operand->texture.p1.y = image_node->p1.y;
+ operand->texture.p2.x = image_node->p2.x;
+ operand->texture.p2.y = image_node->p2.y;
+
+ operand->texture.p1.x += 0.5 / ctx->image_cache->surface->width;
+ operand->texture.p1.y += 0.5 / ctx->image_cache->surface->height;
+ operand->texture.p2.x -= 0.5 / ctx->image_cache->surface->width;
+ operand->texture.p2.y -= 0.5 / ctx->image_cache->surface->height;
+
+
+ operand->texture.surface = ctx->image_cache->surface;
+ operand->texture.owns_surface = NULL;
+ operand->texture.tex = ctx->image_cache->surface->tex;
+ matrix.x0 += image_node->node.x;
+ matrix.y0 += image_node->node.y;
+ cairo_matrix_multiply (&attributes->matrix,
+ &matrix,
+ &ctx->image_cache->surface->operand.texture.attributes.matrix);
+ }
+
+ cairo_surface_destroy (&blur_surface->base);
+
+ status = CAIRO_STATUS_SUCCESS;
+
+ if (ctx_acquired)
+ return _cairo_gl_context_release (ctx, status);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_gl_pattern_texture_setup (cairo_gl_operand_t *operand,
+ const cairo_pattern_t *_src,
+ cairo_gl_surface_t *dst,
+ const cairo_rectangle_int_t *extents)
+{
+ cairo_status_t status;
+ cairo_gl_surface_t *surface;
+ cairo_gl_context_t *ctx;
+ cairo_image_surface_t *image;
+ cairo_bool_t src_is_gl_surface = FALSE;
+ cairo_rectangle_int_t map_extents;
+
+ if (_src->type == CAIRO_PATTERN_TYPE_SURFACE) {
+ cairo_surface_t* src_surface = ((cairo_surface_pattern_t *) _src)->surface;
+ src_is_gl_surface = src_surface->type == CAIRO_SURFACE_TYPE_GL;
+ }
+
+ status = _cairo_gl_context_acquire (dst->base.device, &ctx);
+ if (unlikely (status))
+ return status;
+
+ surface = (cairo_gl_surface_t *)
+ _cairo_gl_surface_create_scratch (ctx,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ extents->width, extents->height);
+ map_extents = *extents;
+ map_extents.x = map_extents.y = 0;
+ image = _cairo_surface_map_to_image (&surface->base, &map_extents);
+
+ /* If the pattern is a GL surface, it belongs to some other GL context,
+ so we need to release this device while we paint it to the image. */
+ if (src_is_gl_surface) {
+ status = _cairo_gl_context_release (ctx, status);
+ if (unlikely (status))
+ goto fail;
+
+ /* we need to release one more time */
+ status = _cairo_gl_context_release (ctx, status);
+ if (unlikely (status))
+ goto fail;
+ }
+
+ status = _cairo_surface_offset_paint (&image->base, extents->x, extents->y,
+ CAIRO_OPERATOR_SOURCE, _src, NULL);
+
+ if (src_is_gl_surface) {
+ status = _cairo_gl_context_acquire (dst->base.device, &ctx);
+ if (unlikely (status))
+ goto fail;
+ /* one more time acquire */
+ status = _cairo_gl_context_acquire (dst->base.device, &ctx);
+ if (unlikely (status))
+ goto fail;
+ }
+
+ status = _cairo_surface_unmap_image (&surface->base, image);
+ status = _cairo_gl_context_release (ctx, status);
+ if (unlikely (status))
+ goto fail;
+
+ *operand = surface->operand;
+ operand->texture.owns_surface = surface;
+ operand->texture.attributes.matrix.x0 -= extents->x * operand->texture.attributes.matrix.xx;
+ operand->texture.attributes.matrix.y0 -= extents->y * operand->texture.attributes.matrix.yy;
+
+ if (_cairo_gl_surface_is_texture (dst) &&
+ dst->width <= IMAGE_CACHE_MAX_SIZE &&
+ dst->height <= IMAGE_CACHE_MAX_SIZE &&
+ ! dst->force_no_cache)
+ dst->needs_to_cache = TRUE;
+
+ operand->texture.use_atlas = FALSE;
+
+ return CAIRO_STATUS_SUCCESS;
+
+fail:
+ cairo_surface_destroy (&surface->base);
+ cairo_surface_destroy (image);
+ return status;
+}
+
+void
+_cairo_gl_solid_operand_init (cairo_gl_operand_t *operand,
+ const cairo_color_t *color)
+{
+ operand->type = CAIRO_GL_OPERAND_CONSTANT;
+ operand->constant.color[0] = color->red * color->alpha;
+ operand->constant.color[1] = color->green * color->alpha;
+ operand->constant.color[2] = color->blue * color->alpha;
+ operand->constant.color[3] = color->alpha;
+}
+
+void
+_cairo_gl_operand_translate (cairo_gl_operand_t *operand,
+ double tx, double ty)
+{
+ switch (operand->type) {
+ case CAIRO_GL_OPERAND_TEXTURE:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ operand->texture.attributes.matrix.x0 -= tx * operand->texture.attributes.matrix.xx;
+ operand->texture.attributes.matrix.y0 -= ty * operand->texture.attributes.matrix.yy;
+ break;
+
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ operand->gradient.m.x0 -= tx * operand->gradient.m.xx;
+ operand->gradient.m.y0 -= ty * operand->gradient.m.yy;
+ break;
+
+ case CAIRO_GL_OPERAND_NONE:
+ case CAIRO_GL_OPERAND_CONSTANT:
+ case CAIRO_GL_OPERAND_COUNT:
+ default:
+ break;
+ }
+}
+
+static cairo_status_t
+_cairo_gl_gradient_operand_init (cairo_gl_operand_t *operand,
+ const cairo_pattern_t *pattern,
+ cairo_gl_surface_t *dst,
+ cairo_bool_t use_texgen)
+{
+ const cairo_gradient_pattern_t *gradient = (const cairo_gradient_pattern_t *)pattern;
+ cairo_status_t status;
+
+ assert (gradient->base.type == CAIRO_PATTERN_TYPE_LINEAR ||
+ gradient->base.type == CAIRO_PATTERN_TYPE_RADIAL);
+
+ if (! _cairo_gl_device_has_glsl (dst->base.device))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ status = _cairo_gl_create_gradient_texture (dst,
+ gradient,
+ &operand->gradient.gradient);
+ if (unlikely (status))
+ return status;
+
+ if (gradient->base.type == CAIRO_PATTERN_TYPE_LINEAR) {
+ cairo_linear_pattern_t *linear = (cairo_linear_pattern_t *) gradient;
+ double x0, y0, dx, dy, sf, offset;
+
+ dx = linear->pd2.x - linear->pd1.x;
+ dy = linear->pd2.y - linear->pd1.y;
+ sf = 1.0 / (dx * dx + dy * dy);
+ dx *= sf;
+ dy *= sf;
+
+ x0 = linear->pd1.x;
+ y0 = linear->pd1.y;
+ offset = dx * x0 + dy * y0;
+
+ operand->type = CAIRO_GL_OPERAND_LINEAR_GRADIENT;
+
+ cairo_matrix_init (&operand->gradient.m, dx, 0, dy, 1, -offset, 0);
+ if (! _cairo_matrix_is_identity (&pattern->matrix)) {
+ cairo_matrix_multiply (&operand->gradient.m,
+ &pattern->matrix,
+ &operand->gradient.m);
+ }
+ } else {
+ cairo_matrix_t m;
+ cairo_circle_double_t circles[2];
+ double x0, y0, r0, dx, dy, dr;
+ double scale = 1.0;
+ cairo_radial_pattern_t *radial_pattern = (cairo_radial_pattern_t *)gradient;
+
+ /*
+ * Some fragment shader implementations use half-floats to
+ * represent numbers, so the maximum number they can represent
+ * is about 2^14. Some intermediate computations used in the
+ * radial gradient shaders can produce results of up to 2*k^4.
+ * Setting k=8 makes the maximum result about 8192 (assuming
+ * that the extreme circles are not much smaller than the
+ * destination image).
+ */
+ _cairo_gradient_pattern_fit_to_range (gradient, 8.,
+ &operand->gradient.m, circles);
+
+ /*
+ * Instead of using scaled data that might introducing rounding
+ * errors, we use original data directly
+ */
+ if (circles[0].center.x)
+ scale = radial_pattern->cd1.center.x / circles[0].center.x;
+ else if (circles[0].center.y)
+ scale = radial_pattern->cd1.center.y / circles[0].center.y;
+ else if (circles[0].radius)
+ scale = radial_pattern->cd1.radius / circles[0].radius;
+ else if (circles[1].center.x)
+ scale = radial_pattern->cd2.center.x / circles[1].center.x;
+ else if (circles[1].center.y)
+ scale = radial_pattern->cd2.center.y / circles[1].center.y;
+ else if (circles[1].radius)
+ scale = radial_pattern->cd2.radius / circles[1].radius;
+
+ x0 = circles[0].center.x;
+ y0 = circles[0].center.y;
+ r0 = circles[0].radius;
+ dx = radial_pattern->cd2.center.x - radial_pattern->cd1.center.x;
+ dy = radial_pattern->cd2.center.y - radial_pattern->cd1.center.y;
+ dr = radial_pattern->cd2.radius - radial_pattern->cd1.radius;
+
+ operand->gradient.a = (dx * dx + dy * dy - dr * dr)/(scale * scale);
+ operand->gradient.radius_0 = r0;
+ operand->gradient.circle_d.center.x = dx / scale;
+ operand->gradient.circle_d.center.y = dy / scale;
+ operand->gradient.circle_d.radius = dr / scale;
+
+ if (operand->gradient.a == 0)
+ operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0;
+ else if (pattern->extend == CAIRO_EXTEND_NONE)
+ operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE;
+ else
+ operand->type = CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT;
+
+ cairo_matrix_init_translate (&m, -x0, -y0);
+ cairo_matrix_multiply (&operand->gradient.m,
+ &operand->gradient.m,
+ &m);
+ }
+
+ operand->gradient.extend = pattern->extend;
+ operand->gradient.texgen = use_texgen;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+void
+_cairo_gl_operand_copy (cairo_gl_operand_t *dst,
+ const cairo_gl_operand_t *src)
+{
+ *dst = *src;
+ switch (dst->type) {
+ case CAIRO_GL_OPERAND_CONSTANT:
+ break;
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ _cairo_gl_gradient_reference (dst->gradient.gradient);
+ break;
+ case CAIRO_GL_OPERAND_TEXTURE:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ cairo_surface_reference (&dst->texture.owns_surface->base);
+ break;
+ default:
+ case CAIRO_GL_OPERAND_COUNT:
+ ASSERT_NOT_REACHED;
+ case CAIRO_GL_OPERAND_NONE:
+ break;
+ }
+}
+
+void
+_cairo_gl_operand_destroy (cairo_gl_operand_t *operand)
+{
+ switch (operand->type) {
+ case CAIRO_GL_OPERAND_CONSTANT:
+ break;
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ _cairo_gl_gradient_destroy (operand->gradient.gradient);
+ break;
+ case CAIRO_GL_OPERAND_TEXTURE:
+ cairo_surface_destroy (&operand->texture.owns_surface->base);
+ break;
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ cairo_surface_destroy (&operand->texture.owns_surface->base);
+ break;
+ default:
+ case CAIRO_GL_OPERAND_COUNT:
+ ASSERT_NOT_REACHED;
+ case CAIRO_GL_OPERAND_NONE:
+ break;
+ }
+
+ operand->type = CAIRO_GL_OPERAND_NONE;
+}
+
+cairo_int_status_t
+_cairo_gl_operand_init (cairo_gl_operand_t *operand,
+ const cairo_pattern_t *pattern,
+ cairo_gl_surface_t *dst,
+ const cairo_rectangle_int_t *sample,
+ const cairo_rectangle_int_t *extents,
+ cairo_bool_t use_texgen,
+ cairo_bool_t encode_color_as_attribute)
+{
+ cairo_int_status_t status;
+
+ TRACE ((stderr, "%s: type=%d\n", __FUNCTION__, pattern->type));
+ switch (pattern->type) {
+ case CAIRO_PATTERN_TYPE_SOLID:
+ _cairo_gl_solid_operand_init (operand,
+ &((cairo_solid_pattern_t *) pattern)->color);
+ operand->constant.encode_as_attribute = encode_color_as_attribute;
+ return CAIRO_STATUS_SUCCESS;
+ case CAIRO_PATTERN_TYPE_SURFACE:
+ status = _cairo_gl_surface_operand_init (operand, pattern, dst,
+ sample, extents, use_texgen);
+ if (status == CAIRO_INT_STATUS_UNSUPPORTED)
+ break;
+
+ return status;
+
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ status = _cairo_gl_gradient_operand_init (operand, pattern, dst,
+ use_texgen);
+ if (status == CAIRO_INT_STATUS_UNSUPPORTED)
+ break;
+
+ return status;
+
+ default:
+ case CAIRO_PATTERN_TYPE_MESH:
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
+ break;
+ }
+
+ return _cairo_gl_pattern_texture_setup (operand, pattern, dst, extents);
+}
+
+cairo_filter_t
+_cairo_gl_operand_get_filter (cairo_gl_operand_t *operand)
+{
+ cairo_filter_t filter;
+
+ switch ((int) operand->type) {
+ case CAIRO_GL_OPERAND_TEXTURE:
+ filter = operand->texture.attributes.filter;
+ break;
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ filter = CAIRO_FILTER_BILINEAR;
+ break;
+ default:
+ filter = CAIRO_FILTER_DEFAULT;
+ break;
+ }
+
+ return filter;
+}
+
+GLint
+_cairo_gl_operand_get_gl_filter (cairo_gl_operand_t *operand)
+{
+ cairo_filter_t filter = _cairo_gl_operand_get_filter (operand);
+
+ if (filter == CAIRO_FILTER_GAUSSIAN)
+ return GL_LINEAR;
+
+ return filter != CAIRO_FILTER_FAST && filter != CAIRO_FILTER_NEAREST ?
+ GL_LINEAR :
+ GL_NEAREST;
+}
+
+cairo_bool_t
+_cairo_gl_operand_get_use_atlas (cairo_gl_operand_t *operand)
+{
+ if (operand->type != CAIRO_GL_OPERAND_TEXTURE &&
+ operand->type != CAIRO_GL_OPERAND_GAUSSIAN)
+ return FALSE;
+
+ return operand->texture.use_atlas;
+}
+
+cairo_extend_t
+_cairo_gl_operand_get_extend (cairo_gl_operand_t *operand)
+{
+ cairo_extend_t extend;
+
+ switch ((int) operand->type) {
+ case CAIRO_GL_OPERAND_TEXTURE:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ if (! operand->texture.use_atlas)
+ extend = operand->texture.attributes.extend;
+ else
+ extend = operand->texture.extend;
+ break;
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ extend = operand->gradient.extend;
+ break;
+ default:
+ extend = CAIRO_EXTEND_NONE;
+ break;
+ }
+
+ return extend;
+}
+
+cairo_extend_t
+_cairo_gl_operand_get_atlas_extend (cairo_gl_operand_t *operand)
+{
+ cairo_extend_t extend;
+
+ switch ((int) operand->type) {
+ case CAIRO_GL_OPERAND_TEXTURE:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ if (operand->texture.use_atlas)
+ extend = operand->texture.extend;
+ else
+ extend = CAIRO_EXTEND_NONE;
+ break;
+ default:
+ extend = CAIRO_EXTEND_NONE;
+ break;
+ }
+
+ return extend;
+}
+
+void
+_cairo_gl_operand_bind_to_shader (cairo_gl_context_t *ctx,
+ cairo_gl_operand_t *operand,
+ cairo_gl_tex_t tex_unit)
+{
+ const cairo_matrix_t *texgen = NULL;
+
+ switch (operand->type) {
+ default:
+ case CAIRO_GL_OPERAND_COUNT:
+ ASSERT_NOT_REACHED;
+ case CAIRO_GL_OPERAND_NONE:
+ return;
+ case CAIRO_GL_OPERAND_CONSTANT:
+ if (operand->constant.encode_as_attribute)
+ return;
+
+ _cairo_gl_shader_bind_vec4 (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_CONSTANT, tex_unit),
+ operand->constant.color[0],
+ operand->constant.color[1],
+ operand->constant.color[2],
+ operand->constant.color[3]);
+ return;
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_A, tex_unit),
+ operand->gradient.a);
+ /* fall through */
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ _cairo_gl_shader_bind_vec3 (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_CIRCLE_D, tex_unit),
+ operand->gradient.circle_d.center.x,
+ operand->gradient.circle_d.center.y,
+ operand->gradient.circle_d.radius);
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_RADIUS_0, tex_unit),
+ operand->gradient.radius_0);
+ /* fall through */
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_TEXTURE:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ /*
+ * For GLES2 we use shaders to implement GL_CLAMP_TO_BORDER (used
+ * with CAIRO_EXTEND_NONE). When bilinear filtering is enabled,
+ * these shaders need the texture dimensions for their calculations.
+ */
+ if ((ctx->gl_flavor == CAIRO_GL_FLAVOR_ES2 ||
+ ctx->gl_flavor == CAIRO_GL_FLAVOR_ES3) &&
+ _cairo_gl_operand_get_extend (operand) == CAIRO_EXTEND_NONE &&
+ _cairo_gl_operand_get_gl_filter (operand) == GL_LINEAR)
+ {
+ float width, height;
+ if (operand->type == CAIRO_GL_OPERAND_TEXTURE ||
+ operand->type == CAIRO_GL_OPERAND_GAUSSIAN) {
+ width = operand->texture.surface->width;
+ height = operand->texture.surface->height;
+ }
+ else {
+ width = operand->gradient.gradient->cache_entry.size,
+ height = 1;
+ }
+ if (operand->type != CAIRO_GL_OPERAND_GAUSSIAN)
+ _cairo_gl_shader_bind_vec2 (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_TEXDIMS, tex_unit),
+ width, height);
+ }
+
+ break;
+ }
+
+ if (operand->type == CAIRO_GL_OPERAND_GAUSSIAN &&
+ operand->pass == 1) {
+ float x_axis = 1.0;
+ float y_axis = 0.0;
+ float temp_width;
+ float near_zero = 0.00001;
+
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_X_AXIS, tex_unit),
+ x_axis);
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_Y_AXIS, tex_unit),
+ y_axis);
+ _cairo_gl_shader_bind_int (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_RADIUS, tex_unit),
+ operand->texture.x_radius);
+
+ temp_width = cairo_gl_surface_get_width (&operand->texture.surface->base);
+ temp_width = (temp_width == 0) ? near_zero : temp_width;
+
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_STEP, tex_unit),
+ 1.0 / temp_width);
+
+ _cairo_gl_shader_bind_float_array (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLURS, tex_unit),
+ operand->texture.x_radius * 2 + 1,
+ &operand->texture.coef[0]);
+ }
+ else if (operand->type == CAIRO_GL_OPERAND_GAUSSIAN &&
+ operand->pass == 2) {
+ float x_axis = 0.0;
+ float y_axis = 1.0;
+
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_X_AXIS, tex_unit),
+ x_axis);
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_Y_AXIS, tex_unit),
+ y_axis);
+ _cairo_gl_shader_bind_int (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_RADIUS, tex_unit),
+ operand->texture.y_radius);
+
+ _cairo_gl_shader_bind_float (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLUR_STEP, tex_unit),
+ 1.0 / cairo_gl_surface_get_height (&operand->texture.surface->base));
+
+ _cairo_gl_shader_bind_float_array (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_BLURS, tex_unit),
+ operand->texture.y_radius * 2 + 1,
+ &operand->texture.coef[0]);
+ }
+
+ if (operand->type == CAIRO_GL_OPERAND_TEXTURE ||
+ operand->type == CAIRO_GL_OPERAND_GAUSSIAN) {
+ if (operand->texture.texgen)
+ texgen = &operand->texture.attributes.matrix;
+ } else {
+ if (operand->gradient.texgen)
+ texgen = &operand->gradient.m;
+ }
+
+ if (texgen) {
+ _cairo_gl_shader_bind_matrix (ctx,
+ _cairo_gl_shader_uniform_for_texunit (
+ CAIRO_GL_UNIFORM_TEXGEN, tex_unit),
+ texgen);
+ }
+}
+
+cairo_bool_t
+_cairo_gl_operand_needs_setup (cairo_gl_operand_t *dest,
+ cairo_gl_operand_t *source,
+ unsigned int vertex_offset)
+{
+ if (dest->type != source->type)
+ return TRUE;
+ if (dest->vertex_offset != vertex_offset)
+ return TRUE;
+
+ switch (source->type) {
+ case CAIRO_GL_OPERAND_NONE:
+ return FALSE;
+ case CAIRO_GL_OPERAND_CONSTANT:
+ if (dest->constant.encode_as_attribute &&
+ source->constant.encode_as_attribute)
+ return FALSE;
+ if (dest->constant.encode_as_attribute !=
+ source->constant.encode_as_attribute)
+ return TRUE;
+ return dest->constant.color[0] != source->constant.color[0] ||
+ dest->constant.color[1] != source->constant.color[1] ||
+ dest->constant.color[2] != source->constant.color[2] ||
+ dest->constant.color[3] != source->constant.color[3];
+ case CAIRO_GL_OPERAND_TEXTURE:
+ return dest->texture.surface != source->texture.surface ||
+ dest->texture.attributes.extend != source->texture.attributes.extend ||
+ dest->texture.attributes.filter != source->texture.attributes.filter ||
+ dest->texture.attributes.has_component_alpha != source->texture.attributes.has_component_alpha;
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ /* XXX: improve this */
+ return TRUE;
+ default:
+ case CAIRO_GL_OPERAND_COUNT:
+ ASSERT_NOT_REACHED;
+ break;
+ }
+ return TRUE;
+}
+
+unsigned int
+_cairo_gl_operand_get_vertex_size (const cairo_gl_operand_t *operand)
+{
+ switch (operand->type) {
+ default:
+ case CAIRO_GL_OPERAND_COUNT:
+ ASSERT_NOT_REACHED;
+ case CAIRO_GL_OPERAND_NONE:
+ case CAIRO_GL_OPERAND_CONSTANT:
+ return operand->constant.encode_as_attribute ? 4 * sizeof (GLfloat) : 0;
+ case CAIRO_GL_OPERAND_TEXTURE:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ if (operand->texture.texgen) {
+ if (operand->texture.use_atlas)
+ return 4 * sizeof (GLfloat);
+ return 0;
+ }
+ else {
+ if (operand->texture.use_atlas)
+ return 6 * sizeof (GLfloat);
+ return 2 * sizeof (GLfloat);
+ }
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ return operand->gradient.texgen ? 0 : 2 * sizeof (GLfloat);
+ }
+}
+
+void
+_cairo_gl_operand_emit (cairo_gl_operand_t *operand,
+ GLfloat ** vb,
+ GLfloat x,
+ GLfloat y)
+{
+ switch (operand->type) {
+ default:
+ case CAIRO_GL_OPERAND_COUNT:
+ ASSERT_NOT_REACHED;
+ case CAIRO_GL_OPERAND_NONE:
+ break;
+ case CAIRO_GL_OPERAND_CONSTANT: {
+ if (operand->constant.encode_as_attribute) {
+ *(*vb)++ = operand->constant.color[0];
+ *(*vb)++ = operand->constant.color[1];
+ *(*vb)++ = operand->constant.color[2];
+ *(*vb)++ = operand->constant.color[3];
+ }
+ break;
+ }
+ case CAIRO_GL_OPERAND_LINEAR_GRADIENT:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_A0:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_NONE:
+ case CAIRO_GL_OPERAND_RADIAL_GRADIENT_EXT:
+ if (! operand->gradient.texgen) {
+ double s = x;
+ double t = y;
+
+ cairo_matrix_transform_point (&operand->gradient.m, &s, &t);
+
+ *(*vb)++ = s;
+ *(*vb)++ = t;
+ }
+ break;
+ case CAIRO_GL_OPERAND_TEXTURE:
+ case CAIRO_GL_OPERAND_GAUSSIAN:
+ if (! operand->texture.texgen) {
+ cairo_surface_attributes_t *src_attributes = &operand->texture.attributes;
+ double s = x;
+ double t = y;
+
+ cairo_matrix_transform_point (&src_attributes->matrix, &s, &t);
+ *(*vb)++ = s;
+ *(*vb)++ = t;
+ }
+
+ if (operand->texture.use_atlas) {
+ *(*vb)++ = operand->texture.p1.x;
+ *(*vb)++ = operand->texture.p1.y;
+ *(*vb)++ = operand->texture.p2.x;
+ *(*vb)++ = operand->texture.p2.y;
+ }
+ break;
+ }
+}
+
+static inline cairo_int_status_t
+_cairo_gl_context_get_image_cache (cairo_gl_context_t *ctx,
+ cairo_gl_image_cache_t **cache_out)
+{
+ if (! ctx->image_cache)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ *cache_out = ctx->image_cache;
+ return CAIRO_INT_STATUS_SUCCESS;
+}
+
+/* Called from _cairo_rtree_node_remove. */
+void
+_cairo_gl_image_node_destroy (cairo_rtree_node_t *node)
+{
+ cairo_surface_t *surface;
+
+ cairo_gl_image_t *image_node = cairo_container_of (node,
+ cairo_gl_image_t,
+ node);
+
+ surface = image_node->original_surface;
+ /* Remove from original surface. */
+ if (image_node->original_surface)
+ ((cairo_gl_surface_t *)surface)->image_node = NULL;
+}