BGE: Add setMistType and setMistIntensity API.
[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 #ifdef _MSC_VER
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_IPolygonMaterial.h"
46
47 class RAS_IStorage;
48 class RAS_ICanvas;
49 class RAS_OpenGLLight;
50
51 #define RAS_MAX_TEXCO  8     /* match in BL_Material */
52 #define RAS_MAX_ATTRIB 16    /* match in BL_BlenderShader */
53
54 enum RAS_STORAGE_TYPE   {
55         RAS_AUTO_STORAGE,
56         RAS_IMMEDIATE,
57         RAS_VA,
58         RAS_VBO,
59 };
60
61 struct OglDebugShape
62 {
63         enum SHAPE_TYPE{
64                 LINE,
65                 CIRCLE,
66         };
67         SHAPE_TYPE m_type;
68         MT_Vector3 m_pos;
69         MT_Vector3 m_param;
70         MT_Vector3 m_param2;
71         MT_Vector3 m_color;
72 };
73
74 /**
75  * 3D rendering device context.
76  */
77 class RAS_OpenGLRasterizer : public RAS_IRasterizer
78 {
79         RAS_ICanvas *m_2DCanvas;
80         
81         /* fogging vars */
82         bool m_fogenabled;
83         short m_fogtype;
84         float m_fogstart;
85         float m_fogdist;
86         float m_fogintensity;
87         float m_fogr;
88         float m_fogg;
89         float m_fogb;
90         
91         float m_redback;
92         float m_greenback;
93         float m_blueback;
94         float m_alphaback;
95         
96         float m_ambr;
97         float m_ambg;
98         float m_ambb;
99         double m_time;
100         MT_Matrix4x4 m_viewmatrix;
101         MT_Matrix4x4 m_viewinvmatrix;
102         MT_Point3 m_campos;
103         bool m_camortho;
104
105         StereoMode m_stereomode;
106         StereoEye m_curreye;
107         float m_eyeseparation;
108         float m_focallength;
109         bool m_setfocallength;
110         int m_noOfScanlines;
111
112         short m_prevafvalue;
113
114         /* motion blur */
115         int m_motionblur;
116         float m_motionblurvalue;
117
118         bool m_usingoverrideshader;
119
120         /* Render tools */
121         void *m_clientobject;
122         void *m_auxilaryClientInfo;
123         std::vector<RAS_OpenGLLight *> m_lights;
124         int m_lastlightlayer;
125         bool m_lastlighting;
126         void *m_lastauxinfo;
127         unsigned int m_numgllights;
128
129 protected:
130         int m_drawingmode;
131         TexCoGen m_texco[RAS_MAX_TEXCO];
132         TexCoGen m_attrib[RAS_MAX_ATTRIB];
133         int m_attrib_layer[RAS_MAX_ATTRIB];
134         int m_texco_num;
135         int m_attrib_num;
136         /* int m_last_alphablend; */
137         bool m_last_frontface;
138
139         /* Stores the caching information for the last material activated. */
140         RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;
141
142         /* Making use of a Strategy design pattern for storage behavior.
143          * Examples of concrete strategies: Vertex Arrays, VBOs, Immediate Mode*/
144         int m_storage_type;
145         RAS_IStorage *m_storage;
146         RAS_IStorage *m_failsafe_storage; /* So derived mesh can use immediate mode */
147
148 public:
149         double GetTime();
150         RAS_OpenGLRasterizer(RAS_ICanvas *canv, int storage=RAS_AUTO_STORAGE);
151         virtual ~RAS_OpenGLRasterizer();
152
153         /*enum DrawType
154         {
155                         KX_BOUNDINGBOX = 1,
156                         KX_WIREFRAME,
157                         KX_SOLID,
158                         KX_SHADED,
159                         KX_TEXTURED
160         };
161
162         enum DepthMask
163         {
164                         KX_DEPTHMASK_ENABLED =1,
165                         KX_DEPTHMASK_DISABLED,
166         };*/
167         virtual void SetDepthMask(DepthMask depthmask);
168
169         virtual bool SetMaterial(const RAS_IPolyMaterial &mat);
170         virtual bool Init();
171         virtual void Exit();
172         virtual bool BeginFrame(double time);
173         virtual void ClearColorBuffer();
174         virtual void ClearDepthBuffer();
175         virtual void ClearCachingInfo(void);
176         virtual void EndFrame();
177         virtual void SetRenderArea();
178
179         virtual void SetStereoMode(const StereoMode stereomode);
180         virtual RAS_IRasterizer::StereoMode GetStereoMode();
181         virtual bool Stereo();
182         virtual bool InterlacedStereo();
183         virtual void SetEye(const StereoEye eye);
184         virtual StereoEye GetEye();
185         virtual void SetEyeSeparation(const float eyeseparation);
186         virtual float GetEyeSeparation();
187         virtual void SetFocalLength(const float focallength);
188         virtual float GetFocalLength();
189
190         virtual void SwapBuffers();
191
192         virtual void IndexPrimitives(class RAS_MeshSlot &ms);
193         virtual void IndexPrimitivesMulti(class RAS_MeshSlot &ms);
194         virtual void IndexPrimitives_3DText(class RAS_MeshSlot &ms, class RAS_IPolyMaterial *polymat);
195
196         virtual void SetProjectionMatrix(MT_CmMatrix4x4 &mat);
197         virtual void SetProjectionMatrix(const MT_Matrix4x4 &mat);
198         virtual void SetViewMatrix(const MT_Matrix4x4 &mat, const MT_Matrix3x3 &ori, const MT_Point3 &pos, bool perspective);
199
200         virtual const MT_Point3& GetCameraPosition();
201         virtual bool GetCameraOrtho();
202         
203         virtual void SetFog(short type, float start, float dist, float intensity, float r, float g, float b);
204         virtual void SetFogColor(float r, float g, float b);
205         virtual void SetFogStart(float fogstart);
206         virtual void SetFogEnd(float fogend);
207         virtual void EnableFog(bool enable);
208         virtual void DisplayFog();
209         virtual bool IsFogEnabled();
210
211         virtual void SetBackColor(float red, float green, float blue, float alpha);
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, float right, float bottom, float top,
221                 float frustnear, float frustfar, 
222                 float focallength, bool perspective);
223         virtual MT_Matrix4x4 GetOrthoMatrix(
224                 float left, float right, float bottom, float top,
225                 float frustnear, float frustfar);
226
227         virtual void SetSpecularity(float specX, float specY, float specZ, float specval);
228         virtual void SetShinyness(float shiny);
229         virtual void SetDiffuse(float difX, float difY, float difZ, float diffuse);
230         virtual void SetEmissive(float eX, float eY, float eZ, float e);
231
232         virtual void SetAmbientColor(float red, float green, float blue);
233         virtual void SetAmbient(float factor);
234
235         virtual void SetPolygonOffset(float mult, float add);
236
237         virtual void FlushDebugShapes();
238
239         virtual void DrawDebugLine(const MT_Vector3 &from,const MT_Vector3 &to, const MT_Vector3 &color)
240         {
241                 OglDebugShape line;
242                 line.m_type = OglDebugShape::LINE;
243                 line.m_pos= from;
244                 line.m_param = to;
245                 line.m_color = color;
246                 m_debugShapes.push_back(line);
247         }
248
249         virtual void DrawDebugCircle(const MT_Vector3 &center, const MT_Scalar radius, const MT_Vector3 &color,
250                                      const MT_Vector3 &normal, int nsector)
251         {
252                 OglDebugShape line;
253                 line.m_type = OglDebugShape::CIRCLE;
254                 line.m_pos= center;
255                 line.m_param = normal;
256                 line.m_color = color;
257                 line.m_param2.x() = radius;
258                 line.m_param2.y() = (float) nsector;
259                 m_debugShapes.push_back(line);
260         }
261
262         std::vector <OglDebugShape>     m_debugShapes;
263
264         virtual void SetTexCoordNum(int num);
265         virtual void SetAttribNum(int num);
266         virtual void SetTexCoord(TexCoGen coords, int unit);
267         virtual void SetAttrib(TexCoGen coords, int unit, int layer = 0);
268
269         void TexCoord(const RAS_TexVert &tv);
270
271         const MT_Matrix4x4 &GetViewMatrix() const;
272         const MT_Matrix4x4 &GetViewInvMatrix() const;
273         
274         virtual void EnableMotionBlur(float motionblurvalue);
275         virtual void DisableMotionBlur();
276         virtual float GetMotionBlurValue() { return m_motionblurvalue; }
277         virtual int GetMotionBlurState() { return m_motionblur; }
278         virtual void SetMotionBlurState(int newstate)
279         {
280                 if (newstate < 0)
281                         m_motionblur = 0;
282                 else if (newstate > 2)
283                         m_motionblur = 2;
284                 else 
285                         m_motionblur = newstate;
286         }
287
288         virtual void SetAlphaBlend(int alphablend);
289         virtual void SetFrontFace(bool ccw);
290         
291         virtual void SetAnisotropicFiltering(short level);
292         virtual short GetAnisotropicFiltering();
293
294         virtual void SetMipmapping(MipmapOption val);
295         virtual MipmapOption GetMipmapping();
296
297         virtual void SetUsingOverrideShader(bool val);
298         virtual bool GetUsingOverrideShader();
299
300         /**
301          * Render Tools
302          */
303         void EnableOpenGLLights();
304         void DisableOpenGLLights();
305         void ProcessLighting(bool uselights, const MT_Transform &viewmat);
306
307         void RenderBox2D(int xco, int yco, int width, int height, float percentage);
308         void RenderText3D(int fontid, const char *text, int size, int dpi,
309                           const float color[4], const double mat[16], float aspect);
310         void RenderText2D(RAS_TEXT_RENDER_MODE mode, const char *text,
311                           int xco, int yco, int width, int height);
312
313         void applyTransform(double *oglmatrix, int objectdrawmode);
314
315         void PushMatrix();
316         void PopMatrix();
317
318         bool RayHit(struct KX_ClientObjectInfo *client, class KX_RayCast *result, void * const data);
319         bool NeedRayCast(struct KX_ClientObjectInfo *) { return true; }
320
321         RAS_ILightObject* CreateLight();
322         void AddLight(RAS_ILightObject* lightobject);
323
324         void RemoveLight(RAS_ILightObject* lightobject);
325         int ApplyLights(int objectlayer, const MT_Transform& viewmat);
326
327         void MotionBlur();
328
329         void SetClientObject(void *obj);
330
331         void SetAuxilaryClientInfo(void *inf);
332
333
334 #ifdef WITH_CXX_GUARDEDALLOC
335         MEM_CXX_CLASS_ALLOC_FUNCS("GE:RAS_OpenGLRasterizer")
336 #endif
337 };
338
339 #endif  /* __RAS_OPENGLRASTERIZER_H__ */