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