Refugee from Dead Machine 4: MDB Monster

src/gpu/effects/GrMatrixConvolutionEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrMatrixConvolutionEffect.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/GrGLTexture.h"
 #include "gl/builders/GrGLProgramBuilder.h"
@@ skipping 120 matching lines @@
 }
 
 GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrTexture* texture,
                                                      const SkIRect& bounds,
                                                      const SkISize& kernelSize,
                                                      const SkScalar* kernel,
                                                      SkScalar gain,
                                                      SkScalar bias,
                                                      const SkIPoint& kernelOffset,
                                                      GrTextureDomain::Mode tileMode,
-                                                     bool convolveAlpha)
-  : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture)),
+                                                     bool convolveAlpha, GrRenderTarget* dst)
+  : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture), kLocal_GrCoordSet, dst),
     fKernelSize(kernelSize),
     fGain(SkScalarToFloat(gain)),
     fBias(SkScalarToFloat(bias) / 255.0f),
     fConvolveAlpha(convolveAlpha),
     fDomain(GrTextureDomain::MakeTexelDomainForMode(texture, bounds, tileMode), tileMode) {
     this->initClassID<GrMatrixConvolutionEffect>();
     for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
         fKernel[i] = SkScalarToFloat(kernel[i]);
     }
     fKernelOffset[0] = static_cast<float>(kernelOffset.x());
@@ skipping 28 matching lines @@
 GrFragmentProcessor*
 GrMatrixConvolutionEffect::CreateGaussian(GrTexture* texture,
                                           const SkIRect& bounds,
                                           const SkISize& kernelSize,
                                           SkScalar gain,
                                           SkScalar bias,
                                           const SkIPoint& kernelOffset,
                                           GrTextureDomain::Mode tileMode,
                                           bool convolveAlpha,
                                           SkScalar sigmaX,
-                                          SkScalar sigmaY) {
+                                          SkScalar sigmaY, GrRenderTarget* dst) {
     float kernel[MAX_KERNEL_SIZE];
     int width = kernelSize.width();
     int height = kernelSize.height();
     SkASSERT(width * height <= MAX_KERNEL_SIZE);
     float sum = 0.0f;
     float sigmaXDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaX)));
     float sigmaYDenom = 1.0f / (2.0f * SkScalarToFloat(SkScalarSquare(sigmaY)));
     int xRadius = width / 2;
     int yRadius = height / 2;
     for (int x = 0; x < width; x++) {
       float xTerm = static_cast<float>(x - xRadius);
       xTerm = xTerm * xTerm * sigmaXDenom;
       for (int y = 0; y < height; y++) {
         float yTerm = static_cast<float>(y - yRadius);
         float xyTerm = sk_float_exp(-(xTerm + yTerm * yTerm * sigmaYDenom));
         // Note that the constant term (1/(sqrt(2*pi*sigma^2)) of the Gaussian
        // is dropped here, since we renormalize the kernel below.
         kernel[y * width + x] = xyTerm;
         sum += xyTerm;
       }
     }
     // Normalize the kernel
     float scale = 1.0f / sum;
     for (int i = 0; i < width * height; ++i) {
         kernel[i] *= scale;
     }
-    return new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain, bias,
-                                         kernelOffset, tileMode, convolveAlpha);
+    return new GrMatrixConvolutionEffect(texture, bounds, kernelSize, kernel, gain,
+                                         bias, kernelOffset, tileMode, convolveAlpha, dst);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect);
 
 const GrFragmentProcessor* GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                           GrProcessorUnitTest::kAlphaTextureIdx;
     int width = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE);
     int height = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE / width);
     SkISize kernelSize = SkISize::Make(width, height);
@@ skipping 13 matching lines @@
             static_cast<GrTextureDomain::Mode>(d->fRandom->nextRangeU(0, 2));
     bool convolveAlpha = d->fRandom->nextBool();
     return GrMatrixConvolutionEffect::Create(d->fTextures[texIdx],
                                              bounds,
                                              kernelSize,
                                              kernel.get(),
                                              gain,
                                              bias,
                                              kernelOffset,
                                              tileMode,
-                                             convolveAlpha);
+                                             convolveAlpha, NULL);
 }