diff options
Diffstat (limited to 'src/gallium/state_trackers/vega/api_path.c')
| -rw-r--r-- | src/gallium/state_trackers/vega/api_path.c | 487 |
1 files changed, 0 insertions, 487 deletions
diff --git a/src/gallium/state_trackers/vega/api_path.c b/src/gallium/state_trackers/vega/api_path.c deleted file mode 100644 index ab6ce958945..00000000000 --- a/src/gallium/state_trackers/vega/api_path.c +++ /dev/null @@ -1,487 +0,0 @@ -/************************************************************************** - * - * Copyright 2009 VMware, Inc. All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR - * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE - * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ - -#include "VG/openvg.h" - -#include "vg_context.h" -#include "handle.h" -#include "path.h" -#include "api.h" - -#include "pipe/p_context.h" - -VGPath vegaCreatePath(VGint pathFormat, - VGPathDatatype datatype, - VGfloat scale, VGfloat bias, - VGint segmentCapacityHint, - VGint coordCapacityHint, - VGbitfield capabilities) -{ - struct vg_context *ctx = vg_current_context(); - - if (pathFormat != VG_PATH_FORMAT_STANDARD) { - vg_set_error(ctx, VG_UNSUPPORTED_PATH_FORMAT_ERROR); - return VG_INVALID_HANDLE; - } - if (datatype < VG_PATH_DATATYPE_S_8 || - datatype > VG_PATH_DATATYPE_F) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return VG_INVALID_HANDLE; - } - if (!scale) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return VG_INVALID_HANDLE; - } - - return path_to_handle(path_create(datatype, scale, bias, - segmentCapacityHint, coordCapacityHint, - capabilities)); -} - -void vegaClearPath(VGPath path, VGbitfield capabilities) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - - p = handle_to_path(path); - path_clear(p, capabilities); -} - -void vegaDestroyPath(VGPath p) -{ - struct path *path = 0; - struct vg_context *ctx = vg_current_context(); - - if (p == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - - path = handle_to_path(p); - path_destroy(path); -} - -void vegaRemovePathCapabilities(VGPath path, - VGbitfield capabilities) -{ - struct vg_context *ctx = vg_current_context(); - VGbitfield current; - struct path *p; - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - - p = handle_to_path(path); - current = path_capabilities(p); - path_set_capabilities(p, (current & - (~(capabilities & VG_PATH_CAPABILITY_ALL)))); -} - -VGbitfield vegaGetPathCapabilities(VGPath path) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return 0; - } - p = handle_to_path(path); - return path_capabilities(p); -} - -void vegaAppendPath(VGPath dstPath, VGPath srcPath) -{ - struct vg_context *ctx = vg_current_context(); - struct path *src, *dst; - - if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - src = handle_to_path(srcPath); - dst = handle_to_path(dstPath); - - if (!(path_capabilities(src) & VG_PATH_CAPABILITY_APPEND_FROM) || - !(path_capabilities(dst) & VG_PATH_CAPABILITY_APPEND_TO)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return; - } - path_append_path(dst, src); -} - -void vegaAppendPathData(VGPath dstPath, - VGint numSegments, - const VGubyte * pathSegments, - const void * pathData) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - VGint i; - - if (dstPath == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - if (!pathSegments) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - if (numSegments <= 0) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - for (i = 0; i < numSegments; ++i) { - if (pathSegments[i] > VG_LCWARC_TO_REL) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - } - - p = handle_to_path(dstPath); - - if (!p || !is_aligned_to(p, path_datatype_size(p))) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - if (!(path_capabilities(p)&VG_PATH_CAPABILITY_APPEND_TO)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return; - } - - path_append_data(p, numSegments, pathSegments, pathData); -} - -void vegaModifyPathCoords(VGPath dstPath, - VGint startIndex, - VGint numSegments, - const void * pathData) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - - if (dstPath == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - if (startIndex < 0 || numSegments <= 0) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - p = handle_to_path(dstPath); - - if (!pathData || !is_aligned_to(pathData, path_datatype_size(p))) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - if (startIndex + numSegments > path_num_segments(p)) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - if (!(path_capabilities(p)&VG_PATH_CAPABILITY_MODIFY)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return; - } - path_modify_coords(p, startIndex, numSegments, pathData); -} - -void vegaTransformPath(VGPath dstPath, VGPath srcPath) -{ - struct vg_context *ctx = vg_current_context(); - struct path *src = 0, *dst = 0; - - if (dstPath == VG_INVALID_HANDLE || srcPath == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - src = handle_to_path(srcPath); - dst = handle_to_path(dstPath); - - if (!(path_capabilities(src) & VG_PATH_CAPABILITY_TRANSFORM_FROM) || - !(path_capabilities(dst) & VG_PATH_CAPABILITY_TRANSFORM_TO)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return; - } - path_transform(dst, src); -} - -VGboolean vegaInterpolatePath(VGPath dstPath, - VGPath startPath, - VGPath endPath, - VGfloat amount) -{ - struct vg_context *ctx = vg_current_context(); - struct path *start = 0, *dst = 0, *end = 0; - - if (dstPath == VG_INVALID_HANDLE || - startPath == VG_INVALID_HANDLE || - endPath == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return VG_FALSE; - } - dst = handle_to_path(dstPath); - start = handle_to_path(startPath); - end = handle_to_path(endPath); - - if (!(path_capabilities(dst) & VG_PATH_CAPABILITY_INTERPOLATE_TO) || - !(path_capabilities(start) & VG_PATH_CAPABILITY_INTERPOLATE_FROM) || - !(path_capabilities(end) & VG_PATH_CAPABILITY_INTERPOLATE_FROM)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return VG_FALSE; - } - - return path_interpolate(dst, - start, end, amount); -} - -VGfloat vegaPathLength(VGPath path, - VGint startSegment, - VGint numSegments) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return -1; - } - if (startSegment < 0) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return -1; - } - if (numSegments <= 0) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return -1; - } - p = handle_to_path(path); - - if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return -1; - } - if (startSegment + numSegments > path_num_segments(p)) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return -1; - } - - return path_length(p, startSegment, numSegments); -} - -void vegaPointAlongPath(VGPath path, - VGint startSegment, - VGint numSegments, - VGfloat distance, - VGfloat * x, VGfloat * y, - VGfloat * tangentX, - VGfloat * tangentY) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - VGbitfield caps; - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - if (startSegment < 0) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - if (numSegments <= 0) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - if (!is_aligned(x) || !is_aligned(y) || - !is_aligned(tangentX) || !is_aligned(tangentY)) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - p = handle_to_path(path); - - caps = path_capabilities(p); - if (!(caps & VG_PATH_CAPABILITY_POINT_ALONG_PATH) || - !(caps & VG_PATH_CAPABILITY_TANGENT_ALONG_PATH)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return; - } - - if (startSegment + numSegments > path_num_segments(p)) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - { - VGfloat point[2], normal[2]; - path_point(p, startSegment, numSegments, distance, - point, normal); - if (x) - *x = point[0]; - if (y) - *y = point[1]; - if (tangentX) - *tangentX = -normal[1]; - if (tangentY) - *tangentY = normal[0]; - } -} - -void vegaPathBounds(VGPath path, - VGfloat * minX, - VGfloat * minY, - VGfloat * width, - VGfloat * height) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - VGbitfield caps; - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - - if (!minX || !minY || !width || !height) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - if (!is_aligned(minX) || !is_aligned(minY) || - !is_aligned(width) || !is_aligned(height)) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - p = handle_to_path(path); - - caps = path_capabilities(p); - if (!(caps & VG_PATH_CAPABILITY_PATH_BOUNDS)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return; - } - - path_bounding_rect(p, minX, minY, width, height); -} - -void vegaPathTransformedBounds(VGPath path, - VGfloat * minX, - VGfloat * minY, - VGfloat * width, - VGfloat * height) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = 0; - VGbitfield caps; - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - - if (!minX || !minY || !width || !height) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - if (!is_aligned(minX) || !is_aligned(minY) || - !is_aligned(width) || !is_aligned(height)) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - p = handle_to_path(path); - - caps = path_capabilities(p); - if (!(caps & VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS)) { - vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR); - return; - } - -#if 0 - /* faster, but seems to have precision problems... */ - path_bounding_rect(p, minX, minY, width, height); - if (*width > 0 && *height > 0) { - VGfloat pts[] = {*minX, *minY, - *minX + *width, *minY, - *minX + *width, *minY + *height, - *minX, *minY + *height}; - struct matrix *matrix = &ctx->state.vg.path_user_to_surface_matrix; - VGfloat maxX, maxY; - matrix_map_point(matrix, pts[0], pts[1], pts + 0, pts + 1); - matrix_map_point(matrix, pts[2], pts[3], pts + 2, pts + 3); - matrix_map_point(matrix, pts[4], pts[5], pts + 4, pts + 5); - matrix_map_point(matrix, pts[6], pts[7], pts + 6, pts + 7); - *minX = MIN2(pts[0], MIN2(pts[2], MIN2(pts[4], pts[6]))); - *minY = MIN2(pts[1], MIN2(pts[3], MIN2(pts[5], pts[7]))); - maxX = MAX2(pts[0], MAX2(pts[2], MAX2(pts[4], pts[6]))); - maxY = MAX2(pts[1], MAX2(pts[3], MAX2(pts[5], pts[7]))); - *width = maxX - *minX; - *height = maxY - *minY; - } -#else - { - struct path *dst = path_create(VG_PATH_DATATYPE_F, 1.0, 0, - 0, 0, VG_PATH_CAPABILITY_ALL); - path_transform(dst, p); - path_bounding_rect(dst, minX, minY, width, height); - path_destroy(dst); - } -#endif -} - - -void vegaDrawPath(VGPath path, VGbitfield paintModes) -{ - struct vg_context *ctx = vg_current_context(); - struct path *p = handle_to_path(path); - - if (path == VG_INVALID_HANDLE) { - vg_set_error(ctx, VG_BAD_HANDLE_ERROR); - return; - } - - if (!(paintModes & (VG_STROKE_PATH | VG_FILL_PATH))) { - vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR); - return; - } - - if (path_is_empty(p)) - return; - path_render(p, paintModes, - &ctx->state.vg.path_user_to_surface_matrix); -} - |