New SVG turbulence in Skia

src/effects/SkPerlinNoiseShader.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDither.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkFlattenableBuffers.h"
@@ skipping 56 matching lines @@
                fWrapY == other.fWrapY;
     }
 
     int fWidth; // How much to subtract to wrap for stitching.
     int fWrapX; // Minimum value to wrap.
     int fHeight;
     int fWrapY;
 };
 
 struct SkPerlinNoiseShader::PaintingData {
-    PaintingData(int paintingSeed, const SkISize& tileSize)
-      : fSeed(paintingSeed)
+    PaintingData(const SkISize& tileSize)
+      : fSeed(0)
       , fTileSize(tileSize)
       , fPermutationsBitmap(NULL)
       , fNoiseBitmap(NULL)
     {}
 
     ~PaintingData()
     {
         SkDELETE(fPermutationsBitmap);
         SkDELETE(fNoiseBitmap);
     }
@@ skipping 18 matching lines @@
         static const int gRandQ = 127773; // m / a
         static const int gRandR = 2836; // m % a
 
         int result = gRandAmplitude * (fSeed % gRandQ) - gRandR * (fSeed / gRandQ);
         if (result <= 0)
             result += kRandMaximum;
         fSeed = result;
         return result;
     }
 
-    void init()
+    void init(SkScalar seed)
     {
         static const SkScalar gInvBlockSizef = SkScalarInvert(SkIntToScalar(kBlockSize));
 
         // The seed value clamp to the range [1, kRandMaximum - 1].
+        fSeed = SkScalarRoundToInt(seed);
         if (fSeed <= 0) {
             fSeed = -(fSeed % (kRandMaximum - 1)) + 1;
         }
         if (fSeed > kRandMaximum - 1) {
             fSeed = kRandMaximum - 1;
         }
         for (int channel = 0; channel < 4; ++channel) {
             for (int i = 0; i < kBlockSize; ++i) {
                 fLatticeSelector[i] = i;
                 fNoise[channel][i][0] = (random() % (2 * kBlockSize));
@@ skipping 180 matching lines @@
     buffer.writeScalar(fBaseFrequencyY);
     buffer.writeInt(fNumOctaves);
     buffer.writeScalar(fSeed);
     buffer.writeBool(fStitchTiles);
     buffer.writeInt(fTileSize.fWidth);
     buffer.writeInt(fTileSize.fHeight);
 }
 
 void SkPerlinNoiseShader::initPaint(PaintingData& paintingData)
 {
-    paintingData.init();
+    paintingData.init(fSeed);
 
     // Set frequencies to original values
     paintingData.fBaseFrequency.set(fBaseFrequencyX, fBaseFrequencyY);
     // Adjust frequecies based on size if stitching is enabled
     if (fStitchTiles) {
         paintingData.stitch();
     }
 }
 
 void SkPerlinNoiseShader::setTileSize(const SkISize& tileSize) {
     fTileSize = tileSize;
 
     if (NULL == fPaintingData) {
-        fPaintingData = SkNEW_ARGS(PaintingData, (SkScalarRoundToInt(fSeed), fTileSize));
+        fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize));
         initPaint(*fPaintingData);
     } else {
         // Set Size
         fPaintingData->fTileSize = fTileSize;
         // Set frequencies to original values
         fPaintingData->fBaseFrequency.set(fBaseFrequencyX, fBaseFrequencyY);
         // Adjust frequecies based on size if stitching is enabled
         if (fStitchTiles) {
             fPaintingData->stitch();
         }
@@ skipping 261 matching lines @@
 
     typedef GrEffect INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(GrPerlinNoiseEffect);
 
 GrEffectRef* GrPerlinNoiseEffect::TestCreate(SkMWCRandom* random,
                                              GrContext* context,
+                                             const GrDrawTargetCaps&,
                                              GrTexture**) {
     int      numOctaves = random->nextRangeU(2, 10);
     bool     stitchTiles = random->nextBool();
     SkScalar seed = SkIntToScalar(random->nextU());
     SkISize  tileSize = SkISize::Make(random->nextRangeU(4, 4096), random->nextRangeU(4, 4096));
     SkScalar baseFrequencyX = random->nextRangeScalar(SkFloatToScalar(0.01f),
                                                       SkFloatToScalar(0.99f));
     SkScalar baseFrequencyY = random->nextRangeScalar(SkFloatToScalar(0.01f),
                                                       SkFloatToScalar(0.99f));
 
@@ skipping 361 matching lines @@
     str->append(" seed: ");
     str->appendScalar(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif