Initial revision
[blender.git] / source / gameengine / GamePlayer / common / GPC_Canvas.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 #ifndef _GPC_CANVAS_H_
34 #define _GPC_CANVAS_H_
35
36 #include "RAS_ICanvas.h"
37 #include "RAS_Rect.h"
38
39 #if defined(WIN32) || defined(__APPLE__)
40         #ifdef WIN32
41                 #pragma warning (disable:4786) // suppress stl-MSVC debug info warning
42                 #include <windows.h>
43                 #include <GL/gl.h>
44         #else // WIN32
45                 // __APPLE__ is defined
46                 #include <AGL/gl.h>
47         #endif // WIN32
48 #else //defined(WIN32) || defined(__APPLE__)
49         #include <GL/gl.h>
50 #endif //defined(WIN32) || defined(__APPLE__)
51
52 #include <map>
53
54
55 class GPC_Canvas : public RAS_ICanvas
56 {
57 public:
58         /**
59          * Used to position banners in the canvas.
60          */
61         typedef enum {
62                 alignTopLeft,
63                 alignBottomRight
64         } TBannerAlignment;
65
66         typedef int TBannerId;
67
68 protected:
69         /** 
70          * Used to store info for banners drawn on top of the canvas.
71          */
72         typedef struct {
73                 /** Where the banner will be displayed. */
74                 TBannerAlignment alignment;
75                 /** Banner display enabled. */
76                 bool enabled;
77                 /** Banner display width. */
78                 unsigned int displayWidth;
79                 /** Banner display height. */
80                 unsigned int displayHeight;
81                 /** Banner image width. */
82                 unsigned int imageWidth;
83                 /** Banner image height. */
84                 unsigned int imageHeight;
85                 /** Banner image data. */
86                 unsigned char* imageData;
87                 /** Banner OpenGL texture name. */
88                 unsigned int textureName;
89         } TBannerData;
90         typedef std::map<TBannerId, TBannerData> TBannerMap;
91
92         /** Width of the context. */
93         int m_width;
94         /** Height of the context. */
95         int m_height;
96         /** Rect that defines the area used for rendering,
97             relative to the context */
98         RAS_Rect m_displayarea;
99
100         /** Storage for the banners to display. */
101         TBannerMap m_banners;
102         /** State of banner display. */
103         bool m_bannersEnabled;
104
105 public:
106
107         GPC_Canvas(int width, int height);
108
109         virtual ~GPC_Canvas();
110
111         void Resize(int width, int height);
112
113
114         /**
115          * @section Methods inherited from abstract base class RAS_ICanvas.
116          */
117         
118                 int 
119         GetWidth(
120         ) const {
121                 return m_width;
122         }
123         
124                 int 
125         GetHeight(
126         ) const {
127                 return m_height;
128         }
129
130         const 
131                 RAS_Rect &
132         GetDisplayArea(
133         ) const {
134                 return m_displayarea;
135         };
136
137                 RAS_Rect &
138         GetDisplayArea(
139         ) {
140                 return m_displayarea;
141         };
142
143                 void 
144         BeginFrame(
145         ) {};
146
147         /**
148          * Draws overlay banners and progress bars.
149          */
150                 void 
151         EndFrame(
152         );
153         
154         void SetViewPort(int x1, int y1, int x2, int y2);
155
156         void ClearColor(float r, float g, float b, float a);
157
158         /**
159          * @section Methods inherited from abstract base class RAS_ICanvas.
160          * Semantics are not yet honoured.
161          */
162         
163         void SetMouseState(RAS_MouseState mousestate)
164         {
165                 // not yet              
166         }
167
168         void SetMousePosition(int x, int y)
169         {
170                 // not yet
171         }
172
173         void MakeScreenShot(const char* filename)
174         {
175                 // not yet      
176         }
177
178         void ClearBuffer(int type);
179
180         /**
181          * @section Services provided by this class.
182          */
183
184         /**
185          * Enables display of a banner.
186          * The image data is copied inside.
187          * @param bannerWidth           Display width of the banner.
188          * @param bannerHeight          Display height of the banner.
189          * @param imageWidth            Width of the banner image in pixels.
190          * @param imageHeight           Height of the banner image in pixels.
191          * @param imageData                     Pointer to the pixels of the image to display.
192          * @param alignement            Where the banner will be positioned on the canvas.
193          * @param enabled                       Whether the banner will be displayed intiallly.
194          * @return A banner id.
195          */
196         TBannerId AddBanner(
197                 unsigned int bannerWidth, unsigned int bannerHeight,
198                 unsigned int imageWidth, unsigned int imageHeight,
199                 unsigned char* imageData, TBannerAlignment alignment = alignTopLeft, 
200                 bool enabled = true);
201
202         /**
203          * Disposes a banner.
204          * @param id Bannner to be disposed.
205          */
206         void DisposeBanner(TBannerId id);
207
208         /**
209          * Disposes all the banners.
210          */
211         void DisposeAllBanners();
212
213         /**
214          * Enables or disables display of a banner.
215          * @param id            Banner id of the banner to be enabled/disabled.
216          * @param enabled       New state of the banner.
217          */
218         void SetBannerEnabled(TBannerId id, bool enabled = true);
219
220         /**
221          * Enables or disables display of all banners.
222          * @param enabled       New state of the banners.
223          */
224         void SetBannerDisplayEnabled(bool enabled = true);
225
226 protected:
227         /**
228          * Disposes a banner.
229          * @param it Bannner to be disposed.
230          */
231         void DisposeBanner(TBannerData& banner);
232
233         /**
234          * Draws all the banners enabled.
235          */
236         void DrawAllBanners(void);
237
238         /**
239          * Draws a banner.
240          */
241         void DrawBanner(TBannerData& banner);
242
243         struct CanvasRenderState {
244                 int oldLighting;
245                 int oldDepthTest;
246                 int oldFog;
247                 int oldTexture2D;
248                 int oldBlend;
249                 int oldBlendSrc;
250                 int oldBlendDst;
251                 float oldColor[4];
252                 int oldWriteMask;
253         };
254
255                 void                    
256         PushRenderState(
257                 CanvasRenderState & render_state
258         );
259                 void
260         PopRenderState(
261                 const CanvasRenderState & render_state
262         );
263
264         /** 
265          * Set up an orthogonal viewing,model and texture matrix
266          * for banners and progress bars.
267          */
268                 void
269         SetOrthoProjection(
270         );
271         
272         static TBannerId s_bannerId;
273 };
274
275 #endif // _GPC_CANVAS_H_