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