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