src/gallium/state_trackers/vega/vgu.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.  All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  **************************************************************************/
  26
  27 #include "VG/openvg.h"
  28 #include "VG/vgu.h"
  29
  30 #include "matrix.h"
  31 #include "path.h"
  32 #include "handle.h"
  33
  34 #include "util/u_debug.h"
  35 #include "util/u_pointer.h"
  36
  37 #include <math.h>
  38 #include <assert.h>
  39
  40
  41 static void vgu_append_float_coords(VGPath path,
  42                                     const VGubyte *cmds,
  43                                     VGint num_cmds,
  44                                     const VGfloat *coords,
  45                                     VGint num_coords)
  46 {
  47    VGubyte common_data[40 * sizeof(VGfloat)];
  48    struct path *p = handle_to_path(path);
  49
  50    vg_float_to_datatype(path_datatype(p), common_data, coords, num_coords);
  51    vgAppendPathData(path, num_cmds, cmds, common_data);
  52 }
  53
  54 VGUErrorCode vguLine(VGPath path,
  55                      VGfloat x0, VGfloat y0,
  56                      VGfloat x1, VGfloat y1)
  57 {
  58    static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS};
  59    VGfloat coords[4];
  60    VGbitfield caps;
  61
  62    if (path == VG_INVALID_HANDLE) {
  63       return VGU_BAD_HANDLE_ERROR;
  64    }
  65    caps = vgGetPathCapabilities(path);
  66    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  67       return VGU_PATH_CAPABILITY_ERROR;
  68    }
  69
  70    coords[0] = x0;
  71    coords[1] = y0;
  72    coords[2] = x1;
  73    coords[3] = y1;
  74
  75    vgu_append_float_coords(path, cmds, 2, coords, 4);
  76
  77    return VGU_NO_ERROR;
  78 }
  79
  80 VGUErrorCode vguPolygon(VGPath path,
  81                         const VGfloat * points,
  82                         VGint count,
  83                         VGboolean closed)
  84 {
  85    VGubyte *cmds;
  86    VGfloat *coords;
  87    VGbitfield caps;
  88    VGint i;
  89
  90    if (path == VG_INVALID_HANDLE) {
  91       return VGU_BAD_HANDLE_ERROR;
  92    }
  93
  94    if (!points || count <= 0 || !is_aligned(points)) {
  95       return VGU_ILLEGAL_ARGUMENT_ERROR;
  96    }
  97
  98    caps = vgGetPathCapabilities(path);
  99    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 100       return VGU_PATH_CAPABILITY_ERROR;
 101    }
 102
 103    cmds   = malloc(sizeof(VGubyte) * count + 1);
 104    coords = malloc(sizeof(VGfloat) * count * 2);
 105
 106    cmds[0] = VG_MOVE_TO_ABS;
 107    coords[0] = points[0];
 108    coords[1] = points[1];
 109    for (i = 1; i < count; ++i) {
 110       cmds[i] = VG_LINE_TO_ABS;
 111       coords[2*i + 0] = points[2*i + 0];
 112       coords[2*i + 1] = points[2*i + 1];
 113    }
 114
 115    if (closed) {
 116       cmds[i] = VG_CLOSE_PATH;
 117       ++i;
 118    }
 119
 120    vgu_append_float_coords(path, cmds, i, coords, 2*i);
 121
 122    free(cmds);
 123    free(coords);
 124
 125    return VGU_NO_ERROR;
 126 }
 127
 128 VGUErrorCode  vguRect(VGPath path,
 129                       VGfloat x, VGfloat y,
 130                       VGfloat width, VGfloat height)
 131 {
 132    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
 133                                   VG_HLINE_TO_REL,
 134                                   VG_VLINE_TO_REL,
 135                                   VG_HLINE_TO_REL,
 136                                   VG_CLOSE_PATH
 137    };
 138    VGfloat coords[5];
 139    VGbitfield caps;
 140
 141    if (path == VG_INVALID_HANDLE) {
 142       return VGU_BAD_HANDLE_ERROR;
 143    }
 144    caps = vgGetPathCapabilities(path);
 145    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 146       return VGU_PATH_CAPABILITY_ERROR;
 147    }
 148    if (width <= 0 || height <= 0) {
 149       return VGU_ILLEGAL_ARGUMENT_ERROR;
 150    }
 151
 152    coords[0] =  x;
 153    coords[1] =  y;
 154    coords[2] =  width;
 155    coords[3] =  height;
 156    coords[4] = -width;
 157
 158    vgu_append_float_coords(path, cmds, 5, coords, 5);
 159
 160    return VGU_NO_ERROR;
 161 }
 162
 163 VGUErrorCode vguRoundRect(VGPath path,
 164                           VGfloat x, VGfloat y,
 165                           VGfloat width,
 166                           VGfloat height,
 167                           VGfloat arcWidth,
 168                           VGfloat arcHeight)
 169 {
 170    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
 171                                   VG_HLINE_TO_REL,
 172                                   VG_SCCWARC_TO_REL,
 173                                   VG_VLINE_TO_REL,
 174                                   VG_SCCWARC_TO_REL,
 175                                   VG_HLINE_TO_REL,
 176                                   VG_SCCWARC_TO_REL,
 177                                   VG_VLINE_TO_REL,
 178                                   VG_SCCWARC_TO_REL,
 179                                   VG_CLOSE_PATH
 180    };
 181    VGfloat c[26];
 182    VGbitfield caps;
 183
 184    if (path == VG_INVALID_HANDLE) {
 185       return VGU_BAD_HANDLE_ERROR;
 186    }
 187    caps = vgGetPathCapabilities(path);
 188    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 189       return VGU_PATH_CAPABILITY_ERROR;
 190    }
 191    if (width <= 0 || height <= 0) {
 192       return VGU_ILLEGAL_ARGUMENT_ERROR;
 193    }
 194
 195    c[0] =  x + arcWidth/2; c[1] =  y;
 196
 197    c[2] = width - arcWidth;
 198
 199    c[3] = arcWidth/2; c[4] = arcHeight/2; c[5] = 0;
 200    c[6] = arcWidth/2; c[7] = arcHeight/2;
 201
 202    c[8] = height - arcHeight;
 203
 204    c[9] = arcWidth/2; c[10] = arcHeight/2; c[11] = 0;
 205    c[12] = -arcWidth/2; c[13] = arcHeight/2;
 206
 207    c[14] = -(width - arcWidth);
 208
 209    c[15] = arcWidth/2; c[16] = arcHeight/2; c[17] = 0;
 210    c[18] = -arcWidth/2; c[19] = -arcHeight/2;
 211
 212    c[20] = -(height - arcHeight);
 213
 214    c[21] = arcWidth/2; c[22] = arcHeight/2; c[23] = 0;
 215    c[24] = arcWidth/2; c[25] = -arcHeight/2;
 216
 217    vgu_append_float_coords(path, cmds, 10, c, 26);
 218
 219    return VGU_NO_ERROR;
 220 }
 221
 222 VGUErrorCode vguEllipse(VGPath path,
 223                         VGfloat cx, VGfloat cy,
 224                         VGfloat width,
 225                         VGfloat height)
 226 {
 227    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
 228                                   VG_SCCWARC_TO_REL,
 229                                   VG_SCCWARC_TO_REL,
 230                                   VG_CLOSE_PATH
 231    };
 232    VGfloat coords[12];
 233    VGbitfield caps;
 234
 235    if (path == VG_INVALID_HANDLE) {
 236       return VGU_BAD_HANDLE_ERROR;
 237    }
 238    caps = vgGetPathCapabilities(path);
 239    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 240       return VGU_PATH_CAPABILITY_ERROR;
 241    }
 242    if (width <= 0 || height <= 0) {
 243       return VGU_ILLEGAL_ARGUMENT_ERROR;
 244    }
 245
 246    coords[0] = cx + width/2; coords[1] = cy;
 247
 248    coords[2] = width/2; coords[3] = height/2; coords[4] = 0;
 249    coords[5] = -width; coords[6] = 0;
 250
 251    coords[7] = width/2; coords[8] = height/2; coords[9] = 0;
 252    coords[10] = width; coords[11] = 0;
 253
 254    vgu_append_float_coords(path, cmds, 4, coords, 11);
 255
 256    return VGU_NO_ERROR;
 257 }
 258
 259 VGUErrorCode vguArc(VGPath path,
 260                     VGfloat x, VGfloat y,
 261                     VGfloat width, VGfloat height,
 262                     VGfloat startAngle,
 263                     VGfloat angleExtent,
 264                     VGUArcType arcType)
 265 {
 266    VGubyte cmds[11];
 267    VGfloat coords[40];
 268    VGbitfield caps;
 269    VGfloat last = startAngle + angleExtent;
 270    VGint i, c = 0;
 271
 272    if (path == VG_INVALID_HANDLE) {
 273       return VGU_BAD_HANDLE_ERROR;
 274    }
 275    caps = vgGetPathCapabilities(path);
 276    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 277       return VGU_PATH_CAPABILITY_ERROR;
 278    }
 279    if (width <= 0 || height <= 0) {
 280       return VGU_ILLEGAL_ARGUMENT_ERROR;
 281    }
 282    if (arcType != VGU_ARC_OPEN &&
 283        arcType != VGU_ARC_CHORD &&
 284        arcType != VGU_ARC_PIE) {
 285       return VGU_ILLEGAL_ARGUMENT_ERROR;
 286    }
 287
 288    cmds[c] = VG_MOVE_TO_ABS; ++c;
 289    coords[0] = x+cos(DEGREES_TO_RADIANS(startAngle))*width/2;
 290    coords[1] = y+sin(DEGREES_TO_RADIANS(startAngle))*height/2;
 291 #ifdef DEBUG_VGUARC
 292    debug_printf("start [%f, %f]\n", coords[0], coords[1]);
 293 #endif
 294    i = 2;
 295    if (angleExtent > 0) {
 296       VGfloat angle = startAngle + 180;
 297       while (angle < last) {
 298          cmds[c] = VG_SCCWARC_TO_ABS; ++c;
 299          coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
 300          coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle))*width/2;
 301          coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle))*height/2;
 302 #ifdef DEBUG_VGUARC
 303          debug_printf("1 [%f, %f]\n", coords[i+3],
 304                       coords[i+4]);
 305 #endif
 306          i += 5;
 307          angle += 180;
 308       }
 309       cmds[c] = VG_SCCWARC_TO_ABS; ++c;
 310       coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
 311       coords[i+3] = x+cos(DEGREES_TO_RADIANS(last))*width/2;
 312       coords[i+4] = y+sin(DEGREES_TO_RADIANS(last))*height/2;
 313 #ifdef DEBUG_VGUARC
 314       debug_printf("2 [%f, %f]\n", coords[i+3],
 315                    coords[i+4]);
 316 #endif
 317       i += 5;
 318    } else {
 319       VGfloat angle = startAngle - 180;
 320       while (angle > last) {
 321          cmds[c] = VG_SCWARC_TO_ABS; ++c;
 322          coords[i] =  width/2; coords[i+1] = height/2; coords[i+2] = 0;
 323          coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle)) * width/2;
 324          coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle)) * height/2;
 325 #ifdef DEBUG_VGUARC
 326          debug_printf("3 [%f, %f]\n", coords[i+3],
 327                       coords[i+4]);
 328 #endif
 329          angle -= 180;
 330          i += 5;
 331       }
 332       cmds[c] = VG_SCWARC_TO_ABS; ++c;
 333       coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
 334       coords[i+3] = x + cos(DEGREES_TO_RADIANS(last)) * width/2;
 335       coords[i+4] = y + sin(DEGREES_TO_RADIANS(last)) * height/2;
 336 #ifdef DEBUG_VGUARC
 337       debug_printf("4 [%f, %f]\n", coords[i+3],
 338                    coords[i+4]);
 339 #endif
 340       i += 5;
 341    }
 342
 343    if (arcType == VGU_ARC_PIE) {
 344       cmds[c] = VG_LINE_TO_ABS; ++c;
 345       coords[i] = x; coords[i + 1] = y;
 346       i += 2;
 347    }
 348    if (arcType == VGU_ARC_PIE || arcType == VGU_ARC_CHORD) {
 349       cmds[c] = VG_CLOSE_PATH;
 350       ++c;
 351    }
 352
 353    assert(c < 11);
 354
 355    vgu_append_float_coords(path, cmds, c, coords, i);
 356
 357    return VGU_NO_ERROR;
 358 }
 359
 360 VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
 361                                         VGfloat sx1, VGfloat sy1,
 362                                         VGfloat sx2, VGfloat sy2,
 363                                         VGfloat sx3, VGfloat sy3,
 364                                         VGfloat * matrix)
 365 {
 366    struct matrix mat;
 367
 368    if (!matrix || !is_aligned(matrix))
 369       return VGU_ILLEGAL_ARGUMENT_ERROR;
 370
 371    if (!matrix_quad_to_square(sx0, sy0,
 372                               sx1, sy1,
 373                               sx2, sy2,
 374                               sx3, sy3,
 375                               &mat))
 376       return VGU_BAD_WARP_ERROR;
 377
 378    if (!matrix_is_invertible(&mat))
 379       return VGU_BAD_WARP_ERROR;
 380
 381    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
 382
 383    return VGU_NO_ERROR;
 384 }
 385
 386 VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
 387                                         VGfloat dx1, VGfloat dy1,
 388                                         VGfloat dx2, VGfloat dy2,
 389                                         VGfloat dx3, VGfloat dy3,
 390                                         VGfloat * matrix)
 391 {
 392    struct matrix mat;
 393
 394    if (!matrix || !is_aligned(matrix))
 395       return VGU_ILLEGAL_ARGUMENT_ERROR;
 396
 397    if (!matrix_square_to_quad(dx0, dy0,
 398                               dx1, dy1,
 399                               dx2, dy2,
 400                               dx3, dy3,
 401                               &mat))
 402       return VGU_BAD_WARP_ERROR;
 403
 404    if (!matrix_is_invertible(&mat))
 405       return VGU_BAD_WARP_ERROR;
 406
 407    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
 408
 409    return VGU_NO_ERROR;
 410 }
 411
 412 VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
 413                                       VGfloat dx1, VGfloat dy1,
 414                                       VGfloat dx2, VGfloat dy2,
 415                                       VGfloat dx3, VGfloat dy3,
 416                                       VGfloat sx0, VGfloat sy0,
 417                                       VGfloat sx1, VGfloat sy1,
 418                                       VGfloat sx2, VGfloat sy2,
 419                                       VGfloat sx3, VGfloat sy3,
 420                                       VGfloat * matrix)
 421 {
 422    struct matrix mat;
 423
 424    if (!matrix || !is_aligned(matrix))
 425       return VGU_ILLEGAL_ARGUMENT_ERROR;
 426
 427    if (!matrix_quad_to_quad(dx0, dy0,
 428                             dx1, dy1,
 429                             dx2, dy2,
 430                             dx3, dy3,
 431                             sx0, sy0,
 432                             sx1, sy1,
 433                             sx2, sy2,
 434                             sx3, sy3,
 435                             &mat))
 436       return VGU_BAD_WARP_ERROR;
 437
 438    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
 439
 440    return VGU_NO_ERROR;
 441 }