aa rect renderer takes a gpu on construction

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/builders/GrGLProgramBuilder.h"
@@ skipping 373 matching lines @@
     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,
 };
 
 static const int kIndicesPerBevelStrokeRect = SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
 static const int kVertsPerBevelStrokeRect = 24;
 static const int kNumBevelStrokeRectsInIndexBuffer = 256;
 
-int GrAARectRenderer::aaStrokeRectIndexCount(bool miterStroke) {
+static int aa_stroke_rect_index_count(bool miterStroke) {
     return miterStroke ? SK_ARRAY_COUNT(gMiterStrokeAARectIdx) :
                          SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
 }
 
-GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(GrGpu* gpu, bool miterStroke) {
+GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(bool miterStroke) {
     if (miterStroke) {
         if (NULL == fAAMiterStrokeRectIndexBuffer) {
             fAAMiterStrokeRectIndexBuffer =
-                    gpu->createInstancedIndexBuffer(gMiterStrokeAARectIdx,
-                                                    kIndicesPerMiterStrokeRect,
-                                                    kNumMiterStrokeRectsInIndexBuffer,
-                                                    kVertsPerMiterStrokeRect);
+                    fGpu->createInstancedIndexBuffer(gMiterStrokeAARectIdx,
+                                                     kIndicesPerMiterStrokeRect,
+                                                     kNumMiterStrokeRectsInIndexBuffer,
+                                                     kVertsPerMiterStrokeRect);
         }
         return fAAMiterStrokeRectIndexBuffer;
     } else {
         if (NULL == fAABevelStrokeRectIndexBuffer) {
             fAABevelStrokeRectIndexBuffer =
-                    gpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
-                                                    kIndicesPerBevelStrokeRect,
-                                                    kNumBevelStrokeRectsInIndexBuffer,
-                                                    kVertsPerBevelStrokeRect);
+                    fGpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
+                                                     kIndicesPerBevelStrokeRect,
+                                                     kNumBevelStrokeRectsInIndexBuffer,
+                                                     kVertsPerBevelStrokeRect);
         }
         return fAABevelStrokeRectIndexBuffer;
     }
 }
 
-void GrAARectRenderer::geometryFillAARect(GrGpu* gpu,
-                                          GrDrawTarget* target,
+void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
                                           const SkRect& rect,
                                           const SkMatrix& combinedMatrix,
                                           const SkRect& devRect) {
     GrDrawState* drawState = target->drawState();
 
     GrColor color = drawState->getColor();
 
     CoverageAttribType covAttribType = set_rect_attribs(drawState);
     if (kUseCoverage_CoverageAttribType == covAttribType && GrColorIsOpaque(color)) {
         drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
     }
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 8, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
 
     if (NULL == fAAFillRectIndexBuffer) {
-        fAAFillRectIndexBuffer = gpu->createInstancedIndexBuffer(gFillAARectIdx,
-                                                                 kIndicesPerAAFillRect,
-                                                                 kNumAAFillRectsInIndexBuffer,
-                                                                 kVertsPerAAFillRect);
+        fAAFillRectIndexBuffer = fGpu->createInstancedIndexBuffer(gFillAARectIdx,
+                                                                  kIndicesPerAAFillRect,
+                                                                  kNumAAFillRectsInIndexBuffer,
+                                                                  kVertsPerAAFillRect);
     }
     GrIndexBuffer* indexBuffer = fAAFillRectIndexBuffer;
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
     size_t vstride = drawState->getVertexStride();
 
@@ skipping 119 matching lines @@
 };
 
 // Axis Aligned
 extern const GrVertexAttrib gAAAARectVertexAttribs[] = {
     { kVec2f_GrVertexAttribType, 0,                 kPosition_GrVertexAttribBinding },
     { kVec4f_GrVertexAttribType, sizeof(SkPoint),   kGeometryProcessor_GrVertexAttribBinding },
 };
 
 };
 
-void GrAARectRenderer::shaderFillAARect(GrGpu* gpu,
-                                        GrDrawTarget* target,
+void GrAARectRenderer::shaderFillAARect(GrDrawTarget* target,
                                         const SkRect& rect,
                                         const SkMatrix& combinedMatrix) {
     GrDrawState* drawState = target->drawState();
 
     SkPoint center = SkPoint::Make(rect.centerX(), rect.centerY());
     combinedMatrix.mapPoints(&center, 1);
 
     // compute transformed (0, 1) vector
     SkVector dir = { combinedMatrix[SkMatrix::kMSkewX], combinedMatrix[SkMatrix::kMScaleY] };
     dir.normalize();
@@ skipping 35 matching lines @@
         devRect.fTop    - SK_ScalarHalf,
         devRect.fRight  + SK_ScalarHalf,
         devRect.fBottom + SK_ScalarHalf
     };
 
     verts[0].fPos = SkPoint::Make(devBounds.fLeft, devBounds.fTop);
     verts[1].fPos = SkPoint::Make(devBounds.fLeft, devBounds.fBottom);
     verts[2].fPos = SkPoint::Make(devBounds.fRight, devBounds.fBottom);
     verts[3].fPos = SkPoint::Make(devBounds.fRight, devBounds.fTop);
 
-    target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
+    target->setIndexSourceToBuffer(fGpu->getContext()->getQuadIndexBuffer());
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6);
     target->resetIndexSource();
 }
 
