qemu/pixman/pixman/pixman-conical-gradient.c

   1 /*
   2  * Copyright © 2000 SuSE, Inc.
   3  * Copyright © 2007 Red Hat, Inc.
   4  * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
   5  *             2005 Lars Knoll & Zack Rusin, Trolltech
   6  *
   7  * Permission to use, copy, modify, distribute, and sell this software and its
   8  * documentation for any purpose is hereby granted without fee, provided that
   9  * the above copyright notice appear in all copies and that both that
  10  * copyright notice and this permission notice appear in supporting
  11  * documentation, and that the name of Keith Packard not be used in
  12  * advertising or publicity pertaining to distribution of the software without
  13  * specific, written prior permission.  Keith Packard makes no
  14  * representations about the suitability of this software for any purpose.  It
  15  * is provided "as is" without express or implied warranty.
  16  *
  17  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  18  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  19  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  20  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  21  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  22  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  23  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  24  * SOFTWARE.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include <config.h>
  29 #endif
  30
  31 #include <stdlib.h>
  32 #include <math.h>
  33 #include "pixman-private.h"
  34
  35 static force_inline double
  36 coordinates_to_parameter (double x, double y, double angle)
  37 {
  38     double t;
  39
  40     t = atan2 (y, x) + angle;
  41
  42     while (t < 0)
  43         t += 2 * M_PI;
  44
  45     while (t >= 2 * M_PI)
  46         t -= 2 * M_PI;
  47
  48     return 1 - t * (1 / (2 * M_PI)); /* Scale t to [0, 1] and
  49                                       * make rotation CCW
  50                                       */
  51 }
  52
  53 static uint32_t *
  54 conical_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)
  55 {
  56     pixman_image_t *image = iter->image;
  57     int x = iter->x;
  58     int y = iter->y;
  59     int width = iter->width;
  60     uint32_t *buffer = iter->buffer;
  61
  62     gradient_t *gradient = (gradient_t *)image;
  63     conical_gradient_t *conical = (conical_gradient_t *)image;
  64     uint32_t       *end = buffer + width;
  65     pixman_gradient_walker_t walker;
  66     pixman_bool_t affine = TRUE;
  67     double cx = 1.;
  68     double cy = 0.;
  69     double cz = 0.;
  70     double rx = x + 0.5;
  71     double ry = y + 0.5;
  72     double rz = 1.;
  73
  74     _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);
  75
  76     if (image->common.transform)
  77     {
  78         pixman_vector_t v;
  79
  80         /* reference point is the center of the pixel */
  81         v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;
  82         v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;
  83         v.vector[2] = pixman_fixed_1;
  84
  85         if (!pixman_transform_point_3d (image->common.transform, &v))
  86             return iter->buffer;
  87
  88         cx = image->common.transform->matrix[0][0] / 65536.;
  89         cy = image->common.transform->matrix[1][0] / 65536.;
  90         cz = image->common.transform->matrix[2][0] / 65536.;
  91
  92         rx = v.vector[0] / 65536.;
  93         ry = v.vector[1] / 65536.;
  94         rz = v.vector[2] / 65536.;
  95
  96         affine =
  97             image->common.transform->matrix[2][0] == 0 &&
  98             v.vector[2] == pixman_fixed_1;
  99     }
 100
 101     if (affine)
 102     {
 103         rx -= conical->center.x / 65536.;
 104         ry -= conical->center.y / 65536.;
 105
 106         while (buffer < end)
 107         {
 108             if (!mask || *mask++)
 109             {
 110                 double t = coordinates_to_parameter (rx, ry, conical->angle);
 111
 112                 *buffer = _pixman_gradient_walker_pixel (
 113                     &walker, (pixman_fixed_48_16_t)pixman_double_to_fixed (t));
 114             }
 115
 116             ++buffer;
 117
 118             rx += cx;
 119             ry += cy;
 120         }
 121     }
 122     else
 123     {
 124         while (buffer < end)
 125         {
 126             double x, y;
 127
 128             if (!mask || *mask++)
 129             {
 130                 double t;
 131
 132                 if (rz != 0)
 133                 {
 134                     x = rx / rz;
 135                     y = ry / rz;
 136                 }
 137                 else
 138                 {
 139                     x = y = 0.;
 140                 }
 141
 142                 x -= conical->center.x / 65536.;
 143                 y -= conical->center.y / 65536.;
 144
 145                 t = coordinates_to_parameter (x, y, conical->angle);
 146
 147                 *buffer = _pixman_gradient_walker_pixel (
 148                     &walker, (pixman_fixed_48_16_t)pixman_double_to_fixed (t));
 149             }
 150
 151             ++buffer;
 152
 153             rx += cx;
 154             ry += cy;
 155             rz += cz;
 156         }
 157     }
 158
 159     iter->y++;
 160     return iter->buffer;
 161 }
 162
 163 static uint32_t *
 164 conical_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
 165 {
 166     uint32_t *buffer = conical_get_scanline_narrow (iter, NULL);
 167
 168     pixman_expand_to_float (
 169         (argb_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
 170
 171     return buffer;
 172 }
 173
 174 void
 175 _pixman_conical_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
 176 {
 177     if (iter->iter_flags & ITER_NARROW)
 178         iter->get_scanline = conical_get_scanline_narrow;
 179     else
 180         iter->get_scanline = conical_get_scanline_wide;
 181 }
 182
 183 PIXMAN_EXPORT pixman_image_t *
 184 pixman_image_create_conical_gradient (const pixman_point_fixed_t *  center,
 185                                       pixman_fixed_t                angle,
 186                                       const pixman_gradient_stop_t *stops,
 187                                       int                           n_stops)
 188 {
 189     pixman_image_t *image = _pixman_image_allocate ();
 190     conical_gradient_t *conical;
 191
 192     if (!image)
 193         return NULL;
 194
 195     conical = &image->conical;
 196
 197     if (!_pixman_init_gradient (&conical->common, stops, n_stops))
 198     {
 199         free (image);
 200         return NULL;
 201     }
 202
 203     angle = MOD (angle, pixman_int_to_fixed (360));
 204
 205     image->type = CONICAL;
 206
 207     conical->center = *center;
 208     conical->angle = (pixman_fixed_to_double (angle) / 180.0) * M_PI;
 209
 210     return image;
 211 }
 212