+++ /dev/null
-/**************************************************************************
- *
- * 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);
-}
-
projects / mesa.git / blobdiff