SK_SUPPORT_LEGACY_GRTYPES to hide duplicate types from SkTypes.h

src/gpu/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
@@ skipping 17 matching lines @@
 }
 
 struct Segment {
     enum {
         // These enum values are assumed in member functions below.
         kLine = 0,
         kQuad = 1,
     } fType;
 
     // line uses one pt, quad uses 2 pts
-    GrPoint fPts[2];
+    SkPoint fPts[2];
     // normal to edge ending at each pt
-    GrVec fNorms[2];
+    SkVector fNorms[2];
     // is the corner where the previous segment meets this segment
     // sharp. If so, fMid is a normalized bisector facing outward.
-    GrVec fMid;
+    SkVector fMid;
 
     int countPoints() {
         GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
         return fType + 1;
     }
     const SkPoint& endPt() const {
         GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
         return fPts[fType];
     };
     const SkPoint& endNorm() const {
@@ skipping 57 matching lines @@
 
 static void compute_vectors(SegmentArray* segments,
                             SkPoint* fanPt,
                             SkPath::Direction dir,
                             int* vCount,
                             int* iCount) {
     center_of_mass(*segments, fanPt);
     int count = segments->count();
 
     // Make the normals point towards the outside
-    GrPoint::Side normSide;
+    SkPoint::Side normSide;
     if (dir == SkPath::kCCW_Direction) {
-        normSide = GrPoint::kRight_Side;
+        normSide = SkPoint::kRight_Side;
     } else {
-        normSide = GrPoint::kLeft_Side;
+        normSide = SkPoint::kLeft_Side;
     }
 
     *vCount = 0;
     *iCount = 0;
     // compute normals at all points
     for (int a = 0; a < count; ++a) {
         Segment& sega = (*segments)[a];
         int b = (a + 1) % count;
         Segment& segb = (*segments)[b];
 
-        const GrPoint* prevPt = &sega.endPt();
+        const SkPoint* prevPt = &sega.endPt();
         int n = segb.countPoints();
         for (int p = 0; p < n; ++p) {
             segb.fNorms[p] = segb.fPts[p] - *prevPt;
             segb.fNorms[p].normalize();
             segb.fNorms[p].setOrthog(segb.fNorms[p], normSide);
             prevPt = &segb.fPts[p];
         }
         if (Segment::kLine == segb.fType) {
             *vCount += 5;
             *iCount += 9;
@@ skipping 19 matching lines @@
 
 struct DegenerateTestData {
     DegenerateTestData() { fStage = kInitial; }
     bool isDegenerate() const { return kNonDegenerate != fStage; }
     enum {
         kInitial,
         kPoint,
         kLine,
         kNonDegenerate
     }           fStage;
-    GrPoint     fFirstPoint;
-    GrVec       fLineNormal;
+    SkPoint     fFirstPoint;
+    SkVector    fLineNormal;
     SkScalar    fLineC;
 };
 
 static const SkScalar kClose = (SK_Scalar1 / 16);
 static const SkScalar kCloseSqd = SkScalarMul(kClose, kClose);
 
-static void update_degenerate_test(DegenerateTestData* data, const GrPoint& pt) {
+static void update_degenerate_test(DegenerateTestData* data, const SkPoint& pt) {
     switch (data->fStage) {
         case DegenerateTestData::kInitial:
             data->fFirstPoint = pt;
             data->fStage = DegenerateTestData::kPoint;
             break;
         case DegenerateTestData::kPoint:
             if (pt.distanceToSqd(data->fFirstPoint) > kCloseSqd) {
                 data->fLineNormal = pt - data->fFirstPoint;
                 data->fLineNormal.normalize();
                 data->fLineNormal.setOrthog(data->fLineNormal);
@@ skipping 86 matching lines @@
     // line paths. We detect paths that are very close to a line (zero area) and
     // draw nothing.
     DegenerateTestData degenerateData;
     SkPath::Direction dir;
     // get_direction can fail for some degenerate paths.
     if (!get_direction(path, m, &dir)) {
         return false;
     }
 
     for (;;) {
-        GrPoint pts[4];
+        SkPoint pts[4];
         SkPath::Verb verb = iter.next(pts);
         switch (verb) {
             case SkPath::kMove_Verb:
                 m.mapPoints(pts, 1);
                 update_degenerate_test(&degenerateData, pts[0]);
                 devBounds->set(pts->fX, pts->fY, pts->fX, pts->fY);
                 break;
             case SkPath::kLine_Verb: {
                 m.mapPoints(&pts[1], 1);
                 update_degenerate_test(&degenerateData, pts[1]);
@@ skipping 21 matching lines @@
                     compute_vectors(segments, fanPt, dir, vCount, iCount);
                     return true;
                 }
             default:
                 break;
         }
     }
 }
 
 struct QuadVertex {
-    GrPoint  fPos;
-    GrPoint  fUV;
+    SkPoint  fPos;
+    SkPoint  fUV;
     SkScalar fD0;
     SkScalar fD1;
 };
 
 struct Draw {
     Draw() : fVertexCnt(0), fIndexCnt(0) {}
     int fVertexCnt;
     int fIndexCnt;
 };
 
@@ skipping 87 matching lines @@
             idxs[*i + 4] = *v + 1;
             idxs[*i + 5] = *v + 2;
 
             idxs[*i + 6] = *v + 4;
             idxs[*i + 7] = *v + 3;
             idxs[*i + 8] = *v + 2;
 
             *v += 5;
             *i += 9;
         } else {
-            GrPoint qpts[] = {sega.endPt(), segb.fPts[0], segb.fPts[1]};
+            SkPoint qpts[] = {sega.endPt(), segb.fPts[0], segb.fPts[1]};
 
-            GrVec midVec = segb.fNorms[0] + segb.fNorms[1];
+            SkVector midVec = segb.fNorms[0] + segb.fNorms[1];
             midVec.normalize();
 
             verts[*v + 0].fPos = fanPt;
             verts[*v + 1].fPos = qpts[0];
             verts[*v + 2].fPos = qpts[2];
             verts[*v + 3].fPos = qpts[0] + segb.fNorms[0];
             verts[*v + 4].fPos = qpts[2] + segb.fNorms[1];
             verts[*v + 5].fPos = qpts[1] + midVec;
 
             SkScalar c = segb.fNorms[0].dot(qpts[0]);
             verts[*v + 0].fD0 =  -segb.fNorms[0].dot(fanPt) + c;
             verts[*v + 1].fD0 =  0.f;
             verts[*v + 2].fD0 =  -segb.fNorms[0].dot(qpts[2]) + c;
             verts[*v + 3].fD0 = -SK_ScalarMax/100;
             verts[*v + 4].fD0 = -SK_ScalarMax/100;
             verts[*v + 5].fD0 = -SK_ScalarMax/100;
 
             c = segb.fNorms[1].dot(qpts[2]);
             verts[*v + 0].fD1 =  -segb.fNorms[1].dot(fanPt) + c;
             verts[*v + 1].fD1 =  -segb.fNorms[1].dot(qpts[0]) + c;
             verts[*v + 2].fD1 =  0.f;
             verts[*v + 3].fD1 = -SK_ScalarMax/100;
             verts[*v + 4].fD1 = -SK_ScalarMax/100;
             verts[*v + 5].fD1 = -SK_ScalarMax/100;
 
             GrPathUtils::QuadUVMatrix toUV(qpts);
-            toUV.apply<6, sizeof(QuadVertex), sizeof(GrPoint)>(verts + *v);
+            toUV.apply<6, sizeof(QuadVertex), sizeof(SkPoint)>(verts + *v);
 
             idxs[*i + 0] = *v + 3;
             idxs[*i + 1] = *v + 1;
             idxs[*i + 2] = *v + 2;
             idxs[*i + 3] = *v + 4;
             idxs[*i + 4] = *v + 3;
             idxs[*i + 5] = *v + 2;
 
             idxs[*i + 6] = *v + 5;
             idxs[*i + 7] = *v + 3;
@@ skipping 129 matching lines @@
                                          bool antiAlias) const {
     return (target->caps()->shaderDerivativeSupport() && antiAlias &&
             stroke.isFillStyle() && !path.isInverseFillType() && path.isConvex());
 }
 
 namespace {
 
 // position + edge
 extern const GrVertexAttrib gPathAttribs[] = {
     {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
-    {kVec4f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding}
+    {kVec4f_GrVertexAttribType, sizeof(SkPoint), kEffect_GrVertexAttribBinding}
 };
 
 };
 
 bool GrAAConvexPathRenderer::onDrawPath(const SkPath& origPath,
                                         const SkStrokeRec&,
                                         GrDrawTarget* target,
                                         bool antiAlias) {
 
     const SkPath* path = &origPath;
@@ skipping 76 matching lines @@
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }