Merged changes in the trunk up to revision 28600.
[blender.git] / source / blender / freestyle / intern / stroke / Canvas.h
1 //
2 //  Filename         : Canvas.h
3 //  Author(s)        : Stephane Grabli
4 //  Purpose          : Class to define a canvas designed to draw style modules
5 //  Date of creation : 20/10/2002
6 //
7 ///////////////////////////////////////////////////////////////////////////////
8
9
10 //
11 //  Copyright (C) : Please refer to the COPYRIGHT file distributed 
12 //   with this source distribution. 
13 //
14 //  This program is free software; you can redistribute it and/or
15 //  modify it under the terms of the GNU General Public License
16 //  as published by the Free Software Foundation; either version 2
17 //  of the License, or (at your option) any later version.
18 //
19 //  This program is distributed in the hope that it will be useful,
20 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
21 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 //  GNU General Public License for more details.
23 //
24 //  You should have received a copy of the GNU General Public License
25 //  along with this program; if not, write to the Free Software
26 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
27 //
28 ///////////////////////////////////////////////////////////////////////////////
29
30 #ifndef  CANVAS_H
31 # define CANVAS_H
32
33 # include <cstring>
34 # include <deque>
35 # include <vector>
36 # include <map>
37 # include "../system/FreestyleConfig.h"
38 # include "StrokeLayer.h"
39 # include "../geometry/BBox.h"
40 # include "../geometry/Geom.h"
41
42 using namespace Geometry;
43
44 struct ltstr
45 {
46   bool operator()(const char* s1, const char* s2) const
47   {
48     return strcmp(s1, s2) < 0;
49   }
50 };
51
52 class InformationMap;
53 class StrokeRenderer;
54 class ViewMap;
55 class ViewEdge;
56 class FEdge;
57 class RGBImage;
58 class GrayImage;
59 class QImage;
60 class ImagePyramid;
61 class SteerableViewMap;
62 class StyleModule;
63
64 /*! Class to define the canvas on which strokes are drawn.
65  *  It's used to store state information about the drawing.
66  */
67 class LIB_STROKE_EXPORT Canvas 
68 {
69 public:
70   /*! Returns a pointer on the Canvas instance */
71   static Canvas * getInstance() {return _pInstance;}
72   typedef std::map<const char*, ImagePyramid*, ltstr> mapsMap ;
73   static const int NB_STEERABLE_VIEWMAP = 5;
74 protected:
75   static Canvas *_pInstance;
76   std::deque<StrokeLayer*> _Layers;
77   std::deque<StyleModule*> _StyleModules;
78   FEdge *_SelectedFEdge;
79
80   StrokeRenderer *_Renderer;
81   StyleModule* _current_sm;
82   mapsMap _maps;
83   static const char * _MapsPath;
84   SteerableViewMap *_steerableViewMap;
85   bool _basic;
86
87 public:
88   /* Builds the Canvas */
89   Canvas();
90   /* Copy constructor */
91   Canvas(const Canvas& iBrother);
92   /* Destructor */
93   virtual ~Canvas();
94
95   /* operations that need to be done before a draw */
96   virtual void preDraw();
97
98   /* Draw the canvas using the current shader */
99   virtual void Draw();
100
101   /* operations that need to be done after a draw */
102   virtual void postDraw();
103
104   /* Renders the created strokes */
105   virtual void Render(const StrokeRenderer *iRenderer);
106   /* Basic Renders the created strokes */
107   virtual void RenderBasic(const StrokeRenderer *iRenderer);
108   /* Renders a stroke */
109   virtual void RenderStroke(Stroke *iStroke) = 0;
110   
111   /* init the canvas */
112   virtual void init() = 0;
113   
114   /* Clears the Canvas (shaders stack, layers stack...)*/
115   void Clear();
116
117   /* Erases the layers */
118   virtual void Erase(); 
119
120   /* Reads a pixel area from the canvas */
121   virtual void readColorPixels(int x, int y,int w, int h, RGBImage& oImage) const = 0;
122   /* Reads a depth pixel area from the canvas */
123   virtual void readDepthPixels(int x, int y,int w, int h, GrayImage& oImage) const = 0;
124
125   /* update the canvas (display) */
126   virtual void update() = 0;
127
128   /* checks whether the canvas is empty or not */
129   bool isEmpty() const {return (_Layers.empty());}
130
131   /* Maps management */
132   /*! Loads an image map. The map will be scaled 
133    *  (without preserving the ratio in order 
134    *  to fit the actual canvas size.)
135    *  The image must be a gray values image...
136    *  \param iFileName
137    *    The name of the image file
138    *  \param iMapName
139    *    The name that will be used to access
140    *    this image
141    *  \param iNbLevels
142    *    The number of levels in the map pyramid. (default = 4).
143    *    If iNbLevels == 0, the complete pyramid is built.
144    */
145   void loadMap(const char *iFileName, const char *iMapName, unsigned iNbLevels=4, float iSigma = 1.f);
146
147   /*! Reads a pixel value in a map.
148    *  Returns a value between 0 and 1.
149    *  \param iMapName
150    *    The name of the map
151    *  \param level
152    *    The level of the pyramid from which the pixel must 
153    *    be read.
154    *  \param x
155    *    The abscissa of the desired pixel specified in level0 coordinate 
156    *    system. The origin is the lower left corner.
157    *  \param y
158    *    The ordinate of the desired pixel specified in level0 coordinate 
159    *    system. The origin is the lower left corner.
160    */
161   float readMapPixel(const char *iMapName, int level, int x, int y);
162
163   /*! Sets the steerable viewmap */
164   void loadSteerableViewMap(SteerableViewMap * iSVM) {_steerableViewMap = iSVM;}
165
166   /*! Returns the steerable VM */
167   SteerableViewMap * getSteerableViewMap() {return _steerableViewMap;}
168   
169   /*! accessors */
170   inline const FEdge * selectedFEdge() const {return _SelectedFEdge;}
171   inline FEdge * selectedFEdge() {return _SelectedFEdge;}
172   virtual int width() const = 0;
173   virtual int height() const = 0;
174   virtual BBox<Vec3r> scene3DBBox() const = 0;
175   inline const StrokeRenderer * renderer() const {return _Renderer;}
176   inline StyleModule* getCurrentStyleModule() { return _current_sm; }
177   virtual bool getRecordFlag() const {return false;}
178         int stroke_count;
179
180   /*! modifiers */
181   inline void setSelectedFEdge(FEdge *iFEdge) {_SelectedFEdge = iFEdge;}
182   /*! inserts a shader at pos index+1 */
183   void PushBackStyleModule(StyleModule *iStyleModule);
184   void InsertStyleModule(unsigned index, StyleModule *iStyleModule);
185   void RemoveStyleModule(unsigned index);
186   void SwapStyleModules(unsigned i1, unsigned i2);
187   void ReplaceStyleModule(unsigned index, StyleModule *iStyleModule);
188   void setVisible(unsigned index, bool iVisible) ;
189   //inline void setDensityMap(InformationMap<RGBImage>* iMap) {_DensityMap = iMap;}
190   inline void AddLayer(StrokeLayer *iLayer) {_Layers.push_back(iLayer);}        
191   void resetModified(bool iMod=false);
192   void causalStyleModules(std::vector<unsigned>& vec, unsigned index = 0);
193   void setModified(unsigned index, bool b);
194 };
195
196 #endif // CANVAS_H