Cleanup: misc spelling fixes
[blender.git] / source / blender / freestyle / intern / stroke / AdvancedStrokeShaders.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 #ifndef __FREESTYLE_ADVANCED_STROKE_SHADERS_H__
18 #define __FREESTYLE_ADVANCED_STROKE_SHADERS_H__
19
20 /** \file
21  * \ingroup freestyle
22  * \brief Fredo's stroke shaders
23  */
24
25 #include "BasicStrokeShaders.h"
26
27 namespace Freestyle {
28
29 /*! [ Thickness Shader ].
30  *  Assigns thicknesses to the stroke vertices so that the stroke looks like made with a
31  * calligraphic tool. i.e. The stroke will be the thickest in a main direction, the thinnest in the
32  * direction perpendicular to this one, and an interpolation in between.
33  */
34 class CalligraphicShader : public StrokeShader {
35  public:
36   /*! Builds the shader.
37    *  \param iMinThickness:
38    *    The minimum thickness in the direction perpandicular to the main direction.
39    *  \param iMaxThickness:
40    *    The maximum thickness in the main direction.
41    *  \param iOrientation:
42    *    The 2D vector giving the main direction.
43    *  \param clamp:
44    *    Tells ???
45    */
46   CalligraphicShader(real iMinThickness,
47                      real iMaxThickness,
48                      const Vec2f &iOrientation,
49                      bool clamp);
50
51   /*! Destructor. */
52   virtual ~CalligraphicShader()
53   {
54   }
55
56   /*! The shading method */
57   virtual int shade(Stroke &ioStroke) const;
58
59  protected:
60   real _maxThickness;
61   real _minThickness;
62   Vec2f _orientation;
63   bool _clamp;
64 };
65
66 /*! [ Geometry Shader ].
67  *  Spatial Noise stroke shader.
68  *  Moves the vertices to make the stroke more noisy.
69  * \see \htmlonly <a href=noise/noise.html>noise/noise.html</a> \endhtmlonly
70  */
71 class SpatialNoiseShader : public StrokeShader {
72  public:
73   /*! Builds the shader.
74    *  \param iAmount:
75    *    The amplitude of the noise.
76    *  \param ixScale:
77    *    The noise frequency
78    *  \param nbOctave:
79    *    The number of octaves
80    *  \param smooth:
81    *    If you want the noise to be smooth
82    *  \param pureRandom:
83    *    If you don't want any coherence
84    */
85   SpatialNoiseShader(float iAmount, float ixScale, int nbOctave, bool smooth, bool pureRandom);
86
87   /*! Destructor. */
88   virtual ~SpatialNoiseShader()
89   {
90   }
91
92   /*! The shading method. */
93   virtual int shade(Stroke &ioStroke) const;
94
95  protected:
96   float _amount;
97   float _xScale;
98   int _nbOctave;
99   bool _smooth;
100   bool _pureRandom;
101 };
102
103 /*! [ Geometry Shader ].
104  *  Smoothes the stroke.
105  *  (Moves the vertices to make the stroke smoother).
106  *  Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we
107  * use is anisotropic to prevent the diffusion across corners. \see \htmlonly <a
108  * href=/smoothing/smoothing.html>smoothing/smoothing.html</a> \endhtmlonly
109  */
110 class SmoothingShader : public StrokeShader {
111  public:
112   /*! Builds the shader.
113    *  \param iNbIteration:
114    *    The number of iterations. (400)
115    *  \param iFactorPoint:
116    *    0
117    *  \param ifactorCurvature:
118    *    0
119    *  \param iFactorCurvatureDifference:
120    *    0.2
121    *  \param iAnisoPoint:
122    *    0
123    *  \param iAnisNormal:
124    *    0
125    *  \param iAnisoCurvature:
126    *    0
127    *  \param icarricatureFactor:
128    *    1
129    */
130   SmoothingShader(int iNbIteration,
131                   real iFactorPoint,
132                   real ifactorCurvature,
133                   real iFactorCurvatureDifference,
134                   real iAnisoPoint,
135                   real iAnisoNormal,
136                   real iAnisoCurvature,
137                   real icarricatureFactor);
138
139   /*! Destructor. */
140   virtual ~SmoothingShader()
141   {
142   }
143
144   /*! The shading method. */
145   virtual int shade(Stroke &ioStroke) const;
146
147  protected:
148   int _nbIterations;
149   real _factorPoint;
150   real _factorCurvature;
151   real _factorCurvatureDifference;
152   real _anisoPoint;
153   real _anisoNormal;
154   real _anisoCurvature;
155   real _carricatureFactor;
156 };
157
158 class Smoother {
159  public:
160   Smoother(Stroke &ioStroke);
161
162   virtual ~Smoother();
163
164   void smooth(int nbIterations,
165               real iFactorPoint,
166               real ifactorCurvature,
167               real iFactorCurvatureDifference,
168               real iAnisoPoint,
169               real iAnisoNormal,
170               real iAnisoCurvature,
171               real icarricatureFactor);
172
173   void computeCurvature();
174
175  protected:
176   real _factorPoint;
177   real _factorCurvature;
178   real _factorCurvatureDifference;
179   real _anisoPoint;
180   real _anisoNormal;
181   real _anisoCurvature;
182   real _carricatureFactor;
183
184   void iteration();
185   void copyVertices();
186
187   Stroke *_stroke;
188   int _nbVertices;
189   Vec2r *_vertex;
190   Vec2r *_normal;
191   real *_curvature;
192   bool *_isFixedVertex;
193
194   bool _isClosedCurve;
195   bool _safeTest;
196 };
197
198 class Omitter : public Smoother {
199  public:
200   Omitter(Stroke &ioStroke);
201
202   virtual ~Omitter()
203   {
204   }
205
206   void omit(real sizeWindow, real thrVari, real thrFlat, real lFlat);
207
208  protected:
209   real *_u;
210
211   real _sizeWindow;
212   real _thresholdVariation;
213   real _thresholdFlat;
214   real _lengthFlat;
215 };
216
217 /*! Omission shader */
218 class OmissionShader : public StrokeShader {
219  public:
220   OmissionShader(real sizeWindow, real thrVari, real thrFlat, real lFlat);
221   virtual ~OmissionShader()
222   {
223   }
224
225   virtual int shade(Stroke &ioStroke) const;
226
227  protected:
228   real _sizeWindow;
229   real _thresholdVariation;
230   real _thresholdFlat;
231   real _lengthFlat;
232 };
233
234 } /* namespace Freestyle */
235
236 #endif  // __FREESTYLE_ADVANCED_STROKE_SHADERS_H__