Image filters: implement offsets in GPU path.

src/effects/SkBlendImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlendImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
@@ skipping 50 matching lines @@
 
 bool SkBlendImageFilter::onFilterImage(Proxy* proxy,
                                        const SkBitmap& src,
                                        const SkMatrix& ctm,
                                        SkBitmap* dst,
                                        SkIPoint* offset) {
     SkBitmap background, foreground = src;
     SkImageFilter* backgroundInput = getBackgroundInput();
     SkImageFilter* foregroundInput = getForegroundInput();
     SkASSERT(NULL != backgroundInput);
-    if (!backgroundInput->filterImage(proxy, src, ctm, &background, offset)) {
+    SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
+    if (!backgroundInput->filterImage(proxy, src, ctm, &background, &backgroundOffset)) {
         return false;
     }
-    if (foregroundInput && !foregroundInput->filterImage(proxy, src, ctm, &foreground, offset)) {
+    SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
+    if (foregroundInput &&
+        !foregroundInput->filterImage(proxy, src, ctm, &foreground, &foregroundOffset)) {
         return false;
     }
     SkAutoLockPixels alp_foreground(foreground), alp_background(background);
     if (!foreground.getPixels() || !background.getPixels()) {
         return false;
     }
     dst->setConfig(background.config(), background.width(), background.height());
     dst->allocPixels();
     SkCanvas canvas(*dst);
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
-    canvas.drawBitmap(background, 0, 0, &paint);
+    canvas.drawBitmap(background, backgroundOffset.fX, backgroundOffset.fY, &paint);
     paint.setXfermodeMode(modeToXfermode(fMode));
-    canvas.drawBitmap(foreground, 0, 0, &paint);
+    canvas.drawBitmap(foreground, foregroundOffset.fX, foregroundOffset.fY, &paint);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 class GrGLBlendEffect : public GrGLEffect {
 public:
     GrGLBlendEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
     virtual ~GrGLBlendEffect();
@@ skipping 18 matching lines @@
 
     typedef GrGLEffect INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrBlendEffect : public GrEffect {
 public:
     static GrEffectRef* Create(SkBlendImageFilter::Mode mode,
                                GrTexture* foreground,
-                               GrTexture* background) {
-        AutoEffectUnref effect(SkNEW_ARGS(GrBlendEffect, (mode, foreground, background)));
+                               const SkIPoint& foregroundOffset,
+                               GrTexture* background,
+                               const SkIPoint& backgroundOffset) {
+        AutoEffectUnref effect(SkNEW_ARGS(GrBlendEffect, (mode, foreground, foregroundOffset,
+                                                          background, backgroundOffset)));
         return CreateEffectRef(effect);
     }
 
     virtual ~GrBlendEffect();
 
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
     SkBlendImageFilter::Mode mode() const { return fMode; }
+    const SkMatrix& foregroundMatrix() const { return fForegroundMatrix; }
+    const SkMatrix& backgroundMatrix() const { return fBackgroundMatrix; }
 
     typedef GrGLBlendEffect GLEffect;
     static const char* Name() { return "Blend"; }
 
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
 private:
     virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
 
-    GrBlendEffect(SkBlendImageFilter::Mode mode, GrTexture* foreground, GrTexture* background);
+    GrBlendEffect(SkBlendImageFilter::Mode mode,
+                  GrTexture* foreground, const SkIPoint& foregroundOffset,
+                  GrTexture* background, const SkIPoint& backgroundOffset);
     GrTextureAccess             fForegroundAccess;
+    SkMatrix                    fForegroundMatrix;
     GrTextureAccess             fBackgroundAccess;
+    SkMatrix                    fBackgroundMatrix;
     SkBlendImageFilter::Mode    fMode;
 
     typedef GrEffect INHERITED;
 };
 
-bool SkBlendImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, SkBitmap* result) {
+bool SkBlendImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, SkBitmap* result,
+                                        SkIPoint* offset) {
     SkBitmap backgroundBM;
-    if (!SkImageFilterUtils::GetInputResultGPU(getBackgroundInput(), proxy, src, &backgroundBM)) {
+    SkIPoint backgroundOffset = SkIPoint::Make(0, 0);
+    if (!SkImageFilterUtils::GetInputResultGPU(getBackgroundInput(), proxy, src, &backgroundBM,
+                                               &backgroundOffset)) {
         return false;
     }
     GrTexture* background = backgroundBM.getTexture();
     SkBitmap foregroundBM;
-    if (!SkImageFilterUtils::GetInputResultGPU(getForegroundInput(), proxy, src, &foregroundBM)) {
+    SkIPoint foregroundOffset = SkIPoint::Make(0, 0);
+    if (!SkImageFilterUtils::GetInputResultGPU(getForegroundInput(), proxy, src, &foregroundBM,
+                                               &foregroundOffset)) {
         return false;
     }
     GrTexture* foreground = foregroundBM.getTexture();
     GrContext* context = foreground->getContext();
 
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
     desc.fWidth = src.width();
     desc.fHeight = src.height();
     desc.fConfig = kSkia8888_GrPixelConfig;
 
     GrAutoScratchTexture ast(context, desc);
     SkAutoTUnref<GrTexture> dst(ast.detach());
 
     GrContext::AutoRenderTarget art(context, dst->asRenderTarget());
 
     GrPaint paint;
     paint.colorStage(0)->setEffect(
-        GrBlendEffect::Create(fMode, foreground, background))->unref();
+        GrBlendEffect::Create(fMode, foreground, foregroundOffset, background, backgroundOffset))->unref();
     SkRect srcRect;
     src.getBounds(&srcRect);
     context->drawRect(paint, srcRect);
     return SkImageFilterUtils::WrapTexture(dst, src.width(), src.height(), result);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrBlendEffect::GrBlendEffect(SkBlendImageFilter::Mode mode,
                              GrTexture* foreground,
-                             GrTexture* background)
+                             const SkIPoint& foregroundOffset,
+                             GrTexture* background,
+                             const SkIPoint& backgroundOffset)
     : fForegroundAccess(foreground)
     , fBackgroundAccess(background)
     , fMode(mode) {
     this->addTextureAccess(&fForegroundAccess);
     this->addTextureAccess(&fBackgroundAccess);
+    fForegroundMatrix = GrEffect::MakeDivByTextureWHMatrix(foreground);
+    fForegroundMatrix.preTranslate(SkIntToScalar(-foregroundOffset.fX),
+                                   SkIntToScalar(-foregroundOffset.fY));
+    fBackgroundMatrix = GrEffect::MakeDivByTextureWHMatrix(background);
+    fBackgroundMatrix.preTranslate(SkIntToScalar(-backgroundOffset.fX),
+                                   SkIntToScalar(-backgroundOffset.fY));
 }
 
 GrBlendEffect::~GrBlendEffect() {
 }
 
 bool GrBlendEffect::onIsEqual(const GrEffect& sBase) const {
     const GrBlendEffect& s = CastEffect<GrBlendEffect>(sBase);
     return fForegroundAccess.getTexture() == s.fForegroundAccess.getTexture() &&
            fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture() &&
            fMode == s.fMode;
@@ skipping 75 matching lines @@
         builder->fsCodeAppendf("\t\t%s.rgb = max((1.0 - %s.a) * %s.rgb + %s.rgb, (1.0 - %s.a) * %s.rgb + %s.rgb);\n", outputColor, fgColor, bgColor, fgColor, bgColor, fgColor, bgColor);
         break;
     }
 }
 
 void GrGLBlendEffect::setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) {
     const GrBlendEffect& blend = drawEffect.castEffect<GrBlendEffect>();
     GrTexture* fgTex = blend.texture(0);
     GrTexture* bgTex = blend.texture(1);
     fForegroundEffectMatrix.setData(uman,
-                                    GrEffect::MakeDivByTextureWHMatrix(fgTex),
+                                    blend.foregroundMatrix(),
                                     drawEffect,
                                     fgTex);
     fBackgroundEffectMatrix.setData(uman,
-                                    GrEffect::MakeDivByTextureWHMatrix(bgTex),
+                                    blend.backgroundMatrix(),
                                     drawEffect,
                                     bgTex);
 
 }
 
 GrGLEffect::EffectKey GrGLBlendEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
     const GrBlendEffect& blend = drawEffect.castEffect<GrBlendEffect>();
 
     GrTexture* fgTex = blend.texture(0);
     GrTexture* bgTex = blend.texture(1);
 
     EffectKey fgKey = GrGLEffectMatrix::GenKey(GrEffect::MakeDivByTextureWHMatrix(fgTex),
                                                drawEffect,
                                                kCoordsType,
                                                fgTex);
 
     EffectKey bgKey = GrGLEffectMatrix::GenKey(GrEffect::MakeDivByTextureWHMatrix(bgTex),
                                                drawEffect,
                                                kCoordsType,
                                                bgTex);
     bgKey <<= GrGLEffectMatrix::kKeyBits;
     EffectKey modeKey = blend.mode() << (2 * GrGLEffectMatrix::kKeyBits);
 
     return  modeKey | bgKey | fgKey;
 }
 #endif