Remove setFromPaint from GrPipelineBuilder

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 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 "GrAtlasTextContext.h"
@@ skipping 169 matching lines @@
         inverse.mapRect(&r);
         this->drawRect(rt, clip, *paint, viewMatrix, r);
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fContext);
-        GrPipelineBuilder pipelineBuilder;
-        if (!this->prepareToDraw(&pipelineBuilder, rt, clip, paint)) {
+        if (!this->prepareToDraw(rt)) {
             return;
         }
 
+        GrPipelineBuilder pipelineBuilder(*paint, rt, clip);
         fDrawTarget->drawBWRect(&pipelineBuilder,
                                 paint->getColor(),
                                 SkMatrix::I(),
                                 r,
                                 NULL,
                                 &localMatrix);
     }
 }
 
 static inline bool is_irect(const SkRect& r) {
@@ skipping 223 matching lines @@
     RETURN_IF_ABANDONED
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(rt, clip, paint, viewMatrix, path, *strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
-    GrPipelineBuilder pipelineBuilder;
-    if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+
     SkScalar width = NULL == strokeInfo ? -1 : strokeInfo->getWidth();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
     if (width < 0) {
         SkRect rtRect;
         pipelineBuilder.getRenderTarget()->getBoundsRect(&rtRect);
         SkRect clipSpaceRTRect = rtRect;
         bool checkClip = GrClip::kWideOpen_ClipType != clip.clipType();
         if (checkClip) {
@@ skipping 76 matching lines @@
 
 void GrDrawContext::drawNonAARectToRect(GrRenderTarget* rt,
                                         const GrClip& clip,
                                         const GrPaint& paint,
                                         const SkMatrix& viewMatrix,
                                         const SkRect& rectToDraw,
                                         const SkRect& localRect,
                                         const SkMatrix* localMatrix) {
     RETURN_IF_ABANDONED
     AutoCheckFlush acf(fContext);
-    GrPipelineBuilder pipelineBuilder;
-    if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     fDrawTarget->drawBWRect(&pipelineBuilder,
                             paint.getColor(),
                             viewMatrix,
                             rectToDraw,
                             &localRect,
                             localMatrix);
 }
 
 static const GrGeometryProcessor* set_vertex_attributes(bool hasLocalCoords,
                                                         bool hasColors,
@@ skipping 271 matching lines @@
                                  const SkMatrix& viewMatrix,
                                  GrPrimitiveType primitiveType,
                                  int vertexCount,
                                  const SkPoint positions[],
                                  const SkPoint texCoords[],
                                  const GrColor colors[],
                                  const uint16_t indices[],
                                  int indexCount) {
     RETURN_IF_ABANDONED
     AutoCheckFlush acf(fContext);
-    GrPipelineBuilder pipelineBuilder;
-
-    if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+
     // TODO clients should give us bounds
     SkRect bounds;
     if (!bounds.setBoundsCheck(positions, vertexCount)) {
         SkDebugf("drawVertices call empty bounds\n");
         return;
     }
 
     viewMatrix.mapRect(&bounds);
 
     // If we don't have AA then we outset for a half pixel in each direction to account for
@@ skipping 27 matching lines @@
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(rrect);
         this->drawPath(rt, clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
-    GrPipelineBuilder pipelineBuilder;
-    if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     GrColor color = paint.getColor();
     if (!GrOvalRenderer::DrawRRect(fDrawTarget,
                                    &pipelineBuilder,
                                    color,
                                    viewMatrix,
                                    paint.isAntiAlias(),
                                    rrect,
                                    strokeInfo)) {
         SkPath path;
         path.setIsVolatile(true);
@@ skipping 10 matching lines @@
                                const GrPaint& paint,
                                const SkMatrix& viewMatrix,
                                const SkRRect& outer,
                                const SkRRect& inner) {
     RETURN_IF_ABANDONED
     if (outer.isEmpty()) {
        return;
     }
 
     AutoCheckFlush acf(fContext);
-    GrPipelineBuilder pipelineBuilder;
-    if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     GrColor color = paint.getColor();
     if (!GrOvalRenderer::DrawDRRect(fDrawTarget,
                                     &pipelineBuilder,
                                     color,
                                     viewMatrix,
                                     paint.isAntiAlias(),
                                     outer,
                                     inner)) {
         SkPath path;
         path.setIsVolatile(true);
@@ skipping 22 matching lines @@
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
         this->drawPath(rt, clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
-    GrPipelineBuilder pipelineBuilder;
-    if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     GrColor color = paint.getColor();
     if (!GrOvalRenderer::DrawOval(fDrawTarget,
                                   &pipelineBuilder,
                                   color,
                                   viewMatrix,
                                   paint.isAntiAlias(),
                                   oval,
                                   strokeInfo)) {
         SkPath path;
         path.setIsVolatile(true);
@@ skipping 71 matching lines @@
     }
 
     GrColor color = paint.getColor();
 
     // Note that internalDrawPath may sw-rasterize the path into a scratch texture.
     // Scratch textures can be recycled after they are returned to the texture
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
     AutoCheckFlush acf(fContext);
-    GrPipelineBuilder pipelineBuilder;
-    if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
+    if (!this->prepareToDraw(rt)) {
         return;
     }
 
+    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     if (!strokeInfo.isDashed()) {
         bool useCoverageAA = paint.isAntiAlias() &&
                 !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
         if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
             if (is_nested_rects(fDrawTarget, &pipelineBuilder, color, viewMatrix, path, strokeInfo,
                                 rects)) {
@@ skipping 94 matching lines @@
     if (NULL == pr) {
 #ifdef SK_DEBUG
         SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
     pr->drawPath(target, pipelineBuilder, color, viewMatrix, *pathPtr, *strokeInfoPtr, useCoverageAA);
 }
 
-bool GrDrawContext::prepareToDraw(GrPipelineBuilder* pipelineBuilder,
-                                  GrRenderTarget* rt,
-                                  const GrClip& clip,
-                                  const GrPaint* paint) {
-    RETURN_FALSE_IF_ABANDONED
-
-    ASSERT_OWNED_RESOURCE(rt);
-    SkASSERT(rt && paint);
-    pipelineBuilder->setFromPaint(*paint, rt, clip);
-    return true;
-}
-
 bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrBatch* batch) {
     fDrawTarget->drawBatch(pipelineBuilder, batch);
@@ skipping 119 matching lines @@
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif