synched with trunk at revision 36569
[blender-staging.git] / source / gameengine / Rasterizer / RAS_IRasterizer.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_IRasterizer.h
31  *  \ingroup bgerast
32  */
33
34 #ifndef __RAS_IRASTERIZER
35 #define __RAS_IRASTERIZER
36
37 #if defined(WIN32) && !defined(FREE_WINDOWS)
38 #pragma warning (disable:4786)
39 #endif
40
41 #include "STR_HashedString.h"
42
43 #include "MT_CmMatrix4x4.h"
44 #include "MT_Matrix4x4.h"
45
46 #include "RAS_TexVert.h"
47
48 #include <vector>
49 using namespace std;
50
51 #ifdef WITH_CXX_GUARDEDALLOC
52 #include "MEM_guardedalloc.h"
53 #endif
54
55 class RAS_ICanvas;
56 class RAS_IPolyMaterial;
57
58 typedef vector<unsigned short> KX_IndexArray;
59 typedef vector<RAS_TexVert> KX_VertexArray;
60 typedef vector< KX_VertexArray* >  vecVertexArray;
61 typedef vector< KX_IndexArray* > vecIndexArrays;
62
63 /**
64  * 3D rendering device context interface. 
65  */
66 class RAS_IRasterizer
67 {
68 public:
69         RAS_IRasterizer(RAS_ICanvas* canv){};
70         virtual ~RAS_IRasterizer(){};
71         /**
72          */
73         enum    {
74                         RAS_RENDER_3DPOLYGON_TEXT = 16384       /* TF_BMFONT */
75         };
76         /**
77          * Drawing types
78          */
79         enum DrawType {
80                         KX_BOUNDINGBOX = 1,
81                         KX_WIREFRAME,
82                         KX_SOLID,
83                         KX_SHADED,
84                         KX_TEXTURED,
85                         KX_SHADOW
86         };
87
88         /**
89          * Drawing modes
90          */
91
92         enum DrawMode {
93                 KX_MODE_LINES = 1,
94                 KX_MODE_TRIANGLES,
95                 KX_MODE_QUADS
96         };
97
98         /**
99          * Valid SetDepthMask parameters
100          */
101         enum DepthMask {
102                         KX_DEPTHMASK_ENABLED =1,
103                         KX_DEPTHMASK_DISABLED
104         };
105
106         /**
107          */
108         enum    {        
109                         KX_TEX = 4,                     /* TF_TEX */
110                         KX_LIGHT = 16,          /* TF_LIGHT */
111                         KX_TWOSIDE = 512,       /* TF_TWOSIDE */
112                         KX_LINES = 32768         
113         };
114
115         /**
116          * Stereo mode types
117          */
118         enum StereoMode {
119                         RAS_STEREO_NOSTEREO = 1,
120                         RAS_STEREO_QUADBUFFERED,
121                         RAS_STEREO_ABOVEBELOW,
122                         RAS_STEREO_INTERLACED,
123                         RAS_STEREO_ANAGLYPH,
124                         RAS_STEREO_SIDEBYSIDE,
125                         RAS_STEREO_VINTERLACE,
126                         RAS_STEREO_DOME,
127                         
128                         RAS_STEREO_MAXSTEREO
129         };
130
131         /**
132          * Texture gen modes.
133          */
134         enum TexCoGen {
135                 RAS_TEXCO_GEN,          //< GPU will generate texture coordinates
136                 RAS_TEXCO_ORCO,         //< Vertex coordinates (object space)
137                 RAS_TEXCO_GLOB,         //< Vertex coordinates (world space)
138                 RAS_TEXCO_UV1,          //< UV coordinates
139                 RAS_TEXCO_OBJECT,       //< Use another object's position as coordinates
140                 RAS_TEXCO_LAVECTOR,     //< Light vector as coordinates
141                 RAS_TEXCO_VIEW,         //< View vector as coordinates
142                 RAS_TEXCO_STICKY,       //< Sticky coordinates
143                 RAS_TEXCO_WINDOW,       //< Window coordinates
144                 RAS_TEXCO_NORM,         //< Normal coordinates 
145                 RAS_TEXTANGENT,         //<
146                 RAS_TEXCO_UV2,          //<
147                 RAS_TEXCO_VCOL,         //< Vertex Color
148                 RAS_TEXCO_DISABLE       //< Disable this texture unit (cached)
149         };
150
151         /**
152          * Render pass identifiers for stereo.
153          */
154         enum StereoEye {
155                         RAS_STEREO_LEFTEYE = 1,
156                         RAS_STEREO_RIGHTEYE
157         };
158
159         /**
160          * SetDepthMask enables or disables writing a fragment's depth value
161          * to the Z buffer.
162          */
163         virtual void    SetDepthMask(DepthMask depthmask)=0;
164         /**
165          * SetMaterial sets the material settings for subsequent primitives
166          * to be rendered with.
167          * The material will be cached.
168          */
169         virtual bool    SetMaterial(const RAS_IPolyMaterial& mat)=0;
170         /**
171          * Init initialises the renderer.
172          */
173         virtual bool    Init()=0;
174         /**
175          * Exit cleans up the renderer.
176          */
177         virtual void    Exit()=0;
178         /**
179          * BeginFrame is called at the start of each frame.
180          */
181         virtual bool    BeginFrame(int drawingmode, double time)=0;
182         /**
183          * ClearColorBuffer clears the color buffer.
184          */
185         virtual void    ClearColorBuffer()=0;
186         /**
187          * ClearDepthBuffer clears the depth buffer.
188          */
189         virtual void    ClearDepthBuffer()=0;
190         /**
191          * ClearCachingInfo clears the currently cached material.
192          */
193         virtual void    ClearCachingInfo(void)=0;
194         /**
195          * EndFrame is called at the end of each frame.
196          */
197         virtual void    EndFrame()=0;
198         /**
199          * SetRenderArea sets the render area from the 2d canvas.
200          * Returns true if only of subset of the canvas is used.
201          */
202         virtual void    SetRenderArea()=0;
203
204         // Stereo Functions
205         /**
206          * SetStereoMode will set the stereo mode
207          */
208         virtual void    SetStereoMode(const StereoMode stereomode)=0;
209         /**
210          * Stereo can be used to query if the rasterizer is in stereo mode.
211          * @return true if stereo mode is enabled.
212          */
213         virtual bool    Stereo()=0;
214     virtual StereoMode GetStereoMode()=0;
215         virtual bool    InterlacedStereo()=0;
216         /**
217          * Sets which eye buffer subsequent primitives will be rendered to.
218          */
219         virtual void    SetEye(const StereoEye eye)=0;
220         virtual StereoEye       GetEye()=0;
221         /**
222          * Sets the distance between eyes for stereo mode.
223          */
224         virtual void    SetEyeSeparation(const float eyeseparation)=0;
225         virtual float   GetEyeSeparation() = 0;
226         /**
227          * Sets the focal length for stereo mode.
228          */
229         virtual void    SetFocalLength(const float focallength)=0;
230         virtual float   GetFocalLength() = 0;
231         /**
232          * SwapBuffers swaps the back buffer with the front buffer.
233          */
234         virtual void    SwapBuffers()=0;
235         
236         // Drawing Functions
237         /**
238          * IndexPrimitives: Renders primitives from mesh slot.
239          */
240         virtual void IndexPrimitives(class RAS_MeshSlot& ms)=0;
241         virtual void IndexPrimitivesMulti(class RAS_MeshSlot& ms)=0;
242
243         /**
244          * IndexPrimitives_3DText will render text into the polygons.
245          * The text to be rendered is from @param rendertools client object's text property.
246          */
247         virtual void    IndexPrimitives_3DText(class RAS_MeshSlot& ms,
248                                                         class RAS_IPolyMaterial* polymat,
249                                                         class RAS_IRenderTools* rendertools)=0;
250
251         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
252         /* This one should become our final version, methinks. */
253         /**
254          * Set the projection matrix for the rasterizer. This projects
255          * from camera coordinates to window coordinates.
256          * @param mat The projection matrix.
257          */
258         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat)=0;
259         /**
260          * Sets the modelview matrix.
261          */
262         virtual void    SetViewMatrix(const MT_Matrix4x4 & mat,
263                                                                 const MT_Matrix3x3 & ori,
264                                                                 const MT_Point3 & pos,
265                                                                 bool perspective)=0;
266         /**
267          */
268         virtual const   MT_Point3& GetCameraPosition()=0;
269         virtual bool    GetCameraOrtho()=0;
270
271         /**
272          */
273         virtual void    SetFog(float start,
274                                                    float dist,
275                                                    float r,
276                                                    float g,
277                                                    float b)=0;
278         
279         virtual void    SetFogColor(float r,
280                                                                 float g,
281                                                                 float b)=0;
282
283         virtual void    SetFogStart(float start)=0;
284         /**
285          */
286         virtual void    SetFogEnd(float end)=0;
287         /**
288          */
289         virtual void    DisplayFog()=0;
290         /**
291          */
292         virtual void    DisableFog()=0;
293         virtual bool    IsFogEnabled()=0;
294
295         virtual void    SetBackColor(float red,
296                                                                  float green,
297                                                                  float blue,
298                                                                  float alpha)=0;
299         
300         /**
301          * @param drawingmode = KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
302          */
303         virtual void    SetDrawingMode(int drawingmode)=0;
304         /**
305          * @return the current drawing mode: KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
306          */
307         virtual int     GetDrawingMode()=0;
308         /**
309          * Sets face culling
310          */     
311         virtual void    SetCullFace(bool enable)=0;
312         /**
313          * Sets wireframe mode.
314          */
315         virtual void    SetLines(bool enable)=0;
316         /**
317          */
318         virtual double  GetTime()=0;
319         /**
320          * Generates a projection matrix from the specified frustum.
321          * @param left the left clipping plane
322          * @param right the right clipping plane
323          * @param bottom the bottom clipping plane
324          * @param top the top clipping plane
325          * @param frustnear the near clipping plane
326          * @param frustfar the far clipping plane
327          * @return a 4x4 matrix representing the projection transform.
328          */
329         virtual MT_Matrix4x4 GetFrustumMatrix(
330                 float left,
331                 float right,
332                 float bottom,
333                 float top,
334                 float frustnear,
335                 float frustfar,
336                 float focallength = 0.0f,
337                 bool perspective = true
338         )=0;
339
340         /**
341          * Generates a orthographic projection matrix from the specified frustum.
342          * @param left the left clipping plane
343          * @param right the right clipping plane
344          * @param bottom the bottom clipping plane
345          * @param top the top clipping plane
346          * @param frustnear the near clipping plane
347          * @param frustfar the far clipping plane
348          * @return a 4x4 matrix representing the projection transform.
349          */
350         virtual MT_Matrix4x4 GetOrthoMatrix(
351                 float left,
352                 float right,
353                 float bottom,
354                 float top,
355                 float frustnear,
356                 float frustfar
357         )=0;
358
359         /**
360          * Sets the specular color component of the lighting equation.
361          */
362         virtual void    SetSpecularity(float specX,
363                                                                    float specY,
364                                                                    float specZ,
365                                                                    float specval)=0;
366         
367         /**
368          * Sets the specular exponent component of the lighting equation.
369          */
370         virtual void    SetShinyness(float shiny)=0;
371         /**
372          * Sets the diffuse color component of the lighting equation.
373          */
374         virtual void    SetDiffuse(float difX,
375                                                            float difY,
376                                                            float difZ,
377                                                            float diffuse)=0;
378         /**
379          * Sets the emissive color component of the lighting equation.
380          */ 
381         virtual void    SetEmissive(float eX,
382                                                                 float eY,
383                                                                 float eZ,
384                                                                 float e
385                                                            )=0;
386         
387         virtual void    SetAmbientColor(float red, float green, float blue)=0;
388         virtual void    SetAmbient(float factor)=0;
389
390         /**
391          * Sets a polygon offset.  z depth will be: z1 = mult*z0 + add
392          */
393         virtual void    SetPolygonOffset(float mult, float add) = 0;
394         
395         virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)=0;
396         virtual void    DrawDebugCircle(const MT_Vector3& center, const MT_Scalar radius, const MT_Vector3& color,
397                                                                         const MT_Vector3& normal, int nsector)=0;
398         virtual void    FlushDebugShapes()=0;
399         
400
401
402         virtual void    SetTexCoordNum(int num) = 0;
403         virtual void    SetAttribNum(int num) = 0;
404         virtual void    SetTexCoord(TexCoGen coords, int unit) = 0;
405         virtual void    SetAttrib(TexCoGen coords, int unit) = 0;
406
407         virtual const MT_Matrix4x4&     GetViewMatrix() const = 0;
408         virtual const MT_Matrix4x4&     GetViewInvMatrix() const = 0;
409
410         virtual bool    QueryLists(){return false;}
411         virtual bool    QueryArrays(){return false;}
412         
413         virtual void    EnableMotionBlur(float motionblurvalue)=0;
414         virtual void    DisableMotionBlur()=0;
415         
416         virtual float   GetMotionBlurValue()=0;
417         virtual int             GetMotionBlurState()=0;
418         virtual void    SetMotionBlurState(int newstate)=0;
419
420         virtual void    SetBlendingMode(int blendmode)=0;
421         virtual void    SetFrontFace(bool ccw)=0;
422         
423         
424 #ifdef WITH_CXX_GUARDEDALLOC
425 public:
426         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:RAS_IRasterizer"); }
427         void operator delete( void *mem ) { MEM_freeN(mem); }
428 #endif
429 };
430
431 #endif //__RAS_IRASTERIZER
432
433