e10d006994fe93954b91491ff4721aa183eb183a
[blender.git] / source / gameengine / Rasterizer / RAS_OpenGLRasterizer / RAS_OpenGLRasterizer.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) 2001-2002 by NaN Holding BV.
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 /** \file RAS_OpenGLRasterizer.h
29  *  \ingroup bgerastogl
30  */
31
32 #ifndef __RAS_OPENGLRASTERIZER_H__
33 #define __RAS_OPENGLRASTERIZER_H__
34
35 #if defined(WIN32) && !defined(FREE_WINDOWS)
36 #pragma warning (disable:4786)
37 #endif
38
39 #include "MT_CmMatrix4x4.h"
40 #include <vector>
41 using namespace std;
42
43 #include "RAS_IRasterizer.h"
44 #include "RAS_MaterialBucket.h"
45 #include "RAS_ICanvas.h"
46
47 #define RAS_MAX_TEXCO   8       // match in BL_Material
48 #define RAS_MAX_ATTRIB  16      // match in BL_BlenderShader
49
50 struct  OglDebugShape
51 {
52         enum SHAPE_TYPE{
53                 LINE, CIRCLE
54         };
55         SHAPE_TYPE  m_type;
56         MT_Vector3      m_pos;
57         MT_Vector3      m_param;
58         MT_Vector3      m_param2;
59         MT_Vector3      m_color;
60 };
61
62 /**
63  * 3D rendering device context.
64  */
65 class RAS_OpenGLRasterizer : public RAS_IRasterizer
66 {
67
68         RAS_ICanvas*    m_2DCanvas;
69         
70         // fogging vars
71         bool                    m_fogenabled;
72         float                   m_fogstart;
73         float                   m_fogdist;
74         float                   m_fogr;
75         float                   m_fogg;
76         float                   m_fogb;
77         
78         float                   m_redback;
79         float                   m_greenback;
80         float                   m_blueback;
81         float                   m_alphaback;
82         
83         float                   m_ambr;
84         float                   m_ambg;
85         float                   m_ambb;
86
87         double                  m_time;
88         MT_Matrix4x4    m_viewmatrix;
89         MT_Matrix4x4    m_viewinvmatrix;
90         MT_Point3               m_campos;
91         bool                    m_camortho;
92
93         StereoMode              m_stereomode;
94         StereoEye               m_curreye;
95         float                   m_eyeseparation;
96         float                   m_focallength;
97         bool                    m_setfocallength;
98         int                             m_noOfScanlines;
99
100         short                   m_prevafvalue;
101
102         //motion blur
103         int     m_motionblur;
104         float   m_motionblurvalue;
105
106 protected:
107         int                             m_drawingmode;
108         TexCoGen                m_texco[RAS_MAX_TEXCO];
109         TexCoGen                m_attrib[RAS_MAX_ATTRIB];
110         int                             m_texco_num;
111         int                             m_attrib_num;
112         //int                           m_last_alphablend;
113         bool                    m_last_frontface;
114
115         /** Stores the caching information for the last material activated. */
116         RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;
117
118 public:
119         double GetTime();
120         RAS_OpenGLRasterizer(RAS_ICanvas* canv);
121         virtual ~RAS_OpenGLRasterizer();
122
123         /*enum DrawType
124         {
125                         KX_BOUNDINGBOX = 1,
126                         KX_WIREFRAME,
127                         KX_SOLID,
128                         KX_SHADED,
129                         KX_TEXTURED
130         };
131
132         enum DepthMask
133         {
134                         KX_DEPTHMASK_ENABLED =1,
135                         KX_DEPTHMASK_DISABLED,
136         };*/
137         virtual void    SetDepthMask(DepthMask depthmask);
138
139         virtual bool    SetMaterial(const RAS_IPolyMaterial& mat);
140         virtual bool    Init();
141         virtual void    Exit();
142         virtual bool    BeginFrame(int drawingmode, double time);
143         virtual void    ClearColorBuffer();
144         virtual void    ClearDepthBuffer();
145         virtual void    ClearCachingInfo(void);
146         virtual void    EndFrame();
147         virtual void    SetRenderArea();
148
149         virtual void    SetStereoMode(const StereoMode stereomode);
150         virtual RAS_IRasterizer::StereoMode GetStereoMode();
151         virtual bool    Stereo();
152         virtual bool    InterlacedStereo();
153         virtual void    SetEye(const StereoEye eye);
154         virtual StereoEye       GetEye();
155         virtual void    SetEyeSeparation(const float eyeseparation);
156         virtual float   GetEyeSeparation();
157         virtual void    SetFocalLength(const float focallength);
158         virtual float   GetFocalLength();
159
160         virtual void    SwapBuffers();
161
162         virtual void    IndexPrimitives(class RAS_MeshSlot& ms);
163         virtual void    IndexPrimitivesMulti(class RAS_MeshSlot& ms);
164         virtual void    IndexPrimitives_3DText(
165                                                 class RAS_MeshSlot& ms,
166                                                 class RAS_IPolyMaterial* polymat,
167                                                 class RAS_IRenderTools* rendertools);
168
169         void                    IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi);
170
171         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat);
172         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat);
173         virtual void    SetViewMatrix(
174                                                 const MT_Matrix4x4 & mat,
175                                                 const MT_Matrix3x3 & ori,
176                                                 const MT_Point3 & pos,
177                                                 bool perspective
178                                         );
179
180         virtual const   MT_Point3& GetCameraPosition();
181         virtual bool    GetCameraOrtho();
182         
183         virtual void    SetFog(
184                                                 float start,
185                                                 float dist,
186                                                 float r,
187                                                 float g,
188                                                 float b
189                                         );
190
191         virtual void    SetFogColor(
192                                                 float r,
193                                                 float g,
194                                                 float b
195                                         );
196
197         virtual void    SetFogStart(float fogstart);
198         virtual void    SetFogEnd(float fogend);
199
200         void                    DisableFog();
201         virtual void    DisplayFog();
202         virtual bool    IsFogEnabled();
203
204         virtual void    SetBackColor(
205                                                 float red,
206                                                 float green,
207                                                 float blue,
208                                                 float alpha
209                                         );
210         
211         virtual void    SetDrawingMode(int drawingmode);
212         virtual int             GetDrawingMode();
213
214         virtual void    SetCullFace(bool enable);
215         virtual void    SetLines(bool enable);
216
217         virtual MT_Matrix4x4 GetFrustumMatrix(
218                                                         float left,
219                                                         float right,
220                                                         float bottom,
221                                                         float top,
222                                                         float frustnear,
223                                                         float frustfar,
224                                                         float focallength,
225                                                         bool perspective
226                                                 );
227
228         virtual MT_Matrix4x4 GetOrthoMatrix(
229                                                         float left,
230                                                         float right,
231                                                         float bottom,
232                                                         float top,
233                                                         float frustnear,
234                                                         float frustfar
235                                                 );
236
237         virtual void    SetSpecularity(
238                                                 float specX,
239                                                 float specY,
240                                                 float specZ,
241                                                 float specval
242                                         );
243
244         virtual void    SetShinyness(float shiny);
245         virtual void    SetDiffuse(
246                                                 float difX,
247                                                 float difY,
248                                                 float difZ,
249                                                 float diffuse
250                                         );
251         virtual void    SetEmissive(float eX,
252                                                                 float eY,
253                                                                 float eZ,
254                                                                 float e
255                                                            );
256
257         virtual void    SetAmbientColor(float red, float green, float blue);
258         virtual void    SetAmbient(float factor);
259
260         virtual void    SetPolygonOffset(float mult, float add);
261
262         virtual void    FlushDebugShapes();
263
264         virtual void DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)
265         {
266                 OglDebugShape line;
267                 line.m_type = OglDebugShape::LINE;
268                 line.m_pos= from;
269                 line.m_param = to;
270                 line.m_color = color;
271                 m_debugShapes.push_back(line);
272         }
273
274         virtual void DrawDebugCircle(const MT_Vector3& center, const MT_Scalar radius, const MT_Vector3& color,
275                                                                         const MT_Vector3& normal, int nsector)
276         {
277                 OglDebugShape line;
278                 line.m_type = OglDebugShape::CIRCLE;
279                 line.m_pos= center;
280                 line.m_param = normal;
281                 line.m_color = color;   
282                 line.m_param2.x() = radius;
283                 line.m_param2.y() = (float) nsector;
284                 m_debugShapes.push_back(line);
285         }
286
287         std::vector <OglDebugShape>     m_debugShapes;
288
289         virtual void SetTexCoordNum(int num);
290         virtual void SetAttribNum(int num);
291         virtual void SetTexCoord(TexCoGen coords, int unit);
292         virtual void SetAttrib(TexCoGen coords, int unit);
293
294         void TexCoord(const RAS_TexVert &tv);
295
296         const MT_Matrix4x4&     GetViewMatrix() const;
297         const MT_Matrix4x4&     GetViewInvMatrix() const;
298         
299         virtual void    EnableMotionBlur(float motionblurvalue);
300         virtual void    DisableMotionBlur();
301         virtual float   GetMotionBlurValue(){return m_motionblurvalue;};
302         virtual int             GetMotionBlurState(){return m_motionblur;};
303         virtual void    SetMotionBlurState(int newstate)
304         {
305                 if(newstate<0) 
306                         m_motionblur = 0;
307                 else if(newstate>2)
308                         m_motionblur = 2;
309                 else 
310                         m_motionblur = newstate;
311         };
312
313         virtual void    SetAlphaBlend(int alphablend);
314         virtual void    SetFrontFace(bool ccw);
315         
316         virtual void    SetAnisotropicFiltering(short level);
317         virtual short   GetAnisotropicFiltering();
318         
319         
320 #ifdef WITH_CXX_GUARDEDALLOC
321 public:
322         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:RAS_OpenGLRasterizer"); }
323         void operator delete( void *mem ) { MEM_freeN(mem); }
324 #endif
325 };
326
327 #endif //__RAS_OPENGLRASTERIZER_H__
328
329