src/cairo-cogl-utils.c

   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
  32 #include "cairoint.h"
  33 #include "cairo-cogl-utils-private.h"
  34
  35 #include <cogl/cogl.h>
  36 #include <glib.h>
  37
  38 static cairo_status_t
  39 _cogl_move_to (void                *closure,
  40                const cairo_point_t *point)
  41 {
  42     cogl_path_move_to (closure,
  43                        _cairo_cogl_util_fixed_to_float (point->x),
  44                        _cairo_cogl_util_fixed_to_float (point->y));
  45     return CAIRO_STATUS_SUCCESS;
  46 }
  47
  48 static cairo_status_t
  49 _cogl_line_to (void                *closure,
  50                const cairo_point_t *point)
  51 {
  52     cogl_path_line_to (closure,
  53                        _cairo_cogl_util_fixed_to_float (point->x),
  54                        _cairo_cogl_util_fixed_to_float (point->y));
  55     return CAIRO_STATUS_SUCCESS;
  56 }
  57
  58 static cairo_status_t
  59 _cogl_curve_to (void                *closure,
  60                 const cairo_point_t *p0,
  61                 const cairo_point_t *p1,
  62                 const cairo_point_t *p2)
  63 {
  64     cogl_path_curve_to (closure,
  65                         _cairo_cogl_util_fixed_to_float (p0->x),
  66                         _cairo_cogl_util_fixed_to_float (p0->y),
  67                         _cairo_cogl_util_fixed_to_float (p1->x),
  68                         _cairo_cogl_util_fixed_to_float (p1->y),
  69                         _cairo_cogl_util_fixed_to_float (p2->x),
  70                         _cairo_cogl_util_fixed_to_float (p2->y));
  71     return CAIRO_STATUS_SUCCESS;
  72 }
  73
  74 static cairo_status_t
  75 _cogl_close_path (void *closure)
  76 {
  77     cogl_path_close (closure);
  78     return CAIRO_STATUS_SUCCESS;
  79 }
  80
  81 CoglPath *
  82 _cairo_cogl_util_path_from_cairo (const cairo_path_fixed_t *path,
  83                                   cairo_fill_rule_t fill_rule,
  84                                   float tolerance)
  85 {
  86     CoglPath *cogl_path = cogl_path_new ();
  87     cairo_status_t status;
  88
  89     if (fill_rule == CAIRO_FILL_RULE_EVEN_ODD)
  90         cogl_path_set_fill_rule (cogl_path, COGL_PATH_FILL_RULE_EVEN_ODD);
  91     else
  92         cogl_path_set_fill_rule (cogl_path, COGL_PATH_FILL_RULE_NON_ZERO);
  93
  94 #ifdef USE_CAIRO_PATH_FLATTENER
  95     /* XXX: rely on cairo to do path flattening, since it seems Cogl's
  96      * curve_to flattening is much slower */
  97     status = _cairo_path_fixed_interpret_flat (path,
  98                                                _cogl_move_to,
  99                                                _cogl_line_to,
 100                                                _cogl_close_path,
 101                                                cogl_path,
 102                                                tolerance);
 103 #else
 104     status = _cairo_path_fixed_interpret (path,
 105                                           _cogl_move_to,
 106                                           _cogl_line_to,
 107                                           _cogl_curve_to,
 108                                           _cogl_close_path,
 109                                           cogl_path);
 110 #endif
 111
 112     assert (status == CAIRO_STATUS_SUCCESS);
 113     return cogl_path;
 114 }
 115
 116 int
 117 _cairo_cogl_util_next_p2 (int a)
 118 {
 119   int rval = 1;
 120
 121   while (rval < a)
 122     rval <<= 1;
 123
 124   return rval;
 125 }
 126