-void GrAARectRenderer::shaderFillAlignedAARect(GrGpu* gpu,
-                                               GrDrawTarget* target,
+void GrAARectRenderer::shaderFillAlignedAARect(GrDrawTarget* target,
                                                const SkRect& rect,
                                                const SkMatrix& combinedMatrix) {
     GrDrawState* drawState = target->drawState();
     SkASSERT(combinedMatrix.rectStaysRect());
 
     drawState->setVertexAttribs<gAAAARectVertexAttribs>(SK_ARRAY_COUNT(gAAAARectVertexAttribs),
                                                         sizeof(AARectVertex));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
     if (!geo.succeeded()) {
@@ skipping 30 matching lines @@
     verts[1].fWidthHeight = widthHeight;
 
     verts[2].fPos = SkPoint::Make(devBounds.fRight, devBounds.fBottom);
     verts[2].fOffset = widthHeight;
     verts[2].fWidthHeight = widthHeight;
 
     verts[3].fPos = SkPoint::Make(devBounds.fRight, devBounds.fTop);
     verts[3].fOffset = SkPoint::Make(widthHeight.fX, -widthHeight.fY);
     verts[3].fWidthHeight = widthHeight;
 
-    target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
+    target->setIndexSourceToBuffer(fGpu->getContext()->getQuadIndexBuffer());
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6);
     target->resetIndexSource();
 }
 
-void GrAARectRenderer::strokeAARect(GrGpu* gpu,
-                                    GrDrawTarget* target,
+void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
                                     const SkRect& rect,
                                     const SkMatrix& combinedMatrix,
                                     const SkRect& devRect,
                                     const SkStrokeRec& stroke) {
     SkVector devStrokeSize;
     SkScalar width = stroke.getWidth();
     if (width > 0) {
         devStrokeSize.set(width, width);
         combinedMatrix.mapVectors(&devStrokeSize, 1);
         devStrokeSize.setAbs(devStrokeSize);
@@ skipping 26 matching lines @@
 
     bool miterStroke = true;
     // For hairlines, make bevel and round joins appear the same as mitered ones.
     // small miter limit means right angles show bevel...
     if ((width > 0) && (stroke.getJoin() != SkPaint::kMiter_Join ||
                         stroke.getMiter() < SK_ScalarSqrt2)) {
         miterStroke = false;
     }
 
     if (spare <= 0 && miterStroke) {
-        this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
+        this->fillAARect(target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
     SkRect devInside(devRect);
     devInside.inset(rx, ry);
 
     SkRect devOutsideAssist(devRect);
 
     // For bevel-stroke, use 2 SkRect instances(devOutside and devOutsideAssist)
     // to draw the outer of the rect. Because there are 8 vertices on the outer
     // edge, while vertex number of inner edge is 4, the same as miter-stroke.
     if (!miterStroke) {
         devOutside.inset(0, ry);
         devOutsideAssist.outset(0, ry);
     }
 
-    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, miterStroke);
+    this->geometryStrokeAARect(target, devOutside, devOutsideAssist, devInside, miterStroke);
 }
 
-void GrAARectRenderer::geometryStrokeAARect(GrGpu* gpu,
-                                            GrDrawTarget* target,
+void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
                                             bool miterStroke) {
     GrDrawState* drawState = target->drawState();
 
     CoverageAttribType covAttribType = set_rect_attribs(drawState);
 
     GrColor color = drawState->getColor();
     if (kUseCoverage_CoverageAttribType == covAttribType && GrColorIsOpaque(color)) {
         drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
     }
 
     int innerVertexNum = 4;
     int outerVertexNum = miterStroke ? 4 : 8;
     int totalVertexNum = (outerVertexNum + innerVertexNum) * 2;
 
     GrDrawTarget::AutoReleaseGeometry geo(target, totalVertexNum, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
-    GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(gpu, miterStroke);
+    GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(miterStroke);
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
     size_t vstride = drawState->getVertexStride();
 
     // 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.
@@ skipping 86 matching lines @@
         if (kUseCoverage_CoverageAttribType == covAttribType) {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
             *reinterpret_cast<GrColor*>(verts + i * vstride + sizeof(GrColor)) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = 0;
         }
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
     target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1,
-                                 totalVertexNum, aaStrokeRectIndexCount(miterStroke));
+                                 totalVertexNum, aa_stroke_rect_index_count(miterStroke));
     target->resetIndexSource();
 }
 
-void GrAARectRenderer::fillAANestedRects(GrGpu* gpu,
-                                         GrDrawTarget* target,
+void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target,
                                          const SkRect rects[2],
                                          const SkMatrix& combinedMatrix) {
     SkASSERT(combinedMatrix.rectStaysRect());
     SkASSERT(!rects[1].isEmpty());
 
     SkRect devOutside, devOutsideAssist, devInside;
     combinedMatrix.mapRect(&devOutside, rects[0]);
     // can't call mapRect for devInside since it calls sort
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
-        this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
+        this->fillAARect(target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
-    this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, true);
+    this->geometryStrokeAARect(target, devOutside, devOutsideAssist, devInside, true);
 }