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