src/gallium/state_trackers/vega/api_path.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
  29 #include "vg_context.h"
  30 #include "handle.h"
  31 #include "path.h"
  32 #include "api.h"
  33
  34 #include "pipe/p_context.h"
  35
  36 VGPath vegaCreatePath(VGint pathFormat,
  37                       VGPathDatatype datatype,
  38                       VGfloat scale, VGfloat bias,
  39                       VGint segmentCapacityHint,
  40                       VGint coordCapacityHint,
  41                       VGbitfield capabilities)
  42 {
  43    struct vg_context *ctx = vg_current_context();
  44
  45    if (pathFormat != VG_PATH_FORMAT_STANDARD) {
  46       vg_set_error(ctx, VG_UNSUPPORTED_PATH_FORMAT_ERROR);
  47       return VG_INVALID_HANDLE;
  48    }
  49    if (datatype < VG_PATH_DATATYPE_S_8 ||
  50        datatype > VG_PATH_DATATYPE_F) {
  51       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
  52       return VG_INVALID_HANDLE;
  53    }
  54    if (!scale) {
  55       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
  56       return VG_INVALID_HANDLE;
  57    }
  58
  59    return path_to_handle(path_create(datatype, scale, bias,
  60                                      segmentCapacityHint, coordCapacityHint,
  61                                      capabilities));
  62 }
  63
  64 void vegaClearPath(VGPath path, VGbitfield capabilities)
  65 {
  66    struct vg_context *ctx = vg_current_context();
  67    struct path *p = 0;
  68
  69    if (path == VG_INVALID_HANDLE) {
  70       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
  71       return;
  72    }
  73
  74    p = handle_to_path(path);
  75    path_clear(p, capabilities);
  76 }
  77
  78 void vegaDestroyPath(VGPath p)
  79 {
  80    struct path *path = 0;
  81    struct vg_context *ctx = vg_current_context();
  82
  83    if (p == VG_INVALID_HANDLE) {
  84       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
  85       return;
  86    }
  87
  88    path = handle_to_path(p);
  89    path_destroy(path);
  90 }
  91
  92 void vegaRemovePathCapabilities(VGPath path,
  93                                 VGbitfield capabilities)
  94 {
  95    struct vg_context *ctx = vg_current_context();
  96    VGbitfield current;
  97    struct path *p;
  98
  99    if (path == VG_INVALID_HANDLE) {
 100       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 101       return;
 102    }
 103
 104    p = handle_to_path(path);
 105    current = path_capabilities(p);
 106    path_set_capabilities(p, (current &
 107                              (~(capabilities & VG_PATH_CAPABILITY_ALL))));
 108 }
 109
 110 VGbitfield vegaGetPathCapabilities(VGPath path)
 111 {
 112    struct vg_context *ctx = vg_current_context();
 113    struct path *p = 0;
 114
 115    if (path == VG_INVALID_HANDLE) {
 116       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 117       return 0;
 118    }
 119    p = handle_to_path(path);
 120    return path_capabilities(p);
 121 }
 122
 123 void vegaAppendPath(VGPath dstPath, VGPath srcPath)
 124 {
 125    struct vg_context *ctx = vg_current_context();
 126    struct path *src, *dst;
 127
 128    if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {
 129       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 130       return;
 131    }
 132    src = handle_to_path(srcPath);
 133    dst = handle_to_path(dstPath);
 134
 135    if (!(path_capabilities(src) & VG_PATH_CAPABILITY_APPEND_FROM) ||
 136        !(path_capabilities(dst) & VG_PATH_CAPABILITY_APPEND_TO)) {
 137       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 138       return;
 139    }
 140    path_append_path(dst, src);
 141 }
 142
 143 void vegaAppendPathData(VGPath dstPath,
 144                         VGint numSegments,
 145                         const VGubyte * pathSegments,
 146                         const void * pathData)
 147 {
 148    struct vg_context *ctx = vg_current_context();
 149    struct path *p = 0;
 150    VGint i;
 151
 152    if (dstPath == VG_INVALID_HANDLE) {
 153       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 154       return;
 155    }
 156    if (!pathSegments) {
 157       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 158       return;
 159    }
 160    if (numSegments <= 0) {
 161       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 162       return;
 163    }
 164    for (i = 0; i < numSegments; ++i) {
 165       if (pathSegments[i] > VG_LCWARC_TO_REL) {
 166          vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 167          return;
 168       }
 169    }
 170
 171    p = handle_to_path(dstPath);
 172
 173    if (!p || !is_aligned_to(p, path_datatype_size(p))) {
 174       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 175       return;
 176    }
 177
 178    if (!(path_capabilities(p)&VG_PATH_CAPABILITY_APPEND_TO)) {
 179       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 180       return;
 181    }
 182
 183    path_append_data(p, numSegments, pathSegments, pathData);
 184 }
 185
 186 void vegaModifyPathCoords(VGPath dstPath,
 187                           VGint startIndex,
 188                           VGint numSegments,
 189                           const void * pathData)
 190 {
 191    struct vg_context *ctx = vg_current_context();
 192    struct path *p = 0;
 193
 194    if (dstPath == VG_INVALID_HANDLE) {
 195       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 196       return;
 197    }
 198    if (startIndex < 0 || numSegments <= 0) {
 199       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 200       return;
 201    }
 202
 203    p = handle_to_path(dstPath);
 204
 205    if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) {
 206       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 207       return;
 208    }
 209
 210    if (startIndex + numSegments > path_num_segments(p)) {
 211       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 212       return;
 213    }
 214    if (!(path_capabilities(p)&VG_PATH_CAPABILITY_MODIFY)) {
 215       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 216       return;
 217    }
 218    path_modify_coords(p, startIndex, numSegments, pathData);
 219 }
 220
 221 void vegaTransformPath(VGPath dstPath, VGPath srcPath)
 222 {
 223    struct vg_context *ctx = vg_current_context();
 224    struct path *src = 0, *dst = 0;
 225
 226    if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) {
 227       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 228       return;
 229    }
 230    src = handle_to_path(srcPath);
 231    dst = handle_to_path(dstPath);
 232
 233    if (!(path_capabilities(src) & VG_PATH_CAPABILITY_TRANSFORM_FROM) ||
 234        !(path_capabilities(dst) & VG_PATH_CAPABILITY_TRANSFORM_TO)) {
 235       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 236       return;
 237    }
 238    path_transform(dst, src);
 239 }
 240
 241 VGboolean vegaInterpolatePath(VGPath dstPath,
 242                               VGPath startPath,
 243                               VGPath endPath,
 244                               VGfloat amount)
 245 {
 246    struct vg_context *ctx = vg_current_context();
 247    struct path *start = 0, *dst = 0, *end = 0;
 248
 249    if (dstPath == VG_INVALID_HANDLE ||
 250        startPath == VG_INVALID_HANDLE ||
 251        endPath == VG_INVALID_HANDLE) {
 252       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 253       return VG_FALSE;
 254    }
 255    dst = handle_to_path(dstPath);
 256    start = handle_to_path(startPath);
 257    end = handle_to_path(endPath);
 258
 259    if (!(path_capabilities(dst) & VG_PATH_CAPABILITY_INTERPOLATE_TO) ||
 260        !(path_capabilities(start) & VG_PATH_CAPABILITY_INTERPOLATE_FROM) ||
 261        !(path_capabilities(end) & VG_PATH_CAPABILITY_INTERPOLATE_FROM)) {
 262       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 263       return VG_FALSE;
 264    }
 265
 266    return path_interpolate(dst,
 267                            start, end, amount);
 268 }
 269
 270 VGfloat vegaPathLength(VGPath path,
 271                        VGint startSegment,
 272                        VGint numSegments)
 273 {
 274    struct vg_context *ctx = vg_current_context();
 275    struct path *p = 0;
 276
 277    if (path == VG_INVALID_HANDLE) {
 278       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 279       return -1;
 280    }
 281    if (startSegment < 0) {
 282       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 283       return -1;
 284    }
 285    if (numSegments <= 0) {
 286       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 287       return -1;
 288    }
 289    p = handle_to_path(path);
 290
 291    if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) {
 292       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 293       return -1;
 294    }
 295    if (startSegment + numSegments > path_num_segments(p)) {
 296       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 297       return -1;
 298    }
 299
 300    return path_length(p, startSegment, numSegments);
 301 }
 302
 303 void vegaPointAlongPath(VGPath path,
 304                         VGint startSegment,
 305                         VGint numSegments,
 306                         VGfloat distance,
 307                         VGfloat * x, VGfloat * y,
 308                         VGfloat * tangentX,
 309                         VGfloat * tangentY)
 310 {
 311    struct vg_context *ctx = vg_current_context();
 312    struct path *p = 0;
 313    VGbitfield caps;
 314
 315    if (path == VG_INVALID_HANDLE) {
 316       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 317       return;
 318    }
 319    if (startSegment < 0) {
 320       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 321       return;
 322    }
 323    if (numSegments <= 0) {
 324       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 325       return;
 326    }
 327
 328    if (!is_aligned(x) || !is_aligned(y) ||
 329        !is_aligned(tangentX) || !is_aligned(tangentY)) {
 330       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 331       return;
 332    }
 333
 334    p = handle_to_path(path);
 335
 336    caps = path_capabilities(p);
 337    if (!(caps & VG_PATH_CAPABILITY_POINT_ALONG_PATH) ||
 338        !(caps & VG_PATH_CAPABILITY_TANGENT_ALONG_PATH)) {
 339       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 340       return;
 341    }
 342
 343    if (startSegment + numSegments > path_num_segments(p)) {
 344       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 345       return;
 346    }
 347
 348    {
 349       VGfloat point[2], normal[2];
 350       path_point(p, startSegment, numSegments, distance,
 351                  point, normal);
 352       if (x)
 353          *x = point[0];
 354       if (y)
 355          *y = point[1];
 356       if (tangentX)
 357          *tangentX = -normal[1];
 358       if (tangentY)
 359          *tangentY = normal[0];
 360    }
 361 }
 362
 363 void vegaPathBounds(VGPath path,
 364                     VGfloat * minX,
 365                     VGfloat * minY,
 366                     VGfloat * width,
 367                     VGfloat * height)
 368 {
 369    struct vg_context *ctx = vg_current_context();
 370    struct path *p = 0;
 371    VGbitfield caps;
 372
 373    if (path == VG_INVALID_HANDLE) {
 374       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 375       return;
 376    }
 377
 378    if (!minX || !minY || !width || !height) {
 379       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 380       return;
 381    }
 382
 383    if (!is_aligned(minX) || !is_aligned(minY) ||
 384        !is_aligned(width) || !is_aligned(height)) {
 385       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 386       return;
 387    }
 388
 389    p = handle_to_path(path);
 390
 391    caps = path_capabilities(p);
 392    if (!(caps & VG_PATH_CAPABILITY_PATH_BOUNDS)) {
 393       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 394       return;
 395    }
 396
 397    path_bounding_rect(p, minX, minY, width, height);
 398 }
 399
 400 void vegaPathTransformedBounds(VGPath path,
 401                                VGfloat * minX,
 402                                VGfloat * minY,
 403                                VGfloat * width,
 404                                VGfloat * height)
 405 {
 406    struct vg_context *ctx = vg_current_context();
 407    struct path *p = 0;
 408    VGbitfield caps;
 409
 410    if (path == VG_INVALID_HANDLE) {
 411       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 412       return;
 413    }
 414
 415    if (!minX || !minY || !width || !height) {
 416       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 417       return;
 418    }
 419
 420    if (!is_aligned(minX) || !is_aligned(minY) ||
 421        !is_aligned(width) || !is_aligned(height)) {
 422       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 423       return;
 424    }
 425
 426    p = handle_to_path(path);
 427
 428    caps = path_capabilities(p);
 429    if (!(caps & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS)) {
 430       vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
 431       return;
 432    }
 433
 434 #if 0
 435    /* faster, but seems to have precision problems... */
 436    path_bounding_rect(p, minX, minY, width, height);
 437    if (*width > 0 && *height > 0) {
 438       VGfloat pts[] = {*minX,          *minY,
 439                        *minX + *width, *minY,
 440                        *minX + *width, *minY + *height,
 441                        *minX,          *minY + *height};
 442       struct matrix *matrix = &ctx->state.vg.path_user_to_surface_matrix;
 443       VGfloat maxX, maxY;
 444       matrix_map_point(matrix, pts[0], pts[1], pts + 0, pts + 1);
 445       matrix_map_point(matrix, pts[2], pts[3], pts + 2, pts + 3);
 446       matrix_map_point(matrix, pts[4], pts[5], pts + 4, pts + 5);
 447       matrix_map_point(matrix, pts[6], pts[7], pts + 6, pts + 7);
 448       *minX = MIN2(pts[0], MIN2(pts[2], MIN2(pts[4], pts[6])));
 449       *minY = MIN2(pts[1], MIN2(pts[3], MIN2(pts[5], pts[7])));
 450       maxX = MAX2(pts[0], MAX2(pts[2], MAX2(pts[4], pts[6])));
 451       maxY = MAX2(pts[1], MAX2(pts[3], MAX2(pts[5], pts[7])));
 452       *width  = maxX - *minX;
 453       *height = maxY - *minY;
 454    }
 455 #else
 456    {
 457       struct path *dst = path_create(VG_PATH_DATATYPE_F, 1.0, 0,
 458                                      0, 0, VG_PATH_CAPABILITY_ALL);
 459       path_transform(dst, p);
 460       path_bounding_rect(dst, minX, minY, width, height);
 461       path_destroy(dst);
 462    }
 463 #endif
 464 }
 465
 466
 467 void vegaDrawPath(VGPath path, VGbitfield paintModes)
 468 {
 469    struct vg_context *ctx = vg_current_context();
 470    struct path *p = handle_to_path(path);
 471
 472    if (path == VG_INVALID_HANDLE) {
 473       vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
 474       return;
 475    }
 476
 477    if (!(paintModes & (VG_STROKE_PATH | VG_FILL_PATH))) {
 478       vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
 479       return;
 480    }
 481
 482    if (path_is_empty(p))
 483       return;
 484    path_render(p, paintModes,
 485          &ctx->state.vg.path_user_to_surface_matrix);
 486 }
 487