workbench/libs/mesa/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 static void vgu_append_float_coords(VGPath path,
  41                                     const VGubyte *cmds,
  42                                     VGint num_cmds,
  43                                     const VGfloat *coords,
  44                                     VGint num_coords)
  45 {
  46    VGubyte common_data[40 * sizeof(VGfloat)];
  47    struct path *p = handle_to_path(path);
  48
  49    vg_float_to_datatype(path_datatype(p), common_data, coords, num_coords);
  50    vgAppendPathData(path, num_cmds, cmds, common_data);
  51 }
  52
  53 VGUErrorCode vguLine(VGPath path,
  54                      VGfloat x0, VGfloat y0,
  55                      VGfloat x1, VGfloat y1)
  56 {
  57    static const VGubyte cmds[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS};
  58    VGfloat coords[4];
  59    VGbitfield caps;
  60
  61    if (path == VG_INVALID_HANDLE) {
  62       return VGU_BAD_HANDLE_ERROR;
  63    }
  64    caps = vgGetPathCapabilities(path);
  65    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  66       return VGU_PATH_CAPABILITY_ERROR;
  67    }
  68
  69    coords[0] = x0;
  70    coords[1] = y0;
  71    coords[2] = x1;
  72    coords[3] = y1;
  73
  74    vgu_append_float_coords(path, cmds, 2, coords, 4);
  75
  76    return VGU_NO_ERROR;
  77 }
  78
  79 VGUErrorCode vguPolygon(VGPath path,
  80                         const VGfloat * points,
  81                         VGint count,
  82                         VGboolean closed)
  83 {
  84    VGubyte *cmds;
  85    VGfloat *coords;
  86    VGbitfield caps;
  87    VGint i;
  88
  89    if (path == VG_INVALID_HANDLE) {
  90       return VGU_BAD_HANDLE_ERROR;
  91    }
  92
  93    if (!points || count <= 0 || !is_aligned(points)) {
  94       return VGU_ILLEGAL_ARGUMENT_ERROR;
  95    }
  96
  97    caps = vgGetPathCapabilities(path);
  98    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
  99       return VGU_PATH_CAPABILITY_ERROR;
 100    }
 101
 102    cmds   = malloc(sizeof(VGubyte) * count + 1);
 103    coords = malloc(sizeof(VGfloat) * count * 2);
 104
 105    cmds[0] = VG_MOVE_TO_ABS;
 106    coords[0] = points[0];
 107    coords[1] = points[1];
 108    for (i = 1; i < count; ++i) {
 109       cmds[i] = VG_LINE_TO_ABS;
 110       coords[2*i + 0] = points[2*i + 0];
 111       coords[2*i + 1] = points[2*i + 1];
 112    }
 113
 114    if (closed) {
 115       cmds[i] = VG_CLOSE_PATH;
 116       ++i;
 117    }
 118
 119    vgu_append_float_coords(path, cmds, i, coords, 2*i);
 120
 121    free(cmds);
 122    free(coords);
 123
 124    return VGU_NO_ERROR;
 125 }
 126
 127 VGUErrorCode  vguRect(VGPath path,
 128                       VGfloat x, VGfloat y,
 129                       VGfloat width, VGfloat height)
 130 {
 131    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
 132                                   VG_HLINE_TO_REL,
 133                                   VG_VLINE_TO_REL,
 134                                   VG_HLINE_TO_REL,
 135                                   VG_CLOSE_PATH
 136    };
 137    VGfloat coords[5];
 138    VGbitfield caps;
 139
 140    if (path == VG_INVALID_HANDLE) {
 141       return VGU_BAD_HANDLE_ERROR;
 142    }
 143    caps = vgGetPathCapabilities(path);
 144    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 145       return VGU_PATH_CAPABILITY_ERROR;
 146    }
 147    if (width <= 0 || height <= 0) {
 148       return VGU_ILLEGAL_ARGUMENT_ERROR;
 149    }
 150
 151    coords[0] =  x;
 152    coords[1] =  y;
 153    coords[2] =  width;
 154    coords[3] =  height;
 155    coords[4] = -width;
 156
 157    vgu_append_float_coords(path, cmds, 5, coords, 5);
 158
 159    return VGU_NO_ERROR;
 160 }
 161
 162 VGUErrorCode vguRoundRect(VGPath path,
 163                           VGfloat x, VGfloat y,
 164                           VGfloat width,
 165                           VGfloat height,
 166                           VGfloat arcWidth,
 167                           VGfloat arcHeight)
 168 {
 169    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
 170                                   VG_HLINE_TO_REL,
 171                                   VG_SCCWARC_TO_REL,
 172                                   VG_VLINE_TO_REL,
 173                                   VG_SCCWARC_TO_REL,
 174                                   VG_HLINE_TO_REL,
 175                                   VG_SCCWARC_TO_REL,
 176                                   VG_VLINE_TO_REL,
 177                                   VG_SCCWARC_TO_REL,
 178                                   VG_CLOSE_PATH
 179    };
 180    VGfloat c[26];
 181    VGbitfield caps;
 182
 183    if (path == VG_INVALID_HANDLE) {
 184       return VGU_BAD_HANDLE_ERROR;
 185    }
 186    caps = vgGetPathCapabilities(path);
 187    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 188       return VGU_PATH_CAPABILITY_ERROR;
 189    }
 190    if (width <= 0 || height <= 0) {
 191       return VGU_ILLEGAL_ARGUMENT_ERROR;
 192    }
 193
 194    c[0] =  x + arcWidth/2; c[1] =  y;
 195
 196    c[2] = width - arcWidth;
 197
 198    c[3] = arcWidth/2; c[4] = arcHeight/2; c[5] = 0;
 199    c[6] = arcWidth/2; c[7] = arcHeight/2;
 200
 201    c[8] = height - arcHeight;
 202
 203    c[9] = arcWidth/2; c[10] = arcHeight/2; c[11] = 0;
 204    c[12] = -arcWidth/2; c[13] = arcHeight/2;
 205
 206    c[14] = -(width - arcWidth);
 207
 208    c[15] = arcWidth/2; c[16] = arcHeight/2; c[17] = 0;
 209    c[18] = -arcWidth/2; c[19] = -arcHeight/2;
 210
 211    c[20] = -(height - arcHeight);
 212
 213    c[21] = arcWidth/2; c[22] = arcHeight/2; c[23] = 0;
 214    c[24] = arcWidth/2; c[25] = -arcHeight/2;
 215
 216    vgu_append_float_coords(path, cmds, 10, c, 26);
 217
 218    return VGU_NO_ERROR;
 219 }
 220
 221 VGUErrorCode vguEllipse(VGPath path,
 222                         VGfloat cx, VGfloat cy,
 223                         VGfloat width,
 224                         VGfloat height)
 225 {
 226    static const VGubyte cmds[] = {VG_MOVE_TO_ABS,
 227                                   VG_SCCWARC_TO_REL,
 228                                   VG_SCCWARC_TO_REL,
 229                                   VG_CLOSE_PATH
 230    };
 231    VGfloat coords[12];
 232    VGbitfield caps;
 233
 234    if (path == VG_INVALID_HANDLE) {
 235       return VGU_BAD_HANDLE_ERROR;
 236    }
 237    caps = vgGetPathCapabilities(path);
 238    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 239       return VGU_PATH_CAPABILITY_ERROR;
 240    }
 241    if (width <= 0 || height <= 0) {
 242       return VGU_ILLEGAL_ARGUMENT_ERROR;
 243    }
 244
 245    coords[0] = cx + width/2; coords[1] = cy;
 246
 247    coords[2] = width/2; coords[3] = height/2; coords[4] = 0;
 248    coords[5] = -width; coords[6] = 0;
 249
 250    coords[7] = width/2; coords[8] = height/2; coords[9] = 0;
 251    coords[10] = width; coords[11] = 0;
 252
 253    vgu_append_float_coords(path, cmds, 4, coords, 11);
 254
 255    return VGU_NO_ERROR;
 256 }
 257
 258 VGUErrorCode vguArc(VGPath path,
 259                     VGfloat x, VGfloat y,
 260                     VGfloat width, VGfloat height,
 261                     VGfloat startAngle,
 262                     VGfloat angleExtent,
 263                     VGUArcType arcType)
 264 {
 265    VGubyte cmds[11];
 266    VGfloat coords[40];
 267    VGbitfield caps;
 268    VGfloat last = startAngle + angleExtent;
 269    VGint i, c = 0;
 270
 271    if (path == VG_INVALID_HANDLE) {
 272       return VGU_BAD_HANDLE_ERROR;
 273    }
 274    caps = vgGetPathCapabilities(path);
 275    if (!(caps & VG_PATH_CAPABILITY_APPEND_TO)) {
 276       return VGU_PATH_CAPABILITY_ERROR;
 277    }
 278    if (width <= 0 || height <= 0) {
 279       return VGU_ILLEGAL_ARGUMENT_ERROR;
 280    }
 281    if (arcType != VGU_ARC_OPEN &&
 282        arcType != VGU_ARC_CHORD &&
 283        arcType != VGU_ARC_PIE) {
 284       return VGU_ILLEGAL_ARGUMENT_ERROR;
 285    }
 286
 287    cmds[c] = VG_MOVE_TO_ABS; ++c;
 288    coords[0] = x+cos(DEGREES_TO_RADIANS(startAngle))*width/2;
 289    coords[1] = y+sin(DEGREES_TO_RADIANS(startAngle))*height/2;
 290 #ifdef DEBUG_VGUARC
 291    debug_printf("start [%f, %f]\n", coords[0], coords[1]);
 292 #endif
 293    i = 2;
 294    if (angleExtent > 0) {
 295       VGfloat angle = startAngle + 180;
 296       while (angle < last) {
 297          cmds[c] = VG_SCCWARC_TO_ABS; ++c;
 298          coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
 299          coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle))*width/2;
 300          coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle))*height/2;
 301 #ifdef DEBUG_VGUARC
 302          debug_printf("1 [%f, %f]\n", coords[i+3],
 303                       coords[i+4]);
 304 #endif
 305          i += 5;
 306          angle += 180;
 307       }
 308       cmds[c] = VG_SCCWARC_TO_ABS; ++c;
 309       coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
 310       coords[i+3] = x+cos(DEGREES_TO_RADIANS(last))*width/2;
 311       coords[i+4] = y+sin(DEGREES_TO_RADIANS(last))*height/2;
 312 #ifdef DEBUG_VGUARC
 313       debug_printf("2 [%f, %f]\n", coords[i+3],
 314                    coords[i+4]);
 315 #endif
 316       i += 5;
 317    } else {
 318       VGfloat angle = startAngle - 180;
 319       while (angle > last) {
 320          cmds[c] = VG_SCWARC_TO_ABS; ++c;
 321          coords[i] =  width/2; coords[i+1] = height/2; coords[i+2] = 0;
 322          coords[i+3] = x + cos(DEGREES_TO_RADIANS(angle)) * width/2;
 323          coords[i+4] = y + sin(DEGREES_TO_RADIANS(angle)) * height/2;
 324 #ifdef DEBUG_VGUARC
 325          debug_printf("3 [%f, %f]\n", coords[i+3],
 326                       coords[i+4]);
 327 #endif
 328          angle -= 180;
 329          i += 5;
 330       }
 331       cmds[c] = VG_SCWARC_TO_ABS; ++c;
 332       coords[i] = width/2; coords[i+1] = height/2; coords[i+2] = 0;
 333       coords[i+3] = x + cos(DEGREES_TO_RADIANS(last)) * width/2;
 334       coords[i+4] = y + sin(DEGREES_TO_RADIANS(last)) * height/2;
 335 #ifdef DEBUG_VGUARC
 336       debug_printf("4 [%f, %f]\n", coords[i+3],
 337                    coords[i+4]);
 338 #endif
 339       i += 5;
 340    }
 341
 342    if (arcType == VGU_ARC_PIE) {
 343       cmds[c] = VG_LINE_TO_ABS; ++c;
 344       coords[i] = x; coords[i + 1] = y;
 345       i += 2;
 346    }
 347    if (arcType == VGU_ARC_PIE || arcType == VGU_ARC_CHORD) {
 348       cmds[c] = VG_CLOSE_PATH;
 349       ++c;
 350    }
 351
 352    assert(c < 11);
 353
 354    vgu_append_float_coords(path, cmds, c, coords, i);
 355
 356    return VGU_NO_ERROR;
 357 }
 358
 359 VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
 360                                         VGfloat sx1, VGfloat sy1,
 361                                         VGfloat sx2, VGfloat sy2,
 362                                         VGfloat sx3, VGfloat sy3,
 363                                         VGfloat * matrix)
 364 {
 365    struct matrix mat;
 366
 367    if (!matrix || !is_aligned(matrix))
 368       return VGU_ILLEGAL_ARGUMENT_ERROR;
 369
 370    if (!matrix_quad_to_square(sx0, sy0,
 371                               sx1, sy1,
 372                               sx2, sy2,
 373                               sx3, sy3,
 374                               &mat))
 375       return VGU_BAD_WARP_ERROR;
 376
 377    if (!matrix_is_invertible(&mat))
 378       return VGU_BAD_WARP_ERROR;
 379
 380    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
 381
 382    return VGU_NO_ERROR;
 383 }
 384
 385 VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
 386                                         VGfloat dx1, VGfloat dy1,
 387                                         VGfloat dx2, VGfloat dy2,
 388                                         VGfloat dx3, VGfloat dy3,
 389                                         VGfloat * matrix)
 390 {
 391    struct matrix mat;
 392
 393    if (!matrix || !is_aligned(matrix))
 394       return VGU_ILLEGAL_ARGUMENT_ERROR;
 395
 396    if (!matrix_square_to_quad(dx0, dy0,
 397                               dx1, dy1,
 398                               dx2, dy2,
 399                               dx3, dy3,
 400                               &mat))
 401       return VGU_BAD_WARP_ERROR;
 402
 403    if (!matrix_is_invertible(&mat))
 404       return VGU_BAD_WARP_ERROR;
 405
 406    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
 407
 408    return VGU_NO_ERROR;
 409 }
 410
 411 VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
 412                                       VGfloat dx1, VGfloat dy1,
 413                                       VGfloat dx2, VGfloat dy2,
 414                                       VGfloat dx3, VGfloat dy3,
 415                                       VGfloat sx0, VGfloat sy0,
 416                                       VGfloat sx1, VGfloat sy1,
 417                                       VGfloat sx2, VGfloat sy2,
 418                                       VGfloat sx3, VGfloat sy3,
 419                                       VGfloat * matrix)
 420 {
 421    struct matrix mat;
 422
 423    if (!matrix || !is_aligned(matrix))
 424       return VGU_ILLEGAL_ARGUMENT_ERROR;
 425
 426    if (!matrix_quad_to_quad(dx0, dy0,
 427                             dx1, dy1,
 428                             dx2, dy2,
 429                             dx3, dy3,
 430                             sx0, sy0,
 431                             sx1, sy1,
 432                             sx2, sy2,
 433                             sx3, sy3,
 434                             &mat))
 435       return VGU_BAD_WARP_ERROR;
 436
 437    memcpy(matrix, mat.m, sizeof(VGfloat) * 9);
 438
 439    return VGU_NO_ERROR;
 440 }