src/effects/SkPerlinNoiseShader.cpp

   1 /*
   2  * Copyright 2013 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkDither.h"
   9 #include "SkPerlinNoiseShader.h"
  10 #include "SkColorFilter.h"
  11 #include "SkReadBuffer.h"
  12 #include "SkWriteBuffer.h"
  13 #include "SkShader.h"
  14 #include "SkUnPreMultiply.h"
  15 #include "SkString.h"
  16
  17 #if SK_SUPPORT_GPU
  18 #include "GrContext.h"
  19 #include "GrCoordTransform.h"
  20 #include "GrInvariantOutput.h"
  21 #include "SkGr.h"
  22 #include "effects/GrConstColorProcessor.h"
  23 #include "glsl/GrGLSLFragmentProcessor.h"
  24 #include "glsl/GrGLSLFragmentShaderBuilder.h"
  25 #include "glsl/GrGLSLProgramBuilder.h"
  26 #include "glsl/GrGLSLProgramDataManager.h"
  27 #endif
  28
  29 static const int kBlockSize = 256;
  30 static const int kBlockMask = kBlockSize - 1;
  31 static const int kPerlinNoise = 4096;
  32 static const int kRandMaximum = SK_MaxS32; // 2**31 - 1
  33
  34 namespace {
  35
  36 // noiseValue is the color component's value (or color)
  37 // limitValue is the maximum perlin noise array index value allowed
  38 // newValue is the current noise dimension (either width or height)
  39 inline int checkNoise(int noiseValue, int limitValue, int newValue) {
  40     // If the noise value would bring us out of bounds of the current noise array while we are
  41     // stiching noise tiles together, wrap the noise around the current dimension of the noise to
  42     // stay within the array bounds in a continuous fashion (so that tiling lines are not visible)
  43     if (noiseValue >= limitValue) {
  44         noiseValue -= newValue;
  45     }
  46     return noiseValue;
  47 }
  48
  49 inline SkScalar smoothCurve(SkScalar t) {
  50     static const SkScalar SK_Scalar3 = 3.0f;
  51
  52     // returns t * t * (3 - 2 * t)
  53     return SkScalarMul(SkScalarSquare(t), SK_Scalar3 - 2 * t);
  54 }
  55
  56 } // end namespace
  57
  58 struct SkPerlinNoiseShader::StitchData {
  59     StitchData()
  60       : fWidth(0)
  61       , fWrapX(0)
  62       , fHeight(0)
  63       , fWrapY(0)
  64     {}
  65
  66     bool operator==(const StitchData& other) const {
  67         return fWidth == other.fWidth &&
  68                fWrapX == other.fWrapX &&
  69                fHeight == other.fHeight &&
  70                fWrapY == other.fWrapY;
  71     }
  72
  73     int fWidth; // How much to subtract to wrap for stitching.
  74     int fWrapX; // Minimum value to wrap.
  75     int fHeight;
  76     int fWrapY;
  77 };
  78
  79 struct SkPerlinNoiseShader::PaintingData {
  80     PaintingData(const SkISize& tileSize, SkScalar seed,
  81                  SkScalar baseFrequencyX, SkScalar baseFrequencyY,
  82                  const SkMatrix& matrix)
  83     {
  84         SkVector vec[2] = {
  85             { SkScalarInvert(baseFrequencyX),   SkScalarInvert(baseFrequencyY)  },
  86             { SkIntToScalar(tileSize.fWidth),   SkIntToScalar(tileSize.fHeight) },
  87         };
  88         matrix.mapVectors(vec, 2);
  89
  90         fBaseFrequency.set(SkScalarInvert(vec[0].fX), SkScalarInvert(vec[0].fY));
  91         fTileSize.set(SkScalarRoundToInt(vec[1].fX), SkScalarRoundToInt(vec[1].fY));
  92         this->init(seed);
  93         if (!fTileSize.isEmpty()) {
  94             this->stitch();
  95         }
  96
  97 #if SK_SUPPORT_GPU
  98         fPermutationsBitmap.setInfo(SkImageInfo::MakeA8(kBlockSize, 1));
  99         fPermutationsBitmap.setPixels(fLatticeSelector);
 100
 101         fNoiseBitmap.setInfo(SkImageInfo::MakeN32Premul(kBlockSize, 4));
 102         fNoiseBitmap.setPixels(fNoise[0][0]);
 103 #endif
 104     }
 105
 106     int         fSeed;
 107     uint8_t     fLatticeSelector[kBlockSize];
 108     uint16_t    fNoise[4][kBlockSize][2];
 109     SkPoint     fGradient[4][kBlockSize];
 110     SkISize     fTileSize;
 111     SkVector    fBaseFrequency;
 112     StitchData  fStitchDataInit;
 113
 114 private:
 115
 116 #if SK_SUPPORT_GPU
 117     SkBitmap   fPermutationsBitmap;
 118     SkBitmap   fNoiseBitmap;
 119 #endif
 120
 121     inline int random()  {
 122         static const int gRandAmplitude = 16807; // 7**5; primitive root of m
 123         static const int gRandQ = 127773; // m / a
 124         static const int gRandR = 2836; // m % a
 125
 126         int result = gRandAmplitude * (fSeed % gRandQ) - gRandR * (fSeed / gRandQ);
 127         if (result <= 0)
 128             result += kRandMaximum;
 129         fSeed = result;
 130         return result;
 131     }
 132
 133     // Only called once. Could be part of the constructor.
 134     void init(SkScalar seed)
 135     {
 136         static const SkScalar gInvBlockSizef = SkScalarInvert(SkIntToScalar(kBlockSize));
 137
 138         // According to the SVG spec, we must truncate (not round) the seed value.
 139         fSeed = SkScalarTruncToInt(seed);
 140         // The seed value clamp to the range [1, kRandMaximum - 1].
 141         if (fSeed <= 0) {
 142             fSeed = -(fSeed % (kRandMaximum - 1)) + 1;
 143         }
 144         if (fSeed > kRandMaximum - 1) {
 145             fSeed = kRandMaximum - 1;
 146         }
 147         for (int channel = 0; channel < 4; ++channel) {
 148             for (int i = 0; i < kBlockSize; ++i) {
 149                 fLatticeSelector[i] = i;
 150                 fNoise[channel][i][0] = (random() % (2 * kBlockSize));
 151                 fNoise[channel][i][1] = (random() % (2 * kBlockSize));
 152             }
 153         }
 154         for (int i = kBlockSize - 1; i > 0; --i) {
 155             int k = fLatticeSelector[i];
 156             int j = random() % kBlockSize;
 157             SkASSERT(j >= 0);
 158             SkASSERT(j < kBlockSize);
 159             fLatticeSelector[i] = fLatticeSelector[j];
 160             fLatticeSelector[j] = k;
 161         }
 162
 163         // Perform the permutations now
 164         {
 165             // Copy noise data
 166             uint16_t noise[4][kBlockSize][2];
 167             for (int i = 0; i < kBlockSize; ++i) {
 168                 for (int channel = 0; channel < 4; ++channel) {
 169                     for (int j = 0; j < 2; ++j) {
 170                         noise[channel][i][j] = fNoise[channel][i][j];
 171                     }
 172                 }
 173             }
 174             // Do permutations on noise data
 175             for (int i = 0; i < kBlockSize; ++i) {
 176                 for (int channel = 0; channel < 4; ++channel) {
 177                     for (int j = 0; j < 2; ++j) {
 178                         fNoise[channel][i][j] = noise[channel][fLatticeSelector[i]][j];
 179                     }
 180                 }
 181             }
 182         }
 183
 184         // Half of the largest possible value for 16 bit unsigned int
 185         static const SkScalar gHalfMax16bits = 32767.5f;
 186
 187         // Compute gradients from permutated noise data
 188         for (int channel = 0; channel < 4; ++channel) {
 189             for (int i = 0; i < kBlockSize; ++i) {
 190                 fGradient[channel][i] = SkPoint::Make(
 191                     SkScalarMul(SkIntToScalar(fNoise[channel][i][0] - kBlockSize),
 192                                 gInvBlockSizef),
 193                     SkScalarMul(SkIntToScalar(fNoise[channel][i][1] - kBlockSize),
 194                                 gInvBlockSizef));
 195                 fGradient[channel][i].normalize();
 196                 // Put the normalized gradient back into the noise data
 197                 fNoise[channel][i][0] = SkScalarRoundToInt(SkScalarMul(
 198                     fGradient[channel][i].fX + SK_Scalar1, gHalfMax16bits));
 199                 fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
 200                     fGradient[channel][i].fY + SK_Scalar1, gHalfMax16bits));
 201             }
 202         }
 203     }
 204
 205     // Only called once. Could be part of the constructor.
 206     void stitch() {
 207         SkScalar tileWidth  = SkIntToScalar(fTileSize.width());
 208         SkScalar tileHeight = SkIntToScalar(fTileSize.height());
 209         SkASSERT(tileWidth > 0 && tileHeight > 0);
 210         // When stitching tiled turbulence, the frequencies must be adjusted
 211         // so that the tile borders will be continuous.
 212         if (fBaseFrequency.fX) {
 213             SkScalar lowFrequencx =
 214                 SkScalarFloorToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
 215             SkScalar highFrequencx =
 216                 SkScalarCeilToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
 217             // BaseFrequency should be non-negative according to the standard.
 218             if (fBaseFrequency.fX / lowFrequencx < highFrequencx / fBaseFrequency.fX) {
 219                 fBaseFrequency.fX = lowFrequencx;
 220             } else {
 221                 fBaseFrequency.fX = highFrequencx;
 222             }
 223         }
 224         if (fBaseFrequency.fY) {
 225             SkScalar lowFrequency =
 226                 SkScalarFloorToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
 227             SkScalar highFrequency =
 228                 SkScalarCeilToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
 229             if (fBaseFrequency.fY / lowFrequency < highFrequency / fBaseFrequency.fY) {
 230                 fBaseFrequency.fY = lowFrequency;
 231             } else {
 232                 fBaseFrequency.fY = highFrequency;
 233             }
 234         }
 235         // Set up TurbulenceInitial stitch values.
 236         fStitchDataInit.fWidth  =
 237             SkScalarRoundToInt(tileWidth * fBaseFrequency.fX);
 238         fStitchDataInit.fWrapX  = kPerlinNoise + fStitchDataInit.fWidth;
 239         fStitchDataInit.fHeight =
 240             SkScalarRoundToInt(tileHeight * fBaseFrequency.fY);
 241         fStitchDataInit.fWrapY  = kPerlinNoise + fStitchDataInit.fHeight;
 242     }
 243
 244 public:
 245
 246 #if SK_SUPPORT_GPU
 247     const SkBitmap& getPermutationsBitmap() const { return fPermutationsBitmap; }
 248
 249     const SkBitmap& getNoiseBitmap() const { return fNoiseBitmap; }
 250 #endif
 251 };
 252
 253 SkShader* SkPerlinNoiseShader::CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
 254                                                   int numOctaves, SkScalar seed,
 255                                                   const SkISize* tileSize) {
 256     return new SkPerlinNoiseShader(kFractalNoise_Type, baseFrequencyX, baseFrequencyY, numOctaves,
 257                                    seed, tileSize);
 258 }
 259
 260 SkShader* SkPerlinNoiseShader::CreateTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
 261                                               int numOctaves, SkScalar seed,
 262                                               const SkISize* tileSize) {
 263     return new SkPerlinNoiseShader(kTurbulence_Type, baseFrequencyX, baseFrequencyY, numOctaves,
 264                                    seed, tileSize);
 265 }
 266
 267 SkPerlinNoiseShader::SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,
 268                                          SkScalar baseFrequencyX,
 269                                          SkScalar baseFrequencyY,
 270                                          int numOctaves,
 271                                          SkScalar seed,
 272                                          const SkISize* tileSize)
 273   : fType(type)
 274   , fBaseFrequencyX(baseFrequencyX)
 275   , fBaseFrequencyY(baseFrequencyY)
 276   , fNumOctaves(numOctaves > 255 ? 255 : numOctaves/*[0,255] octaves allowed*/)
 277   , fSeed(seed)
 278   , fTileSize(nullptr == tileSize ? SkISize::Make(0, 0) : *tileSize)
 279   , fStitchTiles(!fTileSize.isEmpty())
 280 {
 281     SkASSERT(numOctaves >= 0 && numOctaves < 256);
 282 }
 283
 284 SkPerlinNoiseShader::~SkPerlinNoiseShader() {
 285 }
 286
 287 SkFlattenable* SkPerlinNoiseShader::CreateProc(SkReadBuffer& buffer) {
 288     Type type = (Type)buffer.readInt();
 289     SkScalar freqX = buffer.readScalar();
 290     SkScalar freqY = buffer.readScalar();
 291     int octaves = buffer.readInt();
 292     SkScalar seed = buffer.readScalar();
 293     SkISize tileSize;
 294     tileSize.fWidth = buffer.readInt();
 295     tileSize.fHeight = buffer.readInt();
 296
 297     switch (type) {
 298         case kFractalNoise_Type:
 299             return SkPerlinNoiseShader::CreateFractalNoise(freqX, freqY, octaves, seed, &tileSize);
 300         case kTurbulence_Type:
 301             return SkPerlinNoiseShader::CreateTubulence(freqX, freqY, octaves, seed, &tileSize);
 302         default:
 303             return nullptr;
 304     }
 305 }
 306
 307 void SkPerlinNoiseShader::flatten(SkWriteBuffer& buffer) const {
 308     buffer.writeInt((int) fType);
 309     buffer.writeScalar(fBaseFrequencyX);
 310     buffer.writeScalar(fBaseFrequencyY);
 311     buffer.writeInt(fNumOctaves);
 312     buffer.writeScalar(fSeed);
 313     buffer.writeInt(fTileSize.fWidth);
 314     buffer.writeInt(fTileSize.fHeight);
 315 }
 316
 317 SkScalar SkPerlinNoiseShader::PerlinNoiseShaderContext::noise2D(
 318         int channel, const StitchData& stitchData, const SkPoint& noiseVector) const {
 319     struct Noise {
 320         int noisePositionIntegerValue;
 321         int nextNoisePositionIntegerValue;
 322         SkScalar noisePositionFractionValue;
 323         Noise(SkScalar component)
 324         {
 325             SkScalar position = component + kPerlinNoise;
 326             noisePositionIntegerValue = SkScalarFloorToInt(position);
 327             noisePositionFractionValue = position - SkIntToScalar(noisePositionIntegerValue);
 328             nextNoisePositionIntegerValue = noisePositionIntegerValue + 1;
 329         }
 330     };
 331     Noise noiseX(noiseVector.x());
 332     Noise noiseY(noiseVector.y());
 333     SkScalar u, v;
 334     const SkPerlinNoiseShader& perlinNoiseShader = static_cast<const SkPerlinNoiseShader&>(fShader);
 335     // If stitching, adjust lattice points accordingly.
 336     if (perlinNoiseShader.fStitchTiles) {
 337         noiseX.noisePositionIntegerValue =
 338             checkNoise(noiseX.noisePositionIntegerValue, stitchData.fWrapX, stitchData.fWidth);
 339         noiseY.noisePositionIntegerValue =
 340             checkNoise(noiseY.noisePositionIntegerValue, stitchData.fWrapY, stitchData.fHeight);
 341         noiseX.nextNoisePositionIntegerValue =
 342             checkNoise(noiseX.nextNoisePositionIntegerValue, stitchData.fWrapX, stitchData.fWidth);
 343         noiseY.nextNoisePositionIntegerValue =
 344             checkNoise(noiseY.nextNoisePositionIntegerValue, stitchData.fWrapY, stitchData.fHeight);
 345     }
 346     noiseX.noisePositionIntegerValue &= kBlockMask;
 347     noiseY.noisePositionIntegerValue &= kBlockMask;
 348     noiseX.nextNoisePositionIntegerValue &= kBlockMask;
 349     noiseY.nextNoisePositionIntegerValue &= kBlockMask;
 350     int i =
 351         fPaintingData->fLatticeSelector[noiseX.noisePositionIntegerValue];
 352     int j =
 353         fPaintingData->fLatticeSelector[noiseX.nextNoisePositionIntegerValue];
 354     int b00 = (i + noiseY.noisePositionIntegerValue) & kBlockMask;
 355     int b10 = (j + noiseY.noisePositionIntegerValue) & kBlockMask;
 356     int b01 = (i + noiseY.nextNoisePositionIntegerValue) & kBlockMask;
 357     int b11 = (j + noiseY.nextNoisePositionIntegerValue) & kBlockMask;
 358     SkScalar sx = smoothCurve(noiseX.noisePositionFractionValue);
 359     SkScalar sy = smoothCurve(noiseY.noisePositionFractionValue);
 360     // This is taken 1:1 from SVG spec: http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement
 361     SkPoint fractionValue = SkPoint::Make(noiseX.noisePositionFractionValue,
 362                                           noiseY.noisePositionFractionValue); // Offset (0,0)
 363     u = fPaintingData->fGradient[channel][b00].dot(fractionValue);
 364     fractionValue.fX -= SK_Scalar1; // Offset (-1,0)
 365     v = fPaintingData->fGradient[channel][b10].dot(fractionValue);
 366     SkScalar a = SkScalarInterp(u, v, sx);
 367     fractionValue.fY -= SK_Scalar1; // Offset (-1,-1)
 368     v = fPaintingData->fGradient[channel][b11].dot(fractionValue);
 369     fractionValue.fX = noiseX.noisePositionFractionValue; // Offset (0,-1)
 370     u = fPaintingData->fGradient[channel][b01].dot(fractionValue);
 371     SkScalar b = SkScalarInterp(u, v, sx);
 372     return SkScalarInterp(a, b, sy);
 373 }
 374
 375 SkScalar SkPerlinNoiseShader::PerlinNoiseShaderContext::calculateTurbulenceValueForPoint(
 376         int channel, StitchData& stitchData, const SkPoint& point) const {
 377     const SkPerlinNoiseShader& perlinNoiseShader = static_cast<const SkPerlinNoiseShader&>(fShader);
 378     if (perlinNoiseShader.fStitchTiles) {
 379         // Set up TurbulenceInitial stitch values.
 380         stitchData = fPaintingData->fStitchDataInit;
 381     }
 382     SkScalar turbulenceFunctionResult = 0;
 383     SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), fPaintingData->fBaseFrequency.fX),
 384                                       SkScalarMul(point.y(), fPaintingData->fBaseFrequency.fY)));
 385     SkScalar ratio = SK_Scalar1;
 386     for (int octave = 0; octave < perlinNoiseShader.fNumOctaves; ++octave) {
 387         SkScalar noise = noise2D(channel, stitchData, noiseVector);
 388         SkScalar numer = (perlinNoiseShader.fType == kFractalNoise_Type) ?
 389                             noise : SkScalarAbs(noise);
 390         turbulenceFunctionResult += numer / ratio;
 391         noiseVector.fX *= 2;
 392         noiseVector.fY *= 2;
 393         ratio *= 2;
 394         if (perlinNoiseShader.fStitchTiles) {
 395             // Update stitch values
 396             stitchData.fWidth  *= 2;
 397             stitchData.fWrapX   = stitchData.fWidth + kPerlinNoise;
 398             stitchData.fHeight *= 2;
 399             stitchData.fWrapY   = stitchData.fHeight + kPerlinNoise;
 400         }
 401     }
 402
 403     // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
 404     // by fractalNoise and (turbulenceFunctionResult) by turbulence.
 405     if (perlinNoiseShader.fType == kFractalNoise_Type) {
 406         turbulenceFunctionResult =
 407             SkScalarMul(turbulenceFunctionResult, SK_ScalarHalf) + SK_ScalarHalf;
 408     }
 409
 410     if (channel == 3) { // Scale alpha by paint value
 411         turbulenceFunctionResult *= SkIntToScalar(getPaintAlpha()) / 255;
 412     }
 413
 414     // Clamp result
 415     return SkScalarPin(turbulenceFunctionResult, 0, SK_Scalar1);
 416 }
 417
 418 SkPMColor SkPerlinNoiseShader::PerlinNoiseShaderContext::shade(
 419         const SkPoint& point, StitchData& stitchData) const {
 420     SkPoint newPoint;
 421     fMatrix.mapPoints(&newPoint, &point, 1);
 422     newPoint.fX = SkScalarRoundToScalar(newPoint.fX);
 423     newPoint.fY = SkScalarRoundToScalar(newPoint.fY);
 424
 425     U8CPU rgba[4];
 426     for (int channel = 3; channel >= 0; --channel) {
 427         rgba[channel] = SkScalarFloorToInt(255 *
 428             calculateTurbulenceValueForPoint(channel, stitchData, newPoint));
 429     }
 430     return SkPreMultiplyARGB(rgba[3], rgba[0], rgba[1], rgba[2]);
 431 }
 432
 433 SkShader::Context* SkPerlinNoiseShader::onCreateContext(const ContextRec& rec,
 434                                                         void* storage) const {
 435     return new (storage) PerlinNoiseShaderContext(*this, rec);
 436 }
 437
 438 size_t SkPerlinNoiseShader::contextSize() const {
 439     return sizeof(PerlinNoiseShaderContext);
 440 }
 441
 442 SkPerlinNoiseShader::PerlinNoiseShaderContext::PerlinNoiseShaderContext(
 443         const SkPerlinNoiseShader& shader, const ContextRec& rec)
 444     : INHERITED(shader, rec)
 445 {
 446     SkMatrix newMatrix = *rec.fMatrix;
 447     newMatrix.preConcat(shader.getLocalMatrix());
 448     if (rec.fLocalMatrix) {
 449         newMatrix.preConcat(*rec.fLocalMatrix);
 450     }
 451     // This (1,1) translation is due to WebKit's 1 based coordinates for the noise
 452     // (as opposed to 0 based, usually). The same adjustment is in the setData() function.
 453     fMatrix.setTranslate(-newMatrix.getTranslateX() + SK_Scalar1, -newMatrix.getTranslateY() + SK_Scalar1);
 454     fPaintingData = new PaintingData(shader.fTileSize, shader.fSeed, shader.fBaseFrequencyX,
 455                                      shader.fBaseFrequencyY, newMatrix);
 456 }
 457
 458 SkPerlinNoiseShader::PerlinNoiseShaderContext::~PerlinNoiseShaderContext() { delete fPaintingData; }
 459
 460 void SkPerlinNoiseShader::PerlinNoiseShaderContext::shadeSpan(
 461         int x, int y, SkPMColor result[], int count) {
 462     SkPoint point = SkPoint::Make(SkIntToScalar(x), SkIntToScalar(y));
 463     StitchData stitchData;
 464     for (int i = 0; i < count; ++i) {
 465         result[i] = shade(point, stitchData);
 466         point.fX += SK_Scalar1;
 467     }
 468 }
 469
 470 void SkPerlinNoiseShader::PerlinNoiseShaderContext::shadeSpan16(
 471         int x, int y, uint16_t result[], int count) {
 472     SkPoint point = SkPoint::Make(SkIntToScalar(x), SkIntToScalar(y));
 473     StitchData stitchData;
 474     DITHER_565_SCAN(y);
 475     for (int i = 0; i < count; ++i) {
 476         unsigned dither = DITHER_VALUE(x);
 477         result[i] = SkDitherRGB32To565(shade(point, stitchData), dither);
 478         DITHER_INC_X(x);
 479         point.fX += SK_Scalar1;
 480     }
 481 }
 482
 483 /////////////////////////////////////////////////////////////////////
 484
 485 #if SK_SUPPORT_GPU
 486
 487 class GrGLPerlinNoise : public GrGLSLFragmentProcessor {
 488 public:
 489     GrGLPerlinNoise(const GrProcessor&);
 490     virtual ~GrGLPerlinNoise() {}
 491
 492     virtual void emitCode(EmitArgs&) override;
 493
 494     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
 495
 496 protected:
 497     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 498
 499 private:
 500
 501     GrGLSLProgramDataManager::UniformHandle fStitchDataUni;
 502     SkPerlinNoiseShader::Type               fType;
 503     bool                                    fStitchTiles;
 504     int                                     fNumOctaves;
 505     GrGLSLProgramDataManager::UniformHandle fBaseFrequencyUni;
 506
 507 private:
 508     typedef GrGLSLFragmentProcessor INHERITED;
 509 };
 510
 511 /////////////////////////////////////////////////////////////////////
 512
 513 class GrPerlinNoiseEffect : public GrFragmentProcessor {
 514 public:
 515     static GrFragmentProcessor* Create(SkPerlinNoiseShader::Type type,
 516                                        int numOctaves, bool stitchTiles,
 517                                        SkPerlinNoiseShader::PaintingData* paintingData,
 518                                        GrTexture* permutationsTexture, GrTexture* noiseTexture,
 519                                        const SkMatrix& matrix) {
 520         return new GrPerlinNoiseEffect(type, numOctaves, stitchTiles, paintingData,
 521                                        permutationsTexture, noiseTexture, matrix);
 522     }
 523
 524     virtual ~GrPerlinNoiseEffect() { delete fPaintingData; }
 525
 526     const char* name() const override { return "PerlinNoise"; }
 527
 528     const SkPerlinNoiseShader::StitchData& stitchData() const { return fPaintingData->fStitchDataInit; }
 529
 530     SkPerlinNoiseShader::Type type() const { return fType; }
 531     bool stitchTiles() const { return fStitchTiles; }
 532     const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
 533     int numOctaves() const { return fNumOctaves; }
 534     const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
 535
 536 private:
 537     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
 538         return new GrGLPerlinNoise(*this);
 539     }
 540
 541     virtual void onGetGLSLProcessorKey(const GrGLSLCaps& caps,
 542                                        GrProcessorKeyBuilder* b) const override {
 543         GrGLPerlinNoise::GenKey(*this, caps, b);
 544     }
 545
 546     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
 547         const GrPerlinNoiseEffect& s = sBase.cast<GrPerlinNoiseEffect>();
 548         return fType == s.fType &&
 549                fPaintingData->fBaseFrequency == s.fPaintingData->fBaseFrequency &&
 550                fNumOctaves == s.fNumOctaves &&
 551                fStitchTiles == s.fStitchTiles &&
 552                fPaintingData->fStitchDataInit == s.fPaintingData->fStitchDataInit;
 553     }
 554
 555     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
 556         inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
 557     }
 558
 559     GrPerlinNoiseEffect(SkPerlinNoiseShader::Type type,
 560                         int numOctaves, bool stitchTiles,
 561                         SkPerlinNoiseShader::PaintingData* paintingData,
 562                         GrTexture* permutationsTexture, GrTexture* noiseTexture,
 563                         const SkMatrix& matrix)
 564       : fType(type)
 565       , fNumOctaves(numOctaves)
 566       , fStitchTiles(stitchTiles)
 567       , fPermutationsAccess(permutationsTexture)
 568       , fNoiseAccess(noiseTexture)
 569       , fPaintingData(paintingData) {
 570         this->initClassID<GrPerlinNoiseEffect>();
 571         this->addTextureAccess(&fPermutationsAccess);
 572         this->addTextureAccess(&fNoiseAccess);
 573         fCoordTransform.reset(kLocal_GrCoordSet, matrix);
 574         this->addCoordTransform(&fCoordTransform);
 575     }
 576
 577     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 578
 579     SkPerlinNoiseShader::Type       fType;
 580     GrCoordTransform                fCoordTransform;
 581     int                             fNumOctaves;
 582     bool                            fStitchTiles;
 583     GrTextureAccess                 fPermutationsAccess;
 584     GrTextureAccess                 fNoiseAccess;
 585     SkPerlinNoiseShader::PaintingData *fPaintingData;
 586
 587 private:
 588     typedef GrFragmentProcessor INHERITED;
 589 };
 590
 591 /////////////////////////////////////////////////////////////////////
 592 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrPerlinNoiseEffect);
 593
 594 const GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
 595     int      numOctaves = d->fRandom->nextRangeU(2, 10);
 596     bool     stitchTiles = d->fRandom->nextBool();
 597     SkScalar seed = SkIntToScalar(d->fRandom->nextU());
 598     SkISize  tileSize = SkISize::Make(d->fRandom->nextRangeU(4, 4096),
 599                                       d->fRandom->nextRangeU(4, 4096));
 600     SkScalar baseFrequencyX = d->fRandom->nextRangeScalar(0.01f,
 601                                                           0.99f);
 602     SkScalar baseFrequencyY = d->fRandom->nextRangeScalar(0.01f,
 603                                                           0.99f);
 604
 605     SkAutoTUnref<SkShader> shader(d->fRandom->nextBool() ?
 606         SkPerlinNoiseShader::CreateFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed,
 607                                                 stitchTiles ? &tileSize : nullptr) :
 608         SkPerlinNoiseShader::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed,
 609                                              stitchTiles ? &tileSize : nullptr));
 610
 611     return shader->asFragmentProcessor(d->fContext,
 612                                        GrTest::TestMatrix(d->fRandom), nullptr,
 613                                        kNone_SkFilterQuality);
 614 }
 615
 616 GrGLPerlinNoise::GrGLPerlinNoise(const GrProcessor& processor)
 617   : fType(processor.cast<GrPerlinNoiseEffect>().type())
 618   , fStitchTiles(processor.cast<GrPerlinNoiseEffect>().stitchTiles())
 619   , fNumOctaves(processor.cast<GrPerlinNoiseEffect>().numOctaves()) {
 620 }
 621
 622 void GrGLPerlinNoise::emitCode(EmitArgs& args) {
 623     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
 624     SkString vCoords = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
 625
 626     fBaseFrequencyUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
 627                                                   kVec2f_GrSLType, kDefault_GrSLPrecision,
 628                                                   "baseFrequency");
 629     const char* baseFrequencyUni = args.fBuilder->getUniformCStr(fBaseFrequencyUni);
 630
 631     const char* stitchDataUni = nullptr;
 632     if (fStitchTiles) {
 633         fStitchDataUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
 634                                                    kVec2f_GrSLType, kDefault_GrSLPrecision,
 635                                                    "stitchData");
 636         stitchDataUni = args.fBuilder->getUniformCStr(fStitchDataUni);
 637     }
 638
 639     // There are 4 lines, so the center of each line is 1/8, 3/8, 5/8 and 7/8
 640     const char* chanCoordR  = "0.125";
 641     const char* chanCoordG  = "0.375";
 642     const char* chanCoordB  = "0.625";
 643     const char* chanCoordA  = "0.875";
 644     const char* chanCoord   = "chanCoord";
 645     const char* stitchData  = "stitchData";
 646     const char* ratio       = "ratio";
 647     const char* noiseVec    = "noiseVec";
 648     const char* noiseSmooth = "noiseSmooth";
 649     const char* floorVal    = "floorVal";
 650     const char* fractVal    = "fractVal";
 651     const char* uv          = "uv";
 652     const char* ab          = "ab";
 653     const char* latticeIdx  = "latticeIdx";
 654     const char* bcoords     = "bcoords";
 655     const char* lattice     = "lattice";
 656     const char* inc8bit     = "0.00390625";  // 1.0 / 256.0
 657     // This is the math to convert the two 16bit integer packed into rgba 8 bit input into a
 658     // [-1,1] vector and perform a dot product between that vector and the provided vector.
 659     const char* dotLattice  = "dot(((%s.ga + %s.rb * vec2(%s)) * vec2(2.0) - vec2(1.0)), %s);";
 660
 661     // Add noise function
 662     static const GrGLSLShaderVar gPerlinNoiseArgs[] =  {
 663         GrGLSLShaderVar(chanCoord, kFloat_GrSLType),
 664         GrGLSLShaderVar(noiseVec, kVec2f_GrSLType)
 665     };
 666
 667     static const GrGLSLShaderVar gPerlinNoiseStitchArgs[] =  {
 668         GrGLSLShaderVar(chanCoord, kFloat_GrSLType),
 669         GrGLSLShaderVar(noiseVec, kVec2f_GrSLType),
 670         GrGLSLShaderVar(stitchData, kVec2f_GrSLType)
 671     };
 672
 673     SkString noiseCode;
 674
 675     noiseCode.appendf("\tvec4 %s;\n", floorVal);
 676     noiseCode.appendf("\t%s.xy = floor(%s);\n", floorVal, noiseVec);
 677     noiseCode.appendf("\t%s.zw = %s.xy + vec2(1.0);\n", floorVal, floorVal);
 678     noiseCode.appendf("\tvec2 %s = fract(%s);\n", fractVal, noiseVec);
 679
 680     // smooth curve : t * t * (3 - 2 * t)
 681     noiseCode.appendf("\n\tvec2 %s = %s * %s * (vec2(3.0) - vec2(2.0) * %s);",
 682         noiseSmooth, fractVal, fractVal, fractVal);
 683
 684     // Adjust frequencies if we're stitching tiles
 685     if (fStitchTiles) {
 686         noiseCode.appendf("\n\tif(%s.x >= %s.x) { %s.x -= %s.x; }",
 687                           floorVal, stitchData, floorVal, stitchData);
 688         noiseCode.appendf("\n\tif(%s.y >= %s.y) { %s.y -= %s.y; }",
 689                           floorVal, stitchData, floorVal, stitchData);
 690         noiseCode.appendf("\n\tif(%s.z >= %s.x) { %s.z -= %s.x; }",
 691                           floorVal, stitchData, floorVal, stitchData);
 692         noiseCode.appendf("\n\tif(%s.w >= %s.y) { %s.w -= %s.y; }",
 693                           floorVal, stitchData, floorVal, stitchData);
 694     }
 695
 696     // Get texture coordinates and normalize
 697     noiseCode.appendf("\n\t%s = fract(floor(mod(%s, 256.0)) / vec4(256.0));\n",
 698                       floorVal, floorVal);
 699
 700     // Get permutation for x
 701     {
 702         SkString xCoords("");
 703         xCoords.appendf("vec2(%s.x, 0.5)", floorVal);
 704
 705         noiseCode.appendf("\n\tvec2 %s;\n\t%s.x = ", latticeIdx, latticeIdx);
 706         fragBuilder->appendTextureLookup(&noiseCode, args.fSamplers[0], xCoords.c_str(),
 707                                          kVec2f_GrSLType);
 708         noiseCode.append(".r;");
 709     }
 710
 711     // Get permutation for x + 1
 712     {
 713         SkString xCoords("");
 714         xCoords.appendf("vec2(%s.z, 0.5)", floorVal);
 715
 716         noiseCode.appendf("\n\t%s.y = ", latticeIdx);
 717         fragBuilder->appendTextureLookup(&noiseCode, args.fSamplers[0], xCoords.c_str(),
 718                                          kVec2f_GrSLType);
 719         noiseCode.append(".r;");
 720     }
 721
 722 #if defined(SK_BUILD_FOR_ANDROID)
 723     // Android rounding for Tegra devices, like, for example: Xoom (Tegra 2), Nexus 7 (Tegra 3).
 724     // The issue is that colors aren't accurate enough on Tegra devices. For example, if an 8 bit
 725     // value of 124 (or 0.486275 here) is entered, we can get a texture value of 123.513725
 726     // (or 0.484368 here). The following rounding operation prevents these precision issues from
 727     // affecting the result of the noise by making sure that we only have multiples of 1/255.
 728     // (Note that 1/255 is about 0.003921569, which is the value used here).
 729     noiseCode.appendf("\n\t%s = floor(%s * vec2(255.0) + vec2(0.5)) * vec2(0.003921569);",
 730                       latticeIdx, latticeIdx);
 731 #endif
 732
 733     // Get (x,y) coordinates with the permutated x
 734     noiseCode.appendf("\n\tvec4 %s = fract(%s.xyxy + %s.yyww);", bcoords, latticeIdx, floorVal);
 735
 736     noiseCode.appendf("\n\n\tvec2 %s;", uv);
 737     // Compute u, at offset (0,0)
 738     {
 739         SkString latticeCoords("");
 740         latticeCoords.appendf("vec2(%s.x, %s)", bcoords, chanCoord);
 741         noiseCode.appendf("\n\tvec4 %s = ", lattice);
 742         fragBuilder->appendTextureLookup(&noiseCode, args.fSamplers[1], latticeCoords.c_str(),
 743                                          kVec2f_GrSLType);
 744         noiseCode.appendf(".bgra;\n\t%s.x = ", uv);
 745         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
 746     }
 747
 748     noiseCode.appendf("\n\t%s.x -= 1.0;", fractVal);
 749     // Compute v, at offset (-1,0)
 750     {
 751         SkString latticeCoords("");
 752         latticeCoords.appendf("vec2(%s.y, %s)", bcoords, chanCoord);
 753         noiseCode.append("\n\tlattice = ");
 754         fragBuilder->appendTextureLookup(&noiseCode, args.fSamplers[1], latticeCoords.c_str(),
 755                                          kVec2f_GrSLType);
 756         noiseCode.appendf(".bgra;\n\t%s.y = ", uv);
 757         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
 758     }
 759
 760     // Compute 'a' as a linear interpolation of 'u' and 'v'
 761     noiseCode.appendf("\n\tvec2 %s;", ab);
 762     noiseCode.appendf("\n\t%s.x = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
 763
 764     noiseCode.appendf("\n\t%s.y -= 1.0;", fractVal);
 765     // Compute v, at offset (-1,-1)
 766     {
 767         SkString latticeCoords("");
 768         latticeCoords.appendf("vec2(%s.w, %s)", bcoords, chanCoord);
 769         noiseCode.append("\n\tlattice = ");
 770         fragBuilder->appendTextureLookup(&noiseCode, args.fSamplers[1], latticeCoords.c_str(),
 771                                          kVec2f_GrSLType);
 772         noiseCode.appendf(".bgra;\n\t%s.y = ", uv);
 773         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
 774     }
 775
 776     noiseCode.appendf("\n\t%s.x += 1.0;", fractVal);
 777     // Compute u, at offset (0,-1)
 778     {
 779         SkString latticeCoords("");
 780         latticeCoords.appendf("vec2(%s.z, %s)", bcoords, chanCoord);
 781         noiseCode.append("\n\tlattice = ");
 782         fragBuilder->appendTextureLookup(&noiseCode, args.fSamplers[1], latticeCoords.c_str(),
 783                                          kVec2f_GrSLType);
 784         noiseCode.appendf(".bgra;\n\t%s.x = ", uv);
 785         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
 786     }
 787
 788     // Compute 'b' as a linear interpolation of 'u' and 'v'
 789     noiseCode.appendf("\n\t%s.y = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
 790     // Compute the noise as a linear interpolation of 'a' and 'b'
 791     noiseCode.appendf("\n\treturn mix(%s.x, %s.y, %s.y);\n", ab, ab, noiseSmooth);
 792
 793     SkString noiseFuncName;
 794     if (fStitchTiles) {
 795         fragBuilder->emitFunction(kFloat_GrSLType,
 796                                   "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseStitchArgs),
 797                                   gPerlinNoiseStitchArgs, noiseCode.c_str(), &noiseFuncName);
 798     } else {
 799         fragBuilder->emitFunction(kFloat_GrSLType,
 800                                   "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseArgs),
 801                                   gPerlinNoiseArgs, noiseCode.c_str(), &noiseFuncName);
 802     }
 803
 804     // There are rounding errors if the floor operation is not performed here
 805     fragBuilder->codeAppendf("\n\t\tvec2 %s = floor(%s.xy) * %s;",
 806                              noiseVec, vCoords.c_str(), baseFrequencyUni);
 807
 808     // Clear the color accumulator
 809     fragBuilder->codeAppendf("\n\t\t%s = vec4(0.0);", args.fOutputColor);
 810
 811     if (fStitchTiles) {
 812         // Set up TurbulenceInitial stitch values.
 813         fragBuilder->codeAppendf("\n\t\tvec2 %s = %s;", stitchData, stitchDataUni);
 814     }
 815
 816     fragBuilder->codeAppendf("\n\t\tfloat %s = 1.0;", ratio);
 817
 818     // Loop over all octaves
 819     fragBuilder->codeAppendf("\n\t\tfor (int octave = 0; octave < %d; ++octave) {", fNumOctaves);
 820
 821     fragBuilder->codeAppendf("\n\t\t\t%s += ", args.fOutputColor);
 822     if (fType != SkPerlinNoiseShader::kFractalNoise_Type) {
 823         fragBuilder->codeAppend("abs(");
 824     }
 825     if (fStitchTiles) {
 826         fragBuilder->codeAppendf(
 827             "vec4(\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s),"
 828                  "\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s))",
 829             noiseFuncName.c_str(), chanCoordR, noiseVec, stitchData,
 830             noiseFuncName.c_str(), chanCoordG, noiseVec, stitchData,
 831             noiseFuncName.c_str(), chanCoordB, noiseVec, stitchData,
 832             noiseFuncName.c_str(), chanCoordA, noiseVec, stitchData);
 833     } else {
 834         fragBuilder->codeAppendf(
 835             "vec4(\n\t\t\t\t%s(%s, %s),\n\t\t\t\t%s(%s, %s),"
 836                  "\n\t\t\t\t%s(%s, %s),\n\t\t\t\t%s(%s, %s))",
 837             noiseFuncName.c_str(), chanCoordR, noiseVec,
 838             noiseFuncName.c_str(), chanCoordG, noiseVec,
 839             noiseFuncName.c_str(), chanCoordB, noiseVec,
 840             noiseFuncName.c_str(), chanCoordA, noiseVec);
 841     }
 842     if (fType != SkPerlinNoiseShader::kFractalNoise_Type) {
 843         fragBuilder->codeAppendf(")"); // end of "abs("
 844     }
 845     fragBuilder->codeAppendf(" * %s;", ratio);
 846
 847     fragBuilder->codeAppendf("\n\t\t\t%s *= vec2(2.0);", noiseVec);
 848     fragBuilder->codeAppendf("\n\t\t\t%s *= 0.5;", ratio);
 849
 850     if (fStitchTiles) {
 851         fragBuilder->codeAppendf("\n\t\t\t%s *= vec2(2.0);", stitchData);
 852     }
 853     fragBuilder->codeAppend("\n\t\t}"); // end of the for loop on octaves
 854
 855     if (fType == SkPerlinNoiseShader::kFractalNoise_Type) {
 856         // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
 857         // by fractalNoise and (turbulenceFunctionResult) by turbulence.
 858         fragBuilder->codeAppendf("\n\t\t%s = %s * vec4(0.5) + vec4(0.5);",
 859                                  args.fOutputColor,args.fOutputColor);
 860     }
 861
 862     // Clamp values
 863     fragBuilder->codeAppendf("\n\t\t%s = clamp(%s, 0.0, 1.0);", args.fOutputColor, args.fOutputColor);
 864
 865     // Pre-multiply the result
 866     fragBuilder->codeAppendf("\n\t\t%s = vec4(%s.rgb * %s.aaa, %s.a);\n",
 867                              args.fOutputColor, args.fOutputColor,
 868                              args.fOutputColor, args.fOutputColor);
 869 }
 870
 871 void GrGLPerlinNoise::GenKey(const GrProcessor& processor, const GrGLSLCaps&,
 872                              GrProcessorKeyBuilder* b) {
 873     const GrPerlinNoiseEffect& turbulence = processor.cast<GrPerlinNoiseEffect>();
 874
 875     uint32_t key = turbulence.numOctaves();
 876
 877     key = key << 3; // Make room for next 3 bits
 878
 879     switch (turbulence.type()) {
 880         case SkPerlinNoiseShader::kFractalNoise_Type:
 881             key |= 0x1;
 882             break;
 883         case SkPerlinNoiseShader::kTurbulence_Type:
 884             key |= 0x2;
 885             break;
 886         default:
 887             // leave key at 0
 888             break;
 889     }
 890
 891     if (turbulence.stitchTiles()) {
 892         key |= 0x4; // Flip the 3rd bit if tile stitching is on
 893     }
 894
 895     b->add32(key);
 896 }
 897
 898 void GrGLPerlinNoise::onSetData(const GrGLSLProgramDataManager& pdman,
 899                                 const GrProcessor& processor) {
 900     INHERITED::onSetData(pdman, processor);
 901
 902     const GrPerlinNoiseEffect& turbulence = processor.cast<GrPerlinNoiseEffect>();
 903
 904     const SkVector& baseFrequency = turbulence.baseFrequency();
 905     pdman.set2f(fBaseFrequencyUni, baseFrequency.fX, baseFrequency.fY);
 906
 907     if (turbulence.stitchTiles()) {
 908         const SkPerlinNoiseShader::StitchData& stitchData = turbulence.stitchData();
 909         pdman.set2f(fStitchDataUni, SkIntToScalar(stitchData.fWidth),
 910                                    SkIntToScalar(stitchData.fHeight));
 911     }
 912 }
 913
 914 /////////////////////////////////////////////////////////////////////
 915 const GrFragmentProcessor* SkPerlinNoiseShader::asFragmentProcessor(
 916                                                     GrContext* context,
 917                                                     const SkMatrix& viewM,
 918                                                     const SkMatrix* externalLocalMatrix,
 919                                                     SkFilterQuality) const {
 920     SkASSERT(context);
 921
 922     SkMatrix localMatrix = this->getLocalMatrix();
 923     if (externalLocalMatrix) {
 924         localMatrix.preConcat(*externalLocalMatrix);
 925     }
 926
 927     SkMatrix matrix = viewM;
 928     matrix.preConcat(localMatrix);
 929
 930     if (0 == fNumOctaves) {
 931         if (kFractalNoise_Type == fType) {
 932             // Extract the incoming alpha and emit rgba = (a/4, a/4, a/4, a/2)
 933             SkAutoTUnref<const GrFragmentProcessor> inner(
 934                 GrConstColorProcessor::Create(0x80404040,
 935                                               GrConstColorProcessor::kModulateRGBA_InputMode));
 936             return GrFragmentProcessor::MulOutputByInputAlpha(inner);
 937         }
 938         // Emit zero.
 939         return GrConstColorProcessor::Create(0x0, GrConstColorProcessor::kIgnore_InputMode);
 940     }
 941
 942     // Either we don't stitch tiles, either we have a valid tile size
 943     SkASSERT(!fStitchTiles || !fTileSize.isEmpty());
 944
 945     SkPerlinNoiseShader::PaintingData* paintingData =
 946             new PaintingData(fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY, matrix);
 947     SkAutoTUnref<GrTexture> permutationsTexture(
 948         GrRefCachedBitmapTexture(context, paintingData->getPermutationsBitmap(),
 949                                  GrTextureParams::ClampNoFilter()));
 950     SkAutoTUnref<GrTexture> noiseTexture(
 951         GrRefCachedBitmapTexture(context, paintingData->getNoiseBitmap(),
 952                                  GrTextureParams::ClampNoFilter()));
 953
 954     SkMatrix m = viewM;
 955     m.setTranslateX(-localMatrix.getTranslateX() + SK_Scalar1);
 956     m.setTranslateY(-localMatrix.getTranslateY() + SK_Scalar1);
 957     if ((permutationsTexture) && (noiseTexture)) {
 958         SkAutoTUnref<GrFragmentProcessor> inner(
 959             GrPerlinNoiseEffect::Create(fType,
 960                                         fNumOctaves,
 961                                         fStitchTiles,
 962                                         paintingData,
 963                                         permutationsTexture, noiseTexture,
 964                                         m));
 965         return GrFragmentProcessor::MulOutputByInputAlpha(inner);
 966     }
 967     delete paintingData;
 968     return nullptr;
 969 }
 970
 971 #endif
 972
 973 #ifndef SK_IGNORE_TO_STRING
 974 void SkPerlinNoiseShader::toString(SkString* str) const {
 975     str->append("SkPerlinNoiseShader: (");
 976
 977     str->append("type: ");
 978     switch (fType) {
 979         case kFractalNoise_Type:
 980             str->append("\"fractal noise\"");
 981             break;
 982         case kTurbulence_Type:
 983             str->append("\"turbulence\"");
 984             break;
 985         default:
 986             str->append("\"unknown\"");
 987             break;
 988     }
 989     str->append(" base frequency: (");
 990     str->appendScalar(fBaseFrequencyX);
 991     str->append(", ");
 992     str->appendScalar(fBaseFrequencyY);
 993     str->append(") number of octaves: ");
 994     str->appendS32(fNumOctaves);
 995     str->append(" seed: ");
 996     str->appendScalar(fSeed);
 997     str->append(" stitch tiles: ");
 998     str->append(fStitchTiles ? "true " : "false ");
 999
1000     this->INHERITED::toString(str);
1001
1002     str->append(")");
1003 }
1004 #endif