Begin making SkPerlinNoiseShader const.

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 "SkColorFilter.h"
@@ skipping 63 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(const SkISize& tileSize)
-      : fSeed(0)
-      , fTileSize(tileSize)
-      , fPermutationsBitmap(NULL)
-      , fNoiseBitmap(NULL)
-    {}
+    PaintingData(const SkISize& tileSize, SkScalar seed,
+                 SkScalar baseFrequencyX, SkScalar baseFrequencyY)
+      : fTileSize(tileSize)
+      , fBaseFrequency(SkPoint::Make(baseFrequencyX, baseFrequencyY))
+    {
+        this->init(seed);
+        if (!fTileSize.isEmpty()) {
+            this->stitch();
+        }
 
-    ~PaintingData()
-    {
-        SkDELETE(fPermutationsBitmap);
-        SkDELETE(fNoiseBitmap);
+#if SK_SUPPORT_GPU && !defined(SK_USE_SIMPLEX_NOISE)
+        fPermutationsBitmap.setConfig(SkImageInfo::MakeA8(kBlockSize, 1));
+        fPermutationsBitmap.setPixels(fLatticeSelector);
+
+        fNoiseBitmap.setConfig(SkImageInfo::MakeN32Premul(kBlockSize, 4));
+        fNoiseBitmap.setPixels(fNoise[0][0]);
+#endif
     }
 
     int         fSeed;
     uint8_t     fLatticeSelector[kBlockSize];
     uint16_t    fNoise[4][kBlockSize][2];
     SkPoint     fGradient[4][kBlockSize];
     SkISize     fTileSize;
     SkVector    fBaseFrequency;
     StitchData  fStitchDataInit;
 
 private:
 
-    SkBitmap*    fPermutationsBitmap;
-    SkBitmap*    fNoiseBitmap;
-
-public:
+#if SK_SUPPORT_GPU && !defined(SK_USE_SIMPLEX_NOISE)
+    SkBitmap   fPermutationsBitmap;
+    SkBitmap   fNoiseBitmap;
+#endif
 
     inline int random()  {
         static const int gRandAmplitude = 16807; // 7**5; primitive root of m
         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;
     }
 
+    // Only called once. Could be part of the constructor.
     void init(SkScalar seed)
     {
         static const SkScalar gInvBlockSizef = SkScalarInvert(SkIntToScalar(kBlockSize));
 
         // According to the SVG spec, we must truncate (not round) the seed value.
         fSeed = SkScalarTruncToInt(seed);
         // The seed value clamp to the range [1, kRandMaximum - 1].
         if (fSeed <= 0) {
             fSeed = -(fSeed % (kRandMaximum - 1)) + 1;
         }
@@ skipping 49 matching lines @@
                     SkScalarMul(SkIntToScalar(fNoise[channel][i][1] - kBlockSize),
                                 gInvBlockSizef));
                 fGradient[channel][i].normalize();
                 // Put the normalized gradient back into the noise data
                 fNoise[channel][i][0] = SkScalarRoundToInt(SkScalarMul(
                     fGradient[channel][i].fX + SK_Scalar1, gHalfMax16bits));
                 fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
                     fGradient[channel][i].fY + SK_Scalar1, gHalfMax16bits));
             }
         }
-
-        // Invalidate bitmaps
-        SkDELETE(fPermutationsBitmap);
-        fPermutationsBitmap = NULL;
-        SkDELETE(fNoiseBitmap);
-        fNoiseBitmap = NULL;
     }
 
+    // Only called once. Could be part of the constructor.
     void stitch() {
         SkScalar tileWidth  = SkIntToScalar(fTileSize.width());
         SkScalar tileHeight = SkIntToScalar(fTileSize.height());
         SkASSERT(tileWidth > 0 && tileHeight > 0);
         // When stitching tiled turbulence, the frequencies must be adjusted
         // so that the tile borders will be continuous.
         if (fBaseFrequency.fX) {
             SkScalar lowFrequencx =
                 SkScalarFloorToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
             SkScalar highFrequencx =
@@ skipping 20 matching lines @@
         }
         // Set up TurbulenceInitial stitch values.
         fStitchDataInit.fWidth  =
             SkScalarRoundToInt(tileWidth * fBaseFrequency.fX);
         fStitchDataInit.fWrapX  = kPerlinNoise + fStitchDataInit.fWidth;
         fStitchDataInit.fHeight =
             SkScalarRoundToInt(tileHeight * fBaseFrequency.fY);
         fStitchDataInit.fWrapY  = kPerlinNoise + fStitchDataInit.fHeight;
     }
 
-    SkBitmap* getPermutationsBitmap()
-    {
-        if (!fPermutationsBitmap) {
-            fPermutationsBitmap = SkNEW(SkBitmap);
-            fPermutationsBitmap->allocPixels(SkImageInfo::MakeA8(kBlockSize, 1));
-            uint8_t* bitmapPixels = fPermutationsBitmap->getAddr8(0, 0);
-            memcpy(bitmapPixels, fLatticeSelector, sizeof(uint8_t) * kBlockSize);
-        }
-        return fPermutationsBitmap;
-    }
+public:
 
-    SkBitmap* getNoiseBitmap()
-    {
-        if (!fNoiseBitmap) {
-            fNoiseBitmap = SkNEW(SkBitmap);
-            fNoiseBitmap->allocPixels(SkImageInfo::MakeN32Premul(kBlockSize, 4));
-            uint32_t* bitmapPixels = fNoiseBitmap->getAddr32(0, 0);
-            memcpy(bitmapPixels, fNoise[0][0], sizeof(uint16_t) * kBlockSize * 4 * 2);
-        }
-        return fNoiseBitmap;
-    }
+#if SK_SUPPORT_GPU && !defined(SK_USE_SIMPLEX_NOISE)
+    const SkBitmap& getPermutationsBitmap() const { return fPermutationsBitmap; }
+
+    const SkBitmap& getNoiseBitmap() const { return fNoiseBitmap; }
+#endif
 };
 
 SkShader* SkPerlinNoiseShader::CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
                                                   int numOctaves, SkScalar seed,
                                                   const SkISize* tileSize) {
     return SkNEW_ARGS(SkPerlinNoiseShader, (kFractalNoise_Type, baseFrequencyX, baseFrequencyY,
                                             numOctaves, seed, tileSize));
 }
 
 SkShader* SkPerlinNoiseShader::CreateTubulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
                                               int numOctaves, SkScalar seed,
                                               const SkISize* tileSize) {
     return SkNEW_ARGS(SkPerlinNoiseShader, (kTurbulence_Type, baseFrequencyX, baseFrequencyY,
                                             numOctaves, seed, tileSize));
 }
 
 SkPerlinNoiseShader::SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,
                                          SkScalar baseFrequencyX,
                                          SkScalar baseFrequencyY,
                                          int numOctaves,
                                          SkScalar seed,
                                          const SkISize* tileSize)
   : fType(type)
   , fBaseFrequencyX(baseFrequencyX)
   , fBaseFrequencyY(baseFrequencyY)
   , fNumOctaves(numOctaves > 255 ? 255 : numOctaves/*[0,255] octaves allowed*/)
   , fSeed(seed)
-  , fStitchTiles((tileSize != NULL) && !tileSize->isEmpty())
-  , fPaintingData(NULL)
+  , fTileSize(NULL == tileSize ? SkISize::Make(0, 0) : *tileSize)
+  , fStitchTiles(!fTileSize.isEmpty())
 {
     SkASSERT(numOctaves >= 0 && numOctaves < 256);
-    setTileSize(fStitchTiles ? *tileSize : SkISize::Make(0,0));
     fMatrix.reset();
+    fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY));
 }
 
-SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer) :
-        INHERITED(buffer), fPaintingData(NULL) {
+SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer)
+    : INHERITED(buffer)
+{
     fType           = (SkPerlinNoiseShader::Type) buffer.readInt();
     fBaseFrequencyX = buffer.readScalar();
     fBaseFrequencyY = buffer.readScalar();
     fNumOctaves     = buffer.readInt();
     fSeed           = buffer.readScalar();
     fStitchTiles    = buffer.readBool();
     fTileSize.fWidth  = buffer.readInt();
     fTileSize.fHeight = buffer.readInt();
-    setTileSize(fTileSize);
     fMatrix.reset();
+    fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY));
     buffer.validate(perlin_noise_type_is_valid(fType) &&
-                    (fNumOctaves >= 0) && (fNumOctaves <= 255));
+                    (fNumOctaves >= 0) && (fNumOctaves <= 255) &&
+                    (fStitchTiles != fTileSize.isEmpty()));
 }
 
 SkPerlinNoiseShader::~SkPerlinNoiseShader() {
     // Safety, should have been done in endContext()
     SkDELETE(fPaintingData);
 }
 
 void SkPerlinNoiseShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt((int) fType);
     buffer.writeScalar(fBaseFrequencyX);
     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(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, (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();
-        }
-    }
-}
-
 SkScalar SkPerlinNoiseShader::noise2D(int channel, const PaintingData& paintingData,
-                                     const StitchData& stitchData, const SkPoint& noiseVector)
-{
+                                      const StitchData& stitchData,
+                                      const SkPoint& noiseVector) const {
     struct Noise {
         int noisePositionIntegerValue;
         SkScalar noisePositionFractionValue;
         Noise(SkScalar component)
         {
             SkScalar position = component + kPerlinNoise;
             noisePositionIntegerValue = SkScalarFloorToInt(position);
             noisePositionFractionValue = position - SkIntToScalar(noisePositionIntegerValue);
         }
     };
@@ skipping 25 matching lines @@
     v = paintingData.fGradient[channel][nextLatticeIndex & kBlockMask].dot(fractionValue);
     SkScalar a = SkScalarInterp(u, v, sx);
     fractionValue.fY -= SK_Scalar1; // Offset (-1,-1)
     v = paintingData.fGradient[channel][(nextLatticeIndex + 1) & kBlockMask].dot(fractionValue);
     fractionValue.fX = noiseX.noisePositionFractionValue; // Offset (0,-1)
     u = paintingData.fGradient[channel][(latticeIndex + 1) & kBlockMask].dot(fractionValue);
     SkScalar b = SkScalarInterp(u, v, sx);
     return SkScalarInterp(a, b, sy);
 }
 
-SkScalar SkPerlinNoiseShader::calculateTurbulenceValueForPoint(
-    int channel, const PaintingData& paintingData, StitchData& stitchData, const SkPoint& point)
-{
+SkScalar SkPerlinNoiseShader::calculateTurbulenceValueForPoint(int channel,
+                                                               const PaintingData& paintingData,
+                                                               StitchData& stitchData,
+                                                               const SkPoint& point) const {
     if (fStitchTiles) {
         // Set up TurbulenceInitial stitch values.
         stitchData = paintingData.fStitchDataInit;
     }
     SkScalar turbulenceFunctionResult = 0;
     SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), paintingData.fBaseFrequency.fX),
                                       SkScalarMul(point.y(), paintingData.fBaseFrequency.fY)));
     SkScalar ratio = SK_Scalar1;
     for (int octave = 0; octave < fNumOctaves; ++octave) {
         SkScalar noise = noise2D(channel, paintingData, stitchData, noiseVector);
@@ skipping 20 matching lines @@
 
     if (channel == 3) { // Scale alpha by paint value
         turbulenceFunctionResult = SkScalarMul(turbulenceFunctionResult,
             SkScalarDiv(SkIntToScalar(getPaintAlpha()), SkIntToScalar(255)));
     }
 
     // Clamp result
     return SkScalarPin(turbulenceFunctionResult, 0, SK_Scalar1);
 }
 
-SkPMColor SkPerlinNoiseShader::shade(const SkPoint& point, StitchData& stitchData) {
+SkPMColor SkPerlinNoiseShader::shade(const SkPoint& point, StitchData& stitchData) const {
     SkMatrix matrix = fMatrix;
     matrix.postConcat(getLocalMatrix());
     SkMatrix invMatrix;
     if (!matrix.invert(&invMatrix)) {
         invMatrix.reset();
     } else {
         invMatrix.postConcat(invMatrix); // Square the matrix
     }
     // This (1,1) translation is due to WebKit's 1 based coordinates for the noise
     // (as opposed to 0 based, usually). The same adjustment is in the setData() function.
@@ skipping 857 matching lines @@
 
 #ifdef SK_USE_SIMPLEX_NOISE
     // Simplex noise is currently disabled but can be enabled by defining SK_USE_SIMPLEX_NOISE
     sk_ignore_unused_variable(context);
     GrEffectRef* effect =
         GrSimplexNoiseEffect::Create(fType, fPaintingData->fBaseFrequency,
                                      fNumOctaves, fStitchTiles, fSeed,
                                      this->getLocalMatrix(), paint.getAlpha());
 #else
     GrTexture* permutationsTexture = GrLockAndRefCachedBitmapTexture(
-        context, *fPaintingData->getPermutationsBitmap(), NULL);
+        context, fPaintingData->getPermutationsBitmap(), NULL);
     GrTexture* noiseTexture = GrLockAndRefCachedBitmapTexture(
-        context, *fPaintingData->getNoiseBitmap(), NULL);
+        context, fPaintingData->getNoiseBitmap(), NULL);
 
     GrEffectRef* effect = (NULL != permutationsTexture) && (NULL != noiseTexture) ?
         GrPerlinNoiseEffect::Create(fType, fPaintingData->fBaseFrequency,
                                     fNumOctaves, fStitchTiles,
                                     fPaintingData->fStitchDataInit,
                                     permutationsTexture, noiseTexture,
                                     this->getLocalMatrix(), paint.getAlpha()) :
         NULL;
 
     // Unlock immediately, this is not great, but we don't have a way of
@@ skipping 44 matching lines @@
     str->append(" seed: ");
     str->appendScalar(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif