Patch #18462: Fisheye (Dome) and Spherical Panoramic mode in BGE.
[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                         RAS_STEREO_DOME,
117                         
118                         RAS_STEREO_MAXSTEREO
119         };
120
121         /**
122          * Texture gen modes.
123          */
124         enum TexCoGen {
125                 RAS_TEXCO_GEN,          //< GPU will generate texture coordinates
126                 RAS_TEXCO_ORCO,         //< Vertex coordinates (object space)
127                 RAS_TEXCO_GLOB,         //< Vertex coordinates (world space)
128                 RAS_TEXCO_UV1,          //< UV coordinates
129                 RAS_TEXCO_OBJECT,       //< Use another object's position as coordinates
130                 RAS_TEXCO_LAVECTOR,     //< Light vector as coordinates
131                 RAS_TEXCO_VIEW,         //< View vector as coordinates
132                 RAS_TEXCO_STICKY,       //< Sticky coordinates
133                 RAS_TEXCO_WINDOW,       //< Window coordinates
134                 RAS_TEXCO_NORM,         //< Normal coordinates 
135                 RAS_TEXTANGENT,         //<
136                 RAS_TEXCO_UV2,          //<
137                 RAS_TEXCO_VCOL,         //< Vertex Color
138                 RAS_TEXCO_DISABLE       //< Disable this texture unit (cached)
139         };
140
141         /**
142          * Render pass identifiers for stereo.
143          */
144         enum StereoEye {
145                         RAS_STEREO_LEFTEYE = 1,
146                         RAS_STEREO_RIGHTEYE
147         };
148
149         /**
150          * SetDepthMask enables or disables writing a fragment's depth value
151          * to the Z buffer.
152          */
153         virtual void    SetDepthMask(DepthMask depthmask)=0;
154         /**
155          * SetMaterial sets the material settings for subsequent primitives
156          * to be rendered with.
157          * The material will be cached.
158          */
159         virtual bool    SetMaterial(const RAS_IPolyMaterial& mat)=0;
160         /**
161          * Init initialises the renderer.
162          */
163         virtual bool    Init()=0;
164         /**
165          * Exit cleans up the renderer.
166          */
167         virtual void    Exit()=0;
168         /**
169          * BeginFrame is called at the start of each frame.
170          */
171         virtual bool    BeginFrame(int drawingmode, double time)=0;
172         /**
173          * ClearColorBuffer clears the color buffer.
174          */
175         virtual void    ClearColorBuffer()=0;
176         /**
177          * ClearDepthBuffer clears the depth buffer.
178          */
179         virtual void    ClearDepthBuffer()=0;
180         /**
181          * ClearCachingInfo clears the currently cached material.
182          */
183         virtual void    ClearCachingInfo(void)=0;
184         /**
185          * EndFrame is called at the end of each frame.
186          */
187         virtual void    EndFrame()=0;
188         /**
189          * SetRenderArea sets the render area from the 2d canvas.
190          * Returns true if only of subset of the canvas is used.
191          */
192         virtual void    SetRenderArea()=0;
193
194         // Stereo Functions
195         /**
196          * SetStereoMode will set the stereo mode
197          */
198         virtual void    SetStereoMode(const StereoMode stereomode)=0;
199         /**
200          * Stereo can be used to query if the rasterizer is in stereo mode.
201          * @return true if stereo mode is enabled.
202          */
203         virtual bool    Stereo()=0;
204     virtual StereoMode GetStereoMode()=0;
205         virtual bool    InterlacedStereo()=0;
206         /**
207          * Sets which eye buffer subsequent primitives will be rendered to.
208          */
209         virtual void    SetEye(const StereoEye eye)=0;
210         virtual StereoEye       GetEye()=0;
211         /**
212          * Sets the distance between eyes for stereo mode.
213          */
214         virtual void    SetEyeSeparation(const float eyeseparation)=0;
215         virtual float   GetEyeSeparation() = 0;
216         /**
217          * Sets the focal length for stereo mode.
218          */
219         virtual void    SetFocalLength(const float focallength)=0;
220         virtual float   GetFocalLength() = 0;
221         /**
222          * SwapBuffers swaps the back buffer with the front buffer.
223          */
224         virtual void    SwapBuffers()=0;
225         
226         // Drawing Functions
227         /**
228          * IndexPrimitives: Renders primitives from mesh slot.
229          */
230         virtual void IndexPrimitives(class RAS_MeshSlot& ms)=0;
231         virtual void IndexPrimitivesMulti(class RAS_MeshSlot& ms)=0;
232
233         /**
234          * IndexPrimitives_3DText will render text into the polygons.
235          * The text to be rendered is from @param rendertools client object's text property.
236          */
237         virtual void    IndexPrimitives_3DText(class RAS_MeshSlot& ms,
238                                                         class RAS_IPolyMaterial* polymat,
239                                                         class RAS_IRenderTools* rendertools)=0;
240
241         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
242         /* This one should become our final version, methinks. */
243         /**
244          * Set the projection matrix for the rasterizer. This projects
245          * from camera coordinates to window coordinates.
246          * @param mat The projection matrix.
247          */
248         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat)=0;
249         /**
250          * Sets the modelview matrix.
251          */
252         virtual void    SetViewMatrix(const MT_Matrix4x4 & mat,
253                                                 const MT_Vector3& campos,
254                                                 const MT_Point3 &camLoc,
255                                                 const MT_Quaternion &camOrientQuat)=0;
256         /**
257          */
258         virtual const   MT_Point3& GetCameraPosition()=0;
259         virtual bool    GetCameraOrtho()=0;
260
261         /**
262          */
263         virtual void    SetFog(float start,
264                                                    float dist,
265                                                    float r,
266                                                    float g,
267                                                    float b)=0;
268         
269         virtual void    SetFogColor(float r,
270                                                                 float g,
271                                                                 float b)=0;
272
273         virtual void    SetFogStart(float start)=0;
274         /**
275          */
276         virtual void    SetFogEnd(float end)=0;
277         /**
278          */
279         virtual void    DisplayFog()=0;
280         /**
281          */
282         virtual void    DisableFog()=0;
283
284         virtual void    SetBackColor(float red,
285                                                                  float green,
286                                                                  float blue,
287                                                                  float alpha)=0;
288         
289         /**
290          * @param drawingmode = KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
291          */
292         virtual void    SetDrawingMode(int drawingmode)=0;
293         /**
294          * @return the current drawing mode: KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
295          */
296         virtual int     GetDrawingMode()=0;
297         /**
298          * Sets face culling
299          */     
300         virtual void    SetCullFace(bool enable)=0;
301         /**
302          * Sets wireframe mode.
303          */
304         virtual void    SetLines(bool enable)=0;
305         /**
306          */
307         virtual double  GetTime()=0;
308         /**
309          * Generates a projection matrix from the specified frustum.
310          * @param left the left clipping plane
311          * @param right the right clipping plane
312          * @param bottom the bottom clipping plane
313          * @param top the top clipping plane
314          * @param frustnear the near clipping plane
315          * @param frustfar the far clipping plane
316          * @return a 4x4 matrix representing the projection transform.
317          */
318         virtual MT_Matrix4x4 GetFrustumMatrix(
319                 float left,
320                 float right,
321                 float bottom,
322                 float top,
323                 float frustnear,
324                 float frustfar,
325                 float focallength = 0.0f,
326                 bool perspective = true
327         )=0;
328         /**
329          * Sets the specular color component of the lighting equation.
330          */
331         virtual void    SetSpecularity(float specX,
332                                                                    float specY,
333                                                                    float specZ,
334                                                                    float specval)=0;
335         
336         /**
337          * Sets the specular exponent component of the lighting equation.
338          */
339         virtual void    SetShinyness(float shiny)=0;
340         /**
341          * Sets the diffuse color component of the lighting equation.
342          */
343         virtual void    SetDiffuse(float difX,
344                                                            float difY,
345                                                            float difZ,
346                                                            float diffuse)=0;
347         /**
348          * Sets the emissive color component of the lighting equation.
349          */ 
350         virtual void    SetEmissive(float eX,
351                                                                 float eY,
352                                                                 float eZ,
353                                                                 float e
354                                                            )=0;
355         
356         virtual void    SetAmbientColor(float red, float green, float blue)=0;
357         virtual void    SetAmbient(float factor)=0;
358
359         /**
360          * Sets a polygon offset.  z depth will be: z1 = mult*z0 + add
361          */
362         virtual void    SetPolygonOffset(float mult, float add) = 0;
363         
364         virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)=0;
365         virtual void    FlushDebugLines()=0;
366         
367
368
369         virtual void    SetTexCoordNum(int num) = 0;
370         virtual void    SetAttribNum(int num) = 0;
371         virtual void    SetTexCoord(TexCoGen coords, int unit) = 0;
372         virtual void    SetAttrib(TexCoGen coords, int unit) = 0;
373
374         virtual const MT_Matrix4x4&     GetViewMatrix() const = 0;
375         virtual const MT_Matrix4x4&     GetViewInvMatrix() const = 0;
376
377         virtual bool    QueryLists(){return false;}
378         virtual bool    QueryArrays(){return false;}
379         
380         virtual void    EnableMotionBlur(float motionblurvalue)=0;
381         virtual void    DisableMotionBlur()=0;
382         
383         virtual float   GetMotionBlurValue()=0;
384         virtual int             GetMotionBlurState()=0;
385         virtual void    SetMotionBlurState(int newstate)=0;
386
387         virtual void    SetBlendingMode(int blendmode)=0;
388         virtual void    SetFrontFace(bool ccw)=0;
389 };
390
391 #endif //__RAS_IRASTERIZER
392
393