remove view matrix from context

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrProcessor.h"
@@ skipping 579 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrOvalRenderer::reset() {
     SkSafeSetNull(fRRectIndexBuffer);
     SkSafeSetNull(fStrokeRRectIndexBuffer);
 }
 
 bool GrOvalRenderer::drawOval(GrDrawTarget* target,
                               GrDrawState* drawState,
                               GrColor color,
-                              const GrContext* context,
                               bool useAA,
                               const SkRect& oval,
                               const SkStrokeRec& stroke)
 {
     bool useCoverageAA = useAA &&
         !drawState->getRenderTarget()->isMultisampled() &&
         drawState->canUseFracCoveragePrimProc(color, *target->caps());
 
     if (!useCoverageAA) {
         return false;
     }
 
-    const SkMatrix& vm = context->getMatrix();
+    const SkMatrix& vm = drawState->getViewMatrix();
 
     // we can draw circles
     if (SkScalarNearlyEqual(oval.width(), oval.height())
         && circle_stays_circle(vm)) {
-        this->drawCircle(target, drawState, color, context, useCoverageAA, oval, stroke);
+        this->drawCircle(target, drawState, color, useCoverageAA, oval, stroke);
     // if we have shader derivative support, render as device-independent
     } else if (target->caps()->shaderDerivativeSupport()) {
-        return this->drawDIEllipse(target, drawState, color, context, useCoverageAA, oval, stroke);
+        return this->drawDIEllipse(target, drawState, color, useCoverageAA, oval, stroke);
     // otherwise axis-aligned ellipses only
     } else if (vm.rectStaysRect()) {
-        return this->drawEllipse(target, drawState, color, context, useCoverageAA, oval, stroke);
+        return this->drawEllipse(target, drawState, color, useCoverageAA, oval, stroke);
     } else {
         return false;
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrOvalRenderer::drawCircle(GrDrawTarget* target,
                                 GrDrawState* drawState,
                                 GrColor color,
-                                const GrContext* context,
                                 bool useCoverageAA,
                                 const SkRect& circle,
                                 const SkStrokeRec& stroke)
 {
     const SkMatrix& vm = drawState->getViewMatrix();
     SkPoint center = SkPoint::Make(circle.centerX(), circle.centerY());
     vm.mapPoints(&center, 1);
     SkScalar radius = vm.mapRadius(SkScalarHalf(circle.width()));
     SkScalar strokeWidth = vm.mapRadius(stroke.getWidth());
 
@@ skipping 64 matching lines @@
     verts[2].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
     verts[2].fOffset = SkPoint::Make(1, 1);
     verts[2].fOuterRadius = outerRadius;
     verts[2].fInnerRadius = innerRadius;
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
     verts[3].fOffset = SkPoint::Make(1, -1);
     verts[3].fOuterRadius = outerRadius;
     verts[3].fInnerRadius = innerRadius;
 
-    target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
+    target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrOvalRenderer::drawEllipse(GrDrawTarget* target,
                                  GrDrawState* drawState,
                                  GrColor color,
-                                 const GrContext* context,
                                  bool useCoverageAA,
                                  const SkRect& ellipse,
                                  const SkStrokeRec& stroke)
 {
 #ifdef SK_DEBUG
     {
         // we should have checked for this previously
         bool isAxisAlignedEllipse = drawState->getViewMatrix().rectStaysRect();
         SkASSERT(useCoverageAA && isAxisAlignedEllipse);
     }
@@ skipping 101 matching lines @@
     verts[2].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
     verts[2].fOffset = SkPoint::Make(xRadius, yRadius);
     verts[2].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
     verts[2].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
     verts[3].fOffset = SkPoint::Make(xRadius, -yRadius);
     verts[3].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
     verts[3].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
-    target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
+    target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 
     return true;
 }
 
 bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target,
                                    GrDrawState* drawState,
                                    GrColor color,
-                                   const GrContext* context,
                                    bool useCoverageAA,
                                    const SkRect& ellipse,
                                    const SkStrokeRec& stroke)
 {
     const SkMatrix& vm = drawState->getViewMatrix();
 
     SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
     SkScalar xRadius = SkScalarHalf(ellipse.width());
     SkScalar yRadius = SkScalarHalf(ellipse.height());
 
@@ skipping 80 matching lines @@
     verts[1].fInnerOffset = SkPoint::Make(-innerRatioX - offsetDx, innerRatioY + offsetDy);
 
     verts[2].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
     verts[2].fOuterOffset = SkPoint::Make(1.0f + offsetDx, 1.0f + offsetDy);
     verts[2].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, innerRatioY + offsetDy);
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
     verts[3].fOuterOffset = SkPoint::Make(1.0f + offsetDx, -1.0f - offsetDy);
     verts[3].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, -innerRatioY - offsetDy);
 
-    target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
+    target->setIndexSourceToBuffer(fGpu->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const uint16_t gRRectIndices[] = {
     // corners
@@ skipping 11 matching lines @@
     // center
     // we place this at the end so that we can ignore these indices when rendering stroke-only
     5, 6, 10, 5, 10, 9
 };
 
 static const int kIndicesPerStrokeRRect = SK_ARRAY_COUNT(gRRectIndices) - 6;
 static const int kIndicesPerRRect = SK_ARRAY_COUNT(gRRectIndices);
 static const int kVertsPerRRect = 16;
 static const int kNumRRectsInIndexBuffer = 256;
 
-GrIndexBuffer* GrOvalRenderer::rRectIndexBuffer(bool isStrokeOnly, GrGpu* gpu) {
+GrIndexBuffer* GrOvalRenderer::rRectIndexBuffer(bool isStrokeOnly) {
     if (isStrokeOnly) {
         if (NULL == fStrokeRRectIndexBuffer) {
-            fStrokeRRectIndexBuffer = gpu->createInstancedIndexBuffer(gRRectIndices,
-                                                                      kIndicesPerStrokeRRect,
-                                                                      kNumRRectsInIndexBuffer,
-                                                                      kVertsPerRRect);
+            fStrokeRRectIndexBuffer = fGpu->createInstancedIndexBuffer(gRRectIndices,
+                                                                       kIndicesPerStrokeRRect,
+                                                                       kNumRRectsInIndexBuffer,
+                                                                       kVertsPerRRect);
         }
         return fStrokeRRectIndexBuffer;
     } else {
         if (NULL == fRRectIndexBuffer) {
-            fRRectIndexBuffer = gpu->createInstancedIndexBuffer(gRRectIndices,
-                                                                kIndicesPerRRect,
-                                                                kNumRRectsInIndexBuffer,
-                                                                kVertsPerRRect);
+            fRRectIndexBuffer = fGpu->createInstancedIndexBuffer(gRRectIndices,
+                                                                 kIndicesPerRRect,
+                                                                 kNumRRectsInIndexBuffer,
+                                                                 kVertsPerRRect);
         }
         return fRRectIndexBuffer;
     }
 }
 
 bool GrOvalRenderer::drawDRRect(GrDrawTarget* target,
                                 GrDrawState* drawState,
                                 GrColor color,
-                                GrContext* context,
                                 bool useAA,
                                 const SkRRect& origOuter,
                                 const SkRRect& origInner) {
     bool applyAA = useAA &&
                    !drawState->getRenderTarget()->isMultisampled() &&
                    drawState->canUseFracCoveragePrimProc(color, *target->caps());
     GrDrawState::AutoRestoreEffects are;
     if (!origInner.isEmpty()) {
         SkTCopyOnFirstWrite<SkRRect> inner(origInner);
-        if (!context->getMatrix().isIdentity()) {
-            if (!origInner.transform(context->getMatrix(), inner.writable())) {
+        if (!drawState->getViewMatrix().isIdentity()) {
+            if (!origInner.transform(drawState->getViewMatrix(), inner.writable())) {
                 return false;
             }
         }
         GrPrimitiveEdgeType edgeType = applyAA ?
                 kInverseFillAA_GrProcessorEdgeType :
                 kInverseFillBW_GrProcessorEdgeType;
         // TODO this needs to be a geometry processor
         GrFragmentProcessor* fp = GrRRectEffect::Create(edgeType, *inner);
         if (NULL == fp) {
             return false;
         }
         are.set(drawState);
         drawState->addCoverageProcessor(fp)->unref();
     }
 
     SkStrokeRec fillRec(SkStrokeRec::kFill_InitStyle);
-    if (this->drawRRect(target, drawState, color, context, useAA, origOuter, fillRec)) {
+    if (this->drawRRect(target, drawState, color, useAA, origOuter, fillRec)) {
         return true;
     }
 
     SkASSERT(!origOuter.isEmpty());
     SkTCopyOnFirstWrite<SkRRect> outer(origOuter);
-    if (!context->getMatrix().isIdentity()) {
-        if (!origOuter.transform(context->getMatrix(), outer.writable())) {
+    if (!drawState->getViewMatrix().isIdentity()) {
+        if (!origOuter.transform(drawState->getViewMatrix(), outer.writable())) {
             return false;
         }
     }
     GrPrimitiveEdgeType edgeType = applyAA ? kFillAA_GrProcessorEdgeType :
                                           kFillBW_GrProcessorEdgeType;
     GrFragmentProcessor* effect = GrRRectEffect::Create(edgeType, *outer);
     if (NULL == effect) {
         return false;
     }
     if (!are.isSet()) {
         are.set(drawState);
     }
     GrDrawState::AutoViewMatrixRestore avmr;
     if (!avmr.setIdentity(drawState)) {
         return false;
     }
     drawState->addCoverageProcessor(effect)->unref();
     SkRect bounds = outer->getBounds();
     if (applyAA) {
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
     }
     target->drawRect(drawState, color, bounds, NULL, NULL);
     return true;
 }
 
 bool GrOvalRenderer::drawRRect(GrDrawTarget* target,
                                GrDrawState* drawState,
                                GrColor color,
-                               GrContext* context,
                                bool useAA,
                                const SkRRect& rrect,
                                const SkStrokeRec& stroke) {
     if (rrect.isOval()) {
-        return this->drawOval(target, drawState, color, context, useAA, rrect.getBounds(), stroke);
+        return this->drawOval(target, drawState, color, useAA, rrect.getBounds(), stroke);
     }
 
     bool useCoverageAA = useAA &&
         !drawState->getRenderTarget()->isMultisampled() &&
         drawState->canUseFracCoveragePrimProc(color, *target->caps());
 
     // only anti-aliased rrects for now
     if (!useCoverageAA) {
         return false;
     }
 
-    const SkMatrix& vm = context->getMatrix();
+    const SkMatrix& vm = drawState->getViewMatrix();
 
     if (!vm.rectStaysRect() || !rrect.isSimple()) {
         return false;
     }
 
     // do any matrix crunching before we reset the draw state for device coords
     const SkRect& rrectBounds = rrect.getBounds();
     SkRect bounds;
     vm.mapRect(&bounds, rrectBounds);
 
@@ skipping 37 matching lines @@
     if (!isStrokeOnly && (SK_ScalarHalf > xRadius || SK_ScalarHalf > yRadius)) {
         return false;
     }
 
     // reset to device coordinates
     GrDrawState::AutoViewMatrixRestore avmr;
     if (!avmr.setIdentity(drawState)) {
         return false;
     }
 
-    GrIndexBuffer* indexBuffer = this->rRectIndexBuffer(isStrokeOnly, context->getGpu());
+    GrIndexBuffer* indexBuffer = this->rRectIndexBuffer(isStrokeOnly);
     if (NULL == indexBuffer) {
         SkDebugf("Failed to create index buffer!\n");
         return false;
     }
 
     // if the corners are circles, use the circle renderer
     if ((!hasStroke || scaledStroke.fX == scaledStroke.fY) && xRadius == yRadius) {
         SkScalar innerRadius = 0.0f;
         SkScalar outerRadius = xRadius;
         SkScalar halfWidth = 0;
@@ skipping 179 matching lines @@
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexedInstances(drawState, effect, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
                                      &bounds);
     }
 
     target->resetIndexSource();
     return true;
 }