4972c18d69
TransformedCopyToBuilder is called any time in Canvas2D the transform is modified and then a path op is used. On cases that repeatedly change the transform while building paths, this leads to fairly significant expense in repeatedly copying the path contents as well as allocating and deallocating paths. To work around this, a new primitive TransformedMoveToBuilder is provided that allows in-place transforming of the path contents. Because paths that are "finished" and referenced externally can't be safely modified, extra static methods (i.e. ToBuilder) are added to guarantee that there are no other refs to the path before modifying its contents. One snag is that ArcParams could previously not handle transforms, so it is modified to allow a transform to be supplied to an Arc op, which is only flattened out when it is streamed to a sink. Differential Revision: https://phabricator.services.mozilla.com/D225548
359 lines
14 KiB
C++
359 lines
14 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef MOZILLA_GFX_PATHHELPERS_H_
|
|
#define MOZILLA_GFX_PATHHELPERS_H_
|
|
|
|
#include "2D.h"
|
|
#include "UserData.h"
|
|
|
|
#include <cmath>
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
|
|
const int32_t sPointCount[] = {1, 1, 3, 2, 0, 0};
|
|
|
|
// Kappa constant for 90-degree angle
|
|
const Float kKappaFactor = 0.55191497064665766025f;
|
|
|
|
// Calculate kappa constant for partial curve. The sign of angle in the
|
|
// tangent will actually ensure this is negative for a counter clockwise
|
|
// sweep, so changing signs later isn't needed.
|
|
inline Float ComputeKappaFactor(Float aAngle) {
|
|
return (4.0f / 3.0f) * tanf(aAngle / 4.0f);
|
|
}
|
|
|
|
/**
|
|
* Draws a partial arc <= 90 degrees given exact start and end points.
|
|
* Assumes that it is continuing from an already specified start point.
|
|
*/
|
|
template <typename T>
|
|
inline void PartialArcToBezier(T* aSink, const Point& aStartOffset,
|
|
const Point& aEndOffset,
|
|
const Matrix& aTransform,
|
|
Float aKappaFactor = kKappaFactor) {
|
|
Point cp1 =
|
|
aStartOffset + Point(-aStartOffset.y, aStartOffset.x) * aKappaFactor;
|
|
|
|
Point cp2 = aEndOffset + Point(aEndOffset.y, -aEndOffset.x) * aKappaFactor;
|
|
|
|
aSink->BezierTo(aTransform.TransformPoint(cp1),
|
|
aTransform.TransformPoint(cp2),
|
|
aTransform.TransformPoint(aEndOffset));
|
|
}
|
|
|
|
/**
|
|
* Draws an acute arc (<= 90 degrees) given exact start and end points.
|
|
* Specialized version avoiding kappa calculation.
|
|
*/
|
|
template <typename T>
|
|
inline void AcuteArcToBezier(T* aSink, const Point& aOrigin,
|
|
const Size& aRadius, const Point& aStartPoint,
|
|
const Point& aEndPoint,
|
|
Float aKappaFactor = kKappaFactor) {
|
|
aSink->LineTo(aStartPoint);
|
|
if (!aRadius.IsEmpty()) {
|
|
Float kappaX = aKappaFactor * aRadius.width / aRadius.height;
|
|
Float kappaY = aKappaFactor * aRadius.height / aRadius.width;
|
|
Point startOffset = aStartPoint - aOrigin;
|
|
Point endOffset = aEndPoint - aOrigin;
|
|
aSink->BezierTo(
|
|
aStartPoint + Point(-startOffset.y * kappaX, startOffset.x * kappaY),
|
|
aEndPoint + Point(endOffset.y * kappaX, -endOffset.x * kappaY),
|
|
aEndPoint);
|
|
} else if (aEndPoint != aStartPoint) {
|
|
aSink->LineTo(aEndPoint);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Draws an acute arc (<= 90 degrees) given exact start and end points.
|
|
*/
|
|
template <typename T>
|
|
inline void AcuteArcToBezier(T* aSink, const Point& aOrigin,
|
|
const Size& aRadius, const Point& aStartPoint,
|
|
const Point& aEndPoint, Float aStartAngle,
|
|
Float aEndAngle) {
|
|
AcuteArcToBezier(aSink, aOrigin, aRadius, aStartPoint, aEndPoint,
|
|
ComputeKappaFactor(aEndAngle - aStartAngle));
|
|
}
|
|
|
|
template <typename T>
|
|
void ArcToBezier(T* aSink, const Point& aOrigin, const Size& aRadius,
|
|
float aStartAngle, float aEndAngle, bool aAntiClockwise,
|
|
float aRotation = 0.0f, const Matrix& aTransform = Matrix()) {
|
|
Float sweepDirection = aAntiClockwise ? -1.0f : 1.0f;
|
|
|
|
// Calculate the total arc we're going to sweep.
|
|
Float arcSweepLeft = (aEndAngle - aStartAngle) * sweepDirection;
|
|
|
|
// Clockwise we always sweep from the smaller to the larger angle, ccw
|
|
// it's vice versa.
|
|
if (arcSweepLeft < 0) {
|
|
// Rerverse sweep is modulo'd into range rather than clamped.
|
|
arcSweepLeft = Float(2.0f * M_PI) + fmodf(arcSweepLeft, Float(2.0f * M_PI));
|
|
// Recalculate the start angle to land closer to end angle.
|
|
aStartAngle = aEndAngle - arcSweepLeft * sweepDirection;
|
|
} else if (arcSweepLeft > Float(2.0f * M_PI)) {
|
|
// Sweeping more than 2 * pi is a full circle.
|
|
arcSweepLeft = Float(2.0f * M_PI);
|
|
}
|
|
|
|
Float currentStartAngle = aStartAngle;
|
|
Point currentStartOffset(cosf(aStartAngle), sinf(aStartAngle));
|
|
Matrix transform = Matrix::Scaling(aRadius.width, aRadius.height);
|
|
if (aRotation != 0.0f) {
|
|
transform *= Matrix::Rotation(aRotation);
|
|
}
|
|
transform.PostTranslate(aOrigin);
|
|
transform *= aTransform;
|
|
aSink->LineTo(transform.TransformPoint(currentStartOffset));
|
|
|
|
while (arcSweepLeft > 0) {
|
|
Float currentEndAngle =
|
|
currentStartAngle +
|
|
std::min(arcSweepLeft, Float(M_PI / 2.0f)) * sweepDirection;
|
|
Point currentEndOffset(cosf(currentEndAngle), sinf(currentEndAngle));
|
|
|
|
PartialArcToBezier(aSink, currentStartOffset, currentEndOffset, transform,
|
|
ComputeKappaFactor(currentEndAngle - currentStartAngle));
|
|
|
|
// We guarantee here the current point is the start point of the next
|
|
// curve segment.
|
|
arcSweepLeft -= Float(M_PI / 2.0f);
|
|
currentStartAngle = currentEndAngle;
|
|
currentStartOffset = currentEndOffset;
|
|
}
|
|
}
|
|
|
|
/* This is basically the ArcToBezier with the parameters for drawing a circle
|
|
* inlined which vastly simplifies it and avoids a bunch of transcedental
|
|
* function calls which should make it faster. */
|
|
template <typename T>
|
|
void EllipseToBezier(T* aSink, const Point& aOrigin, const Size& aRadius) {
|
|
Matrix transform(aRadius.width, 0, 0, aRadius.height, aOrigin.x, aOrigin.y);
|
|
Point currentStartOffset(1, 0);
|
|
|
|
aSink->LineTo(transform.TransformPoint(currentStartOffset));
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
// cos(x+pi/2) == -sin(x)
|
|
// sin(x+pi/2) == cos(x)
|
|
Point currentEndOffset(-currentStartOffset.y, currentStartOffset.x);
|
|
|
|
PartialArcToBezier(aSink, currentStartOffset, currentEndOffset, transform);
|
|
|
|
// We guarantee here the current point is the start point of the next
|
|
// curve segment.
|
|
currentStartOffset = currentEndOffset;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Appends a path represending a rectangle to the path being built by
|
|
* aPathBuilder.
|
|
*
|
|
* aRect The rectangle to append.
|
|
* aDrawClockwise If set to true, the path will start at the left of the top
|
|
* left edge and draw clockwise. If set to false the path will
|
|
* start at the right of the top left edge and draw counter-
|
|
* clockwise.
|
|
*/
|
|
GFX2D_API void AppendRectToPath(PathBuilder* aPathBuilder, const Rect& aRect,
|
|
bool aDrawClockwise = true);
|
|
|
|
inline already_AddRefed<Path> MakePathForRect(const DrawTarget& aDrawTarget,
|
|
const Rect& aRect,
|
|
bool aDrawClockwise = true) {
|
|
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
|
|
AppendRectToPath(builder, aRect, aDrawClockwise);
|
|
return builder->Finish();
|
|
}
|
|
|
|
/**
|
|
* Appends a path represending a rounded rectangle to the path being built by
|
|
* aPathBuilder.
|
|
*
|
|
* aRect The rectangle to append.
|
|
* aCornerRadii Contains the radii of the top-left, top-right, bottom-right
|
|
* and bottom-left corners, in that order.
|
|
* aDrawClockwise If set to true, the path will start at the left of the top
|
|
* left edge and draw clockwise. If set to false the path will
|
|
* start at the right of the top left edge and draw counter-
|
|
* clockwise.
|
|
*/
|
|
GFX2D_API void AppendRoundedRectToPath(
|
|
PathBuilder* aPathBuilder, const Rect& aRect, const RectCornerRadii& aRadii,
|
|
bool aDrawClockwise = true, const Maybe<Matrix>& aTransform = Nothing());
|
|
|
|
inline already_AddRefed<Path> MakePathForRoundedRect(
|
|
const DrawTarget& aDrawTarget, const Rect& aRect,
|
|
const RectCornerRadii& aRadii, bool aDrawClockwise = true) {
|
|
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
|
|
AppendRoundedRectToPath(builder, aRect, aRadii, aDrawClockwise);
|
|
return builder->Finish();
|
|
}
|
|
|
|
/**
|
|
* Appends a path represending an ellipse to the path being built by
|
|
* aPathBuilder.
|
|
*
|
|
* The ellipse extends aDimensions.width / 2.0 in the horizontal direction
|
|
* from aCenter, and aDimensions.height / 2.0 in the vertical direction.
|
|
*/
|
|
GFX2D_API void AppendEllipseToPath(PathBuilder* aPathBuilder,
|
|
const Point& aCenter,
|
|
const Size& aDimensions);
|
|
|
|
inline already_AddRefed<Path> MakePathForEllipse(const DrawTarget& aDrawTarget,
|
|
const Point& aCenter,
|
|
const Size& aDimensions) {
|
|
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
|
|
AppendEllipseToPath(builder, aCenter, aDimensions);
|
|
return builder->Finish();
|
|
}
|
|
|
|
inline already_AddRefed<Path> MakePathForCircle(const DrawTarget& aDrawTarget,
|
|
const Point& aCenter,
|
|
float aRadius) {
|
|
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
|
|
builder->Arc(aCenter, aRadius, 0.0f, Float(2.0 * M_PI));
|
|
builder->Close();
|
|
return builder->Finish();
|
|
}
|
|
|
|
/**
|
|
* If aDrawTarget's transform only contains a translation, and if this line is
|
|
* a horizontal or vertical line, this function will snap the line's vertices
|
|
* to align with the device pixel grid so that stroking the line with a one
|
|
* pixel wide stroke will result in a crisp line that is not antialiased over
|
|
* two pixels across its width.
|
|
*
|
|
* @return Returns true if this function snaps aRect's vertices, else returns
|
|
* false.
|
|
*/
|
|
GFX2D_API bool SnapLineToDevicePixelsForStroking(Point& aP1, Point& aP2,
|
|
const DrawTarget& aDrawTarget,
|
|
Float aLineWidth);
|
|
|
|
/**
|
|
* This function paints each edge of aRect separately, snapping the edges using
|
|
* SnapLineToDevicePixelsForStroking. Stroking the edges as separate paths
|
|
* helps ensure not only that the stroke spans a single row of device pixels if
|
|
* possible, but also that the ends of stroke dashes start and end on device
|
|
* pixels too.
|
|
*/
|
|
GFX2D_API void StrokeSnappedEdgesOfRect(const Rect& aRect,
|
|
DrawTarget& aDrawTarget,
|
|
const ColorPattern& aColor,
|
|
const StrokeOptions& aStrokeOptions);
|
|
|
|
/**
|
|
* Return the margin, in device space, by which a stroke can extend beyond the
|
|
* rendered shape.
|
|
* @param aStrokeOptions The stroke options that the stroke is drawn with.
|
|
* @param aTransform The user space to device space transform.
|
|
* @return The stroke margin.
|
|
*/
|
|
GFX2D_API Margin MaxStrokeExtents(const StrokeOptions& aStrokeOptions,
|
|
const Matrix& aTransform);
|
|
|
|
extern UserDataKey sDisablePixelSnapping;
|
|
|
|
/**
|
|
* If aDrawTarget's transform only contains a translation or, if
|
|
* aAllowScaleOr90DegreeRotate is true, and/or a scale/90 degree rotation, this
|
|
* function will convert aRect to device space and snap it to device pixels.
|
|
* This function returns true if aRect is modified, otherwise it returns false.
|
|
*
|
|
* Note that the snapping is such that filling the rect using a DrawTarget
|
|
* which has the identity matrix as its transform will result in crisp edges.
|
|
* (That is, aRect will have integer values, aligning its edges between pixel
|
|
* boundaries.) If on the other hand you stroking the rect with an odd valued
|
|
* stroke width then the edges of the stroke will be antialiased (assuming an
|
|
* AntialiasMode that does antialiasing).
|
|
*
|
|
* Empty snaps are those which result in a rectangle of 0 area. If they are
|
|
* disallowed, an axis is left unsnapped if the rounding process results in a
|
|
* length of 0.
|
|
*/
|
|
inline bool UserToDevicePixelSnapped(Rect& aRect, const DrawTarget& aDrawTarget,
|
|
bool aAllowScaleOr90DegreeRotate = false,
|
|
bool aAllowEmptySnaps = true) {
|
|
if (aDrawTarget.GetUserData(&sDisablePixelSnapping)) {
|
|
return false;
|
|
}
|
|
|
|
Matrix mat = aDrawTarget.GetTransform();
|
|
|
|
const Float epsilon = 0.0000001f;
|
|
#define WITHIN_E(a, b) (fabs((a) - (b)) < epsilon)
|
|
if (!aAllowScaleOr90DegreeRotate &&
|
|
(!WITHIN_E(mat._11, 1.f) || !WITHIN_E(mat._22, 1.f) ||
|
|
!WITHIN_E(mat._12, 0.f) || !WITHIN_E(mat._21, 0.f))) {
|
|
// We have non-translation, but only translation is allowed.
|
|
return false;
|
|
}
|
|
#undef WITHIN_E
|
|
|
|
Point p1 = mat.TransformPoint(aRect.TopLeft());
|
|
Point p2 = mat.TransformPoint(aRect.TopRight());
|
|
Point p3 = mat.TransformPoint(aRect.BottomRight());
|
|
|
|
// Check that the rectangle is axis-aligned. For an axis-aligned rectangle,
|
|
// two opposite corners define the entire rectangle. So check if
|
|
// the axis-aligned rectangle with opposite corners p1 and p3
|
|
// define an axis-aligned rectangle whose other corners are p2 and p4.
|
|
// We actually only need to check one of p2 and p4, since an affine
|
|
// transform maps parallelograms to parallelograms.
|
|
if (p2 == Point(p1.x, p3.y) || p2 == Point(p3.x, p1.y)) {
|
|
Point p1r = p1;
|
|
Point p3r = p3;
|
|
p1r.Round();
|
|
p3r.Round();
|
|
if (aAllowEmptySnaps || p1r.x != p3r.x) {
|
|
p1.x = p1r.x;
|
|
p3.x = p3r.x;
|
|
}
|
|
if (aAllowEmptySnaps || p1r.y != p3r.y) {
|
|
p1.y = p1r.y;
|
|
p3.y = p3r.y;
|
|
}
|
|
|
|
aRect.MoveTo(Point(std::min(p1.x, p3.x), std::min(p1.y, p3.y)));
|
|
aRect.SizeTo(Size(std::max(p1.x, p3.x) - aRect.X(),
|
|
std::max(p1.y, p3.y) - aRect.Y()));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* This function has the same behavior as UserToDevicePixelSnapped except that
|
|
* aRect is not transformed to device space.
|
|
*/
|
|
inline bool MaybeSnapToDevicePixels(Rect& aRect, const DrawTarget& aDrawTarget,
|
|
bool aAllowScaleOr90DegreeRotate = false,
|
|
bool aAllowEmptySnaps = true) {
|
|
if (UserToDevicePixelSnapped(aRect, aDrawTarget, aAllowScaleOr90DegreeRotate,
|
|
aAllowEmptySnaps)) {
|
|
// Since UserToDevicePixelSnapped returned true we know there is no
|
|
// rotation/skew in 'mat', so we can just use TransformBounds() here.
|
|
Matrix mat = aDrawTarget.GetTransform();
|
|
mat.Invert();
|
|
aRect = mat.TransformBounds(aRect);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|
|
|
|
#endif /* MOZILLA_GFX_PATHHELPERS_H_ */
|