Move skPaint2GrPaint to SkGr.h/cpp

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
+#include "SkColorFilter.h"
 #include "SkConfig8888.h"
+#include "SkGpuDevice.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "GrResourceCache.h"
 
 /*  Fill out buffer with the compressed format Ganesh expects from a colortable
  based bitmap. [palette (colortable) + indices].
 
  At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
  we could detect that the colortable.count is <= 16, and then repack the
  indices as nibbles to save RAM, but it would take more time (i.e. a lot
@@ skipping 296 matching lines @@
             ct = kBGRA_8888_SkColorType;
             break;
         default:
             return false;
     }
     if (ctOut) {
         *ctOut = ct;
     }
     return true;
 }
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool SkPaint2GrPaintNoShader(SkGpuDevice* dev, const SkPaint& skPaint, bool justAlpha,
+                             bool constantColor, GrPaint* grPaint) {
+
+    grPaint->setDither(skPaint.isDither());
+    grPaint->setAntiAlias(skPaint.isAntiAlias());
+
+    SkXfermode::Coeff sm;
+    SkXfermode::Coeff dm;
+
+    SkXfermode* mode = skPaint.getXfermode();
+    GrEffectRef* xferEffect = NULL;
+    if (SkXfermode::AsNewEffectOrCoeff(mode, &xferEffect, &sm, &dm)) {
+        if (NULL != xferEffect) {
+            grPaint->addColorEffect(xferEffect)->unref();
+            sm = SkXfermode::kOne_Coeff;
+            dm = SkXfermode::kZero_Coeff;
+        }
+    } else {
+        //SkDEBUGCODE(SkDebugf("Unsupported xfer mode.\n");)

[robertphillips, 2014/05/13 16:24:11]

What's up with this? All caller seem to handle the return type. In which cases
can it fail?

[egdaniel, 2014/05/13 17:35:54]

I tried following AsNewEffectOrCoeff to see what fails, and you basically run
into having to look at all the subclasses asNewEffect implementations to see if
they can fail. Brian do you know what our fail cases are off the top of your
head, so we can remove the return false path and just add a comment for what
cases we fall back to src-over for?
On 2014/05/13 16:24:11, robertphillips wrote:

[bsalomon, 2014/05/13 20:34:29]

I think we should just remove the return false. We don't similarly fail if other
pipeline stages fail to turn themselves into GrEffects. E.g. the color filter
code below.

+#if 0
+        return false;
+#else
+        // Fall back to src-over
+        sm = SkXfermode::kOne_Coeff;
+        dm = SkXfermode::kISA_Coeff;
+#endif
+    }
+    grPaint->setBlendFunc(sk_blend_to_grblend(sm), sk_blend_to_grblend(dm));
+
+    if (justAlpha) {
+        uint8_t alpha = skPaint.getAlpha();
+        grPaint->setColor(GrColorPackRGBA(alpha, alpha, alpha, alpha));
+        // justAlpha is currently set to true only if there is a texture,
+        // so constantColor should not also be true.
+        SkASSERT(!constantColor);
+    } else {
+        grPaint->setColor(SkColor2GrColor(skPaint.getColor()));
+    }
+
+    SkColorFilter* colorFilter = skPaint.getColorFilter();
+    if (NULL != colorFilter) {
+        // if the source color is a constant then apply the filter here once rather than per pixel
+        // in a shader.
+        if (constantColor) {
+            SkColor filtered = colorFilter->filterColor(skPaint.getColor());
+            grPaint->setColor(SkColor2GrColor(filtered));
+        } else {
+            SkAutoTUnref<GrEffectRef> effect(colorFilter->asNewEffect(dev->context()));
+            if (NULL != effect.get()) {
+                grPaint->addColorEffect(effect);
+            }
+        }
+    }
+
+    return true;
+}
+
+bool SkPaint2GrPaintShader(SkGpuDevice* dev, const SkPaint& skPaint,
+                           bool constantColor, GrPaint* grPaint) {
+    SkShader* shader = skPaint.getShader();
+    if (NULL == shader) {
+        return SkPaint2GrPaintNoShader(dev, skPaint, false, constantColor, grPaint);
+    }
+
+    // SkShader::asNewEffect() may do offscreen rendering. Setup default drawing state and require
+    // the shader to set a render target .
+    GrContext::AutoWideOpenIdentityDraw awo(dev->context(), NULL);
+
+    // setup the shader as the first color effect on the paint
+    SkAutoTUnref<GrEffectRef> effect(shader->asNewEffect(dev->context(), skPaint, NULL));
+    if (NULL != effect.get()) {
+        grPaint->addColorEffect(effect);
+        // Now setup the rest of the paint.
+        return SkPaint2GrPaintNoShader(dev, skPaint, true, false, grPaint);
+    } else {

[robertphillips, 2014/05/13 16:24:11]

Do we have a TODO for this? Is it something an intern could do?

[egdaniel, 2014/05/13 17:35:54]

Getting this implemented should allow us to remove any need for return value
(assuming we fall back to src-over in the NoShader function).

[bsalomon, 2014/05/13 20:34:29]

Same argument here. Let's just make the function void. If we want to give
feedback to the client we can use the error reporting mechanism.

I'm not sure we really even want SkColorShader to return a GrEffect. Perhaps the
signature on SkShader::asNewEffect could allow the SkShader to override the
SkPaint's color(). Maybe this could remove the need for justAlpha? Or maybe the
color array on drawVertices() complicates removing it? Anyway, it's orthogonal
to this code move.

+        // We still don't have SkColorShader::asNewEffect() implemented.
+        SkShader::GradientInfo info;
+        SkColor                color;
+
+        info.fColors = &color;
+        info.fColorOffsets = NULL;
+        info.fColorCount = 1;
+        if (SkShader::kColor_GradientType == shader->asAGradient(&info)) {
+            SkPaint copy(skPaint);
+            copy.setShader(NULL);
+            // modulate the paint alpha by the shader's solid color alpha
+            U8CPU newA = SkMulDiv255Round(SkColorGetA(color), copy.getAlpha());
+            copy.setColor(SkColorSetA(color, newA));
+            return SkPaint2GrPaintNoShader(dev, copy, false, constantColor, grPaint);
+        } else {
+            return false;
+        }
+    }
+}
+