+++ /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 "arc.h"
-
-#include "matrix.h"
-#include "bezier.h"
-#include "polygon.h"
-#include "stroker.h"
-#include "path.h"
-
-#include "util/u_debug.h"
-#include "util/u_math.h"
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-#define DEBUG_ARCS 0
-
-static const VGfloat two_pi = M_PI * 2;
-
-
-static const double coeffs3Low[2][4][4] = {
- {
- { 3.85268, -21.229, -0.330434, 0.0127842 },
- { -1.61486, 0.706564, 0.225945, 0.263682 },
- { -0.910164, 0.388383, 0.00551445, 0.00671814 },
- { -0.630184, 0.192402, 0.0098871, 0.0102527 }
- },
- {
- { -0.162211, 9.94329, 0.13723, 0.0124084 },
- { -0.253135, 0.00187735, 0.0230286, 0.01264 },
- { -0.0695069, -0.0437594, 0.0120636, 0.0163087 },
- { -0.0328856, -0.00926032, -0.00173573, 0.00527385 }
- }
-};
-
-/* coefficients for error estimation
- while using cubic Bézier curves for approximation
- 1/4 <= b/a <= 1 */
-static const double coeffs3High[2][4][4] = {
- {
- { 0.0899116, -19.2349, -4.11711, 0.183362 },
- { 0.138148, -1.45804, 1.32044, 1.38474 },
- { 0.230903, -0.450262, 0.219963, 0.414038 },
- { 0.0590565, -0.101062, 0.0430592, 0.0204699 }
- },
- {
- { 0.0164649, 9.89394, 0.0919496, 0.00760802 },
- { 0.0191603, -0.0322058, 0.0134667, -0.0825018 },
- { 0.0156192, -0.017535, 0.00326508, -0.228157 },
- { -0.0236752, 0.0405821, -0.0173086, 0.176187 }
- }
-};
-
-/* safety factor to convert the "best" error approximation
- into a "max bound" error */
-static const double safety3[] = {
- 0.001, 4.98, 0.207, 0.0067
-};
-
-/* The code below is from the OpenVG 1.1 Spec
- * Section 18.4 */
-
-/* Given: Points (x0, y0) and (x1, y1)
- * Return: TRUE if a solution exists, FALSE otherwise
- * Circle centers are written to (cx0, cy0) and (cx1, cy1)
- */
-static VGboolean
-find_unit_circles(double x0, double y0, double x1, double y1,
- double *cx0, double *cy0,
- double *cx1, double *cy1)
-{
- /* Compute differences and averages */
- double dx = x0 - x1;
- double dy = y0 - y1;
- double xm = (x0 + x1)/2;
- double ym = (y0 + y1)/2;
- double dsq, disc, s, sdx, sdy;
-
- /* Solve for intersecting unit circles */
- dsq = dx*dx + dy*dy;
- if (dsq == 0.0) return VG_FALSE; /* Points are coincident */
- disc = 1.0/dsq - 1.0/4.0;
-
- /* the precision we care about here is around float so if we're
- * around the float defined zero then make it official to avoid
- * precision problems later on */
- if (floatIsZero(disc))
- disc = 0.0;
-
- if (disc < 0.0) return VG_FALSE; /* Points are too far apart */
- s = sqrt(disc);
- sdx = s*dx;
- sdy = s*dy;
- *cx0 = xm + sdy;
- *cy0 = ym - sdx;
- *cx1 = xm - sdy;
- *cy1 = ym + sdx;
- return VG_TRUE;
-}
-
-
-/* Given: Ellipse parameters rh, rv, rot (in degrees),
- * endpoints (x0, y0) and (x1, y1)
- * Return: TRUE if a solution exists, FALSE otherwise
- * Ellipse centers are written to (cx0, cy0) and (cx1, cy1)
- */
-static VGboolean
-find_ellipses(double rh, double rv, double rot,
- double x0, double y0, double x1, double y1,
- double *cx0, double *cy0, double *cx1, double *cy1)
-{
- double COS, SIN, x0p, y0p, x1p, y1p, pcx0, pcy0, pcx1, pcy1;
- /* Convert rotation angle from degrees to radians */
- rot *= M_PI/180.0;
- /* Pre-compute rotation matrix entries */
- COS = cos(rot); SIN = sin(rot);
- /* Transform (x0, y0) and (x1, y1) into unit space */
- /* using (inverse) rotate, followed by (inverse) scale */
- x0p = (x0*COS + y0*SIN)/rh;
- y0p = (-x0*SIN + y0*COS)/rv;
- x1p = (x1*COS + y1*SIN)/rh;
- y1p = (-x1*SIN + y1*COS)/rv;
- if (!find_unit_circles(x0p, y0p, x1p, y1p,
- &pcx0, &pcy0, &pcx1, &pcy1)) {
- return VG_FALSE;
- }
- /* Transform back to original coordinate space */
- /* using (forward) scale followed by (forward) rotate */
- pcx0 *= rh; pcy0 *= rv;
- pcx1 *= rh; pcy1 *= rv;
- *cx0 = pcx0*COS - pcy0*SIN;
- *cy0 = pcx0*SIN + pcy0*COS;
- *cx1 = pcx1*COS - pcy1*SIN;
- *cy1 = pcx1*SIN + pcy1*COS;
- return VG_TRUE;
-}
-
-static INLINE VGboolean
-try_to_fix_radii(struct arc *arc)
-{
- double COS, SIN, rot, x0p, y0p, x1p, y1p;
- double dx, dy, dsq, scale;
-
- /* Convert rotation angle from degrees to radians */
- rot = DEGREES_TO_RADIANS(arc->theta);
-
- /* Pre-compute rotation matrix entries */
- COS = cos(rot); SIN = sin(rot);
-
- /* Transform (x0, y0) and (x1, y1) into unit space */
- /* using (inverse) rotate, followed by (inverse) scale */
- x0p = (arc->x1*COS + arc->y1*SIN)/arc->a;
- y0p = (-arc->x1*SIN + arc->y1*COS)/arc->b;
- x1p = (arc->x2*COS + arc->y2*SIN)/arc->a;
- y1p = (-arc->x2*SIN + arc->y2*COS)/arc->b;
- /* Compute differences and averages */
- dx = x0p - x1p;
- dy = y0p - y1p;
-
- dsq = dx*dx + dy*dy;
-#if 0
- if (dsq <= 0.001) {
- debug_printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaaaa\n");
- }
-#endif
- scale = 1/(2/sqrt(dsq));
- arc->a *= scale;
- arc->b *= scale;
- return VG_TRUE;
-}
-
-static INLINE double vector_normalize(double *v)
-{
- double sq = v[0] * v[0] + v[1] * v[1];
- return sqrt(sq);
-}
-static INLINE double vector_orientation(double *v)
-{
- double norm = vector_normalize(v);
- double cosa = v[0] / norm;
- double sina = v[1] / norm;
- return (sina>=0 ? acos(cosa) : 2*M_PI - acos(cosa));
-}
-static INLINE double vector_dot(double *v0,
- double *v1)
-{
- return v0[0] * v1[0] + v0[1] * v1[1];
-}
-
-static INLINE double vector_angles(double *v0,
- double *v1)
-{
- double dot = vector_dot(v0, v1);
- double norm0 = vector_normalize(v0);
- double norm1 = vector_normalize(v1);
-
- return acos(dot / (norm0 * norm1));
-}
-
-static VGboolean find_angles(struct arc *arc)
-{
- double vec0[2], vec1[2];
- double lambda1, lambda2;
- double angle;
- struct matrix matrix;
-
- if (floatIsZero(arc->a) || floatIsZero(arc->b)) {
- return VG_FALSE;
- }
- /* map the points to an identity circle */
- matrix_load_identity(&matrix);
- matrix_scale(&matrix, 1.f, arc->a/arc->b);
- matrix_rotate(&matrix, -arc->theta);
- matrix_map_point(&matrix,
- arc->x1, arc->y1,
- &arc->x1, &arc->y1);
- matrix_map_point(&matrix,
- arc->x2, arc->y2,
- &arc->x2, &arc->y2);
- matrix_map_point(&matrix,
- arc->cx, arc->cy,
- &arc->cx, &arc->cy);
-
-#if DEBUG_ARCS
- debug_printf("Matrix 3 [%f, %f, %f| %f, %f, %f| %f, %f, %f]\n",
- matrix.m[0], matrix.m[1], matrix.m[2],
- matrix.m[3], matrix.m[4], matrix.m[5],
- matrix.m[6], matrix.m[7], matrix.m[8]);
- debug_printf("Endpoints [%f, %f], [%f, %f]\n",
- arc->x1, arc->y1, arc->x2, arc->y2);
-#endif
-
- vec0[0] = arc->x1 - arc->cx;
- vec0[1] = arc->y1 - arc->cy;
- vec1[0] = arc->x2 - arc->cx;
- vec1[1] = arc->y2 - arc->cy;
-
-#if DEBUG_ARCS
- debug_printf("Vec is [%f, %f], [%f, %f], [%f, %f]\n",
- vec0[0], vec0[1], vec1[0], vec1[1], arc->cx, arc->cy);
-#endif
-
- lambda1 = vector_orientation(vec0);
-
- if (isnan(lambda1))
- lambda1 = 0.f;
-
- if (arc->type == VG_SCWARC_TO ||
- arc->type == VG_SCCWARC_TO)
- angle = vector_angles(vec0, vec1);
- else if (arc->type == VG_LCWARC_TO ||
- arc->type == VG_LCCWARC_TO) {
- angle = 2*M_PI - vector_angles(vec0, vec1);
- } else
- abort();
-
- if (isnan(angle))
- angle = M_PI;
-
-
- if (arc->type == VG_SCWARC_TO ||
- arc->type == VG_LCWARC_TO)
- lambda2 = lambda1 - angle;
- else
- lambda2 = lambda1 + angle;
-
-#if DEBUG_ARCS
- debug_printf("Angle is %f and (%f, %f)\n", angle, lambda1, lambda2);
-#endif
-
-#if 0
- arc->eta1 = atan2(sin(lambda1) / arc->b,
- cos(lambda1) / arc->a);
- arc->eta2 = atan2(sin(lambda2) / arc->b,
- cos(lambda2) / arc->a);
-
- /* make sure we have eta1 <= eta2 <= eta1 + 2 PI */
- arc->eta2 -= two_pi * floor((arc->eta2 - arc->eta1) / two_pi);
-
- /* the preceding correction fails if we have exactly et2 - eta1 = 2 PI
- it reduces the interval to zero length */
- if ((lambda2 - lambda1 > M_PI) && (arc->eta2 - arc->eta1 < M_PI)) {
- arc->eta2 += 2 * M_PI;
- }
-#else
- arc->eta1 = lambda1;
- arc->eta2 = lambda2;
-#endif
-
- return VG_TRUE;
-}
-
-#if DEBUG_ARCS
-static void check_endpoints(struct arc *arc)
-{
- double x1, y1, x2, y2;
-
- double a_cos_eta1 = arc->a * cos(arc->eta1);
- double b_sin_eta1 = arc->b * sin(arc->eta1);
- x1 = arc->cx + a_cos_eta1 * arc->cos_theta -
- b_sin_eta1 * arc->sin_theta;
- y1 = arc->cy + a_cos_eta1 * arc->sin_theta +
- b_sin_eta1 * arc->cos_theta;
-
- double a_cos_eta2 = arc->a * cos(arc->eta2);
- double b_sin_eta2 = arc->b * sin(arc->eta2);
- x2 = arc->cx + a_cos_eta2 * arc->cos_theta -
- b_sin_eta2 * arc->sin_theta;
- y2 = arc->cy + a_cos_eta2 * arc->sin_theta +
- b_sin_eta2 * arc->cos_theta;
-
- debug_printf("Computed (%f, %f), (%f, %f)\n",
- x1, y1, x2, y2);
- debug_printf("Real (%f, %f), (%f, %f)\n",
- arc->x1, arc->y1,
- arc->x2, arc->y2);
-}
-#endif
-
-void arc_init(struct arc *arc,
- VGPathSegment type,
- VGfloat x1, VGfloat y1,
- VGfloat x2, VGfloat y2,
- VGfloat rh, VGfloat rv,
- VGfloat rot)
-{
- assert(type == VG_SCCWARC_TO ||
- type == VG_SCWARC_TO ||
- type == VG_LCCWARC_TO ||
- type == VG_LCWARC_TO);
- arc->type = type;
- arc->x1 = x1;
- arc->y1 = y1;
- arc->x2 = x2;
- arc->y2 = y2;
- arc->a = rh;
- arc->b = rv;
- arc->theta = rot;
- arc->cos_theta = cos(arc->theta);
- arc->sin_theta = sin(arc->theta);
- {
- double cx0, cy0, cx1, cy1;
- double cx, cy;
- arc->is_valid = find_ellipses(rh, rv, rot, x1, y1, x2, y2,
- &cx0, &cy0, &cx1, &cy1);
-
- if (!arc->is_valid && try_to_fix_radii(arc)) {
- rh = arc->a;
- rv = arc->b;
- arc->is_valid =
- find_ellipses(rh, rv, rot, x1, y1, x2, y2,
- &cx0, &cy0, &cx1, &cy1);
- }
-
- if (type == VG_SCWARC_TO ||
- type == VG_LCCWARC_TO) {
- cx = cx1;
- cy = cy1;
- } else {
- cx = cx0;
- cy = cy0;
- }
-#if DEBUG_ARCS
- debug_printf("Centers are : (%f, %f) , (%f, %f). Real (%f, %f)\n",
- cx0, cy0, cx1, cy1, cx, cy);
-#endif
- arc->cx = cx;
- arc->cy = cy;
- if (arc->is_valid) {
- arc->is_valid = find_angles(arc);
-#if DEBUG_ARCS
- check_endpoints(arc);
-#endif
- /* remap a few points. find_angles requires
- * rot in angles, the rest of the code
- * will need them in radians. and find_angles
- * modifies the center to match an identity
- * circle so lets reset it */
- arc->theta = DEGREES_TO_RADIANS(rot);
- arc->cos_theta = cos(arc->theta);
- arc->sin_theta = sin(arc->theta);
- arc->cx = cx;
- arc->cy = cy;
- }
- }
-}
-
-static INLINE double rational_function(double x, const double *c)
-{
- return (x * (x * c[0] + c[1]) + c[2]) / (x + c[3]);
-}
-
-static double estimate_error(struct arc *arc,
- double etaA, double etaB)
-{
- double eta = 0.5 * (etaA + etaB);
-
- double x = arc->b / arc->a;
- double dEta = etaB - etaA;
- double cos2 = cos(2 * eta);
- double cos4 = cos(4 * eta);
- double cos6 = cos(6 * eta);
- double c0, c1;
-
- /* select the right coeficients set according to degree and b/a */
- const double (*coeffs)[4][4];
- const double *safety;
- coeffs = (x < 0.25) ? coeffs3Low : coeffs3High;
- safety = safety3;
-
- c0 = rational_function(x, coeffs[0][0])
- + cos2 * rational_function(x, coeffs[0][1])
- + cos4 * rational_function(x, coeffs[0][2])
- + cos6 * rational_function(x, coeffs[0][3]);
-
- c1 = rational_function(x, coeffs[1][0])
- + cos2 * rational_function(x, coeffs[1][1])
- + cos4 * rational_function(x, coeffs[1][2])
- + cos6 * rational_function(x, coeffs[1][3]);
-
- return rational_function(x, safety) * arc->a * exp(c0 + c1 * dEta);
-}
-
-struct arc_cb {
- void (*move)(struct arc_cb *cb, VGfloat x, VGfloat y);
- void (*point)(struct arc_cb *cb, VGfloat x, VGfloat y);
- void (*bezier)(struct arc_cb *cb, struct bezier *bezier);
-
- void *user_data;
-};
-
-static void cb_null_move(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
-}
-
-static void polygon_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct polygon *poly = (struct polygon*)cb->user_data;
- polygon_vertex_append(poly, x, y);
-}
-
-static void polygon_bezier(struct arc_cb *cb, struct bezier *bezier)
-{
- struct polygon *poly = (struct polygon*)cb->user_data;
- bezier_add_to_polygon(bezier, poly);
-}
-
-static void stroke_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_line_to(stroker, x, y);
-}
-
-static void stroke_curve(struct arc_cb *cb, struct bezier *bezier)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_curve_to(stroker,
- bezier->x2, bezier->y2,
- bezier->x3, bezier->y3,
- bezier->x4, bezier->y4);
-}
-
-static void stroke_emit_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_emit_line_to(stroker, x, y);
-}
-
-static void stroke_emit_curve(struct arc_cb *cb, struct bezier *bezier)
-{
- struct stroker *stroker = (struct stroker*)cb->user_data;
- stroker_emit_curve_to(stroker,
- bezier->x2, bezier->y2,
- bezier->x3, bezier->y3,
- bezier->x4, bezier->y4);
-}
-
-static void arc_path_move(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct path *path = (struct path*)cb->user_data;
- path_move_to(path, x, y);
-}
-
-static void arc_path_point(struct arc_cb *cb, VGfloat x, VGfloat y)
-{
- struct path *path = (struct path*)cb->user_data;
- path_line_to(path, x, y);
-}
-
-static void arc_path_bezier(struct arc_cb *cb, struct bezier *bezier)
-{
- struct path *path = (struct path*)cb->user_data;
- path_cubic_to(path,
- bezier->x2, bezier->y2,
- bezier->x3, bezier->y3,
- bezier->x4, bezier->y4);
-}
-
-static INLINE int num_beziers_needed(struct arc *arc)
-{
- double threshold = 0.05;
- VGboolean found = VG_FALSE;
- int n = 1;
- double min_eta, max_eta;
-
- min_eta = MIN2(arc->eta1, arc->eta2);
- max_eta = MAX2(arc->eta1, arc->eta2);
-
- while ((! found) && (n < 1024)) {
- double d_eta = (max_eta - min_eta) / n;
- if (d_eta <= 0.5 * M_PI) {
- double eta_b = min_eta;
- int i;
- found = VG_TRUE;
- for (i = 0; found && (i < n); ++i) {
- double etaA = eta_b;
- eta_b += d_eta;
- found = (estimate_error(arc, etaA, eta_b) <= threshold);
- }
- }
- n = n << 1;
- }
-
- return n;
-}
-
-static void arc_to_beziers(struct arc *arc,
- struct arc_cb cb,
- struct matrix *matrix)
-{
- int i;
- int n = 1;
- double d_eta, eta_b, cos_eta_b,
- sin_eta_b, a_cos_eta_b, b_sin_eta_b, a_sin_eta_b,
- b_cos_eta_b, x_b, y_b, x_b_dot, y_b_dot, lx, ly;
- double t, alpha;
-
- { /* always move to the start of the arc */
- VGfloat x = arc->x1;
- VGfloat y = arc->y1;
- matrix_map_point(matrix, x, y, &x, &y);
- cb.move(&cb, x, y);
- }
-
- if (!arc->is_valid) {
- VGfloat x = arc->x2;
- VGfloat y = arc->y2;
- matrix_map_point(matrix, x, y, &x, &y);
- cb.point(&cb, x, y);
- return;
- }
-
- /* find the number of Bézier curves needed */
- n = num_beziers_needed(arc);
-
- d_eta = (arc->eta2 - arc->eta1) / n;
- eta_b = arc->eta1;
-
- cos_eta_b = cos(eta_b);
- sin_eta_b = sin(eta_b);
- a_cos_eta_b = arc->a * cos_eta_b;
- b_sin_eta_b = arc->b * sin_eta_b;
- a_sin_eta_b = arc->a * sin_eta_b;
- b_cos_eta_b = arc->b * cos_eta_b;
- x_b = arc->cx + a_cos_eta_b * arc->cos_theta -
- b_sin_eta_b * arc->sin_theta;
- y_b = arc->cy + a_cos_eta_b * arc->sin_theta +
- b_sin_eta_b * arc->cos_theta;
- x_b_dot = -a_sin_eta_b * arc->cos_theta -
- b_cos_eta_b * arc->sin_theta;
- y_b_dot = -a_sin_eta_b * arc->sin_theta +
- b_cos_eta_b * arc->cos_theta;
-
- {
- VGfloat x = x_b, y = y_b;
- matrix_map_point(matrix, x, y, &x, &y);
- cb.point(&cb, x, y);
- }
- lx = x_b;
- ly = y_b;
-
- t = tan(0.5 * d_eta);
- alpha = sin(d_eta) * (sqrt(4 + 3 * t * t) - 1) / 3;
-
- for (i = 0; i < n; ++i) {
- struct bezier bezier;
- double xA = x_b;
- double yA = y_b;
- double xADot = x_b_dot;
- double yADot = y_b_dot;
-
- eta_b += d_eta;
- cos_eta_b = cos(eta_b);
- sin_eta_b = sin(eta_b);
- a_cos_eta_b = arc->a * cos_eta_b;
- b_sin_eta_b = arc->b * sin_eta_b;
- a_sin_eta_b = arc->a * sin_eta_b;
- b_cos_eta_b = arc->b * cos_eta_b;
- x_b = arc->cx + a_cos_eta_b * arc->cos_theta -
- b_sin_eta_b * arc->sin_theta;
- y_b = arc->cy + a_cos_eta_b * arc->sin_theta +
- b_sin_eta_b * arc->cos_theta;
- x_b_dot = -a_sin_eta_b * arc->cos_theta -
- b_cos_eta_b * arc->sin_theta;
- y_b_dot = -a_sin_eta_b * arc->sin_theta +
- b_cos_eta_b * arc->cos_theta;
-
- bezier_init(&bezier,
- lx, ly,
- (float) (xA + alpha * xADot), (float) (yA + alpha * yADot),
- (float) (x_b - alpha * x_b_dot), (float) (y_b - alpha * y_b_dot),
- (float) x_b, (float) y_b);
-#if 0
- debug_printf("%d) Bezier (%f, %f), (%f, %f), (%f, %f), (%f, %f)\n",
- i,
- bezier.x1, bezier.y1,
- bezier.x2, bezier.y2,
- bezier.x3, bezier.y3,
- bezier.x4, bezier.y4);
-#endif
- bezier_transform(&bezier, matrix);
- cb.bezier(&cb, &bezier);
- lx = x_b;
- ly = y_b;
- }
-}
-
-
-void arc_add_to_polygon(struct arc *arc,
- struct polygon *poly,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = cb_null_move;
- cb.point = polygon_point;
- cb.bezier = polygon_bezier;
- cb.user_data = poly;
-
- arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_stroke_cb(struct arc *arc,
- struct stroker *stroke,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = cb_null_move;
- cb.point = stroke_point;
- cb.bezier = stroke_curve;
- cb.user_data = stroke;
-
- arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_stroker_emit(struct arc *arc,
- struct stroker *stroker,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = cb_null_move;
- cb.point = stroke_emit_point;
- cb.bezier = stroke_emit_curve;
- cb.user_data = stroker;
-
- arc_to_beziers(arc, cb, matrix);
-}
-
-void arc_to_path(struct arc *arc,
- struct path *path,
- struct matrix *matrix)
-{
- struct arc_cb cb;
-
- cb.move = arc_path_move;
- cb.point = arc_path_point;
- cb.bezier = arc_path_bezier;
- cb.user_data = path;
-
- arc_to_beziers(arc, cb, matrix);
-}
projects / mesa.git / blobdiff