Refugee from Dead Machine 4: MDB Monster

src/effects/SkMagnifierImageFilter.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 "SkBitmap.h"
 #include "SkMagnifierImageFilter.h"
 #include "SkColorPriv.h"
@@ skipping 15 matching lines @@
 class GrMagnifierEffect : public GrSingleTextureEffect {
 
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        const SkRect& bounds,
                                        float xOffset,
                                        float yOffset,
                                        float xInvZoom,
                                        float yInvZoom,
                                        float xInvInset,
-                                       float yInvInset) {
-        return new GrMagnifierEffect(texture, bounds, xOffset, yOffset, xInvZoom, yInvZoom, xInvInset,
-                                     yInvInset);
+                                       float yInvInset,
+                                       GrRenderTarget* dst) {
+        return new GrMagnifierEffect(texture, bounds, xOffset, yOffset, xInvZoom,
+                                     yInvZoom, xInvInset, yInvInset, dst);
     }
 
     virtual ~GrMagnifierEffect() {};
 
     const char* name() const override { return "Magnifier"; }
 
     const SkRect& bounds() const { return fBounds; }    // Bounds of source image.
     // Offset to apply to zoomed pixels, (srcRect position / texture size).
     float x_offset() const { return fXOffset; }
     float y_offset() const { return fYOffset; }
 
     // Scale to apply to zoomed pixels (srcRect size / bounds size).
     float x_inv_zoom() const { return fXInvZoom; }
     float y_inv_zoom() const { return fYInvZoom; }
 
     // 1/radius over which to transition from unzoomed to zoomed pixels (bounds size / inset).
     float x_inv_inset() const { return fXInvInset; }
     float y_inv_inset() const { return fYInvInset; }
 
 private:
     GrMagnifierEffect(GrTexture* texture,
                       const SkRect& bounds,
                       float xOffset,
                       float yOffset,
                       float xInvZoom,
                       float yInvZoom,
                       float xInvInset,
-                      float yInvInset)
-        : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
+                      float yInvInset, GrRenderTarget* dst)
+        : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture), kLocal_GrCoordSet, dst)
         , fBounds(bounds)
         , fXOffset(xOffset)
         , fYOffset(yOffset)
         , fXInvZoom(xInvZoom)
         , fYInvZoom(yInvZoom)
         , fXInvInset(xInvInset)
         , fYInvInset(yInvInset) {
         this->initClassID<GrMagnifierEffect>();
     }
 
@@ skipping 126 matching lines @@
     uint32_t inset = d->fRandom->nextULessThan(kMaxInset);
 
     GrFragmentProcessor* effect = GrMagnifierEffect::Create(
         texture,
         SkRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight)),
         (float) width / texture->width(),
         (float) height / texture->height(),
         texture->width() / (float) x,
         texture->height() / (float) y,
         (float) inset / texture->width(),
-        (float) inset / texture->height());
+        (float) inset / texture->height(), NULL);
     SkASSERT(effect);
     return effect;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>();
     return (this->fBounds == s.fBounds &&
             this->fXOffset == s.fXOffset &&
@@ skipping 28 matching lines @@
 
 SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset,
                                                SkImageFilter* input)
     : INHERITED(1, &input), fSrcRect(srcRect), fInset(inset) {
     SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0);
 }
 
 #if SK_SUPPORT_GPU
 bool SkMagnifierImageFilter::asFragmentProcessor(GrFragmentProcessor** fp,
                                                  GrTexture* texture, const SkMatrix&,
-                                                 const SkIRect&bounds) const {
+                                                 const SkIRect&bounds, GrRenderTarget* dst) const {
     if (fp) {
         SkScalar yOffset = texture->origin() == kTopLeft_GrSurfaceOrigin ? fSrcRect.y() :
            texture->height() - fSrcRect.height() * texture->height() / bounds.height()
                              - fSrcRect.y();
         int boundsY = (texture->origin() == kTopLeft_GrSurfaceOrigin) ? bounds.y() :
                       (texture->height() - bounds.height());
         SkRect effectBounds = SkRect::MakeXYWH(
             SkIntToScalar(bounds.x()) / texture->width(),
             SkIntToScalar(boundsY) / texture->height(),
             SkIntToScalar(texture->width()) / bounds.width(),
             SkIntToScalar(texture->height()) / bounds.height());
         SkScalar invInset = fInset > 0 ? SkScalarInvert(fInset) : SK_Scalar1;
         *fp = GrMagnifierEffect::Create(texture,
                                         effectBounds,
                                         fSrcRect.x() / texture->width(),
                                         yOffset / texture->height(),
                                         fSrcRect.width() / bounds.width(),
                                         fSrcRect.height() / bounds.height(),
                                         bounds.width() * invInset,
-                                        bounds.height() * invInset);
+                                        bounds.height() * invInset, dst);
     }
     return true;
 }
 #endif
 
 SkFlattenable* SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkRect src;
     buffer.readRect(&src);
     return Create(src, buffer.readScalar(), common.getInput(0));
@@ skipping 76 matching lines @@
 
 #ifndef SK_IGNORE_TO_STRING
 void SkMagnifierImageFilter::toString(SkString* str) const {
     str->appendf("SkMagnifierImageFilter: (");
     str->appendf("src: (%f,%f,%f,%f) ",
                  fSrcRect.fLeft, fSrcRect.fTop, fSrcRect.fRight, fSrcRect.fBottom);
     str->appendf("inset: %f", fInset);
     str->append(")");
 }
 #endif