Fix for a static variable in BlenderStrokeRenderer::RenderStrokeRep() left after
[blender.git] / source / blender / freestyle / intern / view_map / Functions0D.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  * The Original Code is Copyright (C) 2010 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #ifndef __FREESTYLE_FUNCTIONS_0D_H__
29 #define __FREESTYLE_FUNCTIONS_0D_H__
30
31 /** \file blender/freestyle/intern/view_map/Functions0D.h
32  *  \ingroup freestyle
33  *  \brief Functions taking 0D input
34  *  \author Stephane Grabli
35  *  \author Emmanuel Turquin
36  *  \date 01/07/2003
37  */
38
39 #include <set>
40 #include <vector>
41
42 #include "Interface0D.h"
43
44 #include "../geometry/Geom.h"
45
46 #include "../python/Director.h"
47
48 #include "../scene_graph/FrsMaterial.h"
49
50 #include "../system/Exception.h"
51 #include "../system/Precision.h"
52
53 class FEdge;
54 class ViewEdge;
55 class SShape;
56
57 using namespace Geometry;
58
59 //
60 // UnaryFunction0D (base class for functions in 0D)
61 //
62 ///////////////////////////////////////////////////////////
63
64 /*! Base class for Unary Functions (functors) working on Interface0DIterator.
65  *  A unary function will be used by calling its operator() on an Interface0DIterator.
66  *  \attention In the scripting language, there exists several prototypes depending on the returned value type.
67  *  For example, you would inherit from a UnaryFunction0DDouble if you wish to define a function that returns a double.
68  *  The different existing prototypes are:
69  *    - UnaryFunction0DVoid
70  *    - UnaryFunction0DUnsigned
71  *    - UnaryFunction0DReal
72  *    - UnaryFunction0DFloat
73  *    - UnaryFunction0DDouble
74  *    - UnaryFunction0DVec2f
75  *    - UnaryFunction0DVec3f
76  */
77 template <class T>
78 class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction0D
79 {
80 public:
81         T result;
82         PyObject *py_uf0D;
83
84         /*! The type of the value returned by the functor. */
85         typedef T ReturnedValueType;
86
87         /*! Default constructor. */
88         UnaryFunction0D()
89         {
90                 py_uf0D = NULL;
91         }
92
93         /*! Destructor; */
94         virtual ~UnaryFunction0D() {}
95
96         /*! Returns the string "UnaryFunction0D" */
97         virtual string getName() const
98         {
99                 return "UnaryFunction0D";
100         }
101
102         /*! The operator ().
103          *  \param iter
104          *    An Interface0DIterator pointing onto the point at which we wish to evaluate the function.
105          *  \return the result of the function of type T.
106          */
107         virtual int operator()(Interface0DIterator& iter)
108         {
109                 return Director_BPy_UnaryFunction0D___call__(this, py_uf0D, iter);
110         }
111 };
112
113 #ifdef SWIG
114 %feature("director")  UnaryFunction0D<void>;
115 %feature("director")  UnaryFunction0D<unsigned>;
116 %feature("director")  UnaryFunction0D<float>;
117 %feature("director")  UnaryFunction0D<double>;
118 %feature("director")  UnaryFunction0D<Vec2f>;
119 %feature("director")  UnaryFunction0D<Vec3f>;
120 %feature("director")  UnaryFunction0D<Id>;
121
122 %template(UnaryFunction0DVoid)             UnaryFunction0D<void>;
123 %template(UnaryFunction0DUnsigned)         UnaryFunction0D<unsigned>;
124 %template(UnaryFunction0DFloat)            UnaryFunction0D<float>;
125 %template(UnaryFunction0DDouble)           UnaryFunction0D<double>;
126 %template(UnaryFunction0DVec2f)            UnaryFunction0D<Vec2f>;
127 %template(UnaryFunction0DVec3f)            UnaryFunction0D<Vec3f>;
128 %template(UnaryFunction0DId)               UnaryFunction0D<Id>;
129 %template(UnaryFunction0DViewShape)        UnaryFunction0D<ViewShape*>;
130 %template(UnaryFunction0DVectorViewShape)  UnaryFunction0D<std::vector<ViewShape*> >;
131 #endif // SWIG
132
133 //
134 // Functions definitions
135 //
136 ///////////////////////////////////////////////////////////
137 class ViewShape;
138
139 namespace Functions0D {
140
141 // GetXF0D
142 /*! Returns the X 3D coordinate of an Interface0D. */
143 class LIB_VIEW_MAP_EXPORT GetXF0D : public UnaryFunction0D<real>
144 {
145 public:
146         /*! Returns the string "GetXF0D" */
147         string getName() const
148         {
149                 return "GetXF0D";
150         }
151
152         /*! the () operator. */
153         int operator()(Interface0DIterator& iter)
154         {
155                 result = iter->getX();
156                 return 0;
157         }
158 };
159
160 // GetYF0D
161 /*! Returns the Y 3D coordinate of an Interface0D. */
162 class LIB_VIEW_MAP_EXPORT GetYF0D : public UnaryFunction0D<real>
163 {
164 public:
165         /*! Returns the string "GetYF0D" */
166         string getName() const
167         {
168                 return "GetYF0D";
169         }
170
171         /*! the () operator. */
172         int operator()(Interface0DIterator& iter)
173         {
174                 result = iter->getY();
175                 return 0;
176         }
177 };
178
179 // GetZF0D
180 /*! Returns the Z 3D coordinate of an Interface0D. */
181 class LIB_VIEW_MAP_EXPORT GetZF0D : public UnaryFunction0D<real>
182 {
183 public:
184         /*! Returns the string "GetZF0D" */
185         string getName() const
186         {
187                 return "GetZF0D";
188         }
189
190         /*! the () operator. */
191         int operator()(Interface0DIterator& iter)
192         {
193                 result = iter->getZ();
194                 return 0;
195         }
196 };
197
198 // GetProjectedXF0D
199 /*! Returns the X 3D projected coordinate of an Interface0D. */
200 class LIB_VIEW_MAP_EXPORT GetProjectedXF0D : public UnaryFunction0D<real>
201 {
202 public:
203         /*! Returns the string "GetProjectedXF0D" */
204         string getName() const
205         {
206                 return "GetProjectedXF0D";
207         }
208
209         /*! the () operator. */
210         int operator()(Interface0DIterator& iter)
211         {
212                 result = iter->getProjectedX();
213                 return 0;
214         }
215 };
216
217 // GetProjectedYF0D
218 /*! Returns the Y projected 3D coordinate of an Interface0D. */
219 class LIB_VIEW_MAP_EXPORT GetProjectedYF0D : public UnaryFunction0D<real>
220 {
221 public:
222         /*! Returns the string "GetProjectedYF0D" */
223         string getName() const
224         {
225                 return "GetProjectedYF0D";
226         }
227
228         /*! the () operator. */
229         int operator()(Interface0DIterator& iter)
230         {
231                 result = iter->getProjectedY();
232                 return 0;
233         }
234 };
235
236 // GetProjectedZF0D
237 /*! Returns the Z projected 3D coordinate of an Interface0D. */
238 class LIB_VIEW_MAP_EXPORT GetProjectedZF0D : public UnaryFunction0D<real>
239 {
240 public:
241         /*! Returns the string "GetProjectedZF0D" */
242         string getName() const
243         {
244                 return "GetProjectedZF0D";
245         }
246
247         /*! the () operator. */
248         int operator()(Interface0DIterator& iter)
249         {
250                 result = iter->getProjectedZ();
251                 return 0;
252         }
253 };
254
255 // GetCurvilinearAbscissaF0D
256 /*! Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */
257 class LIB_VIEW_MAP_EXPORT GetCurvilinearAbscissaF0D : public UnaryFunction0D<float>
258 {
259 public:
260         /*! Returns the string "GetCurvilinearAbscissaF0D" */
261         string getName() const
262         {
263                 return "GetCurvilinearAbscissaF0D";
264         }
265
266         /*! the () operator. */
267         int operator()(Interface0DIterator& iter)
268         {
269                 result = iter.t();
270                 return 0;
271         }
272 };
273
274 // GetParameterF0D
275 /*! Returns the parameter of an Interface0D in the context of its 1D element. */
276 class LIB_VIEW_MAP_EXPORT GetParameterF0D : public UnaryFunction0D<float>
277 {
278 public:
279         /*! Returns the string "GetCurvilinearAbscissaF0D" */
280         string getName() const
281         {
282                 return "GetParameterF0D";
283         }
284
285         /*! the () operator. */
286         int operator()(Interface0DIterator& iter)
287         {
288                 result = iter.u();
289                 return 0;
290         }
291 };
292
293 // VertexOrientation2DF0D
294 /*! Returns a Vec2r giving the 2D oriented tangent to the 1D element to which the Interface0DIterator& belongs to and
295  *  evaluated at the Interface0D pointed by this Interface0DIterator&.
296  */
297 class LIB_VIEW_MAP_EXPORT VertexOrientation2DF0D : public UnaryFunction0D<Vec2f>
298 {
299 public:
300         /*! Returns the string "VertexOrientation2DF0D" */
301         string getName() const
302         {
303                 return "VertexOrientation2DF0D";
304         }
305
306         /*! the () operator. */
307         int operator()(Interface0DIterator& iter);
308 };
309
310 // VertexOrientation3DF0D
311 /*! Returns a Vec3r giving the 3D oriented tangent to the 1D element to which the Interface0DIterator& belongs to and
312  *  evaluated at the Interface0D pointed by this Interface0DIterator&.
313  */
314 class LIB_VIEW_MAP_EXPORT VertexOrientation3DF0D : public UnaryFunction0D<Vec3f>
315 {
316 public:
317         /*! Returns the string "VertexOrientation3DF0D" */
318         string getName() const
319         {
320                 return "VertexOrientation3DF0D";
321         }
322
323         /*! the () operator. */
324         int operator()(Interface0DIterator& iter);
325 };
326
327 // Curvature2DAngleF0D
328 /*! Returns a real giving the 2D curvature (as an angle) of the 1D element to which the Interface0DIterator&
329  *  belongs to and evaluated at the Interface0D pointed by this Interface0DIterator&.
330  */
331 class LIB_VIEW_MAP_EXPORT Curvature2DAngleF0D : public UnaryFunction0D<real>
332 {
333 public:
334         /*! Returns the string "Curvature2DAngleF0D" */
335         string getName() const
336         {
337                 return "Curvature2DAngleF0D";
338         }
339
340         /*! the () operator. */
341         int operator()(Interface0DIterator& iter);
342 };
343
344 // ZDiscontinuity
345 /*! Returns a real giving the distance between and Interface0D and the shape that lies behind (occludee).
346  *  This distance is evaluated in the camera space and normalized between 0 and 1. Therefore, if no oject is occluded
347  *  by the shape to which the Interface0D belongs to, 1 is returned.
348  */
349 class LIB_VIEW_MAP_EXPORT ZDiscontinuityF0D : public UnaryFunction0D<real>
350 {
351 public:
352         /*! Returns the string "ZDiscontinuityF0D" */
353         string getName() const
354         {
355                 return "ZDiscontinuityF0D";
356         }
357
358         /*! the () operator. */
359         int operator()(Interface0DIterator& iter);
360 };
361
362 // Normal2DF0D
363 /*! Returns a Vec2f giving the normalized 2D normal to the 1D element to which the Interface0DIterator& belongs to and
364  *  evaluated at the Interface0D pointed by this Interface0DIterator&.
365  */
366 class LIB_VIEW_MAP_EXPORT Normal2DF0D : public UnaryFunction0D<Vec2f>
367 {
368 public:
369         /*! Returns the string "Normal2DF0D" */
370         string getName() const
371         {
372                 return "Normal2DF0D";
373         }
374
375         /*! the () operator. */
376         int operator()(Interface0DIterator& iter);
377 };
378
379 // MaterialF0D
380 /*! Returns the material of the object evaluated at the Interface0D.
381  *  This evaluation can be ambiguous (in the case of a TVertex for example.
382  *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
383  *  Interface0DIterator& belongs to and by arbitrary chosing the material of the face that lies on its left when
384  *  following the 1D element if there are two different materials on each side of the point.
385  *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
386  *  should implement its own getMaterial functor.
387  */
388 class LIB_VIEW_MAP_EXPORT MaterialF0D : public UnaryFunction0D<FrsMaterial>
389 {
390 public:
391         /*! Returns the string "MaterialF0D" */
392         string getName() const
393         {
394                 return "MaterialF0D";
395         }
396
397         /*! the () operator. */
398         int operator()(Interface0DIterator& iter);
399 };
400
401 // ShapeIdF0D
402 /*! Returns the Id of the Shape the Interface0D belongs to.
403  *  This evaluation can be ambiguous (in the case of a TVertex for example).
404  *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
405  *  Interface0DIterator& belongs to.
406  *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
407  *  should implement its own getShapeIdF0D functor.
408  */
409 class LIB_VIEW_MAP_EXPORT ShapeIdF0D : public UnaryFunction0D<Id>
410 {
411 public:
412         /*! Returns the string "ShapeIdF0D" */
413         string getName() const
414         {
415                 return "ShapeIdF0D";
416         }
417
418         /*! the () operator. */
419         int operator()(Interface0DIterator& iter);
420 };
421
422 // QiF0D
423 /*! Returns the quantitative invisibility of this Interface0D.
424 *  This evaluation can be ambiguous (in the case of a TVertex for example).
425 *  This functor tries to remove this ambiguity using the context offered by the 1D element to which the
426 *  Interface0DIterator& belongs to.
427 *  However, there still can be problematic cases, and the user willing to deal with this cases in a specific way
428 *  should implement its own getQIF0D functor.
429 */
430 class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF0D : public UnaryFunction0D<unsigned int>
431 {
432 public:
433         /*! Returns the string "QuantitativeInvisibilityF0D" */
434         string getName() const
435         {
436                 return "QuantitativeInvisibilityF0D";
437         }
438
439         /*! the () operator. */
440         int operator()(Interface0DIterator& iter);
441 };
442
443 // CurveNatureF0D
444 /*! Returns the Nature::EdgeNature of the 1D element the Interface0DIterator& belongs to. */
445 class LIB_VIEW_MAP_EXPORT CurveNatureF0D : public UnaryFunction0D<Nature::EdgeNature>
446 {
447 public:
448         /*! Returns the string "QuantitativeInvisibilityF0D" */
449         string getName() const
450         {
451                 return "CurveNatureF0D";
452         }
453
454         /*! the () operator. */
455         int operator()(Interface0DIterator& iter);
456 };
457
458 // GetShapeF0D
459 /*! Returns the ViewShape* containing the Interface0D */
460 class LIB_VIEW_MAP_EXPORT GetShapeF0D : public UnaryFunction0D< ViewShape*>
461 {
462 public:
463         /*! Returns the string "GetShapeF0D" */
464         string getName() const
465         {
466                 return "GetShapeF0D";
467         }
468
469         /*! the () operator. */
470         int operator()(Interface0DIterator& iter);
471 };
472
473 // GetOccludersF0D
474 /*! Returns a vector containing the ViewShape* occluding the Interface0D */
475 class LIB_VIEW_MAP_EXPORT GetOccludersF0D : public UnaryFunction0D< std::vector<ViewShape*> >
476 {
477 public:
478         /*! Returns the string "GetOccludersF0D" */
479         string getName() const
480         {
481                 return "GetOccludersF0D";
482         }
483
484         /*! the () operator. */
485         int operator()(Interface0DIterator& iter);
486 };
487
488 // GetOccludeeF0D
489 /*! Returns the ViewShape* "occluded" by the Interface0D */
490 class LIB_VIEW_MAP_EXPORT GetOccludeeF0D: public UnaryFunction0D< ViewShape*>
491 {
492 public:
493         /*! Returns the string "GetOccludeeF0D" */
494         string getName() const
495         {
496                 return "GetOccludeeF0D";
497         }
498
499         /*! the () operator. */
500         int operator()(Interface0DIterator& iter);
501 };
502
503
504 /////////////////////////// Internal ////////////////////////////
505
506 // getFEdge
507 LIB_VIEW_MAP_EXPORT
508 FEdge *getFEdge(Interface0D& it1, Interface0D& it2);
509
510 // getFEdges
511 LIB_VIEW_MAP_EXPORT
512 void getFEdges(Interface0DIterator& it, FEdge *&fe1, FEdge *&fe2);
513
514 // getViewEdges
515 LIB_VIEW_MAP_EXPORT
516 void getViewEdges(Interface0DIterator& it, ViewEdge *&ve1, ViewEdge *&ve2);
517
518 // getShapeF0D
519 LIB_VIEW_MAP_EXPORT
520 ViewShape *getShapeF0D(Interface0DIterator& it);
521
522 // getOccludersF0D
523 LIB_VIEW_MAP_EXPORT
524 void getOccludersF0D(Interface0DIterator& it, std::set<ViewShape*>& oOccluders);
525
526 // getOccludeeF0D
527 LIB_VIEW_MAP_EXPORT
528 ViewShape *getOccludeeF0D(Interface0DIterator& it);
529
530 } // end of namespace Functions0D
531
532 #endif // __FREESTYLE_FUNCTIONS_0D_H__