1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkPerlinNoiseShader_DEFINED
#define SkPerlinNoiseShader_DEFINED
#include "SkShader.h"
/** \class SkPerlinNoiseShader
SkPerlinNoiseShader creates an image using the Perlin turbulence function.
It can produce tileable noise if asked to stitch tiles and provided a tile size.
In order to fill a large area with repeating noise, set the stitchTiles flag to
true, and render exactly a single tile of noise. Without this flag, the result
will contain visible seams between tiles.
The algorithm used is described here :
http://www.w3.org/TR/SVG/filters.html#feTurbulenceElement
*/
class SK_API SkPerlinNoiseShader : public SkShader {
public:
struct StitchData;
struct PaintingData;
/**
* About the noise types : the difference between the 2 is just minor tweaks to the algorithm,
* they're not 2 entirely different noises. The output looks different, but once the noise is
* generated in the [1, -1] range, the output is brought back in the [0, 1] range by doing :
* kFractalNoise_Type : noise * 0.5 + 0.5
* kTurbulence_Type : abs(noise)
* Very little differences between the 2 types, although you can tell the difference visually.
*/
enum Type {
kFractalNoise_Type,
kTurbulence_Type,
kFirstType = kFractalNoise_Type,
kLastType = kTurbulence_Type
};
/**
* This will construct Perlin noise of the given type (Fractal Noise or Turbulence).
*
* Both base frequencies (X and Y) have a usual range of (0..1).
*
* The number of octaves provided should be fairly small, although no limit is enforced.
* Each octave doubles the frequency, so 10 octaves would produce noise from
* baseFrequency * 1, * 2, * 4, ..., * 512, which quickly yields insignificantly small
* periods and resembles regular unstructured noise rather than Perlin noise.
*
* If tileSize isn't NULL or an empty size, the tileSize parameter will be used to modify
* the frequencies so that the noise will be tileable for the given tile size. If tileSize
* is NULL or an empty size, the frequencies will be used as is without modification.
*/
static sk_sp<SkShader> MakeFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
int numOctaves, SkScalar seed,
const SkISize* tileSize = nullptr);
static sk_sp<SkShader> MakeTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
int numOctaves, SkScalar seed,
const SkISize* tileSize = nullptr);
#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR
static SkShader* CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
int numOctaves, SkScalar seed,
const SkISize* tileSize = NULL) {
return MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize).release();
}
static SkShader* CreateTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
int numOctaves, SkScalar seed,
const SkISize* tileSize = NULL) {
return MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize).release();
}
static SkShader* CreateTubulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
int numOctaves, SkScalar seed,
const SkISize* tileSize = NULL) {
return CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize);
}
#endif
class PerlinNoiseShaderContext : public SkShader::Context {
public:
PerlinNoiseShaderContext(const SkPerlinNoiseShader& shader, const ContextRec&);
virtual ~PerlinNoiseShaderContext();
void shadeSpan(int x, int y, SkPMColor[], int count) override;
private:
SkPMColor shade(const SkPoint& point, StitchData& stitchData) const;
SkScalar calculateTurbulenceValueForPoint(
int channel,
StitchData& stitchData, const SkPoint& point) const;
SkScalar noise2D(int channel,
const StitchData& stitchData, const SkPoint& noiseVector) const;
SkMatrix fMatrix;
PaintingData* fPaintingData;
typedef SkShader::Context INHERITED;
};
#if SK_SUPPORT_GPU
const GrFragmentProcessor* asFragmentProcessor(GrContext* context, const SkMatrix& viewM,
const SkMatrix*, SkFilterQuality) const override;
#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPerlinNoiseShader)
protected:
void flatten(SkWriteBuffer&) const override;
Context* onCreateContext(const ContextRec&, void* storage) const override;
size_t onContextSize(const ContextRec&) const override;
private:
SkPerlinNoiseShader(SkPerlinNoiseShader::Type type, SkScalar baseFrequencyX,
SkScalar baseFrequencyY, int numOctaves, SkScalar seed,
const SkISize* tileSize);
virtual ~SkPerlinNoiseShader();
const SkPerlinNoiseShader::Type fType;
const SkScalar fBaseFrequencyX;
const SkScalar fBaseFrequencyY;
const int fNumOctaves;
const SkScalar fSeed;
const SkISize fTileSize;
const bool fStitchTiles;
typedef SkShader INHERITED;
};
#endif
|
