83adcfd8321853b3c7bd7003485525c6ee5c040f
[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., 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          * ClearColorBuffer clears the color buffer.
173          */
174         virtual void    ClearColorBuffer()=0;
175         /**
176          * ClearDepthBuffer clears the depth buffer.
177          */
178         virtual void    ClearDepthBuffer()=0;
179         /**
180          * ClearCachingInfo clears the currently cached material.
181          */
182         virtual void    ClearCachingInfo(void)=0;
183         /**
184          * EndFrame is called at the end of each frame.
185          */
186         virtual void    EndFrame()=0;
187         /**
188          * SetRenderArea sets the render area from the 2d canvas.
189          * Returns true if only of subset of the canvas is used.
190          */
191         virtual void    SetRenderArea()=0;
192
193         // Stereo Functions
194         /**
195          * SetStereoMode will set the stereo mode
196          */
197         virtual void    SetStereoMode(const StereoMode stereomode)=0;
198         /**
199          * Stereo can be used to query if the rasterizer is in stereo mode.
200          * @return true if stereo mode is enabled.
201          */
202         virtual bool    Stereo()=0;
203     virtual StereoMode GetStereoMode()=0;
204         virtual bool    InterlacedStereo()=0;
205         /**
206          * Sets which eye buffer subsequent primitives will be rendered to.
207          */
208         virtual void    SetEye(const StereoEye eye)=0;
209         virtual StereoEye       GetEye()=0;
210         /**
211          * Sets the distance between eyes for stereo mode.
212          */
213         virtual void    SetEyeSeparation(const float eyeseparation)=0;
214         virtual float   GetEyeSeparation() = 0;
215         /**
216          * Sets the focal length for stereo mode.
217          */
218         virtual void    SetFocalLength(const float focallength)=0;
219         virtual float   GetFocalLength() = 0;
220         /**
221          * SwapBuffers swaps the back buffer with the front buffer.
222          */
223         virtual void    SwapBuffers()=0;
224         
225         // Drawing Functions
226         /**
227          * IndexPrimitives: Renders primitives from mesh slot.
228          */
229         virtual void IndexPrimitives(class RAS_MeshSlot& ms)=0;
230         virtual void IndexPrimitivesMulti(class RAS_MeshSlot& ms)=0;
231
232         /**
233          * IndexPrimitives_3DText will render text into the polygons.
234          * The text to be rendered is from @param rendertools client object's text property.
235          */
236         virtual void    IndexPrimitives_3DText(class RAS_MeshSlot& ms,
237                                                         class RAS_IPolyMaterial* polymat,
238                                                         class RAS_IRenderTools* rendertools)=0;
239
240         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
241         /* This one should become our final version, methinks. */
242         /**
243          * Set the projection matrix for the rasterizer. This projects
244          * from camera coordinates to window coordinates.
245          * @param mat The projection matrix.
246          */
247         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat)=0;
248         /**
249          * Sets the modelview matrix.
250          */
251         virtual void    SetViewMatrix(const MT_Matrix4x4 & mat,
252                                                 const MT_Vector3& campos,
253                                                 const MT_Point3 &camLoc,
254                                                 const MT_Quaternion &camOrientQuat)=0;
255         /**
256          */
257         virtual const   MT_Point3& GetCameraPosition()=0;
258         virtual bool    GetCameraOrtho()=0;
259
260         /**
261          */
262         virtual void    SetFog(float start,
263                                                    float dist,
264                                                    float r,
265                                                    float g,
266                                                    float b)=0;
267         
268         virtual void    SetFogColor(float r,
269                                                                 float g,
270                                                                 float b)=0;
271
272         virtual void    SetFogStart(float start)=0;
273         /**
274          */
275         virtual void    SetFogEnd(float end)=0;
276         /**
277          */
278         virtual void    DisplayFog()=0;
279         /**
280          */
281         virtual void    DisableFog()=0;
282
283         virtual void    SetBackColor(float red,
284                                                                  float green,
285                                                                  float blue,
286                                                                  float alpha)=0;
287         
288         /**
289          * @param drawingmode = KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
290          */
291         virtual void    SetDrawingMode(int drawingmode)=0;
292         /**
293          * @return the current drawing mode: KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
294          */
295         virtual int     GetDrawingMode()=0;
296         /**
297          * Sets face culling
298          */     
299         virtual void    SetCullFace(bool enable)=0;
300         /**
301          * Sets wireframe mode.
302          */
303         virtual void    SetLines(bool enable)=0;
304         /**
305          */
306         virtual double  GetTime()=0;
307         /**
308          * Generates a projection matrix from the specified frustum.
309          * @param left the left clipping plane
310          * @param right the right clipping plane
311          * @param bottom the bottom clipping plane
312          * @param top the top clipping plane
313          * @param frustnear the near clipping plane
314          * @param frustfar the far clipping plane
315          * @return a 4x4 matrix representing the projection transform.
316          */
317         virtual MT_Matrix4x4 GetFrustumMatrix(
318                 float left,
319                 float right,
320                 float bottom,
321                 float top,
322                 float frustnear,
323                 float frustfar,
324                 float focallength = 0.0f,
325                 bool perspective = true
326         )=0;
327         /**
328          * Sets the specular color component of the lighting equation.
329          */
330         virtual void    SetSpecularity(float specX,
331                                                                    float specY,
332                                                                    float specZ,
333                                                                    float specval)=0;
334         
335         /**
336          * Sets the specular exponent component of the lighting equation.
337          */
338         virtual void    SetShinyness(float shiny)=0;
339         /**
340          * Sets the diffuse color component of the lighting equation.
341          */
342         virtual void    SetDiffuse(float difX,
343                                                            float difY,
344                                                            float difZ,
345                                                            float diffuse)=0;
346         /**
347          * Sets the emissive color component of the lighting equation.
348          */ 
349         virtual void    SetEmissive(float eX,
350                                                                 float eY,
351                                                                 float eZ,
352                                                                 float e
353                                                            )=0;
354         
355         virtual void    SetAmbientColor(float red, float green, float blue)=0;
356         virtual void    SetAmbient(float factor)=0;
357
358         /**
359          * Sets a polygon offset.  z depth will be: z1 = mult*z0 + add
360          */
361         virtual void    SetPolygonOffset(float mult, float add) = 0;
362         
363         virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)=0;
364         virtual void    FlushDebugLines()=0;
365         
366
367
368         virtual void    SetTexCoordNum(int num) = 0;
369         virtual void    SetAttribNum(int num) = 0;
370         virtual void    SetTexCoord(TexCoGen coords, int unit) = 0;
371         virtual void    SetAttrib(TexCoGen coords, int unit) = 0;
372
373         virtual const MT_Matrix4x4&     GetViewMatrix() const = 0;
374         virtual const MT_Matrix4x4&     GetViewInvMatrix() const = 0;
375
376         virtual bool    QueryLists(){return false;}
377         virtual bool    QueryArrays(){return false;}
378         
379         virtual void    EnableMotionBlur(float motionblurvalue)=0;
380         virtual void    DisableMotionBlur()=0;
381         
382         virtual float   GetMotionBlurValue()=0;
383         virtual int             GetMotionBlurState()=0;
384         virtual void    SetMotionBlurState(int newstate)=0;
385
386         virtual void    SetBlendingMode(int blendmode)=0;
387         virtual void    SetFrontFace(bool ccw)=0;
388 };
389
390 #endif //__RAS_IRASTERIZER
391
392