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 "SkPerlinNoiseShader.h"
9 
10 #include "SkArenaAlloc.h"
11 #include "SkColorFilter.h"
12 #include "SkReadBuffer.h"
13 #include "SkWriteBuffer.h"
14 #include "SkShader.h"
15 #include "SkUnPreMultiply.h"
16 #include "SkString.h"
17 
18 #if SK_SUPPORT_GPU
19 #include "GrContext.h"
20 #include "GrCoordTransform.h"
21 #include "SkGr.h"
22 #include "effects/GrConstColorProcessor.h"
23 #include "glsl/GrGLSLFragmentProcessor.h"
24 #include "glsl/GrGLSLFragmentShaderBuilder.h"
25 #include "glsl/GrGLSLProgramDataManager.h"
26 #include "glsl/GrGLSLUniformHandler.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)
checkNoise(int noiseValue,int limitValue,int newValue)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 
smoothCurve(SkScalar t)49 inline SkScalar smoothCurve(SkScalar t) {
50     return t * t * (3 - 2 * t);
51 }
52 
53 } // end namespace
54 
55 struct SkPerlinNoiseShader::StitchData {
StitchDataSkPerlinNoiseShader::StitchData56     StitchData()
57       : fWidth(0)
58       , fWrapX(0)
59       , fHeight(0)
60       , fWrapY(0)
61     {}
62 
operator ==SkPerlinNoiseShader::StitchData63     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 {
PaintingDataSkPerlinNoiseShader::PaintingData77     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 
randomSkPerlinNoiseShader::PaintingData118     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.
initSkPerlinNoiseShader::PaintingData131     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                     (fNoise[channel][i][0] - kBlockSize) * gInvBlockSizef,
189                     (fNoise[channel][i][1] - kBlockSize) * gInvBlockSizef);
190                 fGradient[channel][i].normalize();
191                 // Put the normalized gradient back into the noise data
192                 fNoise[channel][i][0] = SkScalarRoundToInt(
193                                                 (fGradient[channel][i].fX + 1) * gHalfMax16bits);
194                 fNoise[channel][i][1] = SkScalarRoundToInt(
195                                                 (fGradient[channel][i].fY + 1) * gHalfMax16bits);
196             }
197         }
198     }
199 
200     // Only called once. Could be part of the constructor.
stitchSkPerlinNoiseShader::PaintingData201     void stitch() {
202         SkScalar tileWidth  = SkIntToScalar(fTileSize.width());
203         SkScalar tileHeight = SkIntToScalar(fTileSize.height());
204         SkASSERT(tileWidth > 0 && tileHeight > 0);
205         // When stitching tiled turbulence, the frequencies must be adjusted
206         // so that the tile borders will be continuous.
207         if (fBaseFrequency.fX) {
208             SkScalar lowFrequencx =
209                 SkScalarFloorToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
210             SkScalar highFrequencx =
211                 SkScalarCeilToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
212             // BaseFrequency should be non-negative according to the standard.
213             if (fBaseFrequency.fX / lowFrequencx < highFrequencx / fBaseFrequency.fX) {
214                 fBaseFrequency.fX = lowFrequencx;
215             } else {
216                 fBaseFrequency.fX = highFrequencx;
217             }
218         }
219         if (fBaseFrequency.fY) {
220             SkScalar lowFrequency =
221                 SkScalarFloorToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
222             SkScalar highFrequency =
223                 SkScalarCeilToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
224             if (fBaseFrequency.fY / lowFrequency < highFrequency / fBaseFrequency.fY) {
225                 fBaseFrequency.fY = lowFrequency;
226             } else {
227                 fBaseFrequency.fY = highFrequency;
228             }
229         }
230         // Set up TurbulenceInitial stitch values.
231         fStitchDataInit.fWidth  =
232             SkScalarRoundToInt(tileWidth * fBaseFrequency.fX);
233         fStitchDataInit.fWrapX  = kPerlinNoise + fStitchDataInit.fWidth;
234         fStitchDataInit.fHeight =
235             SkScalarRoundToInt(tileHeight * fBaseFrequency.fY);
236         fStitchDataInit.fWrapY  = kPerlinNoise + fStitchDataInit.fHeight;
237     }
238 
239 public:
240 
241 #if SK_SUPPORT_GPU
getPermutationsBitmapSkPerlinNoiseShader::PaintingData242     const SkBitmap& getPermutationsBitmap() const { return fPermutationsBitmap; }
243 
getNoiseBitmapSkPerlinNoiseShader::PaintingData244     const SkBitmap& getNoiseBitmap() const { return fNoiseBitmap; }
245 #endif
246 };
247 
MakeFractalNoise(SkScalar baseFrequencyX,SkScalar baseFrequencyY,int numOctaves,SkScalar seed,const SkISize * tileSize)248 sk_sp<SkShader> SkPerlinNoiseShader::MakeFractalNoise(SkScalar baseFrequencyX,
249                                                       SkScalar baseFrequencyY,
250                                                       int numOctaves, SkScalar seed,
251                                                       const SkISize* tileSize) {
252     return sk_sp<SkShader>(new SkPerlinNoiseShader(kFractalNoise_Type, baseFrequencyX,
253                                                    baseFrequencyY, numOctaves,
254                                                    seed, tileSize));
255 }
256 
MakeTurbulence(SkScalar baseFrequencyX,SkScalar baseFrequencyY,int numOctaves,SkScalar seed,const SkISize * tileSize)257 sk_sp<SkShader> SkPerlinNoiseShader::MakeTurbulence(SkScalar baseFrequencyX,
258                                                     SkScalar baseFrequencyY,
259                                                     int numOctaves, SkScalar seed,
260                                                     const SkISize* tileSize) {
261     return sk_sp<SkShader>(new SkPerlinNoiseShader(kTurbulence_Type, baseFrequencyX, baseFrequencyY,
262                                                    numOctaves, seed, tileSize));
263 }
264 
SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,SkScalar baseFrequencyX,SkScalar baseFrequencyY,int numOctaves,SkScalar seed,const SkISize * tileSize)265 SkPerlinNoiseShader::SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,
266                                          SkScalar baseFrequencyX,
267                                          SkScalar baseFrequencyY,
268                                          int numOctaves,
269                                          SkScalar seed,
270                                          const SkISize* tileSize)
271   : fType(type)
272   , fBaseFrequencyX(baseFrequencyX)
273   , fBaseFrequencyY(baseFrequencyY)
274   , fNumOctaves(SkTPin<int>(numOctaves, 0, 255)) // [0,255] octaves allowed
275   , fSeed(seed)
276   , fTileSize(nullptr == tileSize ? SkISize::Make(0, 0) : *tileSize)
277   , fStitchTiles(!fTileSize.isEmpty())
278 {
279     SkASSERT(fNumOctaves >= 0 && fNumOctaves < 256);
280 }
281 
~SkPerlinNoiseShader()282 SkPerlinNoiseShader::~SkPerlinNoiseShader() {
283 }
284 
CreateProc(SkReadBuffer & buffer)285 sk_sp<SkFlattenable> SkPerlinNoiseShader::CreateProc(SkReadBuffer& buffer) {
286     Type type = (Type)buffer.readInt();
287     SkScalar freqX = buffer.readScalar();
288     SkScalar freqY = buffer.readScalar();
289     int octaves = buffer.readInt();
290     SkScalar seed = buffer.readScalar();
291     SkISize tileSize;
292     tileSize.fWidth = buffer.readInt();
293     tileSize.fHeight = buffer.readInt();
294 
295     switch (type) {
296         case kFractalNoise_Type:
297             return SkPerlinNoiseShader::MakeFractalNoise(freqX, freqY, octaves, seed,
298                                                          &tileSize);
299         case kTurbulence_Type:
300             return SkPerlinNoiseShader::MakeTurbulence(freqX, freqY, octaves, seed,
301                                                        &tileSize);
302         default:
303             return nullptr;
304     }
305 }
306 
flatten(SkWriteBuffer & buffer) const307 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 
noise2D(int channel,const StitchData & stitchData,const SkPoint & noiseVector) const317 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 
calculateTurbulenceValueForPoint(int channel,StitchData & stitchData,const SkPoint & point) const375 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(point.x() * fPaintingData->fBaseFrequency.fX,
384                                       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 = turbulenceFunctionResult * SK_ScalarHalf + SK_ScalarHalf;
407     }
408 
409     if (channel == 3) { // Scale alpha by paint value
410         turbulenceFunctionResult *= SkIntToScalar(getPaintAlpha()) / 255;
411     }
412 
413     // Clamp result
414     return SkScalarPin(turbulenceFunctionResult, 0, SK_Scalar1);
415 }
416 
shade(const SkPoint & point,StitchData & stitchData) const417 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 
onMakeContext(const ContextRec & rec,SkArenaAlloc * alloc) const432 SkShader::Context* SkPerlinNoiseShader::onMakeContext(
433     const ContextRec& rec, SkArenaAlloc* alloc) const {
434     return alloc->make<PerlinNoiseShaderContext>(*this, rec);
435 }
436 
PerlinNoiseShaderContext(const SkPerlinNoiseShader & shader,const ContextRec & rec)437 SkPerlinNoiseShader::PerlinNoiseShaderContext::PerlinNoiseShaderContext(
438         const SkPerlinNoiseShader& shader, const ContextRec& rec)
439     : INHERITED(shader, rec)
440 {
441     SkMatrix newMatrix = SkMatrix::Concat(*rec.fMatrix, shader.getLocalMatrix());
442     if (rec.fLocalMatrix) {
443         newMatrix.preConcat(*rec.fLocalMatrix);
444     }
445     // This (1,1) translation is due to WebKit's 1 based coordinates for the noise
446     // (as opposed to 0 based, usually). The same adjustment is in the setData() function.
447     fMatrix.setTranslate(-newMatrix.getTranslateX() + SK_Scalar1, -newMatrix.getTranslateY() + SK_Scalar1);
448     fPaintingData = new PaintingData(shader.fTileSize, shader.fSeed, shader.fBaseFrequencyX,
449                                      shader.fBaseFrequencyY, newMatrix);
450 }
451 
~PerlinNoiseShaderContext()452 SkPerlinNoiseShader::PerlinNoiseShaderContext::~PerlinNoiseShaderContext() { delete fPaintingData; }
453 
shadeSpan(int x,int y,SkPMColor result[],int count)454 void SkPerlinNoiseShader::PerlinNoiseShaderContext::shadeSpan(
455         int x, int y, SkPMColor result[], int count) {
456     SkPoint point = SkPoint::Make(SkIntToScalar(x), SkIntToScalar(y));
457     StitchData stitchData;
458     for (int i = 0; i < count; ++i) {
459         result[i] = shade(point, stitchData);
460         point.fX += SK_Scalar1;
461     }
462 }
463 
464 /////////////////////////////////////////////////////////////////////
465 
466 #if SK_SUPPORT_GPU
467 
468 class GrGLPerlinNoise : public GrGLSLFragmentProcessor {
469 public:
470     void emitCode(EmitArgs&) override;
471 
472     static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
473 
474 protected:
475     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
476 
477 private:
478     GrGLSLProgramDataManager::UniformHandle fStitchDataUni;
479     GrGLSLProgramDataManager::UniformHandle fBaseFrequencyUni;
480 
481     typedef GrGLSLFragmentProcessor INHERITED;
482 };
483 
484 /////////////////////////////////////////////////////////////////////
485 
486 class GrPerlinNoiseEffect : public GrFragmentProcessor {
487 public:
Make(GrResourceProvider * resourceProvider,SkPerlinNoiseShader::Type type,int numOctaves,bool stitchTiles,SkPerlinNoiseShader::PaintingData * paintingData,sk_sp<GrTextureProxy> permutationsProxy,sk_sp<GrTextureProxy> noiseProxy,const SkMatrix & matrix)488     static sk_sp<GrFragmentProcessor> Make(GrResourceProvider* resourceProvider,
489                                            SkPerlinNoiseShader::Type type,
490                                            int numOctaves, bool stitchTiles,
491                                            SkPerlinNoiseShader::PaintingData* paintingData,
492                                            sk_sp<GrTextureProxy> permutationsProxy,
493                                            sk_sp<GrTextureProxy> noiseProxy,
494                                            const SkMatrix& matrix) {
495         return sk_sp<GrFragmentProcessor>(
496             new GrPerlinNoiseEffect(resourceProvider, type, numOctaves, stitchTiles, paintingData,
497                                     std::move(permutationsProxy), std::move(noiseProxy), matrix));
498     }
499 
~GrPerlinNoiseEffect()500     ~GrPerlinNoiseEffect() override { delete fPaintingData; }
501 
name() const502     const char* name() const override { return "PerlinNoise"; }
503 
stitchData() const504     const SkPerlinNoiseShader::StitchData& stitchData() const { return fPaintingData->fStitchDataInit; }
505 
type() const506     SkPerlinNoiseShader::Type type() const { return fType; }
stitchTiles() const507     bool stitchTiles() const { return fStitchTiles; }
baseFrequency() const508     const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
numOctaves() const509     int numOctaves() const { return fNumOctaves; }
510 
511 private:
onCreateGLSLInstance() const512     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
513         return new GrGLPerlinNoise;
514     }
515 
onGetGLSLProcessorKey(const GrShaderCaps & caps,GrProcessorKeyBuilder * b) const516     virtual void onGetGLSLProcessorKey(const GrShaderCaps& caps,
517                                        GrProcessorKeyBuilder* b) const override {
518         GrGLPerlinNoise::GenKey(*this, caps, b);
519     }
520 
onIsEqual(const GrFragmentProcessor & sBase) const521     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
522         const GrPerlinNoiseEffect& s = sBase.cast<GrPerlinNoiseEffect>();
523         return fType == s.fType &&
524                fPaintingData->fBaseFrequency == s.fPaintingData->fBaseFrequency &&
525                fNumOctaves == s.fNumOctaves &&
526                fStitchTiles == s.fStitchTiles &&
527                fPaintingData->fStitchDataInit == s.fPaintingData->fStitchDataInit;
528     }
529 
GrPerlinNoiseEffect(GrResourceProvider * resourceProvider,SkPerlinNoiseShader::Type type,int numOctaves,bool stitchTiles,SkPerlinNoiseShader::PaintingData * paintingData,sk_sp<GrTextureProxy> permutationsProxy,sk_sp<GrTextureProxy> noiseProxy,const SkMatrix & matrix)530     GrPerlinNoiseEffect(GrResourceProvider* resourceProvider,
531                         SkPerlinNoiseShader::Type type, int numOctaves, bool stitchTiles,
532                         SkPerlinNoiseShader::PaintingData* paintingData,
533                         sk_sp<GrTextureProxy> permutationsProxy, sk_sp<GrTextureProxy> noiseProxy,
534                         const SkMatrix& matrix)
535             : INHERITED(kNone_OptimizationFlags)
536             , fType(type)
537             , fCoordTransform(matrix)
538             , fNumOctaves(numOctaves)
539             , fStitchTiles(stitchTiles)
540             , fPermutationsSampler(resourceProvider, std::move(permutationsProxy))
541             , fNoiseSampler(resourceProvider, std::move(noiseProxy))
542             , fPaintingData(paintingData) {
543         this->initClassID<GrPerlinNoiseEffect>();
544         this->addTextureSampler(&fPermutationsSampler);
545         this->addTextureSampler(&fNoiseSampler);
546         this->addCoordTransform(&fCoordTransform);
547     }
548 
549     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
550 
551     SkPerlinNoiseShader::Type       fType;
552     GrCoordTransform                fCoordTransform;
553     int                             fNumOctaves;
554     bool                            fStitchTiles;
555     TextureSampler                  fPermutationsSampler;
556     TextureSampler                  fNoiseSampler;
557     SkPerlinNoiseShader::PaintingData *fPaintingData;
558 
559 private:
560     typedef GrFragmentProcessor INHERITED;
561 };
562 
563 /////////////////////////////////////////////////////////////////////
564 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrPerlinNoiseEffect);
565 
566 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)567 sk_sp<GrFragmentProcessor> GrPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
568     int      numOctaves = d->fRandom->nextRangeU(2, 10);
569     bool     stitchTiles = d->fRandom->nextBool();
570     SkScalar seed = SkIntToScalar(d->fRandom->nextU());
571     SkISize  tileSize = SkISize::Make(d->fRandom->nextRangeU(4, 4096),
572                                       d->fRandom->nextRangeU(4, 4096));
573     SkScalar baseFrequencyX = d->fRandom->nextRangeScalar(0.01f,
574                                                           0.99f);
575     SkScalar baseFrequencyY = d->fRandom->nextRangeScalar(0.01f,
576                                                           0.99f);
577 
578     sk_sp<SkShader> shader(d->fRandom->nextBool() ?
579         SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed,
580                                               stitchTiles ? &tileSize : nullptr) :
581         SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed,
582                                             stitchTiles ? &tileSize : nullptr));
583 
584     GrTest::TestAsFPArgs asFPArgs(d);
585     return shader->asFragmentProcessor(asFPArgs.args());
586 }
587 #endif
588 
emitCode(EmitArgs & args)589 void GrGLPerlinNoise::emitCode(EmitArgs& args) {
590     const GrPerlinNoiseEffect& pne = args.fFp.cast<GrPerlinNoiseEffect>();
591 
592     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
593     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
594     SkString vCoords = fragBuilder->ensureCoords2D(args.fTransformedCoords[0]);
595 
596     fBaseFrequencyUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
597                                                    kVec2f_GrSLType, kDefault_GrSLPrecision,
598                                                    "baseFrequency");
599     const char* baseFrequencyUni = uniformHandler->getUniformCStr(fBaseFrequencyUni);
600 
601     const char* stitchDataUni = nullptr;
602     if (pne.stitchTiles()) {
603         fStitchDataUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
604                                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
605                                                     "stitchData");
606         stitchDataUni = uniformHandler->getUniformCStr(fStitchDataUni);
607     }
608 
609     // There are 4 lines, so the center of each line is 1/8, 3/8, 5/8 and 7/8
610     const char* chanCoordR  = "0.125";
611     const char* chanCoordG  = "0.375";
612     const char* chanCoordB  = "0.625";
613     const char* chanCoordA  = "0.875";
614     const char* chanCoord   = "chanCoord";
615     const char* stitchData  = "stitchData";
616     const char* ratio       = "ratio";
617     const char* noiseVec    = "noiseVec";
618     const char* noiseSmooth = "noiseSmooth";
619     const char* floorVal    = "floorVal";
620     const char* fractVal    = "fractVal";
621     const char* uv          = "uv";
622     const char* ab          = "ab";
623     const char* latticeIdx  = "latticeIdx";
624     const char* bcoords     = "bcoords";
625     const char* lattice     = "lattice";
626     const char* inc8bit     = "0.00390625";  // 1.0 / 256.0
627     // This is the math to convert the two 16bit integer packed into rgba 8 bit input into a
628     // [-1,1] vector and perform a dot product between that vector and the provided vector.
629     const char* dotLattice  = "dot(((%s.ga + %s.rb * vec2(%s)) * vec2(2.0) - vec2(1.0)), %s);";
630 
631     // Add noise function
632     static const GrShaderVar gPerlinNoiseArgs[] =  {
633         GrShaderVar(chanCoord, kFloat_GrSLType),
634         GrShaderVar(noiseVec, kVec2f_GrSLType)
635     };
636 
637     static const GrShaderVar gPerlinNoiseStitchArgs[] =  {
638         GrShaderVar(chanCoord, kFloat_GrSLType),
639         GrShaderVar(noiseVec, kVec2f_GrSLType),
640         GrShaderVar(stitchData, kVec2f_GrSLType)
641     };
642 
643     SkString noiseCode;
644 
645     noiseCode.appendf("\tvec4 %s;\n", floorVal);
646     noiseCode.appendf("\t%s.xy = floor(%s);\n", floorVal, noiseVec);
647     noiseCode.appendf("\t%s.zw = %s.xy + vec2(1.0);\n", floorVal, floorVal);
648     noiseCode.appendf("\tvec2 %s = fract(%s);\n", fractVal, noiseVec);
649 
650     // smooth curve : t * t * (3 - 2 * t)
651     noiseCode.appendf("\n\tvec2 %s = %s * %s * (vec2(3.0) - vec2(2.0) * %s);",
652         noiseSmooth, fractVal, fractVal, fractVal);
653 
654     // Adjust frequencies if we're stitching tiles
655     if (pne.stitchTiles()) {
656         noiseCode.appendf("\n\tif(%s.x >= %s.x) { %s.x -= %s.x; }",
657                           floorVal, stitchData, floorVal, stitchData);
658         noiseCode.appendf("\n\tif(%s.y >= %s.y) { %s.y -= %s.y; }",
659                           floorVal, stitchData, floorVal, stitchData);
660         noiseCode.appendf("\n\tif(%s.z >= %s.x) { %s.z -= %s.x; }",
661                           floorVal, stitchData, floorVal, stitchData);
662         noiseCode.appendf("\n\tif(%s.w >= %s.y) { %s.w -= %s.y; }",
663                           floorVal, stitchData, floorVal, stitchData);
664     }
665 
666     // Get texture coordinates and normalize
667     noiseCode.appendf("\n\t%s = fract(floor(mod(%s, 256.0)) / vec4(256.0));\n",
668                       floorVal, floorVal);
669 
670     // Get permutation for x
671     {
672         SkString xCoords("");
673         xCoords.appendf("vec2(%s.x, 0.5)", floorVal);
674 
675         noiseCode.appendf("\n\tvec2 %s;\n\t%s.x = ", latticeIdx, latticeIdx);
676         fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[0], xCoords.c_str(),
677                                          kVec2f_GrSLType);
678         noiseCode.append(".r;");
679     }
680 
681     // Get permutation for x + 1
682     {
683         SkString xCoords("");
684         xCoords.appendf("vec2(%s.z, 0.5)", floorVal);
685 
686         noiseCode.appendf("\n\t%s.y = ", latticeIdx);
687         fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[0], xCoords.c_str(),
688                                          kVec2f_GrSLType);
689         noiseCode.append(".r;");
690     }
691 
692 #if defined(SK_BUILD_FOR_ANDROID)
693     // Android rounding for Tegra devices, like, for example: Xoom (Tegra 2), Nexus 7 (Tegra 3).
694     // The issue is that colors aren't accurate enough on Tegra devices. For example, if an 8 bit
695     // value of 124 (or 0.486275 here) is entered, we can get a texture value of 123.513725
696     // (or 0.484368 here). The following rounding operation prevents these precision issues from
697     // affecting the result of the noise by making sure that we only have multiples of 1/255.
698     // (Note that 1/255 is about 0.003921569, which is the value used here).
699     noiseCode.appendf("\n\t%s = floor(%s * vec2(255.0) + vec2(0.5)) * vec2(0.003921569);",
700                       latticeIdx, latticeIdx);
701 #endif
702 
703     // Get (x,y) coordinates with the permutated x
704     noiseCode.appendf("\n\tvec4 %s = fract(%s.xyxy + %s.yyww);", bcoords, latticeIdx, floorVal);
705 
706     noiseCode.appendf("\n\n\tvec2 %s;", uv);
707     // Compute u, at offset (0,0)
708     {
709         SkString latticeCoords("");
710         latticeCoords.appendf("vec2(%s.x, %s)", bcoords, chanCoord);
711         noiseCode.appendf("\n\tvec4 %s = ", lattice);
712         fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
713                                          kVec2f_GrSLType);
714         noiseCode.appendf(".bgra;\n\t%s.x = ", uv);
715         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
716     }
717 
718     noiseCode.appendf("\n\t%s.x -= 1.0;", fractVal);
719     // Compute v, at offset (-1,0)
720     {
721         SkString latticeCoords("");
722         latticeCoords.appendf("vec2(%s.y, %s)", bcoords, chanCoord);
723         noiseCode.append("\n\tlattice = ");
724         fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
725                                          kVec2f_GrSLType);
726         noiseCode.appendf(".bgra;\n\t%s.y = ", uv);
727         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
728     }
729 
730     // Compute 'a' as a linear interpolation of 'u' and 'v'
731     noiseCode.appendf("\n\tvec2 %s;", ab);
732     noiseCode.appendf("\n\t%s.x = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
733 
734     noiseCode.appendf("\n\t%s.y -= 1.0;", fractVal);
735     // Compute v, at offset (-1,-1)
736     {
737         SkString latticeCoords("");
738         latticeCoords.appendf("vec2(%s.w, %s)", bcoords, chanCoord);
739         noiseCode.append("\n\tlattice = ");
740         fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
741                                          kVec2f_GrSLType);
742         noiseCode.appendf(".bgra;\n\t%s.y = ", uv);
743         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
744     }
745 
746     noiseCode.appendf("\n\t%s.x += 1.0;", fractVal);
747     // Compute u, at offset (0,-1)
748     {
749         SkString latticeCoords("");
750         latticeCoords.appendf("vec2(%s.z, %s)", bcoords, chanCoord);
751         noiseCode.append("\n\tlattice = ");
752         fragBuilder->appendTextureLookup(&noiseCode, args.fTexSamplers[1], latticeCoords.c_str(),
753                                          kVec2f_GrSLType);
754         noiseCode.appendf(".bgra;\n\t%s.x = ", uv);
755         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
756     }
757 
758     // Compute 'b' as a linear interpolation of 'u' and 'v'
759     noiseCode.appendf("\n\t%s.y = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
760     // Compute the noise as a linear interpolation of 'a' and 'b'
761     noiseCode.appendf("\n\treturn mix(%s.x, %s.y, %s.y);\n", ab, ab, noiseSmooth);
762 
763     SkString noiseFuncName;
764     if (pne.stitchTiles()) {
765         fragBuilder->emitFunction(kFloat_GrSLType,
766                                   "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseStitchArgs),
767                                   gPerlinNoiseStitchArgs, noiseCode.c_str(), &noiseFuncName);
768     } else {
769         fragBuilder->emitFunction(kFloat_GrSLType,
770                                   "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseArgs),
771                                   gPerlinNoiseArgs, noiseCode.c_str(), &noiseFuncName);
772     }
773 
774     // There are rounding errors if the floor operation is not performed here
775     fragBuilder->codeAppendf("\n\t\tvec2 %s = floor(%s.xy) * %s;",
776                              noiseVec, vCoords.c_str(), baseFrequencyUni);
777 
778     // Clear the color accumulator
779     fragBuilder->codeAppendf("\n\t\t%s = vec4(0.0);", args.fOutputColor);
780 
781     if (pne.stitchTiles()) {
782         // Set up TurbulenceInitial stitch values.
783         fragBuilder->codeAppendf("vec2 %s = %s;", stitchData, stitchDataUni);
784     }
785 
786     fragBuilder->codeAppendf("float %s = 1.0;", ratio);
787 
788     // Loop over all octaves
789     fragBuilder->codeAppendf("for (int octave = 0; octave < %d; ++octave) {", pne.numOctaves());
790 
791     fragBuilder->codeAppendf("%s += ", args.fOutputColor);
792     if (pne.type() != SkPerlinNoiseShader::kFractalNoise_Type) {
793         fragBuilder->codeAppend("abs(");
794     }
795     if (pne.stitchTiles()) {
796         fragBuilder->codeAppendf(
797             "vec4(\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s),"
798                  "\n\t\t\t\t%s(%s, %s, %s),\n\t\t\t\t%s(%s, %s, %s))",
799             noiseFuncName.c_str(), chanCoordR, noiseVec, stitchData,
800             noiseFuncName.c_str(), chanCoordG, noiseVec, stitchData,
801             noiseFuncName.c_str(), chanCoordB, noiseVec, stitchData,
802             noiseFuncName.c_str(), chanCoordA, noiseVec, stitchData);
803     } else {
804         fragBuilder->codeAppendf(
805             "vec4(\n\t\t\t\t%s(%s, %s),\n\t\t\t\t%s(%s, %s),"
806                  "\n\t\t\t\t%s(%s, %s),\n\t\t\t\t%s(%s, %s))",
807             noiseFuncName.c_str(), chanCoordR, noiseVec,
808             noiseFuncName.c_str(), chanCoordG, noiseVec,
809             noiseFuncName.c_str(), chanCoordB, noiseVec,
810             noiseFuncName.c_str(), chanCoordA, noiseVec);
811     }
812     if (pne.type() != SkPerlinNoiseShader::kFractalNoise_Type) {
813         fragBuilder->codeAppendf(")"); // end of "abs("
814     }
815     fragBuilder->codeAppendf(" * %s;", ratio);
816 
817     fragBuilder->codeAppendf("\n\t\t\t%s *= vec2(2.0);", noiseVec);
818     fragBuilder->codeAppendf("\n\t\t\t%s *= 0.5;", ratio);
819 
820     if (pne.stitchTiles()) {
821         fragBuilder->codeAppendf("\n\t\t\t%s *= vec2(2.0);", stitchData);
822     }
823     fragBuilder->codeAppend("\n\t\t}"); // end of the for loop on octaves
824 
825     if (pne.type() == SkPerlinNoiseShader::kFractalNoise_Type) {
826         // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
827         // by fractalNoise and (turbulenceFunctionResult) by turbulence.
828         fragBuilder->codeAppendf("\n\t\t%s = %s * vec4(0.5) + vec4(0.5);",
829                                  args.fOutputColor,args.fOutputColor);
830     }
831 
832     // Clamp values
833     fragBuilder->codeAppendf("\n\t\t%s = clamp(%s, 0.0, 1.0);", args.fOutputColor, args.fOutputColor);
834 
835     // Pre-multiply the result
836     fragBuilder->codeAppendf("\n\t\t%s = vec4(%s.rgb * %s.aaa, %s.a);\n",
837                              args.fOutputColor, args.fOutputColor,
838                              args.fOutputColor, args.fOutputColor);
839 }
840 
GenKey(const GrProcessor & processor,const GrShaderCaps &,GrProcessorKeyBuilder * b)841 void GrGLPerlinNoise::GenKey(const GrProcessor& processor, const GrShaderCaps&,
842                              GrProcessorKeyBuilder* b) {
843     const GrPerlinNoiseEffect& turbulence = processor.cast<GrPerlinNoiseEffect>();
844 
845     uint32_t key = turbulence.numOctaves();
846 
847     key = key << 3; // Make room for next 3 bits
848 
849     switch (turbulence.type()) {
850         case SkPerlinNoiseShader::kFractalNoise_Type:
851             key |= 0x1;
852             break;
853         case SkPerlinNoiseShader::kTurbulence_Type:
854             key |= 0x2;
855             break;
856         default:
857             // leave key at 0
858             break;
859     }
860 
861     if (turbulence.stitchTiles()) {
862         key |= 0x4; // Flip the 3rd bit if tile stitching is on
863     }
864 
865     b->add32(key);
866 }
867 
onSetData(const GrGLSLProgramDataManager & pdman,const GrProcessor & processor)868 void GrGLPerlinNoise::onSetData(const GrGLSLProgramDataManager& pdman,
869                                 const GrProcessor& processor) {
870     INHERITED::onSetData(pdman, processor);
871 
872     const GrPerlinNoiseEffect& turbulence = processor.cast<GrPerlinNoiseEffect>();
873 
874     const SkVector& baseFrequency = turbulence.baseFrequency();
875     pdman.set2f(fBaseFrequencyUni, baseFrequency.fX, baseFrequency.fY);
876 
877     if (turbulence.stitchTiles()) {
878         const SkPerlinNoiseShader::StitchData& stitchData = turbulence.stitchData();
879         pdman.set2f(fStitchDataUni, SkIntToScalar(stitchData.fWidth),
880                                    SkIntToScalar(stitchData.fHeight));
881     }
882 }
883 
884 /////////////////////////////////////////////////////////////////////
asFragmentProcessor(const AsFPArgs & args) const885 sk_sp<GrFragmentProcessor> SkPerlinNoiseShader::asFragmentProcessor(const AsFPArgs& args) const {
886     SkASSERT(args.fContext);
887 
888     SkMatrix localMatrix = this->getLocalMatrix();
889     if (args.fLocalMatrix) {
890         localMatrix.preConcat(*args.fLocalMatrix);
891     }
892 
893     SkMatrix matrix = *args.fViewMatrix;
894     matrix.preConcat(localMatrix);
895 
896     if (0 == fNumOctaves) {
897         if (kFractalNoise_Type == fType) {
898             // Extract the incoming alpha and emit rgba = (a/4, a/4, a/4, a/2)
899             // TODO: Either treat the output of this shader as sRGB or allow client to specify a
900             // color space of the noise. Either way, this case (and the GLSL) need to convert to
901             // the destination.
902             sk_sp<GrFragmentProcessor> inner(
903                 GrConstColorProcessor::Make(GrColor4f::FromGrColor(0x80404040),
904                                             GrConstColorProcessor::kModulateRGBA_InputMode));
905             return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner));
906         }
907         // Emit zero.
908         return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
909                                            GrConstColorProcessor::kIgnore_InputMode);
910     }
911 
912     // Either we don't stitch tiles, either we have a valid tile size
913     SkASSERT(!fStitchTiles || !fTileSize.isEmpty());
914 
915     SkPerlinNoiseShader::PaintingData* paintingData =
916             new PaintingData(fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY, matrix);
917     sk_sp<GrTextureProxy> permutationsProxy(GrMakeCachedBitmapProxy(
918                                                             args.fContext->resourceProvider(),
919                                                             paintingData->getPermutationsBitmap()));
920     sk_sp<GrTextureProxy> noiseProxy(GrMakeCachedBitmapProxy(args.fContext->resourceProvider(),
921                                                              paintingData->getNoiseBitmap()));
922 
923     SkMatrix m = *args.fViewMatrix;
924     m.setTranslateX(-localMatrix.getTranslateX() + SK_Scalar1);
925     m.setTranslateY(-localMatrix.getTranslateY() + SK_Scalar1);
926     if (permutationsProxy && noiseProxy) {
927         sk_sp<GrFragmentProcessor> inner(
928             GrPerlinNoiseEffect::Make(args.fContext->resourceProvider(),
929                                       fType,
930                                       fNumOctaves,
931                                       fStitchTiles,
932                                       paintingData,
933                                       std::move(permutationsProxy),
934                                       std::move(noiseProxy),
935                                       m));
936         return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner));
937     }
938     delete paintingData;
939     return nullptr;
940 }
941 
942 #endif
943 
944 #ifndef SK_IGNORE_TO_STRING
toString(SkString * str) const945 void SkPerlinNoiseShader::toString(SkString* str) const {
946     str->append("SkPerlinNoiseShader: (");
947 
948     str->append("type: ");
949     switch (fType) {
950         case kFractalNoise_Type:
951             str->append("\"fractal noise\"");
952             break;
953         case kTurbulence_Type:
954             str->append("\"turbulence\"");
955             break;
956         default:
957             str->append("\"unknown\"");
958             break;
959     }
960     str->append(" base frequency: (");
961     str->appendScalar(fBaseFrequencyX);
962     str->append(", ");
963     str->appendScalar(fBaseFrequencyY);
964     str->append(") number of octaves: ");
965     str->appendS32(fNumOctaves);
966     str->append(" seed: ");
967     str->appendScalar(fSeed);
968     str->append(" stitch tiles: ");
969     str->append(fStitchTiles ? "true " : "false ");
970 
971     this->INHERITED::toString(str);
972 
973     str->append(")");
974 }
975 #endif
976