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