| /************************************************************************** |
| * |
| * 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); |
| } |
| |
