SK_SUPPORT_LEGACY_GRTYPES to hide duplicate types from SkTypes.h

src/gpu/GrAARectRenderer.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 "GrAARectRenderer.h"
 #include "GrGpu.h"
 #include "gl/GrGLEffect.h"
@@ skipping 243 matching lines @@
                                       GrTexture* textures[]) {
     return GrRectEffect::Create();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 extern const GrVertexAttrib gAARectCoverageAttribs[] = {
     {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
-    {kVec4ub_GrVertexAttribType, sizeof(GrPoint), kCoverage_GrVertexAttribBinding},
+    {kVec4ub_GrVertexAttribType, sizeof(SkPoint), kCoverage_GrVertexAttribBinding},
 };
 
 extern const GrVertexAttrib gAARectColorAttribs[] = {
     {kVec2f_GrVertexAttribType,  0,               kPosition_GrVertexAttribBinding},
-    {kVec4ub_GrVertexAttribType, sizeof(GrPoint), kColor_GrVertexAttribBinding},
+    {kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_GrVertexAttribBinding},
 };
 
 static void set_aa_rect_vertex_attributes(GrDrawState* drawState, bool useCoverage) {
     if (useCoverage) {
         drawState->setVertexAttribs<gAARectCoverageAttribs>(SK_ARRAY_COUNT(gAARectCoverageAttribs));
     } else {
         drawState->setVertexAttribs<gAARectColorAttribs>(SK_ARRAY_COUNT(gAARectColorAttribs));
     }
 }
 
-static void set_inset_fan(GrPoint* pts, size_t stride,
+static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
 
 };
 
 void GrAARectRenderer::reset() {
     SkSafeSetNull(fAAFillRectIndexBuffer);
     SkSafeSetNull(fAAMiterStrokeRectIndexBuffer);
     SkSafeSetNull(fAABevelStrokeRectIndexBuffer);
 }
 
 static const uint16_t gFillAARectIdx[] = {
     0, 1, 5, 5, 4, 0,
     1, 2, 6, 6, 5, 1,
     2, 3, 7, 7, 6, 2,
     3, 0, 4, 4, 7, 3,
     4, 5, 6, 6, 7, 4,
 };
 
-static const int kIndicesPerAAFillRect = GR_ARRAY_COUNT(gFillAARectIdx);
+static const int kIndicesPerAAFillRect = SK_ARRAY_COUNT(gFillAARectIdx);
 static const int kVertsPerAAFillRect = 8;
 static const int kNumAAFillRectsInIndexBuffer = 256;
 
 GrIndexBuffer* GrAARectRenderer::aaFillRectIndexBuffer(GrGpu* gpu) {
     static const size_t kAAFillRectIndexBufferSize = kIndicesPerAAFillRect *
                                                      sizeof(uint16_t) *
                                                      kNumAAFillRectsInIndexBuffer;
 
     if (NULL == fAAFillRectIndexBuffer) {
         fAAFillRectIndexBuffer = gpu->createIndexBuffer(kAAFillRectIndexBufferSize, false);
@@ skipping 94 matching lines @@
     4 + 8, 0 + 8, 8 + 8,
 
     // Draw the inner AA, from inner edge to inner AA line, shift is 16.
     0 + 16, 1 + 16, 5 + 16, 5 + 16, 4 + 16, 0 + 16,
     1 + 16, 2 + 16, 6 + 16, 6 + 16, 5 + 16, 1 + 16,
     2 + 16, 3 + 16, 7 + 16, 7 + 16, 6 + 16, 2 + 16,
     3 + 16, 0 + 16, 4 + 16, 4 + 16, 7 + 16, 3 + 16,
 };
 
 int GrAARectRenderer::aaStrokeRectIndexCount(bool miterStroke) {
-    return miterStroke ? GR_ARRAY_COUNT(gMiterStrokeAARectIdx) :
-                         GR_ARRAY_COUNT(gBevelStrokeAARectIdx);
+    return miterStroke ? SK_ARRAY_COUNT(gMiterStrokeAARectIdx) :
+                         SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
 }
 
 GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(GrGpu* gpu, bool miterStroke) {
     if (miterStroke) {
         if (NULL == fAAMiterStrokeRectIndexBuffer) {
             fAAMiterStrokeRectIndexBuffer =
                 gpu->createIndexBuffer(sizeof(gMiterStrokeAARectIdx), false);
             if (NULL != fAAMiterStrokeRectIndexBuffer) {
 #ifdef SK_DEBUG
                 bool updated =
@@ skipping 38 matching lines @@
     }
 
     GrIndexBuffer* indexBuffer = this->aaFillRectIndexBuffer(gpu);
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
     size_t vsize = drawState->getVertexSize();
-    SkASSERT(sizeof(GrPoint) + sizeof(GrColor) == vsize);
+    SkASSERT(sizeof(SkPoint) + sizeof(GrColor) == vsize);
 
-    GrPoint* fan0Pos = reinterpret_cast<GrPoint*>(verts);
-    GrPoint* fan1Pos = reinterpret_cast<GrPoint*>(verts + 4 * vsize);
+    SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
+    SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vsize);
 
     SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1);
     inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height());
 
     if (combinedMatrix.rectStaysRect()) {
         // Temporarily #if'ed out. We don't want to pass in the devRect but
         // right now it is computed in GrContext::apply_aa_to_rect and we don't
         // want to throw away the work
 #if 0
         SkRect devRect;
@@ skipping 33 matching lines @@
         // BR
         *((SkPoint*)((intptr_t)fan1Pos + 2 * vsize)) =
             *((SkPoint*)((intptr_t)fan0Pos + 2 * vsize)) - vec[0] - vec[1];
         *((SkPoint*)((intptr_t)fan0Pos + 2 * vsize)) += vec[0] + vec[1];
         // TR
         *((SkPoint*)((intptr_t)fan1Pos + 3 * vsize)) =
             *((SkPoint*)((intptr_t)fan0Pos + 3 * vsize)) - vec[0] + vec[1];
         *((SkPoint*)((intptr_t)fan0Pos + 3 * vsize)) += vec[0] - vec[1];
     }
 
-    verts += sizeof(GrPoint);
+    verts += sizeof(SkPoint);
     for (int i = 0; i < 4; ++i) {
         *reinterpret_cast<GrColor*>(verts + i * vsize) = 0;
     }
 
     int scale;
     if (inset < SK_ScalarHalf) {
         scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
         SkASSERT(scale >= 0 && scale <= 255);
     } else {
         scale = 0xff;
@@ skipping 19 matching lines @@
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1,
                                  kVertsPerAAFillRect,
                                  kIndicesPerAAFillRect);
     target->resetIndexSource();
 }
 
 namespace {
 
 // Rotated
 struct RectVertex {
-    GrPoint fPos;
-    GrPoint fCenter;
-    GrPoint fDir;
-    GrPoint fWidthHeight;
+    SkPoint fPos;
+    SkPoint fCenter;
+    SkPoint fDir;
+    SkPoint fWidthHeight;
 };
 
 // Rotated
 extern const GrVertexAttrib gAARectVertexAttribs[] = {
     { kVec2f_GrVertexAttribType, 0,                 kPosition_GrVertexAttribBinding },
-    { kVec4f_GrVertexAttribType, sizeof(GrPoint),   kEffect_GrVertexAttribBinding },
-    { kVec2f_GrVertexAttribType, 3*sizeof(GrPoint), kEffect_GrVertexAttribBinding }
+    { kVec4f_GrVertexAttribType, sizeof(SkPoint),   kEffect_GrVertexAttribBinding },
+    { kVec2f_GrVertexAttribType, 3*sizeof(SkPoint), kEffect_GrVertexAttribBinding }
 };
 
 // Axis Aligned
 struct AARectVertex {
-    GrPoint fPos;
-    GrPoint fOffset;
-    GrPoint fWidthHeight;
+    SkPoint fPos;
+    SkPoint fOffset;
+    SkPoint fWidthHeight;
 };
 
 // Axis Aligned
 extern const GrVertexAttrib gAAAARectVertexAttribs[] = {
     { kVec2f_GrVertexAttribType, 0,                 kPosition_GrVertexAttribBinding },
-    { kVec4f_GrVertexAttribType, sizeof(GrPoint),   kEffect_GrVertexAttribBinding },
+    { kVec4f_GrVertexAttribType, sizeof(SkPoint),   kEffect_GrVertexAttribBinding },
 };
 
 };
 
 void GrAARectRenderer::shaderFillAARect(GrGpu* gpu,
                                         GrDrawTarget* target,
                                         const SkRect& rect,
                                         const SkMatrix& combinedMatrix) {
     GrDrawState* drawState = target->drawState();
 
@@ skipping 80 matching lines @@
     SkRect devRect;
     combinedMatrix.mapRect(&devRect, rect);
 
     SkRect devBounds = {
         devRect.fLeft   - SK_ScalarHalf,
         devRect.fTop    - SK_ScalarHalf,
         devRect.fRight  + SK_ScalarHalf,
         devRect.fBottom + SK_ScalarHalf
     };
 
-    GrPoint widthHeight = {
+    SkPoint widthHeight = {
         SkScalarHalf(devRect.width()) + SK_ScalarHalf,
         SkScalarHalf(devRect.height()) + SK_ScalarHalf
     };
 
     verts[0].fPos = SkPoint::Make(devBounds.fLeft, devBounds.fTop);
     verts[0].fOffset = SkPoint::Make(-widthHeight.fX, -widthHeight.fY);
     verts[0].fWidthHeight = widthHeight;
 
     verts[1].fPos = SkPoint::Make(devBounds.fLeft, devBounds.fBottom);
     verts[1].fOffset = SkPoint::Make(-widthHeight.fX, widthHeight.fY);
@@ skipping 12 matching lines @@
     target->resetIndexSource();
 }
 
 void GrAARectRenderer::strokeAARect(GrGpu* gpu,
                                     GrDrawTarget* target,
                                     const SkRect& rect,
                                     const SkMatrix& combinedMatrix,
                                     const SkRect& devRect,
                                     const SkStrokeRec* stroke,
                                     bool useVertexCoverage) {
-    GrVec devStrokeSize;
+    SkVector devStrokeSize;
     SkScalar width = stroke->getWidth();
     if (width > 0) {
         devStrokeSize.set(width, width);
         combinedMatrix.mapVectors(&devStrokeSize, 1);
         devStrokeSize.setAbs(devStrokeSize);
     } else {
         devStrokeSize.set(SK_Scalar1, SK_Scalar1);
     }
 
     const SkScalar dx = devStrokeSize.fX;
     const SkScalar dy = devStrokeSize.fY;
     const SkScalar rx = SkScalarMul(dx, SK_ScalarHalf);
     const SkScalar ry = SkScalarMul(dy, SK_ScalarHalf);
 
     // Temporarily #if'ed out. We don't want to pass in the devRect but
     // right now it is computed in GrContext::apply_aa_to_rect and we don't
     // want to throw away the work
 #if 0
     SkRect devRect;
     combinedMatrix.mapRect(&devRect, rect);
 #endif
 
     SkScalar spare;
     {
         SkScalar w = devRect.width() - dx;
         SkScalar h = devRect.height() - dy;
-        spare = GrMin(w, h);
+        spare = SkTMin(w, h);
     }
 
     SkRect devOutside(devRect);
     devOutside.outset(rx, ry);
 
     bool miterStroke = true;
     // small miter limit means right angles show bevel...
     if (stroke->getJoin() != SkPaint::kMiter_Join || stroke->getMiter() < SK_ScalarSqrt2) {
         miterStroke = false;
     }
@@ skipping 42 matching lines @@
         return;
     }
     GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(gpu, miterStroke);
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
     size_t vsize = drawState->getVertexSize();
-    SkASSERT(sizeof(GrPoint) + sizeof(GrColor) == vsize);
+    SkASSERT(sizeof(SkPoint) + sizeof(GrColor) == vsize);
 
     // We create vertices for four nested rectangles. There are two ramps from 0 to full
     // coverage, one on the exterior of the stroke and the other on the interior.
     // The following pointers refer to the four rects, from outermost to innermost.
-    GrPoint* fan0Pos = reinterpret_cast<GrPoint*>(verts);
-    GrPoint* fan1Pos = reinterpret_cast<GrPoint*>(verts + outerVertexNum * vsize);
-    GrPoint* fan2Pos = reinterpret_cast<GrPoint*>(verts + 2 * outerVertexNum * vsize);
-    GrPoint* fan3Pos = reinterpret_cast<GrPoint*>(verts + (2 * outerVertexNum + innerVertexNum) * vsize);
+    SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
+    SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + outerVertexNum * vsize);
+    SkPoint* fan2Pos = reinterpret_cast<SkPoint*>(verts + 2 * outerVertexNum * vsize);
+    SkPoint* fan3Pos = reinterpret_cast<SkPoint*>(verts + (2 * outerVertexNum + innerVertexNum) * vsize);
 
 #ifndef SK_IGNORE_THIN_STROKED_RECT_FIX
     // TODO: this only really works if the X & Y margins are the same all around
     // the rect
     SkScalar inset = SkMinScalar(SK_Scalar1, devOutside.fRight - devInside.fRight);
     inset = SkMinScalar(inset, devInside.fLeft - devOutside.fLeft);
     inset = SkMinScalar(inset, devInside.fTop - devOutside.fTop);
     if (miterStroke) {
         inset = SK_ScalarHalf * SkMinScalar(inset, devOutside.fBottom - devInside.fBottom);
     } else {
         inset = SK_ScalarHalf * SkMinScalar(inset, devOutsideAssist.fBottom - devInside.fBottom);
     }
     SkASSERT(inset >= 0);
 #else
     SkScalar inset = SK_ScalarHalf;
 #endif
 
     if (miterStroke) {
         // outermost
         set_inset_fan(fan0Pos, vsize, devOutside, -SK_ScalarHalf, -SK_ScalarHalf);
         // inner two
         set_inset_fan(fan1Pos, vsize, devOutside,  inset,  inset);
         set_inset_fan(fan2Pos, vsize, devInside,  -inset, -inset);
         // innermost
         set_inset_fan(fan3Pos, vsize, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
     } else {
-        GrPoint* fan0AssistPos = reinterpret_cast<GrPoint*>(verts + 4 * vsize);
-        GrPoint* fan1AssistPos = reinterpret_cast<GrPoint*>(verts + (outerVertexNum + 4) * vsize);
+        SkPoint* fan0AssistPos = reinterpret_cast<SkPoint*>(verts + 4 * vsize);
+        SkPoint* fan1AssistPos = reinterpret_cast<SkPoint*>(verts + (outerVertexNum + 4) * vsize);
         // outermost
         set_inset_fan(fan0Pos, vsize, devOutside, -SK_ScalarHalf, -SK_ScalarHalf);
         set_inset_fan(fan0AssistPos, vsize, devOutsideAssist, -SK_ScalarHalf, -SK_ScalarHalf);
         // outer one of the inner two
         set_inset_fan(fan1Pos, vsize, devOutside,  inset,  inset);
         set_inset_fan(fan1AssistPos, vsize, devOutsideAssist,  inset,  inset);
         // inner one of the inner two
         set_inset_fan(fan2Pos, vsize, devInside,  -inset, -inset);
         // innermost
         set_inset_fan(fan3Pos, vsize, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
     }
 
     // The outermost rect has 0 coverage
-    verts += sizeof(GrPoint);
+    verts += sizeof(SkPoint);
     for (int i = 0; i < outerVertexNum; ++i) {
         *reinterpret_cast<GrColor*>(verts + i * vsize) = 0;
     }
 
     int scale;
     if (inset < SK_ScalarHalf) {
         scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
         SkASSERT(scale >= 0 && scale <= 255);
     } else {
         scale = 0xff;
@@ skipping 41 matching lines @@
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
         this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside, useVertexCoverage);
         return;
     }
 
     this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist,
                                devInside, useVertexCoverage, true);
 }