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