From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- gfx/2d/PathHelpers.cpp | 290 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 290 insertions(+) create mode 100644 gfx/2d/PathHelpers.cpp (limited to 'gfx/2d/PathHelpers.cpp') diff --git a/gfx/2d/PathHelpers.cpp b/gfx/2d/PathHelpers.cpp new file mode 100644 index 0000000000..66fce104b3 --- /dev/null +++ b/gfx/2d/PathHelpers.cpp @@ -0,0 +1,290 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "PathHelpers.h" + +namespace mozilla { +namespace gfx { + +UserDataKey sDisablePixelSnapping; + +void AppendRectToPath(PathBuilder* aPathBuilder, const Rect& aRect, + bool aDrawClockwise) { + if (aDrawClockwise) { + aPathBuilder->MoveTo(aRect.TopLeft()); + aPathBuilder->LineTo(aRect.TopRight()); + aPathBuilder->LineTo(aRect.BottomRight()); + aPathBuilder->LineTo(aRect.BottomLeft()); + } else { + aPathBuilder->MoveTo(aRect.TopRight()); + aPathBuilder->LineTo(aRect.TopLeft()); + aPathBuilder->LineTo(aRect.BottomLeft()); + aPathBuilder->LineTo(aRect.BottomRight()); + } + aPathBuilder->Close(); +} + +void AppendRoundedRectToPath(PathBuilder* aPathBuilder, const Rect& aRect, + const RectCornerRadii& aRadii, bool aDrawClockwise, + const Maybe& aTransform) { + // For CW drawing, this looks like: + // + // ...******0** 1 C + // **** + // *** 2 + // ** + // * + // * + // 3 + // * + // * + // + // Where 0, 1, 2, 3 are the control points of the Bezier curve for + // the corner, and C is the actual corner point. + // + // At the start of the loop, the current point is assumed to be + // the point adjacent to the top left corner on the top + // horizontal. Note that corner indices start at the top left and + // continue clockwise, whereas in our loop i = 0 refers to the top + // right corner. + // + // When going CCW, the control points are swapped, and the first + // corner that's drawn is the top left (along with the top segment). + // + // There is considerable latitude in how one chooses the four + // control points for a Bezier curve approximation to an ellipse. + // For the overall path to be continuous and show no corner at the + // endpoints of the arc, points 0 and 3 must be at the ends of the + // straight segments of the rectangle; points 0, 1, and C must be + // collinear; and points 3, 2, and C must also be collinear. This + // leaves only two free parameters: the ratio of the line segments + // 01 and 0C, and the ratio of the line segments 32 and 3C. See + // the following papers for extensive discussion of how to choose + // these ratios: + // + // Dokken, Tor, et al. "Good approximation of circles by + // curvature-continuous Bezier curves." Computer-Aided + // Geometric Design 7(1990) 33--41. + // Goldapp, Michael. "Approximation of circular arcs by cubic + // polynomials." Computer-Aided Geometric Design 8(1991) 227--238. + // Maisonobe, Luc. "Drawing an elliptical arc using polylines, + // quadratic, or cubic Bezier curves." + // http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf + // + // We follow the approach in section 2 of Goldapp (least-error, + // Hermite-type approximation) and make both ratios equal to + // + // 2 2 + n - sqrt(2n + 28) + // alpha = - * --------------------- + // 3 n - 4 + // + // where n = 3( cbrt(sqrt(2)+1) - cbrt(sqrt(2)-1) ). + // + // This is the result of Goldapp's equation (10b) when the angle + // swept out by the arc is pi/2, and the parameter "a-bar" is the + // expression given immediately below equation (21). + // + // Using this value, the maximum radial error for a circle, as a + // fraction of the radius, is on the order of 0.2 x 10^-3. + // Neither Dokken nor Goldapp discusses error for a general + // ellipse; Maisonobe does, but his choice of control points + // follows different constraints, and Goldapp's expression for + // 'alpha' gives much smaller radial error, even for very flat + // ellipses, than Maisonobe's equivalent. + // + // For the various corners and for each axis, the sign of this + // constant changes, or it might be 0 -- it's multiplied by the + // appropriate multiplier from the list before using. + + const Float alpha = Float(0.55191497064665766025); + + typedef struct { + Float a, b; + } twoFloats; + + twoFloats cwCornerMults[4] = {{-1, 0}, // cc == clockwise + {0, -1}, + {+1, 0}, + {0, +1}}; + twoFloats ccwCornerMults[4] = {{+1, 0}, // ccw == counter-clockwise + {0, -1}, + {-1, 0}, + {0, +1}}; + + twoFloats* cornerMults = aDrawClockwise ? cwCornerMults : ccwCornerMults; + + Point cornerCoords[] = {aRect.TopLeft(), aRect.TopRight(), + aRect.BottomRight(), aRect.BottomLeft()}; + + Point pc, p0, p1, p2, p3; + + if (aDrawClockwise) { + Point pt(aRect.X() + aRadii[eCornerTopLeft].width, aRect.Y()); + if (aTransform) { + pt = aTransform->TransformPoint(pt); + } + aPathBuilder->MoveTo(pt); + } else { + Point pt(aRect.X() + aRect.Width() - aRadii[eCornerTopRight].width, + aRect.Y()); + if (aTransform) { + pt = aTransform->TransformPoint(pt); + } + aPathBuilder->MoveTo(pt); + } + + for (int i = 0; i < 4; ++i) { + // the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw) + int c = aDrawClockwise ? ((i + 1) % 4) : ((4 - i) % 4); + + // i+2 and i+3 respectively. These are used to index into the corner + // multiplier table, and were deduced by calculating out the long form + // of each corner and finding a pattern in the signs and values. + int i2 = (i + 2) % 4; + int i3 = (i + 3) % 4; + + pc = cornerCoords[c]; + + if (aRadii[c].width > 0.0 && aRadii[c].height > 0.0) { + p0.x = pc.x + cornerMults[i].a * aRadii[c].width; + p0.y = pc.y + cornerMults[i].b * aRadii[c].height; + + p3.x = pc.x + cornerMults[i3].a * aRadii[c].width; + p3.y = pc.y + cornerMults[i3].b * aRadii[c].height; + + p1.x = p0.x + alpha * cornerMults[i2].a * aRadii[c].width; + p1.y = p0.y + alpha * cornerMults[i2].b * aRadii[c].height; + + p2.x = p3.x - alpha * cornerMults[i3].a * aRadii[c].width; + p2.y = p3.y - alpha * cornerMults[i3].b * aRadii[c].height; + + if (aTransform.isNothing()) { + aPathBuilder->LineTo(p0); + aPathBuilder->BezierTo(p1, p2, p3); + } else { + const Matrix& transform = *aTransform; + aPathBuilder->LineTo(transform.TransformPoint(p0)); + aPathBuilder->BezierTo(transform.TransformPoint(p1), + transform.TransformPoint(p2), + transform.TransformPoint(p3)); + } + } else { + if (aTransform.isNothing()) { + aPathBuilder->LineTo(pc); + } else { + aPathBuilder->LineTo(aTransform->TransformPoint(pc)); + } + } + } + + aPathBuilder->Close(); +} + +void AppendEllipseToPath(PathBuilder* aPathBuilder, const Point& aCenter, + const Size& aDimensions) { + Size halfDim = aDimensions / 2.f; + Rect rect(aCenter - Point(halfDim.width, halfDim.height), aDimensions); + RectCornerRadii radii(halfDim.width, halfDim.height); + + AppendRoundedRectToPath(aPathBuilder, rect, radii); +} + +bool SnapLineToDevicePixelsForStroking(Point& aP1, Point& aP2, + const DrawTarget& aDrawTarget, + Float aLineWidth) { + Matrix mat = aDrawTarget.GetTransform(); + if (mat.HasNonTranslation()) { + return false; + } + if (aP1.x != aP2.x && aP1.y != aP2.y) { + return false; // not a horizontal or vertical line + } + Point p1 = aP1 + mat.GetTranslation(); // into device space + Point p2 = aP2 + mat.GetTranslation(); + p1.Round(); + p2.Round(); + p1 -= mat.GetTranslation(); // back into user space + p2 -= mat.GetTranslation(); + + aP1 = p1; + aP2 = p2; + + bool lineWidthIsOdd = (int(aLineWidth) % 2) == 1; + if (lineWidthIsOdd) { + if (aP1.x == aP2.x) { + // snap vertical line, adding 0.5 to align it to be mid-pixel: + aP1 += Point(0.5, 0); + aP2 += Point(0.5, 0); + } else { + // snap horizontal line, adding 0.5 to align it to be mid-pixel: + aP1 += Point(0, 0.5); + aP2 += Point(0, 0.5); + } + } + return true; +} + +void StrokeSnappedEdgesOfRect(const Rect& aRect, DrawTarget& aDrawTarget, + const ColorPattern& aColor, + const StrokeOptions& aStrokeOptions) { + if (aRect.IsEmpty()) { + return; + } + + Point p1 = aRect.TopLeft(); + Point p2 = aRect.BottomLeft(); + SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget, + aStrokeOptions.mLineWidth); + aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions); + + p1 = aRect.BottomLeft(); + p2 = aRect.BottomRight(); + SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget, + aStrokeOptions.mLineWidth); + aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions); + + p1 = aRect.TopLeft(); + p2 = aRect.TopRight(); + SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget, + aStrokeOptions.mLineWidth); + aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions); + + p1 = aRect.TopRight(); + p2 = aRect.BottomRight(); + SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget, + aStrokeOptions.mLineWidth); + aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions); +} + +// The logic for this comes from _cairo_stroke_style_max_distance_from_path +Margin MaxStrokeExtents(const StrokeOptions& aStrokeOptions, + const Matrix& aTransform) { + double styleExpansionFactor = 0.5f; + + if (aStrokeOptions.mLineCap == CapStyle::SQUARE) { + styleExpansionFactor = M_SQRT1_2; + } + + if (aStrokeOptions.mLineJoin == JoinStyle::MITER && + styleExpansionFactor < M_SQRT2 * aStrokeOptions.mMiterLimit) { + styleExpansionFactor = M_SQRT2 * aStrokeOptions.mMiterLimit; + } + + styleExpansionFactor *= aStrokeOptions.mLineWidth; + + double dx = styleExpansionFactor * hypot(aTransform._11, aTransform._21); + double dy = styleExpansionFactor * hypot(aTransform._22, aTransform._12); + + // Even if the stroke only partially covers a pixel, it must still render to + // full pixels. Round up to compensate for this. + dx = ceil(dx); + dy = ceil(dy); + + return Margin(dy, dx, dy, dx); +} + +} // namespace gfx +} // namespace mozilla -- cgit v1.2.3