Cleanup: misc spelling fixes
[blender.git] / source / blender / freestyle / intern / stroke / BasicStrokeShaders.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_BASIC_STROKE_SHADERS_H__
18 #define __FREESTYLE_BASIC_STROKE_SHADERS_H__
19
20 /** \file
21  * \ingroup freestyle
22  * \brief Class gathering basic stroke shaders
23  */
24
25 #include <fstream>
26
27 #include "Stroke.h"
28 #include "StrokeShader.h"
29
30 #include "../geometry/Bezier.h"
31 #include "../geometry/Geom.h"
32
33 extern "C" {
34 struct MTex;
35 struct bNodeTree;
36 }
37
38 using namespace std;
39
40 namespace Freestyle {
41
42 using namespace Geometry;
43
44 namespace StrokeShaders {
45
46 //
47 //  Thickness modifiers
48 //
49 //////////////////////////////////////////////////////
50
51 /*! [ Thickness Shader ].
52  *  Assigns an absolute constant thickness to every vertices of the Stroke.
53  */
54 class ConstantThicknessShader : public StrokeShader {
55  public:
56   /*! Builds the shader.
57    *  \param thickness:
58    *    The thickness that must be assigned to the stroke.
59    */
60   ConstantThicknessShader(float thickness) : StrokeShader()
61   {
62     _thickness = thickness;
63   }
64
65   /*! Destructor. */
66   virtual ~ConstantThicknessShader()
67   {
68   }
69
70   /*! Returns the string "ConstantThicknessShader".*/
71   virtual string getName() const
72   {
73     return "ConstantThicknessShader";
74   }
75
76   /*! The shading method. */
77   virtual int shade(Stroke &stroke) const;
78
79  private:
80   float _thickness;
81 };
82
83 /* [ Thickness Shader ].
84  *  Assigns an absolute constant external thickness to every vertices of the Stroke. The external
85  * thickness of a point is its thickness from the point to the strip border in the direction
86  * pointing outside the object the Stroke delimitates.
87  */
88 class ConstantExternThicknessShader : public StrokeShader {
89  public:
90   ConstantExternThicknessShader(float thickness) : StrokeShader()
91   {
92     _thickness = thickness;
93   }
94
95   virtual ~ConstantExternThicknessShader()
96   {
97   }
98
99   virtual string getName() const
100   {
101     return "ConstantExternThicknessShader";
102   }
103
104   virtual int shade(Stroke &stroke) const;
105
106  private:
107   float _thickness;
108 };
109
110 /*! [ Thickness Shader ].
111  *  Assigns thicknesses values such as the thickness increases from a thickness value A to a
112  * thickness value B between the first vertex to the midpoint vertex and then decreases from B to a
113  * A between this midpoint vertex and the last vertex. The thickness is linearly interpolated from
114  * A to B.
115  */
116 class IncreasingThicknessShader : public StrokeShader {
117  public:
118   /*! Builds the shader.
119    *  \param iThicknessMin:
120    *    The first thickness value.
121    *  \param iThicknessMax:
122    *    The second thickness value.
123    */
124   IncreasingThicknessShader(float iThicknessMin, float iThicknessMax) : StrokeShader()
125   {
126     _ThicknessMin = iThicknessMin;
127     _ThicknessMax = iThicknessMax;
128   }
129
130   /*! Destructor.*/
131   virtual ~IncreasingThicknessShader()
132   {
133   }
134
135   virtual string getName() const
136   {
137     return "IncreasingThicknessShader";
138   }
139
140   /*! The shading method. */
141   virtual int shade(Stroke &stroke) const;
142
143  private:
144   float _ThicknessMin;
145   float _ThicknessMax;
146 };
147
148 /*! [ Thickness shader ].
149  *  Same as previous but here we allow the user to control the ratio thickness/length so that  we
150  * don't get fat short lines
151  */
152 class ConstrainedIncreasingThicknessShader : public StrokeShader {
153  private:
154   float _ThicknessMin;
155   float _ThicknessMax;
156   float _ratio;
157
158  public:
159   /*! Builds the shader.
160    *  \param iThicknessMin:
161    *    The first thickness value.
162    *  \param iThicknessMax:
163    *    The second thickness value.
164    *  \param iRatio:
165    *    The ration thickness/length we don't want to exceed.
166    */
167   ConstrainedIncreasingThicknessShader(float iThicknessMin, float iThicknessMax, float iRatio)
168       : StrokeShader()
169   {
170     _ThicknessMin = iThicknessMin;
171     _ThicknessMax = iThicknessMax;
172     _ratio = iRatio;
173   }
174
175   /*! Destructor.*/
176   virtual ~ConstrainedIncreasingThicknessShader()
177   {
178   }
179
180   virtual string getName() const
181   {
182     return "ConstrainedIncreasingThicknessShader";
183   }
184
185   /*! The shading method. */
186   virtual int shade(Stroke &stroke) const;
187 };
188
189 /*  [ Thickness Shader ].
190  *  Modifies the thickness in a relative way depending on its length.
191  */
192 class LengthDependingThicknessShader : public StrokeShader {
193  private:
194   float _minThickness;
195   float _maxThickness;
196   // We divide the strokes in 4 categories:
197   // l > 300
198   // 100 < l < 300
199   // 50 < l < 100
200   // l < 50
201
202  public:
203   LengthDependingThicknessShader(float iMinThickness, float iMaxThickness) : StrokeShader()
204   {
205     _minThickness = iMinThickness;
206     _maxThickness = iMaxThickness;
207   }
208
209   virtual ~LengthDependingThicknessShader()
210   {
211   }
212
213   virtual string getName() const
214   {
215     return "LengthDependingThicknessShader";
216   }
217
218   virtual int shade(Stroke &stroke) const;
219 };
220
221 /*!  [ Thickness Shader ].
222  *   Adds some noise to the stroke thickness.
223  *   \see \htmlonly <a href=noise/noise.html>noise/noise.html</a>\endhtmlonly
224  */
225 class ThicknessNoiseShader : public StrokeShader {
226  private:
227   float _amplitude;
228   float _scale;
229
230  public:
231   ThicknessNoiseShader();
232
233   /*! Builds a Thickness Noise Shader
234    *    \param iAmplitude:
235    *      The amplitude of the noise signal
236    *    \param iPeriod:
237    *      The period of the noise signal
238    */
239   ThicknessNoiseShader(float iAmplitude, float iPeriod);
240
241   virtual string getName() const
242   {
243     return "ThicknessNoiseShader";
244   }
245
246   /*! The shading method. */
247   virtual int shade(Stroke &stroke) const;
248 };
249
250 //
251 //  Color shaders
252 //
253 /////////////////////////////////////////////////////////
254 /*!  [ Color Shader ].
255  *   Assigns a constant color to every vertices of the Stroke.
256  */
257 class ConstantColorShader : public StrokeShader {
258  public:
259   /*! Builds the shader from a user-specified color.
260    *  \param iR:
261    *    The red component
262    *  \param iG:
263    *    The green component
264    *  \param iB:
265    *    The blue component
266    *  \param iAlpha:
267    *    The alpha value
268    */
269   ConstantColorShader(float iR, float iG, float iB, float iAlpha = 1.0f) : StrokeShader()
270   {
271     _color[0] = iR;
272     _color[1] = iG;
273     _color[2] = iB;
274     _color[3] = iAlpha;
275   }
276
277   virtual string getName() const
278   {
279     return "ConstantColorShader";
280   }
281
282   /*! The shading method. */
283   virtual int shade(Stroke &stroke) const;
284
285  private:
286   float _color[4];
287 };
288
289 /*!  [ Color Shader ].
290  *   Assigns a varying color to the stroke.
291  *   The user specifies 2 colors A and B. The stroke color will change linearly from A to B between
292  * the first and the last vertex.
293  */
294 class IncreasingColorShader : public StrokeShader {
295  private:
296   float _colorMin[4];
297   float _colorMax[4];
298
299  public:
300   /*! Builds the shader from 2 user-specified colors.
301    *  \param iRm:
302    *    The first color red component
303    *  \param iGm:
304    *    The first color green component
305    *  \param iBm:
306    *    The first color blue component
307    *  \param iAlpham:
308    *    The first color alpha value
309    *  \param iRM:
310    *    The second color red component
311    *  \param iGM:
312    *    The second color green component
313    *  \param iBM:
314    *    The second color blue component
315    *  \param iAlphaM:
316    *    The second color alpha value
317    */
318   IncreasingColorShader(float iRm,
319                         float iGm,
320                         float iBm,
321                         float iAlpham,
322                         float iRM,
323                         float iGM,
324                         float iBM,
325                         float iAlphaM)
326       : StrokeShader()
327   {
328     _colorMin[0] = iRm;
329     _colorMin[1] = iGm;
330     _colorMin[2] = iBm;
331     _colorMin[3] = iAlpham;
332
333     _colorMax[0] = iRM;
334     _colorMax[1] = iGM;
335     _colorMax[2] = iBM;
336     _colorMax[3] = iAlphaM;
337   }
338
339   virtual string getName() const
340   {
341     return "IncreasingColorShader";
342   }
343
344   /*! The shading method. */
345   virtual int shade(Stroke &stroke) const;
346 };
347
348 /* [ Color Shader ].
349  *  Assigns a color to the stroke depending on the material of the shape to which ot belongs to.
350  * (Disney shader)
351  */
352 class MaterialColorShader : public StrokeShader {
353  private:
354   float _coefficient;
355
356  public:
357   MaterialColorShader(float coeff = 1.0f) : StrokeShader()
358   {
359     _coefficient = coeff;
360   }
361
362   virtual string getName() const
363   {
364     return "MaterialColorShader";
365   }
366
367   virtual int shade(Stroke &stroke) const;
368 };
369
370 /*! [ Color Shader ].
371  *  Shader to add noise to the stroke colors.
372  */
373 class ColorNoiseShader : public StrokeShader {
374  private:
375   float _amplitude;
376   float _scale;
377
378  public:
379   ColorNoiseShader();
380
381   /*! Builds a Color Noise Shader
382    *    \param iAmplitude:
383    *      The amplitude of the noise signal
384    *    \param iPeriod:
385    *      The period of the noise signal
386    */
387   ColorNoiseShader(float iAmplitude, float iPeriod);
388
389   virtual string getName() const
390   {
391     return "ColorNoiseShader";
392   }
393
394   /*! The shading method. */
395   virtual int shade(Stroke &stroke) const;
396 };
397
398 //
399 //  Geometry Shaders
400 //
401 ///////////////////////////////////////////////////////////////////////////////
402 /*! [ Geometry Shader ].
403  *  Stretches the stroke at its two extremities and following the respective directions: v(1)v(0)
404  * and v(n-1)v(n).
405  */
406 class BackboneStretcherShader : public StrokeShader {
407  private:
408   float _amount;
409
410  public:
411   /*! Builds the shader.
412    *  \param iAmount:
413    *    The stretching amount value.
414    */
415   BackboneStretcherShader(float iAmount = 2.0f) : StrokeShader()
416   {
417     _amount = iAmount;
418   }
419
420   virtual string getName() const
421   {
422     return "BackboneStretcherShader";
423   }
424
425   /*! The shading method */
426   virtual int shade(Stroke &stroke) const;
427 };
428
429 /*! [ Geometry Shader. ]
430  *  Resamples the stroke.
431  * \see Stroke::Resample(float).
432  */
433 class SamplingShader : public StrokeShader {
434  private:
435   float _sampling;
436
437  public:
438   /*! Builds the shader.
439    *  \param sampling:
440    *    The sampling to use for the stroke resampling
441    */
442   SamplingShader(float sampling) : StrokeShader()
443   {
444     _sampling = sampling;
445   }
446
447   virtual string getName() const
448   {
449     return "SamplingShader";
450   }
451
452   /*! The shading method */
453   virtual int shade(Stroke &stroke) const;
454 };
455
456 class ExternalContourStretcherShader : public StrokeShader {
457  private:
458   float _amount;
459
460  public:
461   ExternalContourStretcherShader(float iAmount = 2.0f) : StrokeShader()
462   {
463     _amount = iAmount;
464   }
465
466   virtual string getName() const
467   {
468     return "ExternalContourStretcherShader";
469   }
470
471   virtual int shade(Stroke &stroke) const;
472 };
473
474 // Bezier curve stroke shader
475 /*! [ Geometry Shader ].
476  *  Transforms the stroke backbone geometry so that it corresponds to a Bezier Curve approximation
477  * of the original backbone geometry. \see \htmlonly <a
478  * href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
479  */
480 class BezierCurveShader : public StrokeShader {
481  private:
482   float _error;
483
484  public:
485   /*! Builds the shader.
486    *  \param error:
487    *    The error we're allowing for the approximation.
488    *    This error is the max distance allowed between the new curve and the original geometry.
489    */
490   BezierCurveShader(float error = 4.0) : StrokeShader()
491   {
492     _error = error;
493   }
494
495   virtual string getName() const
496   {
497     return "BezierCurveShader";
498   }
499
500   /*! The shading method */
501   virtual int shade(Stroke &stroke) const;
502 };
503
504 /*! [ Geometry Shader ].
505  *  Shader to modify the Stroke geometry so that it looks more "polygonal".
506  *  The basic idea is to start from the minimal stroke approximation consisting in a line joining
507  * the first vertex to the last one and to subdivide using the original stroke vertices until a
508  * certain error is reached.
509  */
510 class PolygonalizationShader : public StrokeShader {
511  private:
512   float _error;
513
514  public:
515   /*! Builds the shader.
516    *  \param iError:
517    *    The error we want our polygonal approximation to have with respect to the original
518    * geometry. The smaller, the closer the new stroke to the orinal one. This error corresponds to
519    * the maximum distance between the new stroke and the old one.
520    */
521   PolygonalizationShader(float iError) : StrokeShader()
522   {
523     _error = iError;
524   }
525
526   virtual string getName() const
527   {
528     return "PolygonalizationShader";
529   }
530
531   /*! The shading method */
532   virtual int shade(Stroke &stroke) const;
533 };
534
535 /*! [ Geometry Shader ].
536  *  Shader to modify the Stroke geometry so that it corresponds to its main direction line.
537  *  This shader must be used together with the splitting operator using the curvature criterion.
538  *  Indeed, the precision of the approximation will depend on the size of the stroke's pieces.
539  *  The bigger the pieces, the rougher the approximation.
540  */
541 class GuidingLinesShader : public StrokeShader {
542  private:
543   float _offset;
544
545  public:
546   /*! Builds a Guiding Lines shader
547    *    \param iOffset:
548    *      The line that replaces the stroke is initially in the middle of the initial stroke
549    * "bbox". iOffset is the value of the displacement which is applied to this line along its
550    * normal.
551    */
552   GuidingLinesShader(float iOffset) : StrokeShader()
553   {
554     _offset = iOffset;
555   }
556
557   virtual string getName() const
558   {
559     return "GuidingLinesShader";
560   }
561
562   /*! The shading method */
563   virtual int shade(Stroke &stroke) const;
564 };
565
566 /*! [ Geometry Shader ].
567  *  Removes the stroke's extremities.
568  */
569 class TipRemoverShader : public StrokeShader {
570  public:
571   /*! Builds the shader.
572    *  \param tipLength:
573    *    The length of the piece of stroke we want to remove at each extremity.
574    */
575   TipRemoverShader(real tipLength);
576
577   /*! Destructor. */
578   virtual ~TipRemoverShader()
579   {
580   }
581
582   /*! The shading method */
583   virtual string getName() const
584   {
585     return "TipRemoverShader";
586   }
587
588   virtual int shade(Stroke &stroke) const;
589
590  protected:
591   real _tipLength;
592 };
593
594 /*! [ Texture Shader ].
595  *  Shader to assign texture to the Stroke material.
596  */
597
598 class BlenderTextureShader : public StrokeShader {
599  private:
600   MTex *_mtex;
601   bNodeTree *_nodeTree;
602
603  public:
604   /*! Builds the shader.
605    *  \param mtex:
606    *    The blender texture to use.
607    */
608   BlenderTextureShader(MTex *mtex) : StrokeShader()
609   {
610     _mtex = mtex;
611     _nodeTree = NULL;
612   }
613
614   /*! Builds the shader.
615    *  \param nodetree:
616    *    A node tree (of new shading nodes) to define textures.
617    */
618   BlenderTextureShader(bNodeTree *nodetree) : StrokeShader()
619   {
620     _nodeTree = nodetree;
621     _mtex = NULL;
622   }
623
624   virtual string getName() const
625   {
626     return "BlenderTextureShader";
627   }
628
629   /*! The shading method */
630   virtual int shade(Stroke &stroke) const;
631 };
632
633 /*! [ Texture Shader ].
634  *  Shader to assign texture to the Stroke material.
635  */
636
637 class StrokeTextureStepShader : public StrokeShader {
638  private:
639   float _step;
640
641  public:
642   /*! Builds the shader.
643    *  \param id:
644    *    The number of the preset to use.
645    */
646   StrokeTextureStepShader(float step) : StrokeShader()
647   {
648     _step = step;
649   }
650
651   virtual string getName() const
652   {
653     return "StrokeTextureStepShader";
654   }
655
656   /*! The shading method */
657   virtual int shade(Stroke &stroke) const;
658 };
659
660 }  // end of namespace StrokeShaders
661
662 } /* namespace Freestyle */
663
664 #endif  // __FREESTYLE_BASIC_STROKE_SHADERS_H__