michael@0: michael@0: /* michael@0: * Copyright 2012 Google Inc. michael@0: * michael@0: * Use of this source code is governed by a BSD-style license that can be michael@0: * found in the LICENSE file. michael@0: */ michael@0: michael@0: #include "GrAAConvexPathRenderer.h" michael@0: michael@0: #include "GrContext.h" michael@0: #include "GrDrawState.h" michael@0: #include "GrDrawTargetCaps.h" michael@0: #include "GrEffect.h" michael@0: #include "GrPathUtils.h" michael@0: #include "GrTBackendEffectFactory.h" michael@0: #include "SkString.h" michael@0: #include "SkStrokeRec.h" michael@0: #include "SkTrace.h" michael@0: michael@0: #include "gl/GrGLEffect.h" michael@0: #include "gl/GrGLSL.h" michael@0: #include "gl/GrGLVertexEffect.h" michael@0: michael@0: #include "effects/GrVertexEffect.h" michael@0: michael@0: GrAAConvexPathRenderer::GrAAConvexPathRenderer() { michael@0: } michael@0: michael@0: struct Segment { michael@0: enum { michael@0: // These enum values are assumed in member functions below. michael@0: kLine = 0, michael@0: kQuad = 1, michael@0: } fType; michael@0: michael@0: // line uses one pt, quad uses 2 pts michael@0: GrPoint fPts[2]; michael@0: // normal to edge ending at each pt michael@0: GrVec fNorms[2]; michael@0: // is the corner where the previous segment meets this segment michael@0: // sharp. If so, fMid is a normalized bisector facing outward. michael@0: GrVec fMid; michael@0: michael@0: int countPoints() { michael@0: GR_STATIC_ASSERT(0 == kLine && 1 == kQuad); michael@0: return fType + 1; michael@0: } michael@0: const SkPoint& endPt() const { michael@0: GR_STATIC_ASSERT(0 == kLine && 1 == kQuad); michael@0: return fPts[fType]; michael@0: }; michael@0: const SkPoint& endNorm() const { michael@0: GR_STATIC_ASSERT(0 == kLine && 1 == kQuad); michael@0: return fNorms[fType]; michael@0: }; michael@0: }; michael@0: michael@0: typedef SkTArray SegmentArray; michael@0: michael@0: static void center_of_mass(const SegmentArray& segments, SkPoint* c) { michael@0: SkScalar area = 0; michael@0: SkPoint center = {0, 0}; michael@0: int count = segments.count(); michael@0: SkPoint p0 = {0, 0}; michael@0: if (count > 2) { michael@0: // We translate the polygon so that the first point is at the origin. michael@0: // This avoids some precision issues with small area polygons far away michael@0: // from the origin. michael@0: p0 = segments[0].endPt(); michael@0: SkPoint pi; michael@0: SkPoint pj; michael@0: // the first and last iteration of the below loop would compute michael@0: // zeros since the starting / ending point is (0,0). So instead we start michael@0: // at i=1 and make the last iteration i=count-2. michael@0: pj = segments[1].endPt() - p0; michael@0: for (int i = 1; i < count - 1; ++i) { michael@0: pi = pj; michael@0: const SkPoint pj = segments[i + 1].endPt() - p0; michael@0: michael@0: SkScalar t = SkScalarMul(pi.fX, pj.fY) - SkScalarMul(pj.fX, pi.fY); michael@0: area += t; michael@0: center.fX += (pi.fX + pj.fX) * t; michael@0: center.fY += (pi.fY + pj.fY) * t; michael@0: michael@0: } michael@0: } michael@0: // If the poly has no area then we instead return the average of michael@0: // its points. michael@0: if (SkScalarNearlyZero(area)) { michael@0: SkPoint avg; michael@0: avg.set(0, 0); michael@0: for (int i = 0; i < count; ++i) { michael@0: const SkPoint& pt = segments[i].endPt(); michael@0: avg.fX += pt.fX; michael@0: avg.fY += pt.fY; michael@0: } michael@0: SkScalar denom = SK_Scalar1 / count; michael@0: avg.scale(denom); michael@0: *c = avg; michael@0: } else { michael@0: area *= 3; michael@0: area = SkScalarDiv(SK_Scalar1, area); michael@0: center.fX = SkScalarMul(center.fX, area); michael@0: center.fY = SkScalarMul(center.fY, area); michael@0: // undo the translate of p0 to the origin. michael@0: *c = center + p0; michael@0: } michael@0: SkASSERT(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY)); michael@0: } michael@0: michael@0: static void compute_vectors(SegmentArray* segments, michael@0: SkPoint* fanPt, michael@0: SkPath::Direction dir, michael@0: int* vCount, michael@0: int* iCount) { michael@0: center_of_mass(*segments, fanPt); michael@0: int count = segments->count(); michael@0: michael@0: // Make the normals point towards the outside michael@0: GrPoint::Side normSide; michael@0: if (dir == SkPath::kCCW_Direction) { michael@0: normSide = GrPoint::kRight_Side; michael@0: } else { michael@0: normSide = GrPoint::kLeft_Side; michael@0: } michael@0: michael@0: *vCount = 0; michael@0: *iCount = 0; michael@0: // compute normals at all points michael@0: for (int a = 0; a < count; ++a) { michael@0: Segment& sega = (*segments)[a]; michael@0: int b = (a + 1) % count; michael@0: Segment& segb = (*segments)[b]; michael@0: michael@0: const GrPoint* prevPt = &sega.endPt(); michael@0: int n = segb.countPoints(); michael@0: for (int p = 0; p < n; ++p) { michael@0: segb.fNorms[p] = segb.fPts[p] - *prevPt; michael@0: segb.fNorms[p].normalize(); michael@0: segb.fNorms[p].setOrthog(segb.fNorms[p], normSide); michael@0: prevPt = &segb.fPts[p]; michael@0: } michael@0: if (Segment::kLine == segb.fType) { michael@0: *vCount += 5; michael@0: *iCount += 9; michael@0: } else { michael@0: *vCount += 6; michael@0: *iCount += 12; michael@0: } michael@0: } michael@0: michael@0: // compute mid-vectors where segments meet. TODO: Detect shallow corners michael@0: // and leave out the wedges and close gaps by stitching segments together. michael@0: for (int a = 0; a < count; ++a) { michael@0: const Segment& sega = (*segments)[a]; michael@0: int b = (a + 1) % count; michael@0: Segment& segb = (*segments)[b]; michael@0: segb.fMid = segb.fNorms[0] + sega.endNorm(); michael@0: segb.fMid.normalize(); michael@0: // corner wedges michael@0: *vCount += 4; michael@0: *iCount += 6; michael@0: } michael@0: } michael@0: michael@0: struct DegenerateTestData { michael@0: DegenerateTestData() { fStage = kInitial; } michael@0: bool isDegenerate() const { return kNonDegenerate != fStage; } michael@0: enum { michael@0: kInitial, michael@0: kPoint, michael@0: kLine, michael@0: kNonDegenerate michael@0: } fStage; michael@0: GrPoint fFirstPoint; michael@0: GrVec fLineNormal; michael@0: SkScalar fLineC; michael@0: }; michael@0: michael@0: static const SkScalar kClose = (SK_Scalar1 / 16); michael@0: static const SkScalar kCloseSqd = SkScalarMul(kClose, kClose); michael@0: michael@0: static void update_degenerate_test(DegenerateTestData* data, const GrPoint& pt) { michael@0: switch (data->fStage) { michael@0: case DegenerateTestData::kInitial: michael@0: data->fFirstPoint = pt; michael@0: data->fStage = DegenerateTestData::kPoint; michael@0: break; michael@0: case DegenerateTestData::kPoint: michael@0: if (pt.distanceToSqd(data->fFirstPoint) > kCloseSqd) { michael@0: data->fLineNormal = pt - data->fFirstPoint; michael@0: data->fLineNormal.normalize(); michael@0: data->fLineNormal.setOrthog(data->fLineNormal); michael@0: data->fLineC = -data->fLineNormal.dot(data->fFirstPoint); michael@0: data->fStage = DegenerateTestData::kLine; michael@0: } michael@0: break; michael@0: case DegenerateTestData::kLine: michael@0: if (SkScalarAbs(data->fLineNormal.dot(pt) + data->fLineC) > kClose) { michael@0: data->fStage = DegenerateTestData::kNonDegenerate; michael@0: } michael@0: case DegenerateTestData::kNonDegenerate: michael@0: break; michael@0: default: michael@0: GrCrash("Unexpected degenerate test stage."); michael@0: } michael@0: } michael@0: michael@0: static inline bool get_direction(const SkPath& path, const SkMatrix& m, SkPath::Direction* dir) { michael@0: if (!path.cheapComputeDirection(dir)) { michael@0: return false; michael@0: } michael@0: // check whether m reverses the orientation michael@0: SkASSERT(!m.hasPerspective()); michael@0: SkScalar det2x2 = SkScalarMul(m.get(SkMatrix::kMScaleX), m.get(SkMatrix::kMScaleY)) - michael@0: SkScalarMul(m.get(SkMatrix::kMSkewX), m.get(SkMatrix::kMSkewY)); michael@0: if (det2x2 < 0) { michael@0: *dir = SkPath::OppositeDirection(*dir); michael@0: } michael@0: return true; michael@0: } michael@0: michael@0: static inline void add_line_to_segment(const SkPoint& pt, michael@0: SegmentArray* segments, michael@0: SkRect* devBounds) { michael@0: segments->push_back(); michael@0: segments->back().fType = Segment::kLine; michael@0: segments->back().fPts[0] = pt; michael@0: devBounds->growToInclude(pt.fX, pt.fY); michael@0: } michael@0: michael@0: #ifdef SK_DEBUG michael@0: static inline bool contains_inclusive(const SkRect& rect, const SkPoint& p) { michael@0: return p.fX >= rect.fLeft && p.fX <= rect.fRight && p.fY >= rect.fTop && p.fY <= rect.fBottom; michael@0: } michael@0: #endif michael@0: michael@0: static inline void add_quad_segment(const SkPoint pts[3], michael@0: SegmentArray* segments, michael@0: SkRect* devBounds) { michael@0: if (pts[0].distanceToSqd(pts[1]) < kCloseSqd || pts[1].distanceToSqd(pts[2]) < kCloseSqd) { michael@0: if (pts[0] != pts[2]) { michael@0: add_line_to_segment(pts[2], segments, devBounds); michael@0: } michael@0: } else { michael@0: segments->push_back(); michael@0: segments->back().fType = Segment::kQuad; michael@0: segments->back().fPts[0] = pts[1]; michael@0: segments->back().fPts[1] = pts[2]; michael@0: SkASSERT(contains_inclusive(*devBounds, pts[0])); michael@0: devBounds->growToInclude(pts + 1, 2); michael@0: } michael@0: } michael@0: michael@0: static inline void add_cubic_segments(const SkPoint pts[4], michael@0: SkPath::Direction dir, michael@0: SegmentArray* segments, michael@0: SkRect* devBounds) { michael@0: SkSTArray<15, SkPoint, true> quads; michael@0: GrPathUtils::convertCubicToQuads(pts, SK_Scalar1, true, dir, &quads); michael@0: int count = quads.count(); michael@0: for (int q = 0; q < count; q += 3) { michael@0: add_quad_segment(&quads[q], segments, devBounds); michael@0: } michael@0: } michael@0: michael@0: static bool get_segments(const SkPath& path, michael@0: const SkMatrix& m, michael@0: SegmentArray* segments, michael@0: SkPoint* fanPt, michael@0: int* vCount, michael@0: int* iCount, michael@0: SkRect* devBounds) { michael@0: SkPath::Iter iter(path, true); michael@0: // This renderer over-emphasizes very thin path regions. We use the distance michael@0: // to the path from the sample to compute coverage. Every pixel intersected michael@0: // by the path will be hit and the maximum distance is sqrt(2)/2. We don't michael@0: // notice that the sample may be close to a very thin area of the path and michael@0: // thus should be very light. This is particularly egregious for degenerate michael@0: // line paths. We detect paths that are very close to a line (zero area) and michael@0: // draw nothing. michael@0: DegenerateTestData degenerateData; michael@0: SkPath::Direction dir; michael@0: // get_direction can fail for some degenerate paths. michael@0: if (!get_direction(path, m, &dir)) { michael@0: return false; michael@0: } michael@0: michael@0: for (;;) { michael@0: GrPoint pts[4]; michael@0: SkPath::Verb verb = iter.next(pts); michael@0: switch (verb) { michael@0: case SkPath::kMove_Verb: michael@0: m.mapPoints(pts, 1); michael@0: update_degenerate_test(°enerateData, pts[0]); michael@0: devBounds->set(pts->fX, pts->fY, pts->fX, pts->fY); michael@0: break; michael@0: case SkPath::kLine_Verb: { michael@0: m.mapPoints(&pts[1], 1); michael@0: update_degenerate_test(°enerateData, pts[1]); michael@0: add_line_to_segment(pts[1], segments, devBounds); michael@0: break; michael@0: } michael@0: case SkPath::kQuad_Verb: michael@0: m.mapPoints(pts, 3); michael@0: update_degenerate_test(°enerateData, pts[1]); michael@0: update_degenerate_test(°enerateData, pts[2]); michael@0: add_quad_segment(pts, segments, devBounds); michael@0: break; michael@0: case SkPath::kCubic_Verb: { michael@0: m.mapPoints(pts, 4); michael@0: update_degenerate_test(°enerateData, pts[1]); michael@0: update_degenerate_test(°enerateData, pts[2]); michael@0: update_degenerate_test(°enerateData, pts[3]); michael@0: add_cubic_segments(pts, dir, segments, devBounds); michael@0: break; michael@0: }; michael@0: case SkPath::kDone_Verb: michael@0: if (degenerateData.isDegenerate()) { michael@0: return false; michael@0: } else { michael@0: compute_vectors(segments, fanPt, dir, vCount, iCount); michael@0: return true; michael@0: } michael@0: default: michael@0: break; michael@0: } michael@0: } michael@0: } michael@0: michael@0: struct QuadVertex { michael@0: GrPoint fPos; michael@0: GrPoint fUV; michael@0: SkScalar fD0; michael@0: SkScalar fD1; michael@0: }; michael@0: michael@0: struct Draw { michael@0: Draw() : fVertexCnt(0), fIndexCnt(0) {} michael@0: int fVertexCnt; michael@0: int fIndexCnt; michael@0: }; michael@0: michael@0: typedef SkTArray DrawArray; michael@0: michael@0: static void create_vertices(const SegmentArray& segments, michael@0: const SkPoint& fanPt, michael@0: DrawArray* draws, michael@0: QuadVertex* verts, michael@0: uint16_t* idxs) { michael@0: Draw* draw = &draws->push_back(); michael@0: // alias just to make vert/index assignments easier to read. michael@0: int* v = &draw->fVertexCnt; michael@0: int* i = &draw->fIndexCnt; michael@0: michael@0: int count = segments.count(); michael@0: for (int a = 0; a < count; ++a) { michael@0: const Segment& sega = segments[a]; michael@0: int b = (a + 1) % count; michael@0: const Segment& segb = segments[b]; michael@0: michael@0: // Check whether adding the verts for this segment to the current draw would cause index michael@0: // values to overflow. michael@0: int vCount = 4; michael@0: if (Segment::kLine == segb.fType) { michael@0: vCount += 5; michael@0: } else { michael@0: vCount += 6; michael@0: } michael@0: if (draw->fVertexCnt + vCount > (1 << 16)) { michael@0: verts += *v; michael@0: idxs += *i; michael@0: draw = &draws->push_back(); michael@0: v = &draw->fVertexCnt; michael@0: i = &draw->fIndexCnt; michael@0: } michael@0: michael@0: // FIXME: These tris are inset in the 1 unit arc around the corner michael@0: verts[*v + 0].fPos = sega.endPt(); michael@0: verts[*v + 1].fPos = verts[*v + 0].fPos + sega.endNorm(); michael@0: verts[*v + 2].fPos = verts[*v + 0].fPos + segb.fMid; michael@0: verts[*v + 3].fPos = verts[*v + 0].fPos + segb.fNorms[0]; michael@0: verts[*v + 0].fUV.set(0,0); michael@0: verts[*v + 1].fUV.set(0,-SK_Scalar1); michael@0: verts[*v + 2].fUV.set(0,-SK_Scalar1); michael@0: verts[*v + 3].fUV.set(0,-SK_Scalar1); michael@0: verts[*v + 0].fD0 = verts[*v + 0].fD1 = -SK_Scalar1; michael@0: verts[*v + 1].fD0 = verts[*v + 1].fD1 = -SK_Scalar1; michael@0: verts[*v + 2].fD0 = verts[*v + 2].fD1 = -SK_Scalar1; michael@0: verts[*v + 3].fD0 = verts[*v + 3].fD1 = -SK_Scalar1; michael@0: michael@0: idxs[*i + 0] = *v + 0; michael@0: idxs[*i + 1] = *v + 2; michael@0: idxs[*i + 2] = *v + 1; michael@0: idxs[*i + 3] = *v + 0; michael@0: idxs[*i + 4] = *v + 3; michael@0: idxs[*i + 5] = *v + 2; michael@0: michael@0: *v += 4; michael@0: *i += 6; michael@0: michael@0: if (Segment::kLine == segb.fType) { michael@0: verts[*v + 0].fPos = fanPt; michael@0: verts[*v + 1].fPos = sega.endPt(); michael@0: verts[*v + 2].fPos = segb.fPts[0]; michael@0: michael@0: verts[*v + 3].fPos = verts[*v + 1].fPos + segb.fNorms[0]; michael@0: verts[*v + 4].fPos = verts[*v + 2].fPos + segb.fNorms[0]; michael@0: michael@0: // we draw the line edge as a degenerate quad (u is 0, v is the michael@0: // signed distance to the edge) michael@0: SkScalar dist = fanPt.distanceToLineBetween(verts[*v + 1].fPos, michael@0: verts[*v + 2].fPos); michael@0: verts[*v + 0].fUV.set(0, dist); michael@0: verts[*v + 1].fUV.set(0, 0); michael@0: verts[*v + 2].fUV.set(0, 0); michael@0: verts[*v + 3].fUV.set(0, -SK_Scalar1); michael@0: verts[*v + 4].fUV.set(0, -SK_Scalar1); michael@0: michael@0: verts[*v + 0].fD0 = verts[*v + 0].fD1 = -SK_Scalar1; michael@0: verts[*v + 1].fD0 = verts[*v + 1].fD1 = -SK_Scalar1; michael@0: verts[*v + 2].fD0 = verts[*v + 2].fD1 = -SK_Scalar1; michael@0: verts[*v + 3].fD0 = verts[*v + 3].fD1 = -SK_Scalar1; michael@0: verts[*v + 4].fD0 = verts[*v + 4].fD1 = -SK_Scalar1; michael@0: michael@0: idxs[*i + 0] = *v + 0; michael@0: idxs[*i + 1] = *v + 2; michael@0: idxs[*i + 2] = *v + 1; michael@0: michael@0: idxs[*i + 3] = *v + 3; michael@0: idxs[*i + 4] = *v + 1; michael@0: idxs[*i + 5] = *v + 2; michael@0: michael@0: idxs[*i + 6] = *v + 4; michael@0: idxs[*i + 7] = *v + 3; michael@0: idxs[*i + 8] = *v + 2; michael@0: michael@0: *v += 5; michael@0: *i += 9; michael@0: } else { michael@0: GrPoint qpts[] = {sega.endPt(), segb.fPts[0], segb.fPts[1]}; michael@0: michael@0: GrVec midVec = segb.fNorms[0] + segb.fNorms[1]; michael@0: midVec.normalize(); michael@0: michael@0: verts[*v + 0].fPos = fanPt; michael@0: verts[*v + 1].fPos = qpts[0]; michael@0: verts[*v + 2].fPos = qpts[2]; michael@0: verts[*v + 3].fPos = qpts[0] + segb.fNorms[0]; michael@0: verts[*v + 4].fPos = qpts[2] + segb.fNorms[1]; michael@0: verts[*v + 5].fPos = qpts[1] + midVec; michael@0: michael@0: SkScalar c = segb.fNorms[0].dot(qpts[0]); michael@0: verts[*v + 0].fD0 = -segb.fNorms[0].dot(fanPt) + c; michael@0: verts[*v + 1].fD0 = 0.f; michael@0: verts[*v + 2].fD0 = -segb.fNorms[0].dot(qpts[2]) + c; michael@0: verts[*v + 3].fD0 = -SK_ScalarMax/100; michael@0: verts[*v + 4].fD0 = -SK_ScalarMax/100; michael@0: verts[*v + 5].fD0 = -SK_ScalarMax/100; michael@0: michael@0: c = segb.fNorms[1].dot(qpts[2]); michael@0: verts[*v + 0].fD1 = -segb.fNorms[1].dot(fanPt) + c; michael@0: verts[*v + 1].fD1 = -segb.fNorms[1].dot(qpts[0]) + c; michael@0: verts[*v + 2].fD1 = 0.f; michael@0: verts[*v + 3].fD1 = -SK_ScalarMax/100; michael@0: verts[*v + 4].fD1 = -SK_ScalarMax/100; michael@0: verts[*v + 5].fD1 = -SK_ScalarMax/100; michael@0: michael@0: GrPathUtils::QuadUVMatrix toUV(qpts); michael@0: toUV.apply<6, sizeof(QuadVertex), sizeof(GrPoint)>(verts + *v); michael@0: michael@0: idxs[*i + 0] = *v + 3; michael@0: idxs[*i + 1] = *v + 1; michael@0: idxs[*i + 2] = *v + 2; michael@0: idxs[*i + 3] = *v + 4; michael@0: idxs[*i + 4] = *v + 3; michael@0: idxs[*i + 5] = *v + 2; michael@0: michael@0: idxs[*i + 6] = *v + 5; michael@0: idxs[*i + 7] = *v + 3; michael@0: idxs[*i + 8] = *v + 4; michael@0: michael@0: idxs[*i + 9] = *v + 0; michael@0: idxs[*i + 10] = *v + 2; michael@0: idxs[*i + 11] = *v + 1; michael@0: michael@0: *v += 6; michael@0: *i += 12; michael@0: } michael@0: } michael@0: } michael@0: michael@0: /////////////////////////////////////////////////////////////////////////////// michael@0: michael@0: /* michael@0: * Quadratic specified by 0=u^2-v canonical coords. u and v are the first michael@0: * two components of the vertex attribute. Coverage is based on signed michael@0: * distance with negative being inside, positive outside. The edge is specified in michael@0: * window space (y-down). If either the third or fourth component of the interpolated michael@0: * vertex coord is > 0 then the pixel is considered outside the edge. This is used to michael@0: * attempt to trim to a portion of the infinite quad. michael@0: * Requires shader derivative instruction support. michael@0: */ michael@0: michael@0: class QuadEdgeEffect : public GrVertexEffect { michael@0: public: michael@0: michael@0: static GrEffectRef* Create() { michael@0: GR_CREATE_STATIC_EFFECT(gQuadEdgeEffect, QuadEdgeEffect, ()); michael@0: gQuadEdgeEffect->ref(); michael@0: return gQuadEdgeEffect; michael@0: } michael@0: michael@0: virtual ~QuadEdgeEffect() {} michael@0: michael@0: static const char* Name() { return "QuadEdge"; } michael@0: michael@0: virtual void getConstantColorComponents(GrColor* color, michael@0: uint32_t* validFlags) const SK_OVERRIDE { michael@0: *validFlags = 0; michael@0: } michael@0: michael@0: virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { michael@0: return GrTBackendEffectFactory::getInstance(); michael@0: } michael@0: michael@0: class GLEffect : public GrGLVertexEffect { michael@0: public: michael@0: GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) michael@0: : INHERITED (factory) {} michael@0: michael@0: virtual void emitCode(GrGLFullShaderBuilder* builder, michael@0: const GrDrawEffect& drawEffect, michael@0: EffectKey key, michael@0: const char* outputColor, michael@0: const char* inputColor, michael@0: const TransformedCoordsArray&, michael@0: const TextureSamplerArray& samplers) SK_OVERRIDE { michael@0: const char *vsName, *fsName; michael@0: const SkString* attrName = michael@0: builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); michael@0: builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n"); michael@0: michael@0: SkAssertResult(builder->enableFeature( michael@0: GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); michael@0: builder->addVarying(kVec4f_GrSLType, "QuadEdge", &vsName, &fsName); michael@0: michael@0: // keep the derivative instructions outside the conditional michael@0: builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName); michael@0: builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName); michael@0: builder->fsCodeAppendf("\t\tif (%s.z > 0.0 && %s.w > 0.0) {\n", fsName, fsName); michael@0: // today we know z and w are in device space. We could use derivatives michael@0: builder->fsCodeAppendf("\t\t\tedgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);\n", fsName, michael@0: fsName); michael@0: builder->fsCodeAppendf ("\t\t} else {\n"); michael@0: builder->fsCodeAppendf("\t\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n" michael@0: "\t\t\t 2.0*%s.x*duvdy.x - duvdy.y);\n", michael@0: fsName, fsName); michael@0: builder->fsCodeAppendf("\t\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, michael@0: fsName); michael@0: builder->fsCodeAppendf("\t\t\tedgeAlpha = " michael@0: "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);\n\t\t}\n"); michael@0: michael@0: michael@0: builder->fsCodeAppendf("\t%s = %s;\n", outputColor, michael@0: (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str()); michael@0: michael@0: builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str()); michael@0: } michael@0: michael@0: static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) { michael@0: return 0x0; michael@0: } michael@0: michael@0: virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {} michael@0: michael@0: private: michael@0: typedef GrGLVertexEffect INHERITED; michael@0: }; michael@0: michael@0: private: michael@0: QuadEdgeEffect() { michael@0: this->addVertexAttrib(kVec4f_GrSLType); michael@0: } michael@0: michael@0: virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { michael@0: return true; michael@0: } michael@0: michael@0: GR_DECLARE_EFFECT_TEST; michael@0: michael@0: typedef GrVertexEffect INHERITED; michael@0: }; michael@0: michael@0: GR_DEFINE_EFFECT_TEST(QuadEdgeEffect); michael@0: michael@0: GrEffectRef* QuadEdgeEffect::TestCreate(SkRandom* random, michael@0: GrContext*, michael@0: const GrDrawTargetCaps& caps, michael@0: GrTexture*[]) { michael@0: // Doesn't work without derivative instructions. michael@0: return caps.shaderDerivativeSupport() ? QuadEdgeEffect::Create() : NULL; michael@0: } michael@0: michael@0: /////////////////////////////////////////////////////////////////////////////// michael@0: michael@0: bool GrAAConvexPathRenderer::canDrawPath(const SkPath& path, michael@0: const SkStrokeRec& stroke, michael@0: const GrDrawTarget* target, michael@0: bool antiAlias) const { michael@0: return (target->caps()->shaderDerivativeSupport() && antiAlias && michael@0: stroke.isFillStyle() && !path.isInverseFillType() && path.isConvex()); michael@0: } michael@0: michael@0: namespace { michael@0: michael@0: // position + edge michael@0: extern const GrVertexAttrib gPathAttribs[] = { michael@0: {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding}, michael@0: {kVec4f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding} michael@0: }; michael@0: michael@0: }; michael@0: michael@0: bool GrAAConvexPathRenderer::onDrawPath(const SkPath& origPath, michael@0: const SkStrokeRec&, michael@0: GrDrawTarget* target, michael@0: bool antiAlias) { michael@0: michael@0: const SkPath* path = &origPath; michael@0: if (path->isEmpty()) { michael@0: return true; michael@0: } michael@0: michael@0: SkMatrix viewMatrix = target->getDrawState().getViewMatrix(); michael@0: GrDrawTarget::AutoStateRestore asr; michael@0: if (!asr.setIdentity(target, GrDrawTarget::kPreserve_ASRInit)) { michael@0: return false; michael@0: } michael@0: GrDrawState* drawState = target->drawState(); michael@0: michael@0: // We use the fact that SkPath::transform path does subdivision based on michael@0: // perspective. Otherwise, we apply the view matrix when copying to the michael@0: // segment representation. michael@0: SkPath tmpPath; michael@0: if (viewMatrix.hasPerspective()) { michael@0: origPath.transform(viewMatrix, &tmpPath); michael@0: path = &tmpPath; michael@0: viewMatrix = SkMatrix::I(); michael@0: } michael@0: michael@0: QuadVertex *verts; michael@0: uint16_t* idxs; michael@0: michael@0: int vCount; michael@0: int iCount; michael@0: enum { michael@0: kPreallocSegmentCnt = 512 / sizeof(Segment), michael@0: kPreallocDrawCnt = 4, michael@0: }; michael@0: SkSTArray segments; michael@0: SkPoint fanPt; michael@0: michael@0: // We can't simply use the path bounds because we may degenerate cubics to quads which produces michael@0: // new control points outside the original convex hull. michael@0: SkRect devBounds; michael@0: if (!get_segments(*path, viewMatrix, &segments, &fanPt, &vCount, &iCount, &devBounds)) { michael@0: return false; michael@0: } michael@0: michael@0: // Our computed verts should all be within one pixel of the segment control points. michael@0: devBounds.outset(SK_Scalar1, SK_Scalar1); michael@0: michael@0: drawState->setVertexAttribs(SK_ARRAY_COUNT(gPathAttribs)); michael@0: michael@0: static const int kEdgeAttrIndex = 1; michael@0: GrEffectRef* quadEffect = QuadEdgeEffect::Create(); michael@0: drawState->addCoverageEffect(quadEffect, kEdgeAttrIndex)->unref(); michael@0: michael@0: GrDrawTarget::AutoReleaseGeometry arg(target, vCount, iCount); michael@0: if (!arg.succeeded()) { michael@0: return false; michael@0: } michael@0: SkASSERT(sizeof(QuadVertex) == drawState->getVertexSize()); michael@0: verts = reinterpret_cast(arg.vertices()); michael@0: idxs = reinterpret_cast(arg.indices()); michael@0: michael@0: SkSTArray draws; michael@0: create_vertices(segments, fanPt, &draws, verts, idxs); michael@0: michael@0: // Check devBounds michael@0: #ifdef SK_DEBUG michael@0: SkRect tolDevBounds = devBounds; michael@0: tolDevBounds.outset(SK_Scalar1 / 10000, SK_Scalar1 / 10000); michael@0: SkRect actualBounds; michael@0: actualBounds.set(verts[0].fPos, verts[1].fPos); michael@0: for (int i = 2; i < vCount; ++i) { michael@0: actualBounds.growToInclude(verts[i].fPos.fX, verts[i].fPos.fY); michael@0: } michael@0: SkASSERT(tolDevBounds.contains(actualBounds)); michael@0: #endif michael@0: michael@0: int vOffset = 0; michael@0: for (int i = 0; i < draws.count(); ++i) { michael@0: const Draw& draw = draws[i]; michael@0: target->drawIndexed(kTriangles_GrPrimitiveType, michael@0: vOffset, // start vertex michael@0: 0, // start index michael@0: draw.fVertexCnt, michael@0: draw.fIndexCnt, michael@0: &devBounds); michael@0: vOffset += draw.fVertexCnt; michael@0: } michael@0: michael@0: return true; michael@0: }