'<(skia_src_path)/gpu/GrStencil.h',
'<(skia_src_path)/gpu/GrStencilAttachment.cpp',
'<(skia_src_path)/gpu/GrStencilAttachment.h',
- '<(skia_src_path)/gpu/GrStrokeInfo.cpp',
- '<(skia_src_path)/gpu/GrStrokeInfo.h',
'<(skia_src_path)/gpu/GrStyle.cpp',
'<(skia_src_path)/gpu/GrStyle.h',
'<(skia_src_path)/gpu/GrTessellator.cpp',
class GrTextContext;
class GrTextureParams;
class GrVertexBuffer;
-class GrStrokeInfo;
class GrSwizzle;
class SkTraceMemoryDump;
class GrPathProcessor;
class GrPipelineBuilder;
class GrRenderTarget;
-class GrStrokeInfo;
+class GrStyle;
class GrSurface;
class SkDrawFilter;
struct SkIPoint;
// TODO: it is odd that we need both the SkPaint in the following 3 methods.
// We should extract the text parameters from SkPaint and pass them separately
- // akin to GrStrokeInfo (GrTextInfo?)
+ // akin to GrStyle (GrTextInfo?)
virtual void drawText(const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix, const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkIRect& clipBounds);
* Draw the rect using a paint.
* @param paint describes how to color pixels.
* @param viewMatrix transformation matrix
- * @param strokeInfo the stroke information (width, join, cap), and.
- * the dash information (intervals, count, phase).
- * If strokeInfo == NULL, then the rect is filled.
- * Otherwise, if stroke width == 0, then the stroke
- * is always a single pixel thick, else the rect is
- * mitered/beveled stroked based on stroke width.
+ * @param style The style to apply. Null means fill. Currently path effects are not
+ * allowed.
* The rects coords are used to access the paint (through texture matrix)
*/
void drawRect(const GrClip&,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect&,
- const GrStrokeInfo* strokeInfo = nullptr);
+ const GrStyle* style = nullptr);
/**
* Maps a rectangle of shader coordinates to a rectangle and fills that rectangle.
* @param paint describes how to color pixels.
* @param viewMatrix transformation matrix
* @param rrect the roundrect to draw
- * @param strokeInfo the stroke information (width, join, cap) and
- * the dash information (intervals, count, phase).
+ * @param style style to apply to the rrect. Currently path effects are not allowed.
*/
void drawRRect(const GrClip&,
const GrPaint&,
const SkMatrix& viewMatrix,
const SkRRect& rrect,
- const GrStrokeInfo&);
+ const GrStyle& style);
/**
* Shortcut for drawing an SkPath consisting of nested rrects using a paint.
* @param paint describes how to color pixels.
* @param viewMatrix transformation matrix
* @param path the path to draw
- * @param strokeInfo the stroke information (width, join, cap) and
- * the dash information (intervals, count, phase).
+ * @param style style to apply to the path.
*/
void drawPath(const GrClip&,
const GrPaint&,
const SkMatrix& viewMatrix,
const SkPath&,
- const GrStrokeInfo&);
+ const GrStyle& style);
/**
* Draws vertices with a paint.
* @param paint describes how to color pixels.
* @param viewMatrix transformation matrix
* @param oval the bounding rect of the oval.
- * @param strokeInfo the stroke information (width, join, cap) and
- * the dash information (intervals, count, phase).
+ * @param style style to apply to the oval. Currently path effects are not allowed.
*/
void drawOval(const GrClip&,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& oval,
- const GrStrokeInfo& strokeInfo);
+ const GrStyle& style);
/**
* Draw the image stretched differentially to fit into dst.
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkPath& path,
- const GrStrokeInfo& strokeInfo);
+ const GrStyle& style);
// This entry point allows the GrTextContext-derived classes to add their batches to
// the drawTarget.
#ifdef GR_TEST_UTILS
#include "GrColor.h"
+#include "SkPathEffect.h"
#include "SkRandom.h"
#include "SkStrokeRec.h"
+#include "../private/SkTemplates.h"
-class GrStrokeInfo;
+class GrStyle;
class SkMatrix;
class SkPath;
class SkRRect;
namespace GrTest {
/**
- * A helper for use in Test functions.
+ * Helpers for use in Test functions.
*/
const SkMatrix& TestMatrix(SkRandom*);
const SkMatrix& TestMatrixPreservesRightAngles(SkRandom*);
const SkPath& TestPath(SkRandom*);
const SkPath& TestPathConvex(SkRandom*);
SkStrokeRec TestStrokeRec(SkRandom*);
-GrStrokeInfo TestStrokeInfo(SkRandom*);
+/** Creates styles with dash path effects and null path effects */
+void TestStyle(SkRandom*, GrStyle*);
-}
+// We have a simplified dash path effect here to avoid relying on SkDashPathEffect which
+// is in the optional build target effects.
+class TestDashPathEffect : public SkPathEffect {
+public:
+ static sk_sp<SkPathEffect> Make(const SkScalar* intervals, int count, SkScalar phase) {
+ return sk_sp<SkPathEffect>(new TestDashPathEffect(intervals, count, phase));
+ }
+
+ bool filterPath(SkPath* dst, const SkPath&, SkStrokeRec* , const SkRect*) const override;
+ DashType asADash(DashInfo* info) const override;
+ Factory getFactory() const override { return nullptr; }
+ void toString(SkString*) const override {}
+
+private:
+ TestDashPathEffect(const SkScalar* intervals, int count, SkScalar phase);
+
+ int fCount;
+ SkAutoTArray<SkScalar> fIntervals;
+ SkScalar fPhase;
+ SkScalar fInitialDashLength;
+ int fInitialDashIndex;
+ SkScalar fIntervalLength;
+};
+
+} // namespace GrTest
static inline GrColor GrRandomColor(SkRandom* random) {
// There are only a few cases of random colors which interest us
#include "GrCaps.h"
#include "GrContext.h"
#include "effects/GrSimpleTextureEffect.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "GrTexture.h"
#include "GrTextureProvider.h"
#include "SkDraw.h"
const SkMaskFilter* filter,
const SkIRect& clipBounds,
GrPaint* grp,
- SkStrokeRec::InitStyle style) {
+ SkStrokeRec::InitStyle fillOrHairline) {
SkMask srcM, dstM;
-
if (!SkDraw::DrawToMask(devPath, &clipBounds, filter, &viewMatrix, &srcM,
- SkMask::kComputeBoundsAndRenderImage_CreateMode, style)) {
+ SkMask::kComputeBoundsAndRenderImage_CreateMode, fillOrHairline)) {
return false;
}
SkAutoMaskFreeImage autoSrc(srcM.fImage);
static sk_sp<GrTexture> create_mask_GPU(GrContext* context,
SkRect* maskRect,
const SkPath& devPath,
- SkStrokeRec::InitStyle style,
+ SkStrokeRec::InitStyle fillOrHairline,
bool doAA,
int sampleCnt) {
// This mask will ultimately be drawn as a non-AA rect (see draw_mask).
// the origin using tempPaint.
SkMatrix translate;
translate.setTranslate(-maskRect->fLeft, -maskRect->fTop);
- drawContext->drawPath(clip, tempPaint, translate, devPath, GrStrokeInfo(style));
+ drawContext->drawPath(clip, tempPaint, translate, devPath, GrStyle(fillOrHairline));
return drawContext->asTexture();;
}
GrPaint* paint,
const SkMatrix& viewMatrix,
const SkMaskFilter* maskFilter,
- const SkPathEffect* pathEffect,
- const GrStrokeInfo& strokeInfo,
- SkPath* pathPtr,
+ const GrStyle& style,
+ const SkPath* path,
bool pathIsMutable) {
SkASSERT(maskFilter);
SkIRect clipBounds;
clip.getConservativeBounds(drawContext->width(), drawContext->height(), &clipBounds);
SkTLazy<SkPath> tmpPath;
+ SkStrokeRec::InitStyle fillOrHairline;
- static const SkRect* cullRect = nullptr; // TODO: what is our bounds?
-
- SkASSERT(strokeInfo.isDashed() || !pathEffect);
- SkStrokeRec::InitStyle maskStyle;
- if (strokeInfo.isHairlineStyle()) {
- maskStyle = SkStrokeRec::kHairline_InitStyle;
- } else {
- SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
- SkStrokeRec rec = strokeInfo;
- if (strokeInfo.isDashed()) {
- if (pathEffect->filterPath(strokedPath, *pathPtr, &rec, cullRect)) {
- pathPtr = strokedPath;
- pathPtr->setIsVolatile(true);
- pathIsMutable = true;
- }
- }
- if (rec.applyToPath(strokedPath, *pathPtr)) {
- // Apply the stroke to the path if there is one
- pathPtr = strokedPath;
- pathPtr->setIsVolatile(true);
- pathIsMutable = true;
+ // We just fully apply the style here.
+ if (style.applies()) {
+ if (!style.applyToPath(tmpPath.init(), &fillOrHairline, *path,
+ GrStyle::MatrixToScaleFactor(viewMatrix))) {
+ return;
}
- maskStyle = SkStrokeRec::kFill_InitStyle;
- }
-
- // avoid possibly allocating a new path in transform if we can
- SkPath* devPathPtr = pathIsMutable ? pathPtr : tmpPath.init();
- if (!pathIsMutable) {
- devPathPtr->setIsVolatile(true);
+ pathIsMutable = true;
+ path = tmpPath.get();
+ } else if (style.isSimpleHairline()) {
+ fillOrHairline = SkStrokeRec::kHairline_InitStyle;
+ } else {
+ SkASSERT(style.isSimpleFill());
+ fillOrHairline = SkStrokeRec::kFill_InitStyle;
}
// transform the path into device space
- pathPtr->transform(viewMatrix, devPathPtr);
+ if (!viewMatrix.isIdentity()) {
+ SkPath* result;
+ if (pathIsMutable) {
+ result = const_cast<SkPath*>(path);
+ } else {
+ if (!tmpPath.isValid()) {
+ tmpPath.init();
+ }
+ result = tmpPath.get();
+ }
+ path->transform(viewMatrix, result);
+ path = result;
+ result->setIsVolatile(true);
+ pathIsMutable = true;
+ }
SkRect maskRect;
- if (maskFilter->canFilterMaskGPU(SkRRect::MakeRect(devPathPtr->getBounds()),
+ if (maskFilter->canFilterMaskGPU(SkRRect::MakeRect(path->getBounds()),
clipBounds,
viewMatrix,
&maskRect)) {
paint,
clip,
viewMatrix,
- SkStrokeRec(maskStyle),
- *devPathPtr)) {
+ SkStrokeRec(fillOrHairline),
+ *path)) {
// the mask filter was able to draw itself directly, so there's nothing
// left to do.
return;
sk_sp<GrTexture> mask(create_mask_GPU(context,
&maskRect,
- *devPathPtr,
- maskStyle,
+ *path,
+ fillOrHairline,
paint->isAntiAlias(),
drawContext->numColorSamples()));
if (mask) {
}
sw_draw_with_mask_filter(drawContext, context->textureProvider(),
- clip, viewMatrix, *devPathPtr,
- maskFilter, clipBounds, paint, maskStyle);
+ clip, viewMatrix, *path,
+ maskFilter, clipBounds, paint, fillOrHairline);
}
void GrBlurUtils::drawPathWithMaskFilter(GrContext* context,
GrDrawContext* drawContext,
const GrClip& clip,
- const SkPath& origPath,
+ const SkPath& path,
GrPaint* paint,
const SkMatrix& viewMatrix,
const SkMaskFilter* mf,
- const SkPathEffect* pathEffect,
- const GrStrokeInfo& origStrokeInfo,
+ const GrStyle& style,
bool pathIsMutable) {
- SkPath* pathPtr = const_cast<SkPath*>(&origPath);
-
- SkTLazy<SkPath> tmpPath;
- GrStrokeInfo strokeInfo(origStrokeInfo);
-
- if (!strokeInfo.isDashed() && pathEffect && pathEffect->filterPath(tmpPath.init(), *pathPtr,
- &strokeInfo, nullptr)) {
- pathPtr = tmpPath.get();
- pathPtr->setIsVolatile(true);
- pathIsMutable = true;
- pathEffect = nullptr;
- }
-
- draw_path_with_mask_filter(context, drawContext, clip, paint, viewMatrix, mf, pathEffect,
- strokeInfo, pathPtr, pathIsMutable);
+ draw_path_with_mask_filter(context, drawContext, clip, paint, viewMatrix, mf,
+ style, &path, pathIsMutable);
}
void GrBlurUtils::drawPathWithMaskFilter(GrContext* context,
GrDrawContext* drawContext,
const GrClip& clip,
- const SkPath& origSrcPath,
+ const SkPath& origPath,
const SkPaint& paint,
const SkMatrix& origViewMatrix,
const SkMatrix* prePathMatrix,
const SkIRect& clipBounds,
bool pathIsMutable) {
- SkASSERT(!pathIsMutable || origSrcPath.isVolatile());
-
- GrStrokeInfo strokeInfo(paint);
- // comment out the line below to determine if it is the reason that the chrome mac perf bot
- // has begun crashing
- // strokeInfo.setResScale(SkDraw::ComputeResScaleForStroking(origViewMatrix));
+ SkASSERT(!pathIsMutable || origPath.isVolatile());
+ GrStyle style(paint);
// If we have a prematrix, apply it to the path, optimizing for the case
// where the original path can in fact be modified in place (even though
// its parameter type is const).
- SkPath* pathPtr = const_cast<SkPath*>(&origSrcPath);
+
+ const SkPath* path = &origPath;
SkTLazy<SkPath> tmpPath;
- SkTLazy<SkPath> effectPath;
- SkPathEffect* pathEffect = paint.getPathEffect();
SkMatrix viewMatrix = origViewMatrix;
if (prePathMatrix) {
- // stroking, path effects, and blurs are supposed to be applied *after* the prePathMatrix.
- // The pre-path-matrix also should not affect shading.
- if (!paint.getMaskFilter() && !pathEffect && !paint.getShader() &&
- (strokeInfo.isFillStyle() || strokeInfo.isHairlineStyle())) {
+ // Styling, blurs, and shading are supposed to be applied *after* the prePathMatrix.
+ if (!paint.getMaskFilter() && !paint.getShader() && !style.applies()) {
viewMatrix.preConcat(*prePathMatrix);
} else {
- SkPath* result = pathPtr;
-
- if (!pathIsMutable) {
- result = tmpPath.init();
- result->setIsVolatile(true);
- pathIsMutable = true;
- }
- // should I push prePathMatrix on our MV stack temporarily, instead
- // of applying it here? See SkDraw.cpp
- pathPtr->transform(*prePathMatrix, result);
- pathPtr = result;
+ SkPath* result = pathIsMutable ? const_cast<SkPath*>(path) : tmpPath.init();
+ pathIsMutable = true;
+ path->transform(*prePathMatrix, result);
+ path = result;
+ result->setIsVolatile(true);
}
}
// at this point we're done with prePathMatrix
SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
- SkTLazy<SkPath> tmpPath2;
-
- if (!strokeInfo.isDashed() && pathEffect &&
- pathEffect->filterPath(tmpPath2.init(), *pathPtr, &strokeInfo, nullptr)) {
- pathPtr = tmpPath2.get();
- pathPtr->setIsVolatile(true);
- pathIsMutable = true;
- pathEffect = nullptr;
- }
-
GrPaint grPaint;
if (!SkPaintToGrPaint(context, paint, viewMatrix, drawContext->isGammaCorrect(),
&grPaint)) {
if (paint.getMaskFilter()) {
draw_path_with_mask_filter(context, drawContext, clip, &grPaint, viewMatrix,
- paint.getMaskFilter(), pathEffect, strokeInfo,
- pathPtr, pathIsMutable);
+ paint.getMaskFilter(), style,
+ path, pathIsMutable);
} else {
- drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
+ drawContext->drawPath(clip, grPaint, viewMatrix, *path, style);
}
}
class GrDrawContext;
class GrPaint;
class GrRenderTarget;
-class GrStrokeInfo;
+class GrStyle;
struct SkIRect;
class SkMaskFilter;
class SkMatrix;
GrPaint*,
const SkMatrix& viewMatrix,
const SkMaskFilter*,
- const SkPathEffect*,
- const GrStrokeInfo&,
+ const GrStyle&,
bool pathIsMutable);
};
if (path.isInverseFillType()) {
path.toggleInverseFillType();
}
- GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
GrPathRendererChain::DrawType type;
canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
canDrawArgs.fViewMatrix = &viewMatrix;
canDrawArgs.fPath = &path;
- canDrawArgs.fStroke = &stroke;
+ canDrawArgs.fStyle = &GrStyle::SimpleFill();
canDrawArgs.fAntiAlias = element->isAA();
canDrawArgs.fIsStencilDisabled = isStencilDisabled;
canDrawArgs.fIsStencilBufferMSAA = rt->isStencilBufferMultisampled();
path.toggleInverseFillType();
}
- dc->drawPath(clip, paint, viewMatrix, path, GrStrokeInfo::FillInfo());
+ dc->drawPath(clip, paint, viewMatrix, path, GrStyle::SimpleFill());
break;
}
}
// stencil with arbitrary stencil settings.
GrPathRenderer::StencilSupport stencilSupport;
- GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
SkRegion::Op op = element->getOp();
GrPathRenderer* pr = nullptr;
canDrawArgs.fShaderCaps = this->getContext()->caps()->shaderCaps();
canDrawArgs.fViewMatrix = &viewMatrix;
canDrawArgs.fPath = &clipPath;
- canDrawArgs.fStroke = &stroke;
+ canDrawArgs.fStyle = &GrStyle::SimpleFill();
canDrawArgs.fAntiAlias = false;
canDrawArgs.fIsStencilDisabled = pipelineBuilder.getStencil().isDisabled();
canDrawArgs.fIsStencilBufferMSAA = rt->isStencilBufferMultisampled();
args.fColor = GrColor_WHITE;
args.fViewMatrix = &viewMatrix;
args.fPath = &clipPath;
- args.fStroke = &stroke;
+ args.fStyle = &GrStyle::SimpleFill();
args.fAntiAlias = false;
args.fGammaCorrect = false;
pr->drawPath(args);
args.fColor = GrColor_WHITE;
args.fViewMatrix = &viewMatrix;
args.fPath = &clipPath;
- args.fStroke = &stroke;
+ args.fStyle = &GrStyle::SimpleFill();
args.fAntiAlias = false;
args.fGammaCorrect = false;
pr->drawPath(args);
helper.init(maskSpaceIBounds, &translate, false);
helper.clear(GrReducedClip::kAllIn_InitialState == initialState ? 0xFF : 0x00);
- SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
for (GrReducedClip::ElementList::Iter iter(elements.headIter()) ; iter.get(); iter.next()) {
const Element* element = iter.get();
SkPath clipPath;
element->asPath(&clipPath);
clipPath.toggleInverseFillType();
- helper.draw(clipPath, stroke, SkRegion::kReplace_Op, element->isAA(), 0x00);
+ helper.draw(clipPath, GrStyle::SimpleFill(), SkRegion::kReplace_Op, element->isAA(),
+ 0x00);
continue;
}
} else {
SkPath path;
element->asPath(&path);
- helper.draw(path, stroke, op, element->isAA(), 0xFF);
+ helper.draw(path, GrStyle::SimpleFill(), op, element->isAA(), 0xFF);
}
}
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
- const GrStrokeInfo* strokeInfo) {
+ const GrStyle* style) {
+ if (!style) {
+ style = &GrStyle::SimpleFill();
+ }
ASSERT_SINGLE_OWNER
RETURN_IF_ABANDONED
SkDEBUGCODE(this->validate();)
GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawRect");
- // Dashing should've been devolved to a path in SkGpuDevice
- SkASSERT(!strokeInfo || !strokeInfo->isDashed());
+ // Path effects should've been devolved to a path in SkGpuDevice
+ SkASSERT(!style->pathEffect());
AutoCheckFlush acf(fDrawingManager);
- SkScalar width = !strokeInfo ? -1 : strokeInfo->getWidth();
+ const SkStrokeRec& stroke = style->strokeRec();
+ SkScalar width = stroke.getWidth();
// Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
// cases where the RT is fully inside a stroke.
// The stroke path needs the rect to remain axis aligned (no rotation or skew).
if (viewMatrix.rectStaysRect()) {
batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect,
- *strokeInfo));
+ stroke));
}
} else {
// Non-AA hairlines are snapped to pixel centers to make which pixels are hit
SkPath path;
path.setIsVolatile(true);
path.addRect(rect);
- this->internalDrawPath(clip, paint, viewMatrix, path,
- strokeInfo ? *strokeInfo : GrStrokeInfo::FillInfo());
+ this->internalDrawPath(clip, paint, viewMatrix, path, *style);
}
bool GrDrawContextPriv::drawAndStencilRect(const SkIRect* scissorRect,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRRect& rrect,
- const GrStrokeInfo& strokeInfo) {
+ const GrStyle& style) {
ASSERT_SINGLE_OWNER
RETURN_IF_ABANDONED
SkDEBUGCODE(this->validate();)
return;
}
- SkASSERT(!strokeInfo.isDashed()); // this should've been devolved to a path in SkGpuDevice
-
+ SkASSERT(!style.pathEffect()); // this should've been devolved to a path in SkGpuDevice
+ const SkStrokeRec stroke = style.strokeRec();
AutoCheckFlush acf(fDrawingManager);
if (should_apply_coverage_aa(paint, fRenderTarget.get())) {
SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(paint.getColor(),
viewMatrix,
rrect,
- strokeInfo,
+ stroke,
shaderCaps));
if (batch) {
GrPipelineBuilder pipelineBuilder(paint, fRenderTarget.get(), clip);
SkPath path;
path.setIsVolatile(true);
path.addRRect(rrect);
- this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
+ this->internalDrawPath(clip, paint, viewMatrix, path, style);
}
bool GrDrawContext::drawFilledDRRect(const GrClip& clip,
path.setFillType(SkPath::kEvenOdd_FillType);
GrPipelineBuilder pipelineBuilder(paint, fRenderTarget.get(), clip);
- this->internalDrawPath(clip, paint, viewMatrix, path, GrStrokeInfo::FillInfo());
+ this->internalDrawPath(clip, paint, viewMatrix, path, GrStyle::SimpleFill());
}
///////////////////////////////////////////////////////////////////////////////
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& oval,
- const GrStrokeInfo& strokeInfo) {
+ const GrStyle& style) {
ASSERT_SINGLE_OWNER
RETURN_IF_ABANDONED
SkDEBUGCODE(this->validate();)
return;
}
- SkASSERT(!strokeInfo.isDashed()); // this should've been devolved to a path in SkGpuDevice
+ SkASSERT(!style.pathEffect()); // this should've been devolved to a path in SkGpuDevice
AutoCheckFlush acf(fDrawingManager);
-
+ const SkStrokeRec& stroke = style.strokeRec();
if (should_apply_coverage_aa(paint, fRenderTarget.get())) {
GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(paint.getColor(),
viewMatrix,
oval,
- strokeInfo,
+ stroke,
shaderCaps));
if (batch) {
GrPipelineBuilder pipelineBuilder(paint, fRenderTarget.get(), clip);
SkPath path;
path.setIsVolatile(true);
path.addOval(oval);
- this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
+ this->internalDrawPath(clip, paint, viewMatrix, path, style);
}
void GrDrawContext::drawImageNine(const GrClip& clip,
// Can 'path' be drawn as a pair of filled nested rectangles?
-static bool is_nested_rects(const SkMatrix& viewMatrix,
- const SkPath& path,
- const SkStrokeRec& stroke,
- SkRect rects[2]) {
- SkASSERT(stroke.isFillStyle());
+static bool fills_as_nested_rects(const SkMatrix& viewMatrix, const SkPath& path, SkRect rects[2]) {
if (path.isInverseFillType()) {
return false;
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkPath& path,
- const GrStrokeInfo& strokeInfo) {
+ const GrStyle& style) {
ASSERT_SINGLE_OWNER
RETURN_IF_ABANDONED
SkDEBUGCODE(this->validate();)
AutoCheckFlush acf(fDrawingManager);
- if (should_apply_coverage_aa(paint, fRenderTarget.get()) && !strokeInfo.isDashed()) {
- if (strokeInfo.getWidth() < 0 && !path.isConvex()) {
+ if (should_apply_coverage_aa(paint, fRenderTarget.get()) && !style.pathEffect()) {
+ if (style.isSimpleFill() && !path.isConvex()) {
// Concave AA paths are expensive - try to avoid them for special cases
SkRect rects[2];
- if (is_nested_rects(viewMatrix, path, strokeInfo, rects)) {
+ if (fills_as_nested_rects(viewMatrix, path, rects)) {
SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateAAFillNestedRects(
paint.getColor(), viewMatrix, rects));
if (batch) {
SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(paint.getColor(),
viewMatrix,
ovalRect,
- strokeInfo,
+ style.strokeRec(),
shaderCaps));
if (batch) {
GrPipelineBuilder pipelineBuilder(paint, fRenderTarget.get(), clip);
// cache. This presents a potential hazard for buffered drawing. However,
// the writePixels that uploads to the scratch will perform a flush so we're
// OK.
- this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
+ this->internalDrawPath(clip, paint, viewMatrix, path, style);
}
bool GrDrawContextPriv::drawAndStencilPath(const SkIRect* scissorRect,
canDrawArgs.fShaderCaps = fDrawContext->fDrawingManager->getContext()->caps()->shaderCaps();
canDrawArgs.fViewMatrix = &viewMatrix;
canDrawArgs.fPath = &path;
- canDrawArgs.fStroke = &GrStrokeInfo::FillInfo();
+ canDrawArgs.fStyle = &GrStyle::SimpleFill();
canDrawArgs.fAntiAlias = useCoverageAA;
canDrawArgs.fIsStencilDisabled = isStencilDisabled;
canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA;
args.fColor = GrColor_WHITE;
args.fViewMatrix = &viewMatrix;
args.fPath = &path;
- args.fStroke = &GrStrokeInfo::FillInfo();
+ args.fStyle = &GrStyle::SimpleFill();
args.fAntiAlias = useCoverageAA;
args.fGammaCorrect = fDrawContext->isGammaCorrect();
pr->drawPath(args);
void GrDrawContext::internalDrawPath(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
- const SkPath& path,
- const GrStrokeInfo& strokeInfo) {
+ const SkPath& origPath,
+ const GrStyle& origStyle) {
ASSERT_SINGLE_OWNER
RETURN_IF_ABANDONED
- SkASSERT(!path.isEmpty());
+ SkASSERT(!origPath.isEmpty());
- // An Assumption here is that path renderer would use some form of tweaking
- // the src color (either the input alpha or in the frag shader) to implement
- // aa. If we have some future driver-mojo path AA that can do the right
- // thing WRT to the blend then we'll need some query on the PR.
bool useCoverageAA = should_apply_coverage_aa(paint, fRenderTarget.get());
const bool isStencilDisabled = true;
bool isStencilBufferMSAA = fRenderTarget->isStencilBufferMultisampled();
useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType
: GrPathRendererChain::kColor_DrawType;
- const SkPath* pathPtr = &path;
SkTLazy<SkPath> tmpPath;
- const GrStrokeInfo* strokeInfoPtr = &strokeInfo;
+ SkTLazy<GrStyle> tmpStyle;
GrPathRenderer::CanDrawPathArgs canDrawArgs;
canDrawArgs.fShaderCaps = fDrawingManager->getContext()->caps()->shaderCaps();
canDrawArgs.fViewMatrix = &viewMatrix;
- canDrawArgs.fPath = pathPtr;
- canDrawArgs.fStroke = strokeInfoPtr;
+ canDrawArgs.fPath = &origPath;
+ canDrawArgs.fStyle = &origStyle;
canDrawArgs.fAntiAlias = useCoverageAA;
canDrawArgs.fIsStencilDisabled = isStencilDisabled;
canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA;
- // Try a 1st time without stroking the path and without allowing the SW renderer
+ // Try a 1st time without applying any of the style to the geometry (and barring sw)
GrPathRenderer* pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type);
-
- GrStrokeInfo dashlessStrokeInfo(strokeInfo, false);
- if (nullptr == pr && strokeInfo.isDashed()) {
- // It didn't work above, so try again with dashed stroke converted to a dashless stroke.
- if (!strokeInfo.applyDashToPath(tmpPath.init(), &dashlessStrokeInfo, *pathPtr)) {
+ SkScalar styleScale = GrStyle::MatrixToScaleFactor(viewMatrix);
+
+ if (!pr && canDrawArgs.fStyle->pathEffect()) {
+ // It didn't work above, so try again with the path effect applied.
+ SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
+ if (!canDrawArgs.fStyle->applyPathEffectToPath(tmpPath.init(), &rec, *canDrawArgs.fPath,
+ styleScale)) {
+ GrStyle noPathEffect(canDrawArgs.fStyle->strokeRec(), nullptr);
+ this->internalDrawPath(clip, paint, viewMatrix, *canDrawArgs.fPath, noPathEffect);
return;
}
- pathPtr = tmpPath.get();
- if (pathPtr->isEmpty()) {
+ tmpStyle.init(rec, nullptr);
+ canDrawArgs.fPath = tmpPath.get();
+ canDrawArgs.fStyle = tmpStyle.get();
+ if (canDrawArgs.fPath->isEmpty()) {
return;
}
- strokeInfoPtr = &dashlessStrokeInfo;
-
- canDrawArgs.fPath = pathPtr;
- canDrawArgs.fStroke = strokeInfoPtr;
pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type);
}
-
- if (nullptr == pr) {
- if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*strokeInfoPtr, viewMatrix, nullptr) &&
- !strokeInfoPtr->isFillStyle()) {
- // It didn't work above, so try again with stroke converted to a fill.
+ if (!pr) {
+ SkASSERT(!canDrawArgs.fStyle->pathEffect());
+ if (canDrawArgs.fStyle->strokeRec().needToApply()) {
if (!tmpPath.isValid()) {
tmpPath.init();
}
- dashlessStrokeInfo.setResScale(SkScalarAbs(viewMatrix.getMaxScale()));
- if (!dashlessStrokeInfo.applyToPath(tmpPath.get(), *pathPtr)) {
+ // It didn't work above, so try again by applying the stroke to the geometry.
+ SkStrokeRec::InitStyle fillOrHairline;
+ if (!canDrawArgs.fStyle->applyToPath(tmpPath.get(), &fillOrHairline,
+ *canDrawArgs.fPath, styleScale)) {
return;
}
- pathPtr = tmpPath.get();
- if (pathPtr->isEmpty()) {
+ if (!tmpStyle.isValid()) {
+ tmpStyle.init(fillOrHairline);
+ } else {
+ tmpStyle.get()->resetToInitStyle(fillOrHairline);
+ }
+ canDrawArgs.fPath = tmpPath.get();
+ canDrawArgs.fStyle = tmpStyle.get();
+ if (canDrawArgs.fPath->isEmpty()) {
return;
}
- dashlessStrokeInfo.setFillStyle();
- strokeInfoPtr = &dashlessStrokeInfo;
- }
- canDrawArgs.fPath = pathPtr;
- canDrawArgs.fStroke = strokeInfoPtr;
+ pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type);
+ }
// This time, allow SW renderer
pr = fDrawingManager->getPathRenderer(canDrawArgs, true, type);
args.fPipelineBuilder = &pipelineBuilder;
args.fColor = paint.getColor();
args.fViewMatrix = &viewMatrix;
- args.fPath = pathPtr;
- args.fStroke = strokeInfoPtr;
+ args.fPath = canDrawArgs.fPath;
+ args.fStyle = canDrawArgs.fStyle;
args.fAntiAlias = useCoverageAA;
args.fGammaCorrect = this->isGammaCorrect();
pr->drawPath(args);
*/
#include "GrPath.h"
+#include "GrStyle.h"
namespace {
// Verb count limit for generating path key from content of a volatile path.
// The value should accomodate at least simple rects and rrects.
static const int kSimpleVolatilePathVerbLimit = 10;
-inline static bool compute_key_for_line_path(const SkPath& path, const GrStrokeInfo& stroke,
+static inline int style_data_cnt(const GrStyle& style) {
+ int cnt = GrStyle::KeySize(style, GrStyle::Apply::kPathEffectAndStrokeRec);
+ // This should only fail for an arbitrary path effect, and we should not have gotten
+ // here with anything other than a dash path effect.
+ SkASSERT(cnt >= 0);
+ return cnt;
+}
+
+static inline void write_style_key(uint32_t* dst, const GrStyle& style) {
+ // Pass 1 for the scale since the GPU will apply the style not GrStyle::applyToPath().
+ GrStyle::WriteKey(dst, style, GrStyle::Apply::kPathEffectAndStrokeRec, SK_Scalar1);
+}
+
+
+inline static bool compute_key_for_line_path(const SkPath& path, const GrStyle& style,
GrUniqueKey* key) {
SkPoint pts[2];
if (!path.isLine(pts)) {
}
static_assert((sizeof(pts) % sizeof(uint32_t)) == 0 && sizeof(pts) > sizeof(uint32_t),
"pts_needs_padding");
+ int styleDataCnt = style_data_cnt(style);
const int kBaseData32Cnt = 1 + sizeof(pts) / sizeof(uint32_t);
- int strokeDataCnt = stroke.computeUniqueKeyFragmentData32Cnt();
static const GrUniqueKey::Domain kOvalPathDomain = GrUniqueKey::GenerateDomain();
- GrUniqueKey::Builder builder(key, kOvalPathDomain, kBaseData32Cnt + strokeDataCnt);
+ GrUniqueKey::Builder builder(key, kOvalPathDomain, kBaseData32Cnt + styleDataCnt);
builder[0] = path.getFillType();
memcpy(&builder[1], &pts, sizeof(pts));
- if (strokeDataCnt > 0) {
- stroke.asUniqueKeyFragment(&builder[kBaseData32Cnt]);
+ if (styleDataCnt > 0) {
+ write_style_key(&builder[kBaseData32Cnt], style);
}
return true;
}
-inline static bool compute_key_for_oval_path(const SkPath& path, const GrStrokeInfo& stroke,
+inline static bool compute_key_for_oval_path(const SkPath& path, const GrStyle& style,
GrUniqueKey* key) {
SkRect rect;
// Point order is significant when dashing, so we cannot devolve to a rect key.
- if (stroke.isDashed() || !path.isOval(&rect)) {
+ if (style.pathEffect() || !path.isOval(&rect)) {
return false;
}
static_assert((sizeof(rect) % sizeof(uint32_t)) == 0 && sizeof(rect) > sizeof(uint32_t),
"rect_needs_padding");
const int kBaseData32Cnt = 1 + sizeof(rect) / sizeof(uint32_t);
- int strokeDataCnt = stroke.computeUniqueKeyFragmentData32Cnt();
+ int styleDataCnt = style_data_cnt(style);
static const GrUniqueKey::Domain kOvalPathDomain = GrUniqueKey::GenerateDomain();
- GrUniqueKey::Builder builder(key, kOvalPathDomain, kBaseData32Cnt + strokeDataCnt);
+ GrUniqueKey::Builder builder(key, kOvalPathDomain, kBaseData32Cnt + styleDataCnt);
builder[0] = path.getFillType();
memcpy(&builder[1], &rect, sizeof(rect));
- if (strokeDataCnt > 0) {
- stroke.asUniqueKeyFragment(&builder[kBaseData32Cnt]);
+ if (styleDataCnt > 0) {
+ write_style_key(&builder[kBaseData32Cnt], style);
}
return true;
}
// Encodes the full path data to the unique key for very small, volatile paths. This is typically
// hit when clipping stencils the clip stack. Intention is that this handles rects too, since
// SkPath::isRect seems to do non-trivial amount of work.
-inline static bool compute_key_for_simple_path(const SkPath& path, const GrStrokeInfo& stroke,
+inline static bool compute_key_for_simple_path(const SkPath& path, const GrStyle& style,
GrUniqueKey* key) {
if (!path.isVolatile()) {
return false;
// 2) stroke data (varying size)
const int baseData32Cnt = 2 + verbData32Cnt + pointData32Cnt + conicWeightData32Cnt;
- const int strokeDataCnt = stroke.computeUniqueKeyFragmentData32Cnt();
+ const int styleDataCnt = style_data_cnt(style);
static const GrUniqueKey::Domain kSimpleVolatilePathDomain = GrUniqueKey::GenerateDomain();
- GrUniqueKey::Builder builder(key, kSimpleVolatilePathDomain, baseData32Cnt + strokeDataCnt);
+ GrUniqueKey::Builder builder(key, kSimpleVolatilePathDomain, baseData32Cnt + styleDataCnt);
int i = 0;
builder[i++] = path.getFillType();
SkDEBUGCODE(i += conicWeightData32Cnt);
}
SkASSERT(i == baseData32Cnt);
- if (strokeDataCnt > 0) {
- stroke.asUniqueKeyFragment(&builder[baseData32Cnt]);
+ if (styleDataCnt > 0) {
+ write_style_key(&builder[baseData32Cnt], style);
}
return true;
}
-inline static void compute_key_for_general_path(const SkPath& path, const GrStrokeInfo& stroke,
+inline static void compute_key_for_general_path(const SkPath& path, const GrStyle& style,
GrUniqueKey* key) {
const int kBaseData32Cnt = 2;
- int strokeDataCnt = stroke.computeUniqueKeyFragmentData32Cnt();
+ int styleDataCnt = style_data_cnt(style);
static const GrUniqueKey::Domain kGeneralPathDomain = GrUniqueKey::GenerateDomain();
- GrUniqueKey::Builder builder(key, kGeneralPathDomain, kBaseData32Cnt + strokeDataCnt);
+ GrUniqueKey::Builder builder(key, kGeneralPathDomain, kBaseData32Cnt + styleDataCnt);
builder[0] = path.getGenerationID();
builder[1] = path.getFillType();
- if (strokeDataCnt > 0) {
- stroke.asUniqueKeyFragment(&builder[kBaseData32Cnt]);
+ if (styleDataCnt > 0) {
+ write_style_key(&builder[kBaseData32Cnt], style);
}
}
}
-void GrPath::ComputeKey(const SkPath& path, const GrStrokeInfo& stroke, GrUniqueKey* key,
+void GrPath::ComputeKey(const SkPath& path, const GrStyle& style, GrUniqueKey* key,
bool* outIsVolatile) {
- if (compute_key_for_line_path(path, stroke, key)) {
+ if (compute_key_for_line_path(path, style, key)) {
*outIsVolatile = false;
return;
}
- if (compute_key_for_oval_path(path, stroke, key)) {
+ if (compute_key_for_oval_path(path, style, key)) {
*outIsVolatile = false;
return;
}
- if (compute_key_for_simple_path(path, stroke, key)) {
+ if (compute_key_for_simple_path(path, style, key)) {
*outIsVolatile = false;
return;
}
- compute_key_for_general_path(path, stroke, key);
+ compute_key_for_general_path(path, style, key);
*outIsVolatile = path.isVolatile();
}
#ifdef SK_DEBUG
-bool GrPath::isEqualTo(const SkPath& path, const GrStrokeInfo& stroke) const {
- if (!fStroke.hasEqualEffect(stroke)) {
+bool GrPath::isEqualTo(const SkPath& path, const GrStyle& style) const {
+ // Since this is only called in debug we don't care about performance.
+ int cnt0 = GrStyle::KeySize(fStyle, GrStyle::Apply::kPathEffectAndStrokeRec);
+ int cnt1 = GrStyle::KeySize(style, GrStyle::Apply::kPathEffectAndStrokeRec);
+ if (cnt0 < 0 || cnt1 < 0 || cnt0 != cnt1) {
return false;
}
-
+ if (cnt0) {
+ SkAutoTArray<uint32_t> key0(cnt0);
+ SkAutoTArray<uint32_t> key1(cnt0);
+ write_style_key(key0.get(), fStyle);
+ write_style_key(key1.get(), style);
+ if (0 != memcmp(key0.get(), key1.get(), cnt0)) {
+ return false;
+ }
+ }
// We treat same-rect ovals as identical - but only when not dashing.
SkRect ovalBounds;
- if (!fStroke.isDashed() && fSkPath.isOval(&ovalBounds)) {
+ if (!fStyle.isDashed() && fSkPath.isOval(&ovalBounds)) {
SkRect otherOvalBounds;
return path.isOval(&otherOvalBounds) && ovalBounds == otherOvalBounds;
}
#define GrPath_DEFINED
#include "GrGpuResource.h"
-#include "GrStrokeInfo.h"
#include "GrPathRendering.h"
+#include "GrStyle.h"
#include "SkPath.h"
#include "SkRect.h"
/**
* Initialize to a path with a fixed stroke. Stroke must not be hairline.
*/
- GrPath(GrGpu* gpu, const SkPath& skPath, const GrStrokeInfo& stroke)
+ GrPath(GrGpu* gpu, const SkPath& skPath, const GrStyle& style)
: INHERITED(gpu)
, fBounds(SkRect::MakeEmpty())
, fFillType(GrPathRendering::kWinding_FillType)
#ifdef SK_DEBUG
, fSkPath(skPath)
- , fStroke(stroke)
+ , fStyle(style)
#endif
{
}
- static void ComputeKey(const SkPath& path, const GrStrokeInfo& stroke, GrUniqueKey* key,
+ static void ComputeKey(const SkPath& path, const GrStyle& style, GrUniqueKey* key,
bool* outIsVolatile);
const SkRect& getBounds() const { return fBounds; }
GrPathRendering::FillType getFillType() const { return fFillType; }
#ifdef SK_DEBUG
- bool isEqualTo(const SkPath& path, const GrStrokeInfo& stroke) const;
+ bool isEqualTo(const SkPath& path, const GrStyle& style) const;
#endif
protected:
GrPathRendering::FillType fFillType;
#ifdef SK_DEBUG
SkPath fSkPath;
- GrStrokeInfo fStroke;
+ GrStyle fStyle;
#endif
private:
#include "GrDrawTarget.h"
#include "GrStencil.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "SkDrawProcs.h"
#include "SkTArray.h"
class SkPath;
-
struct GrPoint;
/**
* fPipelineBuilder The pipelineBuilder
* fViewMatrix The viewMatrix
* fPath The path to draw
- * fStroke The stroke information (width, join, cap)
+ * fStyle The styling info (path effect, stroking info)
* fAntiAlias True if anti-aliasing is required.
*/
struct CanDrawPathArgs {
const GrShaderCaps* fShaderCaps;
const SkMatrix* fViewMatrix;
const SkPath* fPath;
- const GrStrokeInfo* fStroke;
+ const GrStyle* fStyle;
bool fAntiAlias;
// These next two are only used by GrStencilAndCoverPathRenderer
SkASSERT(fShaderCaps);
SkASSERT(fViewMatrix);
SkASSERT(fPath);
- SkASSERT(fStroke);
+ SkASSERT(fStyle);
SkASSERT(!fPath->isEmpty());
}
};
* fColor Color to render with
* fViewMatrix The viewMatrix
* fPath the path to draw.
- * fStroke the stroke information (width, join, cap)
+ * fStyle the style information (path effect, stroke info)
* fAntiAlias true if anti-aliasing is required.
* fGammaCorrect true if gamma-correct rendering is to be used.
*/
GrColor fColor;
const SkMatrix* fViewMatrix;
const SkPath* fPath;
- const GrStrokeInfo* fStroke;
+ const GrStyle* fStyle;
bool fAntiAlias;
bool fGammaCorrect;
SkASSERT(fPipelineBuilder);
SkASSERT(fViewMatrix);
SkASSERT(fPath);
- SkASSERT(fStroke);
+ SkASSERT(fStyle);
SkASSERT(!fPath->isEmpty());
}
};
canArgs.fShaderCaps = args.fTarget->caps()->shaderCaps();
canArgs.fViewMatrix = args.fViewMatrix;
canArgs.fPath = args.fPath;
- canArgs.fStroke = args.fStroke;
+ canArgs.fStyle = args.fStyle;
canArgs.fAntiAlias = args.fAntiAlias;
canArgs.fIsStencilDisabled = args.fPipelineBuilder->getStencil().isDisabled();
SkASSERT(this->canDrawPath(canArgs));
if (!args.fPipelineBuilder->getStencil().isDisabled()) {
SkASSERT(kNoRestriction_StencilSupport == this->getStencilSupport(*args.fPath));
- SkASSERT(!args.fStroke->isDashed());
- SkASSERT(args.fStroke->isFillStyle());
+ SkASSERT(args.fStyle->isSimpleFill());
}
#endif
return this->onDrawPath(args);
/**
* Draws the path to the stencil buffer. Assume the writable stencil bits are already
* initialized to zero. The pixels inside the path will have non-zero stencil values afterwards.
- *
*/
void stencilPath(const StencilPathArgs& args) {
SkDEBUGCODE(args.validate();)
SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(*args.fPath));
-
this->onStencilPath(args);
}
// Helper for determining if we can treat a thin stroke as a hairline w/ coverage.
// If we can, we draw lots faster (raster device does this same test).
- static bool IsStrokeHairlineOrEquivalent(const GrStrokeInfo& stroke, const SkMatrix& matrix,
+ static bool IsStrokeHairlineOrEquivalent(const GrStyle& style, const SkMatrix& matrix,
SkScalar* outCoverage) {
- if (stroke.isDashed()) {
+ if (style.pathEffect()) {
return false;
}
+ const SkStrokeRec& stroke = style.strokeRec();
if (stroke.isHairlineStyle()) {
if (outCoverage) {
*outCoverage = SK_Scalar1;
drawArgs.fColor = 0xFFFFFFFF;
drawArgs.fViewMatrix = args.fViewMatrix;
drawArgs.fPath = args.fPath;
- drawArgs.fStroke = &GrStrokeInfo::FillInfo();
+ drawArgs.fStyle = &GrStyle::SimpleFill();
drawArgs.fAntiAlias = false;
drawArgs.fGammaCorrect = false;
this->drawPath(drawArgs);
}
-
typedef SkRefCnt INHERITED;
};
}
if (minStencilSupport != GrPathRenderer::kNoSupport_StencilSupport) {
// We don't support (and shouldn't need) stenciling of non-fill paths.
- if (!args.fStroke->isFillStyle() || args.fStroke->isDashed()) {
+ if (!args.fStyle->isSimpleFill()) {
return nullptr;
}
}
GrPathRange* GrPathRendering::createGlyphs(const SkTypeface* typeface,
const SkScalerContextEffects& effects,
const SkDescriptor* desc,
- const GrStrokeInfo& stroke) {
+ const GrStyle& style) {
if (nullptr == typeface) {
typeface = SkTypeface::GetDefaultTypeface();
SkASSERT(nullptr != typeface);
if (desc) {
SkAutoTUnref<GlyphGenerator> generator(new GlyphGenerator(*typeface, effects, *desc));
- return this->createPathRange(generator, stroke);
+ return this->createPathRange(generator, style);
}
SkScalerContextRec rec;
SkScalerContextEffects noEffects;
SkAutoTUnref<GlyphGenerator> generator(new GlyphGenerator(*typeface, noEffects, *genericDesc));
- return this->createPathRange(generator, stroke);
+ return this->createPathRange(generator, style);
}
class SkTypeface;
class GrPath;
class GrStencilSettings;
-class GrStrokeInfo;
+class GrStyle;
/**
* Abstract class wrapping HW path rendering API.
* Creates a new gpu path, based on the specified path and stroke and returns it.
* The caller owns a ref on the returned path which must be balanced by a call to unref.
*
- * @param skPath the path geometry.
- * @param stroke the path stroke.
- * @return a new path.
+ * @param SkPath the geometry.
+ * @param GrStyle the style applied to the path. Styles with non-dash path effects are not
+ * allowed.
+ * @return a new GPU path object.
*/
- virtual GrPath* createPath(const SkPath&, const GrStrokeInfo&) = 0;
+ virtual GrPath* createPath(const SkPath&, const GrStyle&) = 0;
/**
- * Creates a range of gpu paths with a common stroke. The caller owns a ref on the
+ * Creates a range of gpu paths with a common style. The caller owns a ref on the
* returned path range which must be balanced by a call to unref.
*
* @param PathGenerator class that generates SkPath objects for each path in the range.
- * @param GrStrokeInfo the common stroke applied to each path in the range.
+ * @param GrStyle the common style applied to each path in the range. Styles with non-dash
+ * path effects are not allowed.
* @return a new path range.
*/
- virtual GrPathRange* createPathRange(GrPathRange::PathGenerator*, const GrStrokeInfo&) = 0;
+ virtual GrPathRange* createPathRange(GrPathRange::PathGenerator*, const GrStyle&) = 0;
/**
* Creates a range of glyph paths, indexed by glyph id. The glyphs will have an
* including with the stroke information baked directly into
* the outlines.
*
- * @param GrStrokeInfo Common stroke that the GPU will apply to every path. Note that
- * if the glyph outlines contain baked-in strokes from the font
- * descriptor, the GPU stroke will be applied on top of those
+ * @param GrStyle Common style that the GPU will apply to every path. Note that
+ * if the glyph outlines contain baked-in styles from the font
+ * descriptor, the GPU style will be applied on top of those
* outlines.
*
* @return a new path range populated with glyphs.
*/
GrPathRange* createGlyphs(const SkTypeface*, const SkScalerContextEffects&,
- const SkDescriptor*, const GrStrokeInfo&);
+ const SkDescriptor*, const GrStyle&);
/** None of these params are optional, pointers used just to avoid making copies. */
struct StencilPathArgs {
return this->createInstancedIndexBuffer(kPattern, 6, kMaxQuads, 4, fQuadIndexBufferKey);
}
-GrPath* GrResourceProvider::createPath(const SkPath& path, const GrStrokeInfo& stroke) {
+GrPath* GrResourceProvider::createPath(const SkPath& path, const GrStyle& style) {
SkASSERT(this->gpu()->pathRendering());
- return this->gpu()->pathRendering()->createPath(path, stroke);
+ return this->gpu()->pathRendering()->createPath(path, style);
}
GrPathRange* GrResourceProvider::createPathRange(GrPathRange::PathGenerator* gen,
- const GrStrokeInfo& stroke) {
+ const GrStyle& style) {
SkASSERT(this->gpu()->pathRendering());
- return this->gpu()->pathRendering()->createPathRange(gen, stroke);
+ return this->gpu()->pathRendering()->createPathRange(gen, style);
}
GrPathRange* GrResourceProvider::createGlyphs(const SkTypeface* tf,
const SkScalerContextEffects& effects,
const SkDescriptor* desc,
- const GrStrokeInfo& stroke) {
+ const GrStyle& style) {
SkASSERT(this->gpu()->pathRendering());
- return this->gpu()->pathRendering()->createGlyphs(tf, effects, desc, stroke);
+ return this->gpu()->pathRendering()->createGlyphs(tf, effects, desc, style);
}
GrBuffer* GrResourceProvider::createBuffer(size_t size, GrBufferType intendedType,
class GrRenderTarget;
class GrSingleOwner;
class GrStencilAttachment;
-class GrStrokeInfo;
+class GrStyle;
class SkDescriptor;
class SkPath;
class SkTypeface;
* Factories for GrPath and GrPathRange objects. It's an error to call these if path rendering
* is not supported.
*/
- GrPath* createPath(const SkPath&, const GrStrokeInfo&);
- GrPathRange* createPathRange(GrPathRange::PathGenerator*, const GrStrokeInfo&);
+ GrPath* createPath(const SkPath&, const GrStyle&);
+ GrPathRange* createPathRange(GrPathRange::PathGenerator*, const GrStyle&);
GrPathRange* createGlyphs(const SkTypeface*, const SkScalerContextEffects&,
- const SkDescriptor*, const GrStrokeInfo&);
+ const SkDescriptor*, const GrStyle&);
using GrTextureProvider::assignUniqueKeyToResource;
using GrTextureProvider::findAndRefResourceByUniqueKey;
#include "GrDrawTarget.h"
#include "GrGpu.h"
#include "GrPipelineBuilder.h"
+#include "GrStyle.h"
#include "SkData.h"
#include "SkDistanceFieldGen.h"
/**
* Draw a single path element of the clip stack into the accumulation bitmap
*/
-void GrSWMaskHelper::draw(const SkPath& path, const SkStrokeRec& stroke, SkRegion::Op op,
+void GrSWMaskHelper::draw(const SkPath& path, const GrStyle& style, SkRegion::Op op,
bool antiAlias, uint8_t alpha) {
-
SkPaint paint;
- if (stroke.isHairlineStyle()) {
- paint.setStyle(SkPaint::kStroke_Style);
- } else {
- if (stroke.isFillStyle()) {
- paint.setStyle(SkPaint::kFill_Style);
- } else {
- paint.setStyle(SkPaint::kStroke_Style);
- paint.setStrokeJoin(stroke.getJoin());
- paint.setStrokeCap(stroke.getCap());
- paint.setStrokeWidth(stroke.getWidth());
- }
- }
+ paint.setPathEffect(sk_ref_sp(style.pathEffect()));
+ style.strokeRec().applyToPaint(&paint);
paint.setAntiAlias(antiAlias);
SkTBlitterAllocator allocator;
*/
GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context,
const SkPath& path,
- const SkStrokeRec& stroke,
+ const GrStyle& style,
const SkIRect& resultBounds,
bool antiAlias,
const SkMatrix* matrix) {
return nullptr;
}
- helper.draw(path, stroke, SkRegion::kReplace_Op, antiAlias, 0xFF);
+ helper.draw(path, style, SkRegion::kReplace_Op, antiAlias, 0xFF);
GrTexture* texture(helper.createTexture());
if (!texture) {
bool init(const SkIRect& resultBounds, const SkMatrix* matrix, bool allowCompression = true);
// Draw a single rect into the accumulation bitmap using the specified op
- void draw(const SkRect& rect, SkRegion::Op op,
- bool antiAlias, uint8_t alpha);
+ void draw(const SkRect& rect, SkRegion::Op op, bool antiAlias, uint8_t alpha);
// Draw a single path into the accumuation bitmap using the specified op
- void draw(const SkPath& path, const SkStrokeRec& stroke, SkRegion::Op op,
+ void draw(const SkPath& path, const GrStyle& style, SkRegion::Op op,
bool antiAlias, uint8_t alpha);
// Move the mask generation results from the internal bitmap to the gpu.
// to the GPU. The result is returned.
static GrTexture* DrawPathMaskToTexture(GrContext* context,
const SkPath& path,
- const SkStrokeRec& stroke,
+ const GrStyle& style,
const SkIRect& resultBounds,
bool antiAlias,
const SkMatrix* matrix);
////////////////////////////////////////////////////////////////////////////////
bool GrSoftwarePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
- if (nullptr == fContext) {
- return false;
- }
- if (args.fStroke->isDashed()) {
- return false;
- }
- return true;
+ return SkToBool(fContext);
}
namespace {
}
SkAutoTUnref<GrTexture> texture(
- GrSWMaskHelper::DrawPathMaskToTexture(fContext, *args.fPath, *args.fStroke,
+ GrSWMaskHelper::DrawPathMaskToTexture(fContext, *args.fPath, *args.fStyle,
devPathBounds,
args.fAntiAlias, args.fViewMatrix));
if (nullptr == texture) {
+++ /dev/null
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "GrStrokeInfo.h"
-#include "GrResourceKey.h"
-#include "SkDashPathPriv.h"
-
-bool all_dash_intervals_zero(const SkScalar* intervals, int count) {
- for (int i = 0 ; i < count; ++i) {
- if (intervals[i] != 0) {
- return false;
- }
- }
- return true;
-}
-
-bool GrStrokeInfo::applyDashToPath(SkPath* dst, GrStrokeInfo* dstStrokeInfo,
- const SkPath& src) const {
- if (this->isDashed()) {
- SkPathEffect::DashInfo info;
- info.fIntervals = fIntervals.get();
- info.fCount = fIntervals.count();
- info.fPhase = fDashPhase;
- GrStrokeInfo filteredStroke(*this, false);
- // Handle the case where all intervals are 0 and we simply drop the dash effect
- if (all_dash_intervals_zero(fIntervals.get(), fIntervals.count())) {
- *dstStrokeInfo = filteredStroke;
- *dst = src;
- return true;
- }
- // See if we can filter the dash into a path on cpu
- if (SkDashPath::FilterDashPath(dst, src, &filteredStroke, nullptr, info)) {
- *dstStrokeInfo = filteredStroke;
- return true;
- }
- }
- return false;
-}
-
-void GrStrokeInfo::asUniqueKeyFragment(uint32_t* data) const {
- const int kSkScalarData32Cnt = sizeof(SkScalar) / sizeof(uint32_t);
- enum {
- kStyleBits = 2,
- kJoinBits = 2,
- kCapBits = 32 - kStyleBits - kJoinBits,
-
- kJoinShift = kStyleBits,
- kCapShift = kJoinShift + kJoinBits,
- };
-
- static_assert(SkStrokeRec::kStyleCount <= (1 << kStyleBits), "style_shift_will_be_wrong");
- static_assert(SkPaint::kJoinCount <= (1 << kJoinBits), "cap_shift_will_be_wrong");
- static_assert(SkPaint::kCapCount <= (1 << kCapBits), "cap_does_not_fit");
- uint32_t styleKey = this->getStyle();
- if (this->needToApply()) {
- styleKey |= this->getJoin() << kJoinShift;
- styleKey |= this->getCap() << kCapShift;
- }
- int i = 0;
- data[i++] = styleKey;
-
- // Memcpy the scalar fields. Does not "reinterpret_cast<SkScalar&>(data[i]) = ..." due to
- // scalars having more strict alignment requirements than what data can guarantee. The
- // compiler should optimize memcpys to assignments.
- SkScalar scalar;
- scalar = this->getMiter();
- memcpy(&data[i], &scalar, sizeof(scalar));
- i += kSkScalarData32Cnt;
-
- scalar = this->getWidth();
- memcpy(&data[i], &scalar, sizeof(scalar));
- i += kSkScalarData32Cnt;
-
- if (this->isDashed()) {
- SkScalar phase = this->getDashPhase();
- memcpy(&data[i], &phase, sizeof(phase));
- i += kSkScalarData32Cnt;
-
- int32_t count = this->getDashCount() & static_cast<int32_t>(~1);
- SkASSERT(count == this->getDashCount());
- const SkScalar* intervals = this->getDashIntervals();
- int intervalByteCnt = count * sizeof(SkScalar);
- memcpy(&data[i], intervals, intervalByteCnt);
- // Enable the line below if fields are added after dashing.
- SkDEBUGCODE(i += kSkScalarData32Cnt * count);
- }
-
- SkASSERT(this->computeUniqueKeyFragmentData32Cnt() == i);
-}
+++ /dev/null
-/*
- * Copyright 2014 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrStrokeInfo_DEFINED
-#define GrStrokeInfo_DEFINED
-
-#include "SkPathEffect.h"
-#include "SkStrokeRec.h"
-#include "SkTemplates.h"
-
-class GrUniqueKey;
-
-/*
- * GrStrokeInfo encapsulates all the pertinent infomation regarding the stroke. The SkStrokeRec
- * which holds information on fill style, width, miter, cap, and join. It also holds information
- * about the dash like intervals, count, and phase.
- */
-class GrStrokeInfo : public SkStrokeRec {
-public:
- static const GrStrokeInfo& FillInfo() {
- static const GrStrokeInfo gFill(kFill_InitStyle);
- return gFill;
- }
-
- GrStrokeInfo(SkStrokeRec::InitStyle style)
- : INHERITED(style)
- , fDashType(SkPathEffect::kNone_DashType) {
- }
-
- GrStrokeInfo(const GrStrokeInfo& src, bool includeDash = true)
- : INHERITED(src) {
- if (includeDash && src.isDashed()) {
- fDashType = src.fDashType;
- fDashPhase = src.fDashPhase;
- fIntervals.reset(src.getDashCount());
- memcpy(fIntervals.get(), src.fIntervals.get(), fIntervals.count() * sizeof(SkScalar));
- } else {
- fDashType = SkPathEffect::kNone_DashType;
- }
- }
-
- GrStrokeInfo(const SkPaint& paint, SkPaint::Style styleOverride)
- : INHERITED(paint, styleOverride)
- , fDashType(SkPathEffect::kNone_DashType) {
- this->init(paint);
- }
-
- explicit GrStrokeInfo(const SkPaint& paint)
- : INHERITED(paint)
- , fDashType(SkPathEffect::kNone_DashType) {
- this->init(paint);
- }
-
- GrStrokeInfo& operator=(const GrStrokeInfo& other) {
- if (other.isDashed()) {
- fDashType = other.fDashType;
- fDashPhase = other.fDashPhase;
- fIntervals.reset(other.getDashCount());
- memcpy(fIntervals.get(), other.fIntervals.get(), fIntervals.count() * sizeof(SkScalar));
- } else {
- this->removeDash();
- }
- this->INHERITED::operator=(other);
- return *this;
- }
-
- bool hasEqualEffect(const GrStrokeInfo& other) const {
- if (this->isDashed() != other.isDashed()) {
- return false;
- }
- if (this->isDashed()) {
- if (fDashPhase != other.fDashPhase ||
- fIntervals.count() != other.fIntervals.count() ||
- memcmp(fIntervals.get(), other.fIntervals.get(),
- fIntervals.count() * sizeof(SkScalar)) != 0) {
- return false;
- }
- }
- return this->INHERITED::hasEqualEffect(other);
- }
-
- /*
- * This functions takes in a patheffect and updates the dashing information if the path effect
- * is a Dash type. Returns true if the path effect is a dashed effect and we are stroking,
- * otherwise it returns false.
- */
- bool setDashInfo(const SkPathEffect* pe) {
- if (pe && !this->isFillStyle()) {
- SkPathEffect::DashInfo dashInfo;
- fDashType = pe->asADash(&dashInfo);
- if (SkPathEffect::kDash_DashType == fDashType) {
- fIntervals.reset(dashInfo.fCount);
- dashInfo.fIntervals = fIntervals.get();
- pe->asADash(&dashInfo);
- fDashPhase = dashInfo.fPhase;
- return true;
- }
- }
- return false;
- }
-
- /*
- * Like the above, but sets with an explicit SkPathEffect::DashInfo
- */
- bool setDashInfo(const SkPathEffect::DashInfo& info) {
- if (!this->isFillStyle()) {
- fDashType = SkPathEffect::kDash_DashType;
- fDashPhase = info.fPhase;
- fIntervals.reset(info.fCount);
- for (int i = 0; i < fIntervals.count(); i++) {
- fIntervals[i] = info.fIntervals[i];
- }
- return true;
- }
- return false;
- }
-
- bool isDashed() const {
- return (!this->isFillStyle() && SkPathEffect::kDash_DashType == fDashType);
- }
-
- int32_t getDashCount() const {
- SkASSERT(this->isDashed());
- return fIntervals.count();
- }
-
- SkScalar getDashPhase() const {
- SkASSERT(this->isDashed());
- return fDashPhase;
- }
-
- const SkScalar* getDashIntervals() const {
- SkASSERT(this->isDashed());
- return fIntervals.get();
- }
-
- void removeDash() {
- fDashType = SkPathEffect::kNone_DashType;
- }
-
- /** Applies the dash to a path, if the stroke info has dashing.
- * @return true if the dashing was applied (dst and dstStrokeInfo will be modified).
- * false if the stroke info did not have dashing. The dst and dstStrokeInfo
- * will be unmodified. The stroking in the SkStrokeRec might still
- * be applicable.
- */
- bool applyDashToPath(SkPath* dst, GrStrokeInfo* dstStrokeInfo, const SkPath& src) const;
-
- /**
- * Computes the length of the data that will be written by asUniqueKeyFragment() function.
- */
- int computeUniqueKeyFragmentData32Cnt() const {
- const int kSkScalarData32Cnt = sizeof(SkScalar) / sizeof(uint32_t);
- // SkStrokeRec data: 32 bits for style+join+cap and 2 scalars for miter and width.
- int strokeKeyData32Cnt = 1 + 2 * kSkScalarData32Cnt;
-
- if (this->isDashed()) {
- // One scalar for dash phase and one for each dash value.
- strokeKeyData32Cnt += (1 + this->getDashCount()) * kSkScalarData32Cnt;
- }
- return strokeKeyData32Cnt;
- }
-
- /**
- * Writes the object contents as uint32_t data, to be used with GrUniqueKey.
- * Note: the data written does not encode the length, so care must be taken to ensure
- * that the full unique key data is encoded properly. For example, GrStrokeInfo
- * fragment can be placed last in the sequence, at fixed index.
- */
- void asUniqueKeyFragment(uint32_t*) const;
-
-private:
- // Prevent accidental usage, should use GrStrokeInfo::hasEqualEffect.
- bool hasEqualEffect(const SkStrokeRec& other) const;
-
- void init(const SkPaint& paint) {
- const SkPathEffect* pe = paint.getPathEffect();
- this->setDashInfo(pe);
- }
-
- SkPathEffect::DashType fDashType;
- SkScalar fDashPhase;
- SkAutoSTArray<2, SkScalar> fIntervals;
- typedef SkStrokeRec INHERITED;
-};
-
-#endif
this->initPathEffect(paint.getPathEffect());
}
+ explicit GrStyle(const SkPaint& paint, SkPaint::Style overrideStyle)
+ : fStrokeRec(paint, overrideStyle) {
+ this->initPathEffect(paint.getPathEffect());
+ }
+
GrStyle& operator=(const GrStyle& that) {
fPathEffect = that.fPathEffect;
fDashInfo = that.fDashInfo;
return this->pathEffect() || (!fStrokeRec.isFillStyle() && !fStrokeRec.isHairlineStyle());
}
+ static SkScalar MatrixToScaleFactor(const SkMatrix& matrix) {
+ // getMaxScale will return -1 if the matrix has perspective. In that case we can use a scale
+ // factor of 1. This isn't necessarily a good choice and in the future we might consider
+ // taking a bounds here for the perspective case.
+ return SkScalarAbs(matrix.getMaxScale());
+ }
/**
* Applies just the path effect and returns remaining stroke information. This will fail if
* there is no path effect. dst may or may not have been overwritten on failure. Scale controls
* found in the LICENSE file.
*/
-#include "GrStrokeInfo.h"
#include "GrTestUtils.h"
+#include "GrStyle.h"
+#include "SkDashPathPriv.h"
#include "SkMatrix.h"
-#include "SkPathEffect.h"
#include "SkPath.h"
#include "SkRRect.h"
return rec;
}
-GrStrokeInfo TestStrokeInfo(SkRandom* random) {
- SkStrokeRec::InitStyle style =
+void TestStyle(SkRandom* random, GrStyle* style) {
+ SkStrokeRec::InitStyle initStyle =
SkStrokeRec::InitStyle(random->nextULessThan(SkStrokeRec::kFill_InitStyle + 1));
- GrStrokeInfo strokeInfo(style);
- randomize_stroke_rec(&strokeInfo, random);
- SkPathEffect::DashInfo dashInfo;
- dashInfo.fCount = random->nextRangeU(1, 50) * 2;
- dashInfo.fIntervals = new SkScalar[dashInfo.fCount];
- SkScalar sum = 0;
- for (int i = 0; i < dashInfo.fCount; i++) {
- dashInfo.fIntervals[i] = random->nextRangeScalar(SkDoubleToScalar(0.01),
- SkDoubleToScalar(10.0));
- sum += dashInfo.fIntervals[i];
+ SkStrokeRec stroke(initStyle);
+ randomize_stroke_rec(&stroke, random);
+ sk_sp<SkPathEffect> pe;
+ if (random->nextBool()) {
+ int cnt = random->nextRangeU(1, 50) * 2;
+ SkAutoTDeleteArray<SkScalar> intervals(new SkScalar[cnt]);
+ SkScalar sum = 0;
+ for (int i = 0; i < cnt; i++) {
+ intervals[i] = random->nextRangeScalar(SkDoubleToScalar(0.01),
+ SkDoubleToScalar(10.0));
+ sum += intervals[i];
+ }
+ SkScalar phase = random->nextRangeScalar(0, sum);
+ pe = TestDashPathEffect::Make(intervals.get(), cnt, phase);
}
- dashInfo.fPhase = random->nextRangeScalar(0, sum);
- strokeInfo.setDashInfo(dashInfo);
- delete[] dashInfo.fIntervals;
- return strokeInfo;
+ *style = GrStyle(stroke, pe.get());
+}
+
+TestDashPathEffect::TestDashPathEffect(const SkScalar* intervals, int count, SkScalar phase) {
+ fCount = count;
+ fIntervals.reset(count);
+ memcpy(fIntervals.get(), intervals, count * sizeof(SkScalar));
+ SkDashPath::CalcDashParameters(phase, intervals, count, &fInitialDashLength,
+ &fInitialDashIndex, &fIntervalLength, &fPhase);
+}
+
+ bool TestDashPathEffect::filterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec,
+ const SkRect* cullRect) const {
+ return SkDashPath::InternalFilter(dst, src, rec, cullRect, fIntervals.get(), fCount,
+ fInitialDashLength, fInitialDashIndex, fIntervalLength);
}
-};
+SkPathEffect::DashType TestDashPathEffect::asADash(DashInfo* info) const {
+ if (info) {
+ if (info->fCount >= fCount && info->fIntervals) {
+ memcpy(info->fIntervals, fIntervals.get(), fCount * sizeof(SkScalar));
+ }
+ info->fCount = fCount;
+ info->fPhase = fPhase;
+ }
+ return kDash_DashType;
+}
+
+
+} // namespace GrTest
#endif
#include "GrImageIDTextureAdjuster.h"
#include "GrLayerHoister.h"
#include "GrRecordReplaceDraw.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "GrTracing.h"
#include "SkCanvasPriv.h"
#include "SkErrorInternals.h"
}
if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
- GrStrokeInfo strokeInfo(paint, SkPaint::kStroke_Style);
+ GrStyle style(paint, SkPaint::kStroke_Style);
GrPaint grPaint;
if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
this->surfaceProps().isGammaCorrect(), &grPaint)) {
path.setIsVolatile(true);
path.moveTo(pts[0]);
path.lineTo(pts[1]);
- fDrawContext->drawPath(fClip, grPaint, *draw.fMatrix, path, strokeInfo);
+ fDrawContext->drawPath(fClip, grPaint, *draw.fMatrix, path, style);
return;
}
return;
}
- GrStrokeInfo strokeInfo(paint);
-
- fDrawContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
+ GrStyle style(paint);
+ fDrawContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &style);
}
///////////////////////////////////////////////////////////////////////////////
return;
}
- GrStrokeInfo strokeInfo(paint);
+ GrStyle style(paint);
if (paint.getMaskFilter()) {
// try to hit the fast path for drawing filtered round rects
&grPaint,
fClip,
*draw.fMatrix,
- strokeInfo,
+ style.strokeRec(),
devRRect)) {
return;
}
}
}
- if (paint.getMaskFilter() || paint.getPathEffect()) {
+ if (paint.getMaskFilter() || style.pathEffect()) {
// The only mask filter the native rrect drawing code could've handle was taken
// care of above.
// A path effect will presumably transform this rrect into something else.
return;
}
- SkASSERT(!strokeInfo.isDashed());
+ SkASSERT(!style.pathEffect());
- fDrawContext->drawRRect(fClip, grPaint, *draw.fMatrix, rect, strokeInfo);
+ fDrawContext->drawRRect(fClip, grPaint, *draw.fMatrix, rect, style);
}
return;
}
- GrStrokeInfo strokeInfo(paint);
- SkASSERT(!strokeInfo.isDashed());
-
- fDrawContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
+ fDrawContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, GrStyle(paint));
}
#include "SkMaskFilter.h"
#include "GrBlurUtils.h"
#include "GrCaps.h"
#include "GrDrawContext.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "GrTextureParamsAdjuster.h"
#include "SkDraw.h"
#include "SkGrPriv.h"
rectPath.addRect(clippedDstRect);
rectPath.setIsVolatile(true);
GrBlurUtils::drawPathWithMaskFilter(this->context(), fDrawContext.get(), fClip,
- rectPath, &grPaint, viewMatrix, mf, paint.getPathEffect(),
- GrStrokeInfo::FillInfo(), true);
+ rectPath, &grPaint, viewMatrix, mf, GrStyle::SimpleFill(),
+ true);
}
#include "GrPathUtils.h"
#include "GrProcessor.h"
#include "GrPipelineBuilder.h"
-#include "GrStrokeInfo.h"
#include "SkGeometry.h"
#include "SkPathPriv.h"
#include "SkString.h"
bool GrAAConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
return (args.fShaderCaps->shaderDerivativeSupport() && args.fAntiAlias &&
- args.fStroke->isFillStyle() && !args.fPath->isInverseFillType() &&
+ args.fStyle->isSimpleFill() && !args.fPath->isInverseFillType() &&
args.fPath->isConvex());
}
////////////////////////////////////////////////////////////////////////////////
bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
-
+ // We don't currently apply the dash or factor it into the DF key. (skbug.com/5082)
+ if (args.fStyle->pathEffect()) {
+ return false;
+ }
// TODO: Support inverse fill
if (!args.fShaderCaps->shaderDerivativeSupport() || !args.fAntiAlias ||
- SkStrokeRec::kHairline_Style == args.fStroke->getStyle() ||
- args.fPath->isInverseFillType() || args.fPath->isVolatile() ||
- // We don't currently apply the dash or factor it into the DF key. (skbug.com/5082)
- args.fStroke->isDashed()) {
+ args.fStyle->isSimpleHairline() || args.fPath->isInverseFillType() ||
+ args.fPath->isVolatile()) {
return false;
}
// scaled to have bounds within 2.0f*kLargeMIP by 2.0f*kLargeMIP
// the goal is to accelerate rendering of lots of small paths that may be scaling
SkScalar maxScale = args.fViewMatrix->getMaxScale();
+#if 0 // This is more accurate but changes some GMs. TODO: Standalone change to enable this.
+ SkRect bounds;
+ args.fStyle->adjustBounds(&bounds, args.fPath->getBounds());
+ SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
+#else
const SkRect& bounds = args.fPath->getBounds();
SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
+ const SkStrokeRec& stroke = args.fStyle->strokeRec();
// Approximate stroked size by adding the maximum of the stroke width or 2x the miter limit
- if (!args.fStroke->isFillStyle()) {
- SkScalar extraWidth = args.fStroke->getWidth();
- if (SkPaint::kMiter_Join == args.fStroke->getJoin()) {
- extraWidth = SkTMax(extraWidth, 2.0f*args.fStroke->getMiter());
+ if (!stroke.isFillStyle()) {
+ SkScalar extraWidth = stroke.getWidth();
+ if (SkPaint::kMiter_Join == stroke.getJoin()) {
+ extraWidth = SkTMax(extraWidth, 2.0f*stroke.getMiter());
}
maxDim += extraWidth;
}
+#endif
return maxDim <= kMediumMIP && maxDim * maxScale <= 2.0f*kLargeMIP;
}
}
}
- AADistanceFieldPathBatch::Geometry geometry(*args.fStroke);
- if (SkStrokeRec::kFill_Style == args.fStroke->getStyle()) {
+ // It's ok to ignore style's path effect because canDrawPath filtered out path effects.
+ AADistanceFieldPathBatch::Geometry geometry(args.fStyle->strokeRec());
+ if (args.fStyle->isSimpleFill()) {
geometry.fPath = *args.fPath;
} else {
- args.fStroke->applyToPath(&geometry.fPath, *args.fPath);
+ args.fStyle->strokeRec().applyToPath(&geometry.fPath, *args.fPath);
}
geometry.fColor = args.fColor;
geometry.fAntiAlias = args.fAntiAlias;
return false;
}
- if (!IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix, nullptr)) {
+ if (!IsStrokeHairlineOrEquivalent(*args.fStyle, *args.fViewMatrix, nullptr)) {
+ return false;
+ }
+
+ // We don't currently handle dashing in this class though perhaps we should.
+ if (args.fStyle->pathEffect()) {
return false;
}
static GrDrawBatch* create_hairline_batch(GrColor color,
const SkMatrix& viewMatrix,
const SkPath& path,
- const GrStrokeInfo& stroke,
+ const GrStyle& style,
const SkIRect& devClipBounds) {
SkScalar hairlineCoverage;
uint8_t newCoverage = 0xff;
- if (GrPathRenderer::IsStrokeHairlineOrEquivalent(stroke, viewMatrix, &hairlineCoverage)) {
+ if (GrPathRenderer::IsStrokeHairlineOrEquivalent(style, viewMatrix, &hairlineCoverage)) {
newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
}
args.fPipelineBuilder->clip().getConservativeBounds(rt->width(), rt->height(), &devClipBounds);
SkAutoTUnref<GrDrawBatch> batch(create_hairline_batch(args.fColor, *args.fViewMatrix, *args.fPath,
- *args.fStroke, devClipBounds));
+ *args.fStyle, devClipBounds));
args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
return true;
DRAW_BATCH_TEST_DEFINE(AAHairlineBatch) {
GrColor color = GrRandomColor(random);
SkMatrix viewMatrix = GrTest::TestMatrix(random);
- GrStrokeInfo stroke(SkStrokeRec::kHairline_InitStyle);
SkPath path = GrTest::TestPath(random);
SkIRect devClipBounds;
devClipBounds.setEmpty();
- return create_hairline_batch(color, viewMatrix, path, stroke, devClipBounds);
+ return create_hairline_batch(color, viewMatrix, path, GrStyle::SimpleHairline(), devClipBounds);
}
#endif
#include "GrPathUtils.h"
#include "GrProcessor.h"
#include "GrPipelineBuilder.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "SkGeometry.h"
#include "SkString.h"
#include "SkTraceEvent.h"
if (!args.fPath->isConvex()) {
return false;
}
- if (args.fStroke->getStyle() == SkStrokeRec::kStroke_Style) {
+ if (args.fStyle->pathEffect()) {
+ return false;
+ }
+ const SkStrokeRec& stroke = args.fStyle->strokeRec();
+ if (stroke.getStyle() == SkStrokeRec::kStroke_Style) {
if (!args.fViewMatrix->isSimilarity()) {
return false;
}
- SkScalar strokeWidth = args.fViewMatrix->getMaxScale() * args.fStroke->getWidth();
- return strokeWidth >= 1.0f && strokeWidth <= kMaxStrokeWidth && !args.fStroke->isDashed() &&
- SkPathPriv::IsClosedSingleContour(*args.fPath) &&
- args.fStroke->getJoin() != SkPaint::Join::kRound_Join;
+ SkScalar strokeWidth = args.fViewMatrix->getMaxScale() * stroke.getWidth();
+ return strokeWidth >= 1.0f && strokeWidth <= kMaxStrokeWidth &&
+ SkPathPriv::IsClosedSingleContour(*args.fPath) &&
+ stroke.getJoin() != SkPaint::Join::kRound_Join;
}
- return args.fStroke->getStyle() == SkStrokeRec::kFill_Style;
+ return stroke.getStyle() == SkStrokeRec::kFill_Style;
}
// extract the result vertices and indices from the GrAAConvexTessellator
geometry.fColor = args.fColor;
geometry.fViewMatrix = *args.fViewMatrix;
geometry.fPath = *args.fPath;
- geometry.fStrokeWidth = args.fStroke->isFillStyle() ? -1.0f : args.fStroke->getWidth();
- geometry.fJoin = args.fStroke->isFillStyle() ? SkPaint::Join::kMiter_Join :
- args.fStroke->getJoin();
- geometry.fMiterLimit = args.fStroke->getMiter();
+ bool fill = args.fStyle->isSimpleFill();
+ geometry.fStrokeWidth = fill ? -1.0f : args.fStyle->strokeRec().getWidth();
+ geometry.fJoin = fill ? SkPaint::Join::kMiter_Join : args.fStyle->strokeRec().getJoin();
+ geometry.fMiterLimit = args.fStyle->strokeRec().getMiter();
SkAutoTUnref<GrDrawBatch> batch(AAFlatteningConvexPathBatch::Create(geometry));
args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
bool GrDashLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
SkPoint pts[2];
- if (args.fStroke->isDashed() && args.fPath->isLine(pts)) {
- return GrDashingEffect::CanDrawDashLine(pts, *args.fStroke, *args.fViewMatrix);
+ if (args.fStyle->isDashed() && args.fPath->isLine(pts)) {
+ return GrDashingEffect::CanDrawDashLine(pts, *args.fStyle, *args.fViewMatrix);
}
return false;
}
pts,
args.fAntiAlias,
msaaIsEnabled,
- *args.fStroke));
+ *args.fStyle));
if (!batch) {
return false;
}
GrColor color,
const SkMatrix& viewMatrix,
const SkPath& path,
- const GrStrokeInfo& origStroke,
+ const GrStyle& origStyle,
bool stencilOnly) {
- SkTCopyOnFirstWrite<GrStrokeInfo> stroke(origStroke);
+ const GrStyle* style = &origStyle;
SkScalar hairlineCoverage;
uint8_t newCoverage = 0xff;
- if (IsStrokeHairlineOrEquivalent(*stroke, viewMatrix, &hairlineCoverage)) {
+ bool isHairline = false;
+ if (IsStrokeHairlineOrEquivalent(*style, viewMatrix, &hairlineCoverage)) {
newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
-
- if (!stroke->isHairlineStyle()) {
- stroke.writable()->setHairlineStyle();
- }
+ style = &GrStyle::SimpleHairline();
+ isHairline = true;
+ } else {
+ SkASSERT(style->isSimpleFill());
}
- const bool isHairline = stroke->isHairlineStyle();
-
// Save the current xp on the draw state so we can reset it if needed
const GrXPFactory* xpFactory = pipelineBuilder->getXPFactory();
SkAutoTUnref<const GrXPFactory> backupXPFactory(SkSafeRef(xpFactory));
lastPassIsBounds = false;
drawFace[0] = GrPipelineBuilder::kBoth_DrawFace;
} else {
- if (single_pass_path(path, *stroke)) {
+ if (single_pass_path(path, style->strokeRec())) {
passCount = 1;
if (stencilOnly) {
passes[0] = &gDirectToStencil;
}
bool GrDefaultPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
- // this class can draw any path with any fill but doesn't do any anti-aliasing.
- return !args.fAntiAlias && (args.fStroke->isFillStyle() ||
- IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix,
- nullptr));
+ // this class can draw any path with any simple fill style but doesn't do any anti-aliasing.
+ return !args.fAntiAlias &&
+ (args.fStyle->isSimpleFill() || IsStrokeHairlineOrEquivalent(*args.fStyle,
+ *args.fViewMatrix,
+ nullptr));
}
bool GrDefaultPathRenderer::onDrawPath(const DrawPathArgs& args) {
args.fColor,
*args.fViewMatrix,
*args.fPath,
- *args.fStroke,
+ *args.fStyle,
false);
}
SkASSERT(SkPath::kInverseEvenOdd_FillType != args.fPath->getFillType());
SkASSERT(SkPath::kInverseWinding_FillType != args.fPath->getFillType());
this->internalDrawPath(args.fTarget, args.fPipelineBuilder, GrColor_WHITE, *args.fViewMatrix,
- *args.fPath, GrStrokeInfo::FillInfo(), true);
+ *args.fPath, GrStyle::SimpleFill(), true);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// For now just hairlines because the other types of draws require two batches.
// TODO we should figure out a way to combine the stencil and cover steps into one batch
- GrStrokeInfo stroke(SkStrokeRec::kHairline_InitStyle);
+ GrStyle style(SkStrokeRec::kHairline_InitStyle);
SkPath path = GrTest::TestPath(random);
// Compute srcSpaceTol
GrColor,
const SkMatrix& viewMatrix,
const SkPath&,
- const GrStrokeInfo&,
+ const GrStyle&,
bool stencilOnly);
bool fSeparateStencil;
////////////////////////////////////////////////////////////////////////////////
// Helpers for drawPath
-static inline bool single_pass_path(const SkPath& path, const SkStrokeRec& stroke) {
+static inline bool single_pass_path(const SkPath& path) {
if (!path.isInverseFillType()) {
return path.isConvex();
}
GrPathRenderer::StencilSupport
GrMSAAPathRenderer::onGetStencilSupport(const SkPath& path) const {
- if (single_pass_path(path, SkStrokeRec(SkStrokeRec::kFill_InitStyle))) {
+ if (single_pass_path(path)) {
return GrPathRenderer::kNoRestriction_StencilSupport;
} else {
return GrPathRenderer::kStencilOnly_StencilSupport;
GrColor color,
const SkMatrix& viewMatrix,
const SkPath& path,
- const GrStrokeInfo& origStroke,
bool stencilOnly) {
- SkTCopyOnFirstWrite<GrStrokeInfo> stroke(origStroke);
const GrXPFactory* xpFactory = pipelineBuilder->getXPFactory();
SkAutoTUnref<const GrXPFactory> backupXPFactory(SkSafeRef(xpFactory));
bool reverse = false;
bool lastPassIsBounds;
- if (single_pass_path(path, *stroke)) {
+ if (single_pass_path(path)) {
passCount = 1;
if (stencilOnly) {
passes[0] = &gDirectToStencil;
}
bool GrMSAAPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
- return !IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix, nullptr) &&
- !args.fAntiAlias;
+ // This path renderer does not support hairlines. We defer on anything that could be handled
+ // as a hairline by another path renderer. Also, arbitrary path effects could produce
+ // a hairline result.
+ return !IsStrokeHairlineOrEquivalent(*args.fStyle, *args.fViewMatrix, nullptr) &&
+ !args.fStyle->hasNonDashPathEffect() && !args.fAntiAlias;
}
bool GrMSAAPathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(), "GrMSAAPathRenderer::onDrawPath");
- SkPath path;
- GrStrokeInfo stroke(*args.fStroke);
- if (stroke.isDashed()) {
- if (!stroke.applyDashToPath(&path, &stroke, *args.fPath)) {
+ SkPath tmpPath;
+ const SkPath* path;
+ if (args.fStyle->applies()) {
+ SkStrokeRec::InitStyle fill;
+ SkScalar styleScale = GrStyle::MatrixToScaleFactor(*args.fViewMatrix);
+ if (!args.fStyle->applyToPath(&tmpPath, &fill, *args.fPath, styleScale)) {
return false;
}
+ // We don't accept styles that are hairlines or have path effects that could produce
+ // hairlines.
+ SkASSERT(SkStrokeRec::kFill_InitStyle == fill);
+ path = &tmpPath;
} else {
- path = *args.fPath;
- }
- if (!stroke.isFillStyle()) {
- stroke.setResScale(SkScalarAbs(args.fViewMatrix->getMaxScale()));
- if (!stroke.applyToPath(&path, path)) {
- return false;
- }
- stroke.setFillStyle();
+ path = args.fPath;
}
return this->internalDrawPath(args.fTarget,
args.fPipelineBuilder,
args.fColor,
*args.fViewMatrix,
- path,
- stroke,
+ *path,
false);
}
SkASSERT(SkPath::kInverseEvenOdd_FillType != args.fPath->getFillType());
SkASSERT(SkPath::kInverseWinding_FillType != args.fPath->getFillType());
this->internalDrawPath(args.fTarget, args.fPipelineBuilder, GrColor_WHITE, *args.fViewMatrix,
- *args.fPath, GrStrokeInfo::FillInfo(), true);
+ *args.fPath, true);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
GrColor,
const SkMatrix& viewMatrix,
const SkPath&,
- const GrStrokeInfo&,
bool stencilOnly);
typedef GrPathRenderer INHERITED;
#include "GrPathUtils.h"
#include "GrProcessor.h"
#include "GrPipelineBuilder.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "GrTessellator.h"
#include "batches/GrVertexBatch.h"
#include "glsl/GrGLSLGeometryProcessor.h"
// We have support for even-odd rendering, but are having some troublesome
// seams. Disable in the presence of even-odd for now.
return args.fShaderCaps->shaderDerivativeSupport() && args.fAntiAlias &&
- args.fStroke->isFillStyle() && !args.fPath->isInverseFillType() &&
+ args.fStyle->isSimpleFill() && !args.fPath->isInverseFillType() &&
args.fPath->getFillType() == SkPath::FillType::kWinding_FillType;
}
#include "GrPath.h"
#include "GrRenderTarget.h"
#include "GrResourceProvider.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "batches/GrRectBatchFactory.h"
GrPathRenderer* GrStencilAndCoverPathRenderer::Create(GrResourceProvider* resourceProvider,
}
bool GrStencilAndCoverPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
- if (args.fStroke->isHairlineStyle()) {
+ // GrPath doesn't support hairline paths. Also, an arbitrary path effect could change
+ // the style type to hairline.
+ if (!args.fStyle->hasNonDashPathEffect() || args.fStyle->strokeRec().isHairlineStyle()) {
return false;
}
if (!args.fIsStencilDisabled) {
}
static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const SkPath& skPath,
- const GrStrokeInfo& stroke) {
+ const GrStyle& style) {
GrUniqueKey key;
bool isVolatile;
- GrPath::ComputeKey(skPath, stroke, &key, &isVolatile);
+ GrPath::ComputeKey(skPath, style, &key, &isVolatile);
SkAutoTUnref<GrPath> path(
static_cast<GrPath*>(resourceProvider->findAndRefResourceByUniqueKey(key)));
if (!path) {
- path.reset(resourceProvider->createPath(skPath, stroke));
+ path.reset(resourceProvider->createPath(skPath, style));
if (!isVolatile) {
resourceProvider->assignUniqueKeyToResource(key, path);
}
} else {
- SkASSERT(path->isEqualTo(skPath, stroke));
+ SkASSERT(path->isEqualTo(skPath, style));
}
return path.release();
}
GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(),
"GrStencilAndCoverPathRenderer::onStencilPath");
SkASSERT(!args.fPath->isInverseFillType());
- SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, *args.fPath, GrStrokeInfo::FillInfo()));
+ SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, *args.fPath, GrStyle::SimpleFill()));
args.fTarget->stencilPath(*args.fPipelineBuilder, *args.fViewMatrix, p, p->getFillType());
}
bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(),
"GrStencilAndCoverPathRenderer::onDrawPath");
- SkASSERT(!args.fStroke->isHairlineStyle());
+ SkASSERT(!args.fStyle->strokeRec().isHairlineStyle());
const SkPath& path = *args.fPath;
GrPipelineBuilder* pipelineBuilder = args.fPipelineBuilder;
const SkMatrix& viewMatrix = *args.fViewMatrix;
pipelineBuilder->enableState(GrPipelineBuilder::kHWAntialias_Flag);
}
- SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, path, *args.fStroke));
+ SkAutoTUnref<GrPath> p(get_gr_path(fResourceProvider, path, *args.fStyle));
if (path.isInverseFillType()) {
static constexpr GrStencilSettings kInvertedStencilPass(
bool GrTessellatingPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
// This path renderer can draw all fill styles, all stroke styles except hairlines, but does
// not do antialiasing. It can do convex and concave paths, but we'll leave the convex ones to
- // simpler algorithms.
- return !IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix, nullptr) &&
- !args.fAntiAlias && !args.fPath->isConvex();
+ // simpler algorithms. Similary, we skip the non-hairlines that can be treated as hairline.
+ // An arbitrary path effect could produce a hairline result so we pass on those.
+ return !IsStrokeHairlineOrEquivalent(*args.fStyle, *args.fViewMatrix, nullptr) &&
+ !args.fStyle->hasNonDashPathEffect() && !args.fAntiAlias && !args.fPath->isConvex();
}
class TessellatingPathBatch : public GrVertexBatch {
static GrDrawBatch* Create(const GrColor& color,
const SkPath& path,
- const GrStrokeInfo& stroke,
+ const GrStyle& style,
const SkMatrix& viewMatrix,
SkRect clipBounds) {
- return new TessellatingPathBatch(color, path, stroke, viewMatrix, clipBounds);
+ return new TessellatingPathBatch(color, path, style, viewMatrix, clipBounds);
}
const char* name() const override { return "TessellatingPathBatch"; }
}
void draw(Target* target, const GrGeometryProcessor* gp) const {
+ GrResourceProvider* rp = target->resourceProvider();
+ SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
+ SkScalar tol = GrPathUtils::scaleToleranceToSrc(screenSpaceTol, fViewMatrix,
+ fPath.getBounds());
+
+ SkScalar styleScale = SK_Scalar1;
+ if (fStyle.applies()) {
+ styleScale = GrStyle::MatrixToScaleFactor(fViewMatrix);
+ }
+
// construct a cache key from the path's genID and the view matrix
static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
GrUniqueKey key;
- int clipBoundsSize32 =
+ int clipBoundsCnt =
fPath.isInverseFillType() ? sizeof(fClipBounds) / sizeof(uint32_t) : 0;
- int strokeDataSize32 = fStroke.computeUniqueKeyFragmentData32Cnt();
- GrUniqueKey::Builder builder(&key, kDomain, 2 + clipBoundsSize32 + strokeDataSize32);
- builder[0] = fPath.getGenerationID();
- builder[1] = fPath.getFillType();
- // For inverse fills, the tessellation is dependent on clip bounds.
- if (fPath.isInverseFillType()) {
- memcpy(&builder[2], &fClipBounds, sizeof(fClipBounds));
- }
- fStroke.asUniqueKeyFragment(&builder[2 + clipBoundsSize32]);
- builder.finish();
- GrResourceProvider* rp = target->resourceProvider();
- SkAutoTUnref<GrBuffer> cachedVertexBuffer(rp->findAndRefTByUniqueKey<GrBuffer>(key));
- int actualCount;
- SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
- SkScalar tol = GrPathUtils::scaleToleranceToSrc(
- screenSpaceTol, fViewMatrix, fPath.getBounds());
- if (cache_match(cachedVertexBuffer.get(), tol, &actualCount)) {
- this->drawVertices(target, gp, cachedVertexBuffer.get(), 0, actualCount);
- return;
+ int styleDataCnt = GrStyle::KeySize(fStyle, GrStyle::Apply::kPathEffectAndStrokeRec);
+ if (styleDataCnt >= 0) {
+ GrUniqueKey::Builder builder(&key, kDomain, 2 + clipBoundsCnt + styleDataCnt);
+ builder[0] = fPath.getGenerationID();
+ builder[1] = fPath.getFillType();
+ // For inverse fills, the tessellation is dependent on clip bounds.
+ if (fPath.isInverseFillType()) {
+ memcpy(&builder[2], &fClipBounds, sizeof(fClipBounds));
+ }
+ if (styleDataCnt) {
+ GrStyle::WriteKey(&builder[2 + clipBoundsCnt], fStyle,
+ GrStyle::Apply::kPathEffectAndStrokeRec, styleScale);
+ }
+ builder.finish();
+ SkAutoTUnref<GrBuffer> cachedVertexBuffer(rp->findAndRefTByUniqueKey<GrBuffer>(key));
+ int actualCount;
+ if (cache_match(cachedVertexBuffer.get(), tol, &actualCount)) {
+ this->drawVertices(target, gp, cachedVertexBuffer.get(), 0, actualCount);
+ return;
+ }
}
SkPath path;
- GrStrokeInfo stroke(fStroke);
- if (stroke.isDashed()) {
- if (!stroke.applyDashToPath(&path, &stroke, fPath)) {
- return;
- }
+ if (fStyle.applies()) {
+ SkStrokeRec::InitStyle fill;
+ SkAssertResult(fStyle.applyToPath(&path, &fill, fPath, styleScale));
+ SkASSERT(SkStrokeRec::kFill_InitStyle == fill);
} else {
path = fPath;
}
- if (!stroke.isFillStyle()) {
- stroke.setResScale(SkScalarAbs(fViewMatrix.getMaxScale()));
- if (!stroke.applyToPath(&path, path)) {
- return;
- }
- stroke.setFillStyle();
- }
bool isLinear;
bool canMapVB = GrCaps::kNone_MapFlags != target->caps().mapBufferFlags();
StaticVertexAllocator allocator(rp, canMapVB);
return;
}
this->drawVertices(target, gp, allocator.vertexBuffer(), 0, count);
- if (!fPath.isVolatile()) {
+ if (!fPath.isVolatile() && styleDataCnt >= 0) {
TessInfo info;
info.fTolerance = isLinear ? 0 : tol;
info.fCount = count;
TessellatingPathBatch(const GrColor& color,
const SkPath& path,
- const GrStrokeInfo& stroke,
+ const GrStyle& style,
const SkMatrix& viewMatrix,
const SkRect& clipBounds)
: INHERITED(ClassID())
, fColor(color)
, fPath(path)
- , fStroke(stroke)
+ , fStyle(style)
, fViewMatrix(viewMatrix) {
const SkRect& pathBounds = path.getBounds();
fClipBounds = clipBounds;
} else {
fBounds = path.getBounds();
}
- SkScalar radius = stroke.getInflationRadius();
- fBounds.outset(radius, radius);
+ style.adjustBounds(&fBounds, fBounds);
viewMatrix.mapRect(&fBounds);
}
GrColor fColor;
SkPath fPath;
- GrStrokeInfo fStroke;
+ GrStyle fStyle;
SkMatrix fViewMatrix;
SkRect fClipBounds; // in source space
GrXPOverridesForBatch fPipelineInfo;
}
vmi.mapRect(&clipBounds);
SkAutoTUnref<GrDrawBatch> batch(TessellatingPathBatch::Create(args.fColor, *args.fPath,
- *args.fStroke, *args.fViewMatrix,
+ *args.fStyle, *args.fViewMatrix,
clipBounds));
args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
SkFAIL("Cannot invert matrix\n");
}
vmi.mapRect(&clipBounds);
- GrStrokeInfo strokeInfo = GrTest::TestStrokeInfo(random);
- return TessellatingPathBatch::Create(color, path, strokeInfo, viewMatrix, clipBounds);
+ GrStyle style;
+ do {
+ GrTest::TestStyle(random, &style);
+ } while (style.strokeRec().isHairlineStyle());
+ return TessellatingPathBatch::Create(color, path, style, viewMatrix, clipBounds);
}
#endif
#include "GrDefaultGeoProcFactory.h"
#include "GrInvariantOutput.h"
#include "GrProcessor.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "SkGr.h"
#include "batches/GrVertexBatch.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
///////////////////////////////////////////////////////////////////////////////
// Returns whether or not the gpu can fast path the dash line effect.
-bool GrDashingEffect::CanDrawDashLine(const SkPoint pts[2], const GrStrokeInfo& strokeInfo,
+bool GrDashingEffect::CanDrawDashLine(const SkPoint pts[2], const GrStyle& style,
const SkMatrix& viewMatrix) {
// Pts must be either horizontal or vertical in src space
if (pts[0].fX != pts[1].fX && pts[0].fY != pts[1].fY) {
return false;
}
- if (!strokeInfo.isDashed() || 2 != strokeInfo.getDashCount()) {
+ if (!style.isDashed() || 2 != style.dashIntervalCnt()) {
return false;
}
- const SkScalar* intervals = strokeInfo.getDashIntervals();
+ const SkScalar* intervals = style.dashIntervals();
if (0 == intervals[0] && 0 == intervals[1]) {
return false;
}
- SkPaint::Cap cap = strokeInfo.getCap();
+ SkPaint::Cap cap = style.strokeRec().getCap();
// Current we do don't handle Round or Square cap dashes
if (SkPaint::kRound_Cap == cap && intervals[0] != 0.f) {
return false;
};
static GrDrawBatch* create_batch(GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2],
- bool useAA, const GrStrokeInfo& strokeInfo, bool msaaRT) {
- const SkScalar* intervals = strokeInfo.getDashIntervals();
- SkScalar phase = strokeInfo.getDashPhase();
+ bool useAA, const GrStyle& style, bool msaaRT) {
+ SkASSERT(GrDashingEffect::CanDrawDashLine(pts, style, viewMatrix));
+ const SkScalar* intervals = style.dashIntervals();
+ SkScalar phase = style.dashPhase();
- SkPaint::Cap cap = strokeInfo.getCap();
+ SkPaint::Cap cap = style.strokeRec().getCap();
DashBatch::Geometry geometry;
- geometry.fSrcStrokeWidth = strokeInfo.getWidth();
+ geometry.fSrcStrokeWidth = style.strokeRec().getWidth();
// the phase should be normalized to be [0, sum of all intervals)
SkASSERT(phase >= 0 && phase < intervals[0] + intervals[1]);
const SkPoint pts[2],
bool useAA,
bool msaaIsEnabled,
- const GrStrokeInfo& strokeInfo) {
- return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaIsEnabled);
+ const GrStyle& style) {
+ return create_batch(color, viewMatrix, pts, useAA, style, msaaIsEnabled);
}
//////////////////////////////////////////////////////////////////////////////
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(SkIntToScalar(1));
p.setStrokeCap(cap);
+ p.setPathEffect(GrTest::TestDashPathEffect::Make(intervals, 2, phase));
- GrStrokeInfo strokeInfo(p);
+ GrStyle style(p);
- SkPathEffect::DashInfo info;
- info.fIntervals = intervals;
- info.fCount = 2;
- info.fPhase = phase;
- SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
- SkASSERT(success);
-
- return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
+ return create_batch(color, viewMatrix, pts, useAA, style, msaaRT);
}
#endif
class GrClip;
class GrDrawBatch;
-class GrStrokeInfo;
+class GrStyle;
namespace GrDashingEffect {
GrDrawBatch* CreateDashLineBatch(GrColor,
const SkPoint pts[2],
bool useAA,
bool msaaIsEnabled,
- const GrStrokeInfo& strokeInfo);
- bool CanDrawDashLine(const SkPoint pts[2], const GrStrokeInfo& strokeInfo,
+ const GrStyle& style);
+ bool CanDrawDashLine(const SkPoint pts[2], const GrStyle& style,
const SkMatrix& viewMatrix);
}
#include "GrGLPath.h"
#include "GrGLPathRendering.h"
#include "GrGLGpu.h"
+#include "GrStyle.h"
namespace {
inline GrGLubyte verb_to_gl_path_cmd(SkPath::Verb verb) {
SkAssertResult(init_path_object_for_general_path<false>(gpu, pathID, skPath));
}
-void GrGLPath::InitPathObjectStroke(GrGLGpu* gpu, GrGLuint pathID, const GrStrokeInfo& stroke) {
- SkASSERT(stroke.needToApply());
- SkASSERT(!stroke.isDashed());
+void GrGLPath::InitPathObjectStroke(GrGLGpu* gpu, GrGLuint pathID, const SkStrokeRec& stroke) {
SkASSERT(!stroke.isHairlineStyle());
GR_GL_CALL(gpu->glInterface(),
PathParameterf(pathID, GR_GL_PATH_STROKE_WIDTH, SkScalarToFloat(stroke.getWidth())));
GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, 0, nullptr, 0, GR_GL_FLOAT, nullptr));
}
-GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStrokeInfo& origStroke)
- : INHERITED(gpu, origSkPath, origStroke),
+GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStyle& style)
+ : INHERITED(gpu, origSkPath, style),
fPathID(gpu->glPathRendering()->genPaths(1)) {
if (origSkPath.isEmpty()) {
} else {
const SkPath* skPath = &origSkPath;
SkTLazy<SkPath> tmpPath;
- const GrStrokeInfo* stroke = &origStroke;
- GrStrokeInfo tmpStroke(SkStrokeRec::kFill_InitStyle);
+ SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
- if (stroke->isDashed()) {
+ if (style.pathEffect()) {
// Skia stroking and NVPR stroking differ with respect to dashing
// pattern.
- // Convert a dashing to either a stroke or a fill.
- if (stroke->applyDashToPath(tmpPath.init(), &tmpStroke, *skPath)) {
+ // Convert a dashing (or other path effect) to either a stroke or a fill.
+ if (style.applyPathEffectToPath(tmpPath.init(), &stroke, *skPath, SK_Scalar1)) {
skPath = tmpPath.get();
- stroke = &tmpStroke;
}
+ } else {
+ stroke = style.strokeRec();
}
bool didInit = false;
- if (stroke->needToApply() && stroke->getCap() != SkPaint::kButt_Cap) {
+ if (stroke.needToApply() && stroke.getCap() != SkPaint::kButt_Cap) {
// Skia stroking and NVPR stroking differ with respect to stroking
// end caps of empty subpaths.
// Convert stroke to fill if path contains empty subpaths.
if (!tmpPath.isValid()) {
tmpPath.init();
}
- SkAssertResult(stroke->applyToPath(tmpPath.get(), *skPath));
+ SkAssertResult(stroke.applyToPath(tmpPath.get(), *skPath));
skPath = tmpPath.get();
- tmpStroke.setFillStyle();
- stroke = &tmpStroke;
+ stroke.setFillStyle();
}
}
InitPathObjectPathData(gpu, fPathID, *skPath);
}
- fShouldStroke = stroke->needToApply();
- fShouldFill = stroke->isFillStyle() ||
- stroke->getStyle() == SkStrokeRec::kStrokeAndFill_Style;
+ fShouldStroke = stroke.needToApply();
+ fShouldFill = stroke.isFillStyle() ||
+ stroke.getStyle() == SkStrokeRec::kStrokeAndFill_Style;
fFillType = convert_skpath_filltype(skPath->getFillType());
fBounds = skPath->getBounds();
-
+ SkScalar radius = stroke.getInflationRadius();
+ fBounds.outset(radius, radius);
if (fShouldStroke) {
- InitPathObjectStroke(gpu, fPathID, *stroke);
-
- // FIXME: try to account for stroking, without rasterizing the stroke.
- fBounds.outset(stroke->getWidth(), stroke->getWidth());
+ InitPathObjectStroke(gpu, fPathID, stroke);
}
}
#include "gl/GrGLTypes.h"
class GrGLGpu;
+class GrStyle;
/**
* Currently this represents a path built using GL_NV_path_rendering. If we
static void InitPathObjectPathData(GrGLGpu*,
GrGLuint pathID,
const SkPath&);
- static void InitPathObjectStroke(GrGLGpu* gpu, GrGLuint pathID, const GrStrokeInfo& stroke);
+ static void InitPathObjectStroke(GrGLGpu*, GrGLuint pathID, const SkStrokeRec&);
static void InitPathObjectEmptyPath(GrGLGpu*, GrGLuint pathID);
- GrGLPath(GrGLGpu* gpu, const SkPath& path, const GrStrokeInfo& stroke);
+ GrGLPath(GrGLGpu*, const SkPath&, const GrStyle&);
GrGLuint pathID() const { return fPathID; }
bool shouldStroke() const { return fShouldStroke; }
#include "GrGLPathRendering.h"
#include "GrGLGpu.h"
-GrGLPathRange::GrGLPathRange(GrGLGpu* gpu, PathGenerator* pathGenerator, const GrStrokeInfo& stroke)
+GrGLPathRange::GrGLPathRange(GrGLGpu* gpu, PathGenerator* pathGenerator, const GrStyle& style)
: INHERITED(gpu, pathGenerator),
- fStroke(stroke),
+ fStyle(style),
fBasePathID(gpu->glPathRendering()->genPaths(this->getNumPaths())),
fGpuMemorySize(0) {
this->init();
GrGLuint basePathID,
int numPaths,
size_t gpuMemorySize,
- const GrStrokeInfo& stroke)
+ const GrStyle& style)
: INHERITED(gpu, numPaths),
- fStroke(stroke),
+ fStyle(style),
fBasePathID(basePathID),
fGpuMemorySize(gpuMemorySize) {
this->init();
}
void GrGLPathRange::init() {
+ const SkStrokeRec& stroke = fStyle.strokeRec();
// Must force fill:
// * dashing: NVPR stroke dashing is different to Skia.
// * end caps: NVPR stroking degenerate contours with end caps is different to Skia.
- bool forceFill = fStroke.isDashed() ||
- (fStroke.needToApply() && fStroke.getCap() != SkPaint::kButt_Cap);
+ bool forceFill = fStyle.pathEffect() ||
+ (stroke.needToApply() && stroke.getCap() != SkPaint::kButt_Cap);
if (forceFill) {
fShouldStroke = false;
fShouldFill = true;
} else {
- fShouldStroke = fStroke.needToApply();
- fShouldFill = fStroke.isFillStyle() ||
- fStroke.getStyle() == SkStrokeRec::kStrokeAndFill_Style;
+ fShouldStroke = stroke.needToApply();
+ fShouldFill = stroke.isFillStyle() ||
+ stroke.getStyle() == SkStrokeRec::kStrokeAndFill_Style;
}
}
if (nullptr == gpu) {
return;
}
-
// Make sure the path at this index hasn't been initted already.
SkDEBUGCODE(
GrGLboolean isPath;
GrGLPath::InitPathObjectEmptyPath(gpu, fBasePathID + index);
} else if (fShouldStroke) {
GrGLPath::InitPathObjectPathData(gpu, fBasePathID + index, origSkPath);
- GrGLPath::InitPathObjectStroke(gpu, fBasePathID + index, fStroke);
+ GrGLPath::InitPathObjectStroke(gpu, fBasePathID + index, fStyle.strokeRec());
} else {
const SkPath* skPath = &origSkPath;
SkTLazy<SkPath> tmpPath;
- const GrStrokeInfo* stroke = &fStroke;
- GrStrokeInfo tmpStroke(SkStrokeRec::kFill_InitStyle);
-
- // Dashing must be applied to the path. However, if dashing is present,
- // we must convert all the paths to fills. The GrStrokeInfo::applyDash leaves
- // simple paths as strokes but converts other paths to fills.
- // Thus we must stroke the strokes here, so that all paths in the
- // path range are using the same style.
- if (fStroke.isDashed()) {
- if (!stroke->applyDashToPath(tmpPath.init(), &tmpStroke, *skPath)) {
+ if (!fStyle.isSimpleFill()) {
+ SkStrokeRec::InitStyle fill;
+ // The path effect must be applied to the path. However, if a path effect is present,
+ // we must convert all the paths to fills. The path effect application may leave
+ // simple paths as strokes but converts other paths to fills.
+ // Thus we must stroke the strokes here, so that all paths in the
+ // path range are using the same style.
+ if (!fStyle.applyToPath(tmpPath.init(), &fill, *skPath, SK_Scalar1)) {
return;
}
+ // We shouldn't have allowed hairlines or arbitrary path effect styles to get here
+ // so after application we better have a filled path.
+ SkASSERT(SkStrokeRec::kFill_InitStyle == fill);
skPath = tmpPath.get();
- stroke = &tmpStroke;
- }
- if (stroke->needToApply()) {
- if (!tmpPath.isValid()) {
- tmpPath.init();
- }
- if (!stroke->applyToPath(tmpPath.get(), *tmpPath.get())) {
- return;
- }
+
}
GrGLPath::InitPathObjectPathData(gpu, fBasePathID + index, *skPath);
}
#define GrGLPathRange_DEFINED
#include "../GrPathRange.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "gl/GrGLTypes.h"
class GrGLGpu;
* Initialize a GL path range from a PathGenerator. This class will allocate
* the GPU path objects and initialize them lazily.
*/
- GrGLPathRange(GrGLGpu*, PathGenerator*, const GrStrokeInfo&);
+ GrGLPathRange(GrGLGpu*, PathGenerator*, const GrStyle&);
/**
* Initialize a GL path range from an existing range of pre-initialized GPU
GrGLuint basePathID,
int numPaths,
size_t gpuMemorySize,
- const GrStrokeInfo&);
+ const GrStyle&);
GrGLuint basePathID() const { return fBasePathID; }
void init();
size_t onGpuMemorySize() const override { return fGpuMemorySize; }
- const GrStrokeInfo fStroke;
+ const GrStyle fStyle;
GrGLuint fBasePathID;
mutable size_t fGpuMemorySize;
bool fShouldStroke;
fHWPathStencilSettings.invalidate();
}
-GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const GrStrokeInfo& stroke) {
- return new GrGLPath(this->gpu(), inPath, stroke);
+GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const GrStyle& style) {
+ return new GrGLPath(this->gpu(), inPath, style);
}
GrPathRange* GrGLPathRendering::createPathRange(GrPathRange::PathGenerator* pathGenerator,
- const GrStrokeInfo& stroke) {
- return new GrGLPathRange(this->gpu(), pathGenerator, stroke);
+ const GrStyle& style) {
+ return new GrGLPathRange(this->gpu(), pathGenerator, style);
}
void GrGLPathRendering::onStencilPath(const StencilPathArgs& args, const GrPath* path) {
class GrGLNameAllocator;
class GrGLGpu;
+class GrStyle;
/**
* This class wraps the NV_path_rendering extension and manages its various
virtual ~GrGLPathRendering();
// GrPathRendering implementations.
- GrPath* createPath(const SkPath&, const GrStrokeInfo&) override;
+ GrPath* createPath(const SkPath&, const GrStyle&) override;
virtual GrPathRange* createPathRange(GrPathRange::PathGenerator*,
- const GrStrokeInfo&) override;
+ const GrStyle&) override;
/* Called when the 3D context state is unknown. */
void resetContext();
}
}
+static inline int style_key_cnt(const GrStyle& style) {
+ int cnt = GrStyle::KeySize(style, GrStyle::Apply::kPathEffectAndStrokeRec);
+ // We should be able to make a key because we filtered out arbitrary path effects.
+ SkASSERT(cnt > 0);
+ return cnt;
+}
+
+static inline void write_style_key(uint32_t* dst, const GrStyle& style) {
+ // Pass 1 for the scale since the GPU will apply the style not GrStyle::applyToPath().
+ GrStyle::WriteKey(dst, style, GrStyle::Apply::kPathEffectAndStrokeRec, SK_Scalar1);
+}
+
const GrStencilAndCoverTextContext::TextBlob&
GrStencilAndCoverTextContext::findOrCreateTextBlob(const SkTextBlob* skBlob,
const SkPaint& skPaint) {
fCacheSize += blob->cpuMemorySize();
return *blob;
} else {
- GrStrokeInfo stroke(skPaint);
+ GrStyle style(skPaint);
SkSTArray<4, uint32_t, true> key;
- key.reset(1 + stroke.computeUniqueKeyFragmentData32Cnt());
+ key.reset(1 + style_key_cnt(style));
key[0] = skBlob->uniqueID();
- stroke.asUniqueKeyFragment(&key[1]);
+ write_style_key(&key[1], style);
if (TextBlob** found = fBlobKeyCache.find(key)) {
fLRUList.remove(*found);
fLRUList.addToTail(*found);
////////////////////////////////////////////////////////////////////////////////////////////////////
GrStencilAndCoverTextContext::TextRun::TextRun(const SkPaint& fontAndStroke)
- : fStroke(fontAndStroke),
+ : fStyle(fontAndStroke),
fFont(fontAndStroke),
fTotalGlyphCount(0),
fFallbackGlyphCount(0),
fDetachedGlyphCache(nullptr),
fLastDrawnGlyphsID(SK_InvalidUniqueID) {
SkASSERT(fFont.getTextSize() > 0);
- SkASSERT(!fStroke.isHairlineStyle()); // Hairlines are not supported.
+ SkASSERT(!fStyle.hasNonDashPathEffect()); // Arbitrary path effects not supported.
+ SkASSERT(!fStyle.isSimpleHairline()); // Hairlines are not supported.
// Setting to "fill" ensures that no strokes get baked into font outlines. (We use the GPU path
// rendering API for stroking).
fFont.setStyle(SkPaint::kFill_Style);
- if (fFont.isFakeBoldText() && SkStrokeRec::kStroke_Style != fStroke.getStyle()) {
+ if (fFont.isFakeBoldText() && fStyle.isSimpleFill()) {
+ const SkStrokeRec& stroke = fStyle.strokeRec();
// Instead of letting fake bold get baked into the glyph outlines, do it with GPU stroke.
SkScalar fakeBoldScale = SkScalarInterpFunc(fFont.getTextSize(),
kStdFakeBoldInterpKeys,
kStdFakeBoldInterpValues,
kStdFakeBoldInterpLength);
SkScalar extra = SkScalarMul(fFont.getTextSize(), fakeBoldScale);
- fStroke.setStrokeStyle(fStroke.needToApply() ? fStroke.getWidth() + extra : extra,
- true /*strokeAndFill*/);
+ SkStrokeRec strokeRec(SkStrokeRec::kFill_InitStyle);
+ strokeRec.setStrokeStyle(stroke.needToApply() ? stroke.getWidth() + extra : extra,
+ true /*strokeAndFill*/);
+ fStyle = GrStyle(strokeRec, fStyle.pathEffect());
fFont.setFakeBoldText(false);
}
- if (!fFont.getPathEffect() && !fStroke.isDashed()) {
+ if (!fFont.getPathEffect() && !fStyle.isDashed()) {
+ const SkStrokeRec& stroke = fStyle.strokeRec();
// We can draw the glyphs from canonically sized paths.
fTextRatio = fFont.getTextSize() / SkPaint::kCanonicalTextSizeForPaths;
fTextInverseRatio = SkPaint::kCanonicalTextSizeForPaths / fFont.getTextSize();
// Compensate for the glyphs being scaled by fTextRatio.
- if (!fStroke.isFillStyle()) {
- fStroke.setStrokeStyle(fStroke.getWidth() / fTextRatio,
- SkStrokeRec::kStrokeAndFill_Style == fStroke.getStyle());
+ if (!fStyle.isSimpleFill()) {
+ SkStrokeRec strokeRec(SkStrokeRec::kFill_InitStyle);
+ strokeRec.setStrokeStyle(stroke.getWidth() / fTextRatio,
+ SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle());
+ fStyle = GrStyle(strokeRec, fStyle.pathEffect());
}
fFont.setLinearText(true);
}
// Generate the key that will be used to cache the GPU glyph path objects.
- if (fUsingRawGlyphPaths && fStroke.isFillStyle()) {
+ if (fUsingRawGlyphPaths && fStyle.isSimpleFill()) {
static const GrUniqueKey::Domain kRawFillPathGlyphDomain = GrUniqueKey::GenerateDomain();
const SkTypeface* typeface = fFont.getTypeface();
} else {
static const GrUniqueKey::Domain kPathGlyphDomain = GrUniqueKey::GenerateDomain();
- int strokeDataCount = fStroke.computeUniqueKeyFragmentData32Cnt();
+ int styleDataCount = GrStyle::KeySize(fStyle, GrStyle::Apply::kPathEffectAndStrokeRec);
+ // Key should be valid since we opted out of drawing arbitrary path effects.
+ SkASSERT(styleDataCount >= 0);
if (fUsingRawGlyphPaths) {
const SkTypeface* typeface = fFont.getTypeface();
- GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain, 2 + strokeDataCount);
+ GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain, 2 + styleDataCount);
reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
- reinterpret_cast<uint32_t&>(builder[1]) = strokeDataCount;
- fStroke.asUniqueKeyFragment(&builder[2]);
+ reinterpret_cast<uint32_t&>(builder[1]) = styleDataCount;
+ if (styleDataCount) {
+ write_style_key(&builder[2], fStyle);
+ }
} else {
SkGlyphCache* glyphCache = this->getGlyphCache();
const SkTypeface* typeface = glyphCache->getScalerContext()->getTypeface();
const SkDescriptor* desc = &glyphCache->getDescriptor();
int descDataCount = (desc->getLength() + 3) / 4;
GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain,
- 2 + strokeDataCount + descDataCount);
+ 2 + styleDataCount + descDataCount);
reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
- reinterpret_cast<uint32_t&>(builder[1]) = strokeDataCount | (descDataCount << 16);
- fStroke.asUniqueKeyFragment(&builder[2]);
- memcpy(&builder[2 + strokeDataCount], desc, desc->getLength());
+ reinterpret_cast<uint32_t&>(builder[1]) = styleDataCount | (descDataCount << 16);
+ if (styleDataCount) {
+ write_style_key(&builder[2], fStyle);
+ }
+ memcpy(&builder[2 + styleDataCount], desc, desc->getLength());
}
}
}
if (fUsingRawGlyphPaths) {
SkScalerContextEffects noeffects;
glyphs = ctx->resourceProvider()->createGlyphs(fFont.getTypeface(), noeffects,
- nullptr, fStroke);
+ nullptr, fStyle);
} else {
SkGlyphCache* cache = this->getGlyphCache();
glyphs = ctx->resourceProvider()->createGlyphs(cache->getScalerContext()->getTypeface(),
cache->getScalerContext()->getEffects(),
&cache->getDescriptor(),
- fStroke);
+ fStyle);
}
ctx->resourceProvider()->assignUniqueKeyToResource(fGlyphPathsKey, glyphs);
}
if (fFallbackTextBlob) {
SkPaint fallbackSkPaint(originalSkPaint);
- fStroke.applyToPaint(&fallbackSkPaint);
- if (!fStroke.isFillStyle()) {
- fallbackSkPaint.setStrokeWidth(fStroke.getWidth() * fTextRatio);
+ fStyle.strokeRec().applyToPaint(&fallbackSkPaint);
+ if (!fStyle.isSimpleFill()) {
+ fallbackSkPaint.setStrokeWidth(fStyle.strokeRec().getWidth() * fTextRatio);
}
fallbackTextContext->drawTextBlob(ctx, dc, pipelineBuilder->clip(), fallbackSkPaint,
#define GrStencilAndCoverTextContext_DEFINED
#include "GrDrawContext.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "SkDrawFilter.h"
#include "SkTextBlob.h"
#include "SkTHash.h"
GrPathRange* createGlyphs(GrContext*) const;
void appendGlyph(const SkGlyph&, const SkPoint&, FallbackBlobBuilder*);
- GrStrokeInfo fStroke;
+ GrStyle fStyle;
SkPaint fFont;
SkScalar fTextRatio;
float fTextInverseRatio;
#include "GrContext.h"
#include "GrPath.h"
-#include "GrStrokeInfo.h"
+#include "GrStyle.h"
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkColor.h"
bool isVolatile;
GrUniqueKey key1, key2;
- GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
- GrPath::ComputeKey(path1, stroke, &key1, &isVolatile);
- GrPath::ComputeKey(path2, stroke, &key2, &isVolatile);
+ GrPath::ComputeKey(path1, GrStyle::SimpleFill(), &key1, &isVolatile);
+ GrPath::ComputeKey(path2, GrStyle::SimpleFill(), &key2, &isVolatile);
REPORTER_ASSERT(reporter, key1 != key2);
}
pipelineBuilder.setXPFactory(
GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
pipelineBuilder.setRenderTarget(rt);
- GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
+ GrStyle style(SkStrokeRec::kFill_InitStyle);
GrPathRenderer::DrawPathArgs args;
args.fTarget = dt;
args.fPipelineBuilder = &pipelineBuilder;
args.fColor = GrColor_WHITE;
args.fViewMatrix = &SkMatrix::I();
args.fPath = &path;
- args.fStroke = &stroke;
+ args.fStyle = &style;
args.fAntiAlias = false;
tess.drawPath(args);
}
projects / platform / upstream / libSkiaSharp.git / commitdiff