update for MingW/CMake
[blender-staging.git] / source / gameengine / Rasterizer / RAS_OpenGLRasterizer / RAS_OpenGLRasterizer.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL 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.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29 #ifndef __RAS_OPENGLRASTERIZER
30 #define __RAS_OPENGLRASTERIZER
31
32 #if defined(WIN32) && !defined(FREE_WINDOWS)
33 #pragma warning (disable:4786)
34 #endif
35
36 #include "MT_CmMatrix4x4.h"
37 #include <vector>
38 using namespace std;
39
40 #include "RAS_IRasterizer.h"
41 #include "RAS_MaterialBucket.h"
42 #include "RAS_ICanvas.h"
43
44 #define RAS_MAX_TEXCO   8       // match in BL_Material
45 #define RAS_MAX_ATTRIB  16      // match in BL_BlenderShader
46
47 struct  OglDebugLine
48 {
49         MT_Vector3      m_from;
50         MT_Vector3      m_to;
51         MT_Vector3      m_color;
52 };
53
54 /**
55  * 3D rendering device context.
56  */
57 class RAS_OpenGLRasterizer : public RAS_IRasterizer
58 {
59
60         RAS_ICanvas*    m_2DCanvas;
61         
62         // fogging vars
63         bool                    m_fogenabled;
64         float                   m_fogstart;
65         float                   m_fogdist;
66         float                   m_fogr;
67         float                   m_fogg;
68         float                   m_fogb;
69         
70         float                   m_redback;
71         float                   m_greenback;
72         float                   m_blueback;
73         float                   m_alphaback;
74         
75         float                   m_ambr;
76         float                   m_ambg;
77         float                   m_ambb;
78
79         double                  m_time;
80         MT_Matrix4x4    m_viewmatrix;
81         MT_Matrix4x4    m_viewinvmatrix;
82         MT_Point3               m_campos;
83         bool                    m_camortho;
84
85         StereoMode              m_stereomode;
86         StereoEye               m_curreye;
87         float                   m_eyeseparation;
88         float                   m_focallength;
89         bool                    m_setfocallength;
90         int                             m_noOfScanlines;
91
92         //motion blur
93         int     m_motionblur;
94         float   m_motionblurvalue;
95
96 protected:
97         int                             m_drawingmode;
98         TexCoGen                m_texco[RAS_MAX_TEXCO];
99         TexCoGen                m_attrib[RAS_MAX_ATTRIB];
100         int                             m_texco_num;
101         int                             m_attrib_num;
102         //int                           m_last_blendmode;
103         bool                    m_last_frontface;
104
105         /** Stores the caching information for the last material activated. */
106         RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;
107
108 public:
109         double GetTime();
110         RAS_OpenGLRasterizer(RAS_ICanvas* canv);
111         virtual ~RAS_OpenGLRasterizer();
112
113         /*enum DrawType
114         {
115                         KX_BOUNDINGBOX = 1,
116                         KX_WIREFRAME,
117                         KX_SOLID,
118                         KX_SHADED,
119                         KX_TEXTURED
120         };
121
122         enum DepthMask
123         {
124                         KX_DEPTHMASK_ENABLED =1,
125                         KX_DEPTHMASK_DISABLED,
126         };*/
127         virtual void    SetDepthMask(DepthMask depthmask);
128
129         virtual bool    SetMaterial(const RAS_IPolyMaterial& mat);
130         virtual bool    Init();
131         virtual void    Exit();
132         virtual bool    BeginFrame(int drawingmode, double time);
133         virtual void    ClearColorBuffer();
134         virtual void    ClearDepthBuffer();
135         virtual void    ClearCachingInfo(void);
136         virtual void    EndFrame();
137         virtual void    SetRenderArea();
138
139         virtual void    SetStereoMode(const StereoMode stereomode);
140     virtual RAS_IRasterizer::StereoMode GetStereoMode();
141         virtual bool    Stereo();
142         virtual bool    InterlacedStereo();
143         virtual void    SetEye(const StereoEye eye);
144         virtual StereoEye       GetEye();
145         virtual void    SetEyeSeparation(const float eyeseparation);
146         virtual float   GetEyeSeparation();
147         virtual void    SetFocalLength(const float focallength);
148         virtual float   GetFocalLength();
149
150         virtual void    SwapBuffers();
151
152         virtual void    IndexPrimitives(class RAS_MeshSlot& ms);
153         virtual void    IndexPrimitivesMulti(class RAS_MeshSlot& ms);
154         virtual void    IndexPrimitives_3DText(
155                                                 class RAS_MeshSlot& ms,
156                                                 class RAS_IPolyMaterial* polymat,
157                                                 class RAS_IRenderTools* rendertools);
158
159         void                    IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi);
160
161         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat);
162         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat);
163         virtual void    SetViewMatrix(
164                                                 const MT_Matrix4x4 & mat,
165                                                 const MT_Matrix3x3 & ori,
166                                                 const MT_Point3 & pos,
167                                                 bool perspective
168                                         );
169
170         virtual const   MT_Point3& GetCameraPosition();
171         virtual bool    GetCameraOrtho();
172         
173         virtual void    SetFog(
174                                                 float start,
175                                                 float dist,
176                                                 float r,
177                                                 float g,
178                                                 float b
179                                         );
180
181         virtual void    SetFogColor(
182                                                 float r,
183                                                 float g,
184                                                 float b
185                                         );
186
187         virtual void    SetFogStart(float fogstart);
188         virtual void    SetFogEnd(float fogend);
189
190         void                    DisableFog();
191         virtual void    DisplayFog();
192         virtual bool    IsFogEnabled();
193
194         virtual void    SetBackColor(
195                                                 float red,
196                                                 float green,
197                                                 float blue,
198                                                 float alpha
199                                         );
200         
201         virtual void    SetDrawingMode(int drawingmode);
202         virtual int             GetDrawingMode();
203
204         virtual void    SetCullFace(bool enable);
205         virtual void    SetLines(bool enable);
206
207         virtual MT_Matrix4x4 GetFrustumMatrix(
208                                                         float left,
209                                                         float right,
210                                                         float bottom,
211                                                         float top,
212                                                         float frustnear,
213                                                         float frustfar,
214                                                         float focallength,
215                                                         bool perspective
216                                                 );
217
218         virtual MT_Matrix4x4 GetOrthoMatrix(
219                                                         float left,
220                                                         float right,
221                                                         float bottom,
222                                                         float top,
223                                                         float frustnear,
224                                                         float frustfar
225                                                 );
226
227         virtual void    SetSpecularity(
228                                                 float specX,
229                                                 float specY,
230                                                 float specZ,
231                                                 float specval
232                                         );
233
234         virtual void    SetShinyness(float shiny);
235         virtual void    SetDiffuse(
236                                                 float difX,
237                                                 float difY,
238                                                 float difZ,
239                                                 float diffuse
240                                         );
241         virtual void    SetEmissive(float eX,
242                                                                 float eY,
243                                                                 float eZ,
244                                                                 float e
245                                                            );
246
247         virtual void    SetAmbientColor(float red, float green, float blue);
248         virtual void    SetAmbient(float factor);
249
250         virtual void    SetPolygonOffset(float mult, float add);
251
252         virtual void    FlushDebugLines();
253
254         virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)
255         {
256                 OglDebugLine line;
257                 line.m_from = from;
258                 line.m_to = to;
259                 line.m_color = color;
260                 m_debugLines.push_back(line);
261         }
262
263         std::vector <OglDebugLine>      m_debugLines;
264
265         virtual void SetTexCoordNum(int num);
266         virtual void SetAttribNum(int num);
267         virtual void SetTexCoord(TexCoGen coords, int unit);
268         virtual void SetAttrib(TexCoGen coords, int unit);
269
270         void TexCoord(const RAS_TexVert &tv);
271
272         const MT_Matrix4x4&     GetViewMatrix() const;
273         const MT_Matrix4x4&     GetViewInvMatrix() const;
274         
275         virtual void    EnableMotionBlur(float motionblurvalue);
276         virtual void    DisableMotionBlur();
277         virtual float   GetMotionBlurValue(){return m_motionblurvalue;};
278         virtual int             GetMotionBlurState(){return m_motionblur;};
279         virtual void    SetMotionBlurState(int newstate)
280         {
281                 if(newstate<0) 
282                         m_motionblur = 0;
283                 else if(newstate>2)
284                         m_motionblur = 2;
285                 else 
286                         m_motionblur = newstate;
287         };
288
289         virtual void    SetBlendingMode(int blendmode);
290         virtual void    SetFrontFace(bool ccw);
291         
292         
293 #ifdef WITH_CXX_GUARDEDALLOC
294 public:
295         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:RAS_OpenGLRasterizer"); }
296         void operator delete( void *mem ) { MEM_freeN(mem); }
297 #endif
298 };
299
300 #endif //__RAS_OPENGLRASTERIZER
301
302