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