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