| Index: src/effects/SkPerlinNoiseShader.cpp
|
| ===================================================================
|
| --- src/effects/SkPerlinNoiseShader.cpp (revision 0)
|
| +++ src/effects/SkPerlinNoiseShader.cpp (revision 0)
|
| @@ -0,0 +1,1007 @@
|
| +/*
|
| + * 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"
|
| +#include "SkShader.h"
|
| +#include "SkUnPreMultiply.h"
|
| +#include "SkString.h"
|
| +
|
| +#if SK_SUPPORT_GPU
|
| +#include "GrContext.h"
|
| +#include "gl/GrGLEffect.h"
|
| +#include "gl/GrGLEffectMatrix.h"
|
| +#include "GrTBackendEffectFactory.h"
|
| +#include "SkGr.h"
|
| +#endif
|
| +
|
| +static const int kBlockSize = 256;
|
| +static const int kBlockMask = kBlockSize - 1;
|
| +static const int kPerlinNoise = 4096;
|
| +static const int kRandMaximum = SK_MaxS32; // 2**31 - 1
|
| +
|
| +namespace {
|
| +
|
| +// noiseValue is the color component's value (or color)
|
| +// limitValue is the maximum perlin noise array index value allowed
|
| +// newValue is the current noise dimension (either width or height)
|
| +inline int checkNoise(int noiseValue, int limitValue, int newValue) {
|
| + // If the noise value would bring us out of bounds of the current noise array while we are
|
| + // stiching noise tiles together, wrap the noise around the current dimension of the noise to
|
| + // stay within the array bounds in a continuous fashion (so that tiling lines are not visible)
|
| + if (noiseValue >= limitValue) {
|
| + noiseValue -= newValue;
|
| + }
|
| + if (noiseValue >= limitValue - 1) {
|
| + noiseValue -= newValue - 1;
|
| + }
|
| + return noiseValue;
|
| +}
|
| +
|
| +inline SkScalar smoothCurve(SkScalar t) {
|
| + static const SkScalar SK_Scalar3 = SkFloatToScalar(3.0f);
|
| +
|
| + // returns t * t * (3 - 2 * t)
|
| + return SkScalarMul(SkScalarSquare(t), SK_Scalar3 - 2 * t);
|
| +}
|
| +
|
| +} // end namespace
|
| +
|
| +struct SkPerlinNoiseShader::StitchData {
|
| + StitchData()
|
| + : fWidth(0)
|
| + , fWrapX(0)
|
| + , fHeight(0)
|
| + , fWrapY(0)
|
| + {}
|
| +
|
| + bool operator==(const StitchData& other) const {
|
| + return fWidth == other.fWidth &&
|
| + fWrapX == other.fWrapX &&
|
| + fHeight == other.fHeight &&
|
| + 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()
|
| + {
|
| + SkDELETE(fPermutationsBitmap);
|
| + SkDELETE(fNoiseBitmap);
|
| + }
|
| +
|
| + 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:
|
| +
|
| + 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;
|
| + }
|
| +
|
| + 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));
|
| + fNoise[channel][i][1] = (random() % (2 * kBlockSize));
|
| + }
|
| + }
|
| + for (int i = kBlockSize - 1; i > 0; --i) {
|
| + int k = fLatticeSelector[i];
|
| + int j = random() % kBlockSize;
|
| + SkASSERT(j >= 0);
|
| + SkASSERT(j < kBlockSize);
|
| + fLatticeSelector[i] = fLatticeSelector[j];
|
| + fLatticeSelector[j] = k;
|
| + }
|
| +
|
| + // Perform the permutations now
|
| + {
|
| + // Copy noise data
|
| + uint16_t noise[4][kBlockSize][2];
|
| + for (int i = 0; i < kBlockSize; ++i) {
|
| + for (int channel = 0; channel < 4; ++channel) {
|
| + for (int j = 0; j < 2; ++j) {
|
| + noise[channel][i][j] = fNoise[channel][i][j];
|
| + }
|
| + }
|
| + }
|
| + // Do permutations on noise data
|
| + for (int i = 0; i < kBlockSize; ++i) {
|
| + for (int channel = 0; channel < 4; ++channel) {
|
| + for (int j = 0; j < 2; ++j) {
|
| + fNoise[channel][i][j] = noise[channel][fLatticeSelector[i]][j];
|
| + }
|
| + }
|
| + }
|
| + }
|
| +
|
| + // Half of the largest possible value for 16 bit unsigned int
|
| + static const SkScalar halfMax16bits = SkFloatToScalar(32767.5f);
|
| +
|
| + // Compute gradients from permutated noise data
|
| + for (int channel = 0; channel < 4; ++channel) {
|
| + for (int i = 0; i < kBlockSize; ++i) {
|
| + fGradient[channel][i] = SkPoint::Make(
|
| + SkScalarMul(SkIntToScalar(fNoise[channel][i][0] - kBlockSize),
|
| + gInvBlockSizef),
|
| + 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, halfMax16bits));
|
| + fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
|
| + fGradient[channel][i].fY + SK_Scalar1, halfMax16bits));
|
| + }
|
| + }
|
| +
|
| + // Invalidate bitmaps
|
| + SkDELETE(fPermutationsBitmap);
|
| + fPermutationsBitmap = NULL;
|
| + SkDELETE(fNoiseBitmap);
|
| + fNoiseBitmap = NULL;
|
| + }
|
| +
|
| + 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 = SkScalarDiv(
|
| + SkScalarMulFloor(tileWidth, fBaseFrequency.fX), tileWidth);
|
| + SkScalar highFrequencx = SkScalarDiv(
|
| + SkScalarMulCeil(tileWidth, fBaseFrequency.fX), tileWidth);
|
| + // BaseFrequency should be non-negative according to the standard.
|
| + if (SkScalarDiv(fBaseFrequency.fX, lowFrequencx) <
|
| + SkScalarDiv(highFrequencx, fBaseFrequency.fX)) {
|
| + fBaseFrequency.fX = lowFrequencx;
|
| + } else {
|
| + fBaseFrequency.fX = highFrequencx;
|
| + }
|
| + }
|
| + if (fBaseFrequency.fY) {
|
| + SkScalar lowFrequency = SkScalarDiv(
|
| + SkScalarMulFloor(tileHeight, fBaseFrequency.fY), tileHeight);
|
| + SkScalar highFrequency = SkScalarDiv(
|
| + SkScalarMulCeil(tileHeight, fBaseFrequency.fY), tileHeight);
|
| + if (SkScalarDiv(fBaseFrequency.fY, lowFrequency) <
|
| + SkScalarDiv(highFrequency, fBaseFrequency.fY)) {
|
| + fBaseFrequency.fY = lowFrequency;
|
| + } else {
|
| + fBaseFrequency.fY = highFrequency;
|
| + }
|
| + }
|
| + // Set up TurbulenceInitial stitch values.
|
| + fStitchDataInit.fWidth =
|
| + SkScalarMulRound(tileWidth, fBaseFrequency.fX);
|
| + fStitchDataInit.fWrapX = kPerlinNoise + fStitchDataInit.fWidth;
|
| + fStitchDataInit.fHeight =
|
| + SkScalarMulRound(tileHeight, fBaseFrequency.fY);
|
| + fStitchDataInit.fWrapY = kPerlinNoise + fStitchDataInit.fHeight;
|
| + }
|
| +
|
| + SkBitmap* getPermutationsBitmap()
|
| + {
|
| + if (!fPermutationsBitmap) {
|
| + fPermutationsBitmap = SkNEW(SkBitmap);
|
| + fPermutationsBitmap->setConfig(SkBitmap::kA8_Config, kBlockSize, 1);
|
| + fPermutationsBitmap->allocPixels();
|
| + uint8_t* bitmapPixels = fPermutationsBitmap->getAddr8(0, 0);
|
| + memcpy(bitmapPixels, fLatticeSelector, sizeof(uint8_t) * kBlockSize);
|
| + }
|
| + return fPermutationsBitmap;
|
| + }
|
| +
|
| + SkBitmap* getNoiseBitmap()
|
| + {
|
| + if (!fNoiseBitmap) {
|
| + fNoiseBitmap = SkNEW(SkBitmap);
|
| + fNoiseBitmap->setConfig(SkBitmap::kARGB_8888_Config, kBlockSize, 4);
|
| + fNoiseBitmap->allocPixels();
|
| + uint32_t* bitmapPixels = fNoiseBitmap->getAddr32(0, 0);
|
| + memcpy(bitmapPixels, fNoise[0][0], sizeof(uint16_t) * kBlockSize * 4 * 2);
|
| + }
|
| + return fNoiseBitmap;
|
| + }
|
| +};
|
| +
|
| +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 & 0xFF /*[0,255] octaves allowed*/)
|
| + , fSeed(seed)
|
| + , fStitchTiles((tileSize != NULL) && !tileSize->isEmpty())
|
| + , fPaintingData(NULL)
|
| +{
|
| + SkASSERT(numOctaves >= 0 && numOctaves < 256);
|
| + setTileSize(fStitchTiles ? *tileSize : SkISize::Make(0,0));
|
| + fMatrix.reset();
|
| +}
|
| +
|
| +SkPerlinNoiseShader::SkPerlinNoiseShader(SkFlattenableReadBuffer& buffer) :
|
| + INHERITED(buffer), fPaintingData(NULL) {
|
| + 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();
|
| +}
|
| +
|
| +SkPerlinNoiseShader::~SkPerlinNoiseShader() {
|
| + // Safety, should have been done in endContext()
|
| + SkDELETE(fPaintingData);
|
| +}
|
| +
|
| +void SkPerlinNoiseShader::flatten(SkFlattenableWriteBuffer& 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)
|
| +{
|
| + struct Noise {
|
| + int noisePositionIntegerValue;
|
| + SkScalar noisePositionFractionValue;
|
| + Noise(SkScalar component)
|
| + {
|
| + SkScalar position = component + kPerlinNoise;
|
| + noisePositionIntegerValue = SkScalarFloorToInt(position);
|
| + noisePositionFractionValue = position - SkIntToScalar(noisePositionIntegerValue);
|
| + }
|
| + };
|
| + Noise noiseX(noiseVector.x());
|
| + Noise noiseY(noiseVector.y());
|
| + SkScalar u, v;
|
| + // If stitching, adjust lattice points accordingly.
|
| + if (fStitchTiles) {
|
| + noiseX.noisePositionIntegerValue =
|
| + checkNoise(noiseX.noisePositionIntegerValue, stitchData.fWrapX, stitchData.fWidth);
|
| + noiseY.noisePositionIntegerValue =
|
| + checkNoise(noiseY.noisePositionIntegerValue, stitchData.fWrapY, stitchData.fHeight);
|
| + }
|
| + noiseX.noisePositionIntegerValue &= kBlockMask;
|
| + noiseY.noisePositionIntegerValue &= kBlockMask;
|
| + int latticeIndex =
|
| + paintingData.fLatticeSelector[noiseX.noisePositionIntegerValue] +
|
| + noiseY.noisePositionIntegerValue;
|
| + int nextLatticeIndex =
|
| + paintingData.fLatticeSelector[(noiseX.noisePositionIntegerValue + 1) & kBlockMask] +
|
| + noiseY.noisePositionIntegerValue;
|
| + SkScalar sx = smoothCurve(noiseX.noisePositionFractionValue);
|
| + SkScalar sy = smoothCurve(noiseY.noisePositionFractionValue);
|
| + // This is taken 1:1 from SVG spec: http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement
|
| + SkPoint fractionValue = SkPoint::Make(noiseX.noisePositionFractionValue,
|
| + noiseY.noisePositionFractionValue); // Offset (0,0)
|
| + u = paintingData.fGradient[channel][latticeIndex & kBlockMask].dot(fractionValue);
|
| + fractionValue.fX -= SK_Scalar1; // Offset (-1,0)
|
| + 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)
|
| +{
|
| + 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);
|
| + turbulenceFunctionResult += SkScalarDiv(
|
| + (fType == kFractalNoise_Type) ? noise : SkScalarAbs(noise), ratio);
|
| + noiseVector.fX *= 2;
|
| + noiseVector.fY *= 2;
|
| + ratio *= 2;
|
| + if (fStitchTiles) {
|
| + // Update stitch values
|
| + stitchData.fWidth *= 2;
|
| + stitchData.fWrapX = stitchData.fWidth + kPerlinNoise;
|
| + stitchData.fHeight *= 2;
|
| + stitchData.fWrapY = stitchData.fHeight + kPerlinNoise;
|
| + }
|
| + }
|
| +
|
| + // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
|
| + // by fractalNoise and (turbulenceFunctionResult) by turbulence.
|
| + if (fType == kFractalNoise_Type) {
|
| + turbulenceFunctionResult =
|
| + SkScalarMul(turbulenceFunctionResult, SK_ScalarHalf) + SK_ScalarHalf;
|
| + }
|
| +
|
| + 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) {
|
| + SkMatrix matrix = fMatrix;
|
| + 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.
|
| + matrix.postTranslate(SK_Scalar1, SK_Scalar1);
|
| + SkPoint newPoint;
|
| + matrix.mapPoints(&newPoint, &point, 1);
|
| + invMatrix.mapPoints(&newPoint, &newPoint, 1);
|
| + newPoint.fX = SkScalarRoundToScalar(newPoint.fX);
|
| + newPoint.fY = SkScalarRoundToScalar(newPoint.fY);
|
| +
|
| + U8CPU rgba[4];
|
| + for (int channel = 3; channel >= 0; --channel) {
|
| + rgba[channel] = SkScalarFloorToInt(255 *
|
| + calculateTurbulenceValueForPoint(channel, *fPaintingData, stitchData, newPoint));
|
| + }
|
| + return SkPreMultiplyARGB(rgba[3], rgba[0], rgba[1], rgba[2]);
|
| +}
|
| +
|
| +bool SkPerlinNoiseShader::setContext(const SkBitmap& device, const SkPaint& paint,
|
| + const SkMatrix& matrix) {
|
| + fMatrix = matrix;
|
| + return INHERITED::setContext(device, paint, matrix);
|
| +}
|
| +
|
| +void SkPerlinNoiseShader::shadeSpan(int x, int y, SkPMColor result[], int count) {
|
| + SkPoint point = SkPoint::Make(SkIntToScalar(x), SkIntToScalar(y));
|
| + StitchData stitchData;
|
| + for (int i = 0; i < count; ++i) {
|
| + result[i] = shade(point, stitchData);
|
| + point.fX += SK_Scalar1;
|
| + }
|
| +}
|
| +
|
| +void SkPerlinNoiseShader::shadeSpan16(int x, int y, uint16_t result[], int count) {
|
| + SkPoint point = SkPoint::Make(SkIntToScalar(x), SkIntToScalar(y));
|
| + StitchData stitchData;
|
| + DITHER_565_SCAN(y);
|
| + for (int i = 0; i < count; ++i) {
|
| + unsigned dither = DITHER_VALUE(x);
|
| + result[i] = SkDitherRGB32To565(shade(point, stitchData), dither);
|
| + DITHER_INC_X(x);
|
| + point.fX += SK_Scalar1;
|
| + }
|
| +}
|
| +
|
| +/////////////////////////////////////////////////////////////////////
|
| +
|
| +#if SK_SUPPORT_GPU
|
| +
|
| +#include "GrTBackendEffectFactory.h"
|
| +
|
| +class GrGLPerlinNoise : public GrGLEffect {
|
| +public:
|
| +
|
| + GrGLPerlinNoise(const GrBackendEffectFactory& factory,
|
| + const GrDrawEffect& drawEffect);
|
| + virtual ~GrGLPerlinNoise() { }
|
| +
|
| + virtual void emitCode(GrGLShaderBuilder*,
|
| + const GrDrawEffect&,
|
| + EffectKey,
|
| + const char* outputColor,
|
| + const char* inputColor,
|
| + const TextureSamplerArray&) SK_OVERRIDE;
|
| +
|
| + static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
|
| +
|
| + virtual void setData(const GrGLUniformManager&, const GrDrawEffect&);
|
| +
|
| +private:
|
| + SkPerlinNoiseShader::Type fType;
|
| + bool fStitchTiles;
|
| + int fNumOctaves;
|
| + GrGLUniformManager::UniformHandle fBaseFrequencyUni;
|
| + GrGLUniformManager::UniformHandle fStitchDataUni;
|
| + GrGLUniformManager::UniformHandle fAlphaUni;
|
| + GrGLUniformManager::UniformHandle fInvMatrixUni;
|
| + GrGLEffectMatrix fEffectMatrix;
|
| +
|
| + typedef GrGLEffect INHERITED;
|
| +};
|
| +
|
| +/////////////////////////////////////////////////////////////////////
|
| +
|
| +class GrPerlinNoiseEffect : public GrEffect {
|
| +public:
|
| + static GrEffectRef* Create(SkPerlinNoiseShader::Type type, const SkVector& baseFrequency,
|
| + int numOctaves, bool stitchTiles,
|
| + const SkPerlinNoiseShader::StitchData& stitchData,
|
| + GrTexture* permutationsTexture, GrTexture* noiseTexture,
|
| + const SkMatrix& matrix, uint8_t alpha) {
|
| + AutoEffectUnref effect(SkNEW_ARGS(GrPerlinNoiseEffect, (type, baseFrequency, numOctaves,
|
| + stitchTiles, stitchData, permutationsTexture, noiseTexture, matrix, alpha)));
|
| + return CreateEffectRef(effect);
|
| + }
|
| +
|
| + virtual ~GrPerlinNoiseEffect() { }
|
| +
|
| + static const char* Name() { return "PerlinNoise"; }
|
| + virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
|
| + return GrTBackendEffectFactory<GrPerlinNoiseEffect>::getInstance();
|
| + }
|
| + SkPerlinNoiseShader::Type type() const { return fType; }
|
| + bool stitchTiles() const { return fStitchTiles; }
|
| + const SkVector& baseFrequency() const { return fBaseFrequency; }
|
| + int numOctaves() const { return fNumOctaves & 0xFF; /*[0,255] octaves allowed*/ }
|
| + const SkPerlinNoiseShader::StitchData& stitchData() const { return fStitchData; }
|
| + const SkMatrix& matrix() const { return fMatrix; }
|
| + uint8_t alpha() const { return fAlpha; }
|
| + GrGLEffectMatrix::CoordsType coordsType() const { return GrEffect::kLocal_CoordsType; }
|
| +
|
| + typedef GrGLPerlinNoise GLEffect;
|
| +
|
| + void getConstantColorComponents(GrColor*, uint32_t* validFlags) const SK_OVERRIDE {
|
| + *validFlags = 0; // This is noise. Nothing is constant.
|
| + }
|
| +
|
| +private:
|
| + virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
|
| + const GrPerlinNoiseEffect& s = CastEffect<GrPerlinNoiseEffect>(sBase);
|
| + return fPermutationsAccess.getTexture() == s.fPermutationsAccess.getTexture() &&
|
| + fNoiseAccess.getTexture() == s.fNoiseAccess.getTexture() &&
|
| + fType == s.fType &&
|
| + fBaseFrequency == s.fBaseFrequency &&
|
| + fStitchTiles == s.fStitchTiles &&
|
| + fStitchData == s.fStitchData &&
|
| + fMatrix == s.fMatrix &&
|
| + fAlpha == s.fAlpha;
|
| + }
|
| +
|
| + GrPerlinNoiseEffect(SkPerlinNoiseShader::Type type, const SkVector& baseFrequency,
|
| + int numOctaves, bool stitchTiles,
|
| + const SkPerlinNoiseShader::StitchData& stitchData,
|
| + GrTexture* permutationsTexture, GrTexture* noiseTexture,
|
| + const SkMatrix& matrix, uint8_t alpha)
|
| + : fPermutationsAccess(permutationsTexture)
|
| + , fNoiseAccess(noiseTexture)
|
| + , fType(type)
|
| + , fBaseFrequency(baseFrequency)
|
| + , fNumOctaves(numOctaves)
|
| + , fStitchTiles(stitchTiles)
|
| + , fStitchData(stitchData)
|
| + , fMatrix(matrix)
|
| + , fAlpha(alpha)
|
| + {
|
| + this->addTextureAccess(&fPermutationsAccess);
|
| + this->addTextureAccess(&fNoiseAccess);
|
| + }
|
| +
|
| + GR_DECLARE_EFFECT_TEST;
|
| +
|
| + GrTextureAccess fPermutationsAccess;
|
| + GrTextureAccess fNoiseAccess;
|
| + SkPerlinNoiseShader::Type fType;
|
| + SkVector fBaseFrequency;
|
| + int fNumOctaves;
|
| + bool fStitchTiles;
|
| + SkPerlinNoiseShader::StitchData fStitchData;
|
| + SkMatrix fMatrix;
|
| + uint8_t fAlpha;
|
| +
|
| + 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));
|
| +
|
| + SkShader* shader = random->nextBool() ?
|
| + SkPerlinNoiseShader::CreateFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed,
|
| + stitchTiles ? &tileSize : NULL) :
|
| + SkPerlinNoiseShader::CreateTubulence(baseFrequencyX, baseFrequencyY, numOctaves, seed,
|
| + stitchTiles ? &tileSize : NULL);
|
| +
|
| + SkPaint paint;
|
| + GrEffectRef* effect = shader->asNewEffect(context, paint);
|
| +
|
| + SkDELETE(shader);
|
| +
|
| + return effect;
|
| +}
|
| +
|
| +/////////////////////////////////////////////////////////////////////
|
| +
|
| +void GrGLPerlinNoise::emitCode(GrGLShaderBuilder* builder,
|
| + const GrDrawEffect&,
|
| + EffectKey key,
|
| + const char* outputColor,
|
| + const char* inputColor,
|
| + const TextureSamplerArray& samplers) {
|
| + sk_ignore_unused_variable(inputColor);
|
| +
|
| + const char* vCoords;
|
| + fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, &vCoords);
|
| +
|
| + fInvMatrixUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
|
| + kMat33f_GrSLType, "invMatrix");
|
| + const char* invMatrixUni = builder->getUniformCStr(fInvMatrixUni);
|
| + fBaseFrequencyUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
|
| + kVec2f_GrSLType, "baseFrequency");
|
| + const char* baseFrequencyUni = builder->getUniformCStr(fBaseFrequencyUni);
|
| + fAlphaUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
|
| + kFloat_GrSLType, "alpha");
|
| + const char* alphaUni = builder->getUniformCStr(fAlphaUni);
|
| +
|
| + const char* stitchDataUni = NULL;
|
| + if (fStitchTiles) {
|
| + fStitchDataUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
|
| + kVec4f_GrSLType, "stitchData");
|
| + stitchDataUni = builder->getUniformCStr(fStitchDataUni);
|
| + }
|
| +
|
| + const char* chanCoords = "chanCoords";
|
| + const char* stitchData = "stitchData";
|
| + const char* ratio = "ratio";
|
| + const char* noise = "noise";
|
| + const char* noiseXY = "noiseXY";
|
| + const char* noiseVec = "noiseVec";
|
| + const char* noiseVecIni = "noiseVecIni";
|
| + const char* noiseSmooth = "noiseSmooth";
|
| + const char* fractVal = "fractVal";
|
| + const char* uv = "uv";
|
| + const char* ab = "ab";
|
| + const char* latticeIdx = "latticeIdx";
|
| + const char* lattice = "lattice";
|
| + const char* perlinNoise = "4096.0";
|
| + const char* inc8bit = "0.00390625"; // 1.0 / 256.0
|
| + // This is the math to convert the two 16bit integer packed into rgba 8 bit input into a
|
| + // [-1,1] vector and perform a dot product between that vector and the provided vector.
|
| + const char* dotLattice = "dot(((%s.ga + %s.rb * vec2(%s)) * vec2(2.0) - vec2(1.0)), %s);";
|
| +
|
| + // There are 4 lines, so the center of each line is 1/8, 3/8, 5/8 and 7/8
|
| + builder->fsCodeAppendf("\t\tconst vec4 %s = vec4(0.125, 0.375, 0.625, 0.875);", chanCoords);
|
| +
|
| + // There are rounding errors if the floor operation is not performed here
|
| + builder->fsCodeAppendf("\t\tvec2 %s = floor((%s*vec3(%s, 1.0)).xy) * %s;",
|
| + noiseVecIni, invMatrixUni, vCoords, baseFrequencyUni);
|
| +
|
| + // Loop over the 4 channels
|
| + builder->fsCodeAppend("\t\tfor (int channel = 3; channel >= 0; --channel) {");
|
| +
|
| + if (fStitchTiles) {
|
| + // Set up TurbulenceInitial stitch values.
|
| + builder->fsCodeAppendf("\t\tvec4 %s = %s;", stitchData, stitchDataUni);
|
| + }
|
| +
|
| + builder->fsCodeAppendf("\t\t%s[channel] = 0.0;", outputColor);
|
| +
|
| + builder->fsCodeAppendf("\t\tfloat %s = 1.0;", ratio);
|
| + builder->fsCodeAppendf("\t\tvec2 %s = %s;", noiseVec, noiseVecIni);
|
| +
|
| + // Loop over all octaves
|
| + builder->fsCodeAppendf("\t\tfor (int octave = 0; octave < %d; ++octave) {", fNumOctaves);
|
| +
|
| + builder->fsCodeAppendf("\t\tvec4 %s = vec4(floor(%s) + vec2(%s), fract(%s));",
|
| + noiseXY, noiseVec, perlinNoise, noiseVec);
|
| +
|
| + // smooth curve : t * t * (3 - 2 * t)
|
| + builder->fsCodeAppendf("\t\tvec2 %s = %s.zw * %s.zw * (vec2(3.0) - vec2(2.0) * %s.zw);",
|
| + noiseSmooth, noiseXY, noiseXY, noiseXY);
|
| +
|
| + // Adjust frequencies if we're stitching tiles
|
| + if (fStitchTiles) {
|
| + builder->fsCodeAppendf("\t\tif(%s.x >= %s.y) { %s.x -= %s.x; }",
|
| + noiseXY, stitchData, noiseXY, stitchData);
|
| + builder->fsCodeAppendf("\t\tif(%s.x >= (%s.y - 1.0)) { %s.x -= (%s.x - 1.0); }",
|
| + noiseXY, stitchData, noiseXY, stitchData);
|
| + builder->fsCodeAppendf("\t\tif(%s.y >= %s.w) { %s.y -= %s.z; }",
|
| + noiseXY, stitchData, noiseXY, stitchData);
|
| + builder->fsCodeAppendf("\t\tif(%s.y >= (%s.w - 1.0)) { %s.y -= (%s.z - 1.0); }",
|
| + noiseXY, stitchData, noiseXY, stitchData);
|
| + }
|
| +
|
| + // Get texture coordinates and normalize
|
| + builder->fsCodeAppendf("\t\t%s.xy = fract(floor(mod(%s.xy, 256.0)) / vec2(256.0));",
|
| + noiseXY, noiseXY);
|
| +
|
| + // Get permutation for x
|
| + {
|
| + SkString xCoords("");
|
| + xCoords.appendf("vec2(%s.x, 0.5)", noiseXY);
|
| +
|
| + builder->fsCodeAppendf("\t\tvec2 %s;\t\t%s.x = ", latticeIdx, latticeIdx);
|
| + builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
|
| + samplers[0], xCoords.c_str(), kVec2f_GrSLType);
|
| + builder->fsCodeAppend(".r;\n");
|
| + }
|
| +
|
| + // Get permutation for x + 1
|
| + {
|
| + SkString xCoords("");
|
| + xCoords.appendf("vec2(fract(%s.x + %s), 0.5)", noiseXY, inc8bit);
|
| +
|
| + builder->fsCodeAppendf("\t\t%s.y = ", latticeIdx);
|
| + builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
|
| + samplers[0], xCoords.c_str(), kVec2f_GrSLType);
|
| + builder->fsCodeAppend(".r;\n");
|
| + }
|
| +
|
| + // Get (x,y) coordinates with the permutated x
|
| + builder->fsCodeAppendf("\t\t%s = fract(%s + %s.yy);", latticeIdx, latticeIdx, noiseXY);
|
| +
|
| + builder->fsCodeAppendf("\t\tvec2 %s = %s.zw;", fractVal, noiseXY);
|
| +
|
| + builder->fsCodeAppendf("\t\tvec2 %s;", uv);
|
| + // Compute u, at offset (0,0)
|
| + {
|
| + SkString latticeCoords("");
|
| + latticeCoords.appendf("vec2(%s.x, %s[channel])", latticeIdx, chanCoords);
|
| + builder->fsCodeAppendf("vec4 %s = ", lattice);
|
| + builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
|
| + samplers[1], latticeCoords.c_str(), kVec2f_GrSLType);
|
| + builder->fsCodeAppendf(".bgra;\n\t\t%s.x = ", uv);
|
| + builder->fsCodeAppendf(dotLattice, lattice, lattice, inc8bit, fractVal);
|
| + }
|
| +
|
| + builder->fsCodeAppendf("\t\t%s.x -= 1.0;", fractVal);
|
| + // Compute v, at offset (-1,0)
|
| + {
|
| + SkString latticeCoords("");
|
| + latticeCoords.appendf("vec2(%s.y, %s[channel])", latticeIdx, chanCoords);
|
| + builder->fsCodeAppend("lattice = ");
|
| + builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
|
| + samplers[1], latticeCoords.c_str(), kVec2f_GrSLType);
|
| + builder->fsCodeAppendf(".bgra;\n\t\t%s.y = ", uv);
|
| + builder->fsCodeAppendf(dotLattice, lattice, lattice, inc8bit, fractVal);
|
| + }
|
| +
|
| + // Compute 'a' as a linear interpolation of 'u' and 'v'
|
| + builder->fsCodeAppendf("\t\tvec2 %s;", ab);
|
| + builder->fsCodeAppendf("\t\t%s.x = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
|
| +
|
| + builder->fsCodeAppendf("\t\t%s.y -= 1.0;", fractVal);
|
| + // Compute v, at offset (-1,-1)
|
| + {
|
| + SkString latticeCoords("");
|
| + latticeCoords.appendf("vec2(fract(%s.y + %s), %s[channel])",
|
| + latticeIdx, inc8bit, chanCoords);
|
| + builder->fsCodeAppend("lattice = ");
|
| + builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
|
| + samplers[1], latticeCoords.c_str(), kVec2f_GrSLType);
|
| + builder->fsCodeAppendf(".bgra;\n\t\t%s.y = ", uv);
|
| + builder->fsCodeAppendf(dotLattice, lattice, lattice, inc8bit, fractVal);
|
| + }
|
| +
|
| + builder->fsCodeAppendf("\t\t%s.x += 1.0;", fractVal);
|
| + // Compute u, at offset (0,-1)
|
| + {
|
| + SkString latticeCoords("");
|
| + latticeCoords.appendf("vec2(fract(%s.x + %s), %s[channel])",
|
| + latticeIdx, inc8bit, chanCoords);
|
| + builder->fsCodeAppend("lattice = ");
|
| + builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
|
| + samplers[1], latticeCoords.c_str(), kVec2f_GrSLType);
|
| + builder->fsCodeAppendf(".bgra;\n\t\t%s.x = ", uv);
|
| + builder->fsCodeAppendf(dotLattice, lattice, lattice, inc8bit, fractVal);
|
| + }
|
| +
|
| + // Compute 'b' as a linear interpolation of 'u' and 'v'
|
| + builder->fsCodeAppendf("\t\t%s.y = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
|
| + // Compute the noise as a linear interpolation of 'a' and 'b'
|
| + builder->fsCodeAppendf("\t\tfloat %s = mix(%s.x, %s.y, %s.y);", noise, ab, ab, noiseSmooth);
|
| +
|
| + builder->fsCodeAppendf("\t\t%s[channel] += ", outputColor);
|
| + builder->fsCodeAppendf((fType == SkPerlinNoiseShader::kFractalNoise_Type) ?
|
| + "%s / %s;" : "abs(%s) / %s;", noise, ratio);
|
| +
|
| + builder->fsCodeAppendf("\t\t%s *= vec2(2.0);", noiseVec);
|
| + builder->fsCodeAppendf("\t\t%s *= 2.0;", ratio);
|
| +
|
| + if (fStitchTiles) {
|
| + builder->fsCodeAppendf("\t\t%s.xz *= vec2(2.0);", stitchData);
|
| + builder->fsCodeAppendf("\t\t%s.yw = %s.xz + vec2(%s);", stitchData, stitchData, perlinNoise);
|
| + }
|
| + builder->fsCodeAppend("\t\t}"); // end of the for loop on octaves
|
| +
|
| + builder->fsCodeAppend("\t\t}"); // end of the for loop on channels
|
| +
|
| + if (fType == SkPerlinNoiseShader::kFractalNoise_Type) {
|
| + // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
|
| + // by fractalNoise and (turbulenceFunctionResult) by turbulence.
|
| + builder->fsCodeAppendf("\t\t%s = %s * vec4(0.5) + vec4(0.5);", outputColor, outputColor);
|
| + }
|
| +
|
| + builder->fsCodeAppendf("\t\t%s.a *= %s;", outputColor, alphaUni);
|
| +
|
| + // Clamp values
|
| + builder->fsCodeAppendf("\t\t%s = clamp(%s, 0.0, 1.0);", outputColor, outputColor);
|
| +
|
| + // Pre-multiply the result
|
| + builder->fsCodeAppendf("\t\t%s = vec4(%s.rgb * %s.aaa, %s.a);\n",
|
| + outputColor, outputColor, outputColor, outputColor);
|
| +}
|
| +
|
| +GrGLPerlinNoise::GrGLPerlinNoise(const GrBackendEffectFactory& factory,
|
| + const GrDrawEffect& drawEffect)
|
| + : INHERITED (factory)
|
| + , fType(drawEffect.castEffect<GrPerlinNoiseEffect>().type())
|
| + , fStitchTiles(drawEffect.castEffect<GrPerlinNoiseEffect>().stitchTiles())
|
| + , fNumOctaves(drawEffect.castEffect<GrPerlinNoiseEffect>().numOctaves())
|
| + , fEffectMatrix(drawEffect.castEffect<GrPerlinNoiseEffect>().coordsType()) {
|
| +}
|
| +
|
| +GrGLEffect::EffectKey GrGLPerlinNoise::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
|
| + const GrPerlinNoiseEffect& turbulence = drawEffect.castEffect<GrPerlinNoiseEffect>();
|
| +
|
| + EffectKey key = turbulence.numOctaves();
|
| +
|
| + key = key << 3; // Make room for next 3 bits
|
| +
|
| + switch (turbulence.type()) {
|
| + case SkPerlinNoiseShader::kFractalNoise_Type:
|
| + key |= 0x1;
|
| + break;
|
| + case SkPerlinNoiseShader::kTurbulence_Type:
|
| + key |= 0x2;
|
| + break;
|
| + default:
|
| + // leave key at 0
|
| + break;
|
| + }
|
| +
|
| + if (turbulence.stitchTiles()) {
|
| + key |= 0x4; // Flip the 3rd bit if tile stitching is on
|
| + }
|
| +
|
| + key = key << GrGLEffectMatrix::kKeyBits;
|
| +
|
| + SkMatrix m = turbulence.matrix();
|
| + m.postTranslate(SK_Scalar1, SK_Scalar1);
|
| + return key | GrGLEffectMatrix::GenKey(m, drawEffect,
|
| + drawEffect.castEffect<GrPerlinNoiseEffect>().coordsType(), NULL);
|
| +}
|
| +
|
| +void GrGLPerlinNoise::setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) {
|
| + const GrPerlinNoiseEffect& turbulence = drawEffect.castEffect<GrPerlinNoiseEffect>();
|
| +
|
| + const SkVector& baseFrequency = turbulence.baseFrequency();
|
| + uman.set2f(fBaseFrequencyUni, baseFrequency.fX, baseFrequency.fY);
|
| + if (turbulence.stitchTiles()) {
|
| + const SkPerlinNoiseShader::StitchData& stitchData = turbulence.stitchData();
|
| + uman.set4f(fStitchDataUni, SkIntToScalar(stitchData.fWidth),
|
| + SkIntToScalar(stitchData.fWrapX),
|
| + SkIntToScalar(stitchData.fHeight),
|
| + SkIntToScalar(stitchData.fWrapY));
|
| + }
|
| +
|
| + uman.set1f(fAlphaUni, SkScalarDiv(SkIntToScalar(turbulence.alpha()), SkIntToScalar(255)));
|
| +
|
| + SkMatrix m = turbulence.matrix();
|
| + SkMatrix invM;
|
| + if (!m.invert(&invM)) {
|
| + invM.reset();
|
| + } else {
|
| + invM.postConcat(invM); // Square the matrix
|
| + }
|
| + uman.setSkMatrix(fInvMatrixUni, invM);
|
| +
|
| + // 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 shadeSpan() functions.
|
| + m.postTranslate(SK_Scalar1, SK_Scalar1);
|
| + fEffectMatrix.setData(uman, m, drawEffect, NULL);
|
| +}
|
| +
|
| +/////////////////////////////////////////////////////////////////////
|
| +
|
| +GrEffectRef* SkPerlinNoiseShader::asNewEffect(GrContext* context, const SkPaint& paint) const {
|
| +#if 0
|
| + SkASSERT(NULL != context);
|
| +
|
| + // Either we don't stitch tiles, either we have a valid tile size
|
| + SkASSERT(!fStitchTiles || !fTileSize.isEmpty());
|
| +
|
| + GrTexture* permutationsTexture = GrLockAndRefCachedBitmapTexture(
|
| + context, *fPaintingData->getPermutationsBitmap(), NULL);
|
| + GrTexture* noiseTexture = GrLockAndRefCachedBitmapTexture(
|
| + 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
|
| + // knowing when else to unlock it currently. TODO: Remove this when
|
| + // unref becomes the unlock replacement for all types of textures.
|
| + if (NULL != permutationsTexture) {
|
| + GrUnlockAndUnrefCachedBitmapTexture(permutationsTexture);
|
| + }
|
| + if (NULL != noiseTexture) {
|
| + GrUnlockAndUnrefCachedBitmapTexture(noiseTexture);
|
| + }
|
| +
|
| + return effect;
|
| +#else
|
| + sk_ignore_unused_variable(context);
|
| + sk_ignore_unused_variable(paint);
|
| + return NULL;
|
| +#endif
|
| +}
|
| +
|
| +#else
|
| +
|
| +GrEffectRef* SkPerlinNoiseShader::asNewEffect(GrContext*, const SkPaint&) const {
|
| + SkDEBUGFAIL("Should not call in GPU-less build");
|
| + return NULL;
|
| +}
|
| +
|
| +#endif
|
| +
|
| +#ifdef SK_DEVELOPER
|
| +void SkPerlinNoiseShader::toString(SkString* str) const {
|
| + str->append("SkPerlinNoiseShader: (");
|
| +
|
| + str->append("type: ");
|
| + switch (fType) {
|
| + case kFractalNoise_Type:
|
| + str->append("\"fractal noise\"");
|
| + break;
|
| + case kTurbulence_Type:
|
| + str->append("\"turbulence\"");
|
| + break;
|
| + default:
|
| + str->append("\"unknown\"");
|
| + break;
|
| + }
|
| + str->append(" base frequency: (");
|
| + str->appendScalar(fBaseFrequencyX);
|
| + str->append(", ");
|
| + str->appendScalar(fBaseFrequencyY);
|
| + str->append(") number of octaves: ");
|
| + str->appendS32(fNumOctaves);
|
| + str->append(" seed: ");
|
| + str->appendScalar(fSeed);
|
| + str->append(" stitch tiles: ");
|
| + str->append(fStitchTiles ? "true " : "false ");
|
| +
|
| + this->INHERITED::toString(str);
|
| +
|
| + str->append(")");
|
| +}
|
| +#endif
|
|
|
Chromium Code Reviews
