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