patch by Charlie, related to recent changes of multi-uv/lightmap generation. This...
[blender-staging.git] / source / gameengine / Rasterizer / RAS_IRasterizer.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32 #ifndef __RAS_IRASTERIZER
33 #define __RAS_IRASTERIZER
34
35 #ifdef WIN32
36 #pragma warning (disable:4786)
37 #endif
38
39 #include "MT_CmMatrix4x4.h"
40 #include "MT_Matrix4x4.h"
41
42 class RAS_ICanvas;
43 class RAS_IPolyMaterial;
44 #include "RAS_MaterialBucket.h"
45
46 /**
47  * 3D rendering device context interface. 
48  */
49 class RAS_IRasterizer
50 {
51
52 public:
53
54         RAS_IRasterizer(RAS_ICanvas* canv){};
55         virtual ~RAS_IRasterizer(){};
56         /**
57          */
58         enum    {
59                         RAS_RENDER_3DPOLYGON_TEXT = 16384
60         };
61         /**
62          * Drawing types
63          */
64         enum DrawType {
65                         KX_BOUNDINGBOX = 1,
66                         KX_WIREFRAME,
67                         KX_SOLID,
68                         KX_SHADED,
69                         KX_TEXTURED 
70         };
71
72         /**
73          * Valid SetDepthMask parameters
74          */
75         enum DepthMask {
76                         KX_DEPTHMASK_ENABLED =1,
77                         KX_DEPTHMASK_DISABLED
78         };
79
80         /**
81          */
82         enum    {        
83                         KX_TWOSIDE = 512,        
84                         KX_LINES = 32768         
85         };
86
87         /**
88          * Stereo mode types
89          */
90         enum StereoMode {
91                         RAS_STEREO_NOSTEREO = 1,
92                         RAS_STEREO_QUADBUFFERED,
93                         RAS_STEREO_ABOVEBELOW,
94                         RAS_STEREO_INTERLACED,
95                         RAS_STEREO_ANAGLYPH,
96                         RAS_STEREO_SIDEBYSIDE,
97                         RAS_STEREO_VINTERLACE,
98                         
99                         RAS_STEREO_MAXSTEREO
100         };
101
102         /**
103          * Texture gen modes.
104          */
105         enum TexCoGen {
106                 RAS_TEXCO_GEN,          //< GPU will generate texture coordinates
107                 RAS_TEXCO_ORCO,         //< Vertex coordinates (object space)
108                 RAS_TEXCO_GLOB,         //< Vertex coordinates (world space)
109                 RAS_TEXCO_UV1,          //< UV coordinates
110                 RAS_TEXCO_OBJECT,       //< Use another object's position as coordinates
111                 RAS_TEXCO_LAVECTOR,     //< Light vector as coordinates
112                 RAS_TEXCO_VIEW,         //< View vector as coordinates
113                 RAS_TEXCO_STICKY,       //< Sticky coordinates
114                 RAS_TEXCO_WINDOW,       //< Window coordinates
115                 RAS_TEXCO_NORM,         //< Normal coordinates 
116                 RAS_TEXTANGENT,         //<
117                 RAS_TEXCO_UV2,          //<
118                 RAS_TEXCO_DISABLE       //< Disable this texture unit (cached)
119         };
120
121         /**
122          * Render pass identifiers for stereo.
123          */
124         enum StereoEye {
125                         RAS_STEREO_LEFTEYE = 1,
126                         RAS_STEREO_RIGHTEYE
127         };
128
129         /**
130          * SetDepthMask enables or disables writing a fragment's depth value
131          * to the Z buffer.
132          */
133         virtual void    SetDepthMask(DepthMask depthmask)=0;
134         /**
135          * SetMaterial sets the material settings for subsequent primitives
136          * to be rendered with.
137          * The material will be cached.
138          */
139         virtual bool    SetMaterial(const RAS_IPolyMaterial& mat)=0;
140         /**
141          * Init initialises the renderer.
142          */
143         virtual bool    Init()=0;
144         /**
145          * Exit cleans up the renderer.
146          */
147         virtual void    Exit()=0;
148         /**
149          * BeginFrame is called at the start of each frame.
150          */
151         virtual bool    BeginFrame(int drawingmode, double time)=0;
152         /**
153          * ClearDepthBuffer clears the depth buffer.
154          */
155         virtual void    ClearDepthBuffer()=0;
156         /**
157          * ClearCachingInfo clears the currently cached material.
158          */
159         virtual void    ClearCachingInfo(void)=0;
160         /**
161          * EndFrame is called at the end of each frame.
162          */
163         virtual void    EndFrame()=0;
164         /**
165          * SetRenderArea sets the render area from the 2d canvas
166          */
167         virtual void    SetRenderArea()=0;
168
169         // Stereo Functions
170         /**
171          * SetStereoMode will set the stereo mode
172          */
173         virtual void    SetStereoMode(const StereoMode stereomode)=0;
174         /**
175          * Stereo can be used to query if the rasterizer is in stereo mode.
176          * @return true if stereo mode is enabled.
177          */
178         virtual bool    Stereo()=0;
179         /**
180          * Sets which eye buffer subsequent primitives will be rendered to.
181          */
182         virtual void    SetEye(const StereoEye eye)=0;
183         virtual StereoEye       GetEye()=0;
184         /**
185          * Sets the distance between eyes for stereo mode.
186          */
187         virtual void    SetEyeSeparation(const float eyeseparation)=0;
188         virtual float   GetEyeSeparation() = 0;
189         /**
190          * Sets the focal length for stereo mode.
191          */
192         virtual void    SetFocalLength(const float focallength)=0;
193         virtual float   GetFocalLength() = 0;
194         /**
195          * SwapBuffers swaps the back buffer with the front buffer.
196          */
197         virtual void    SwapBuffers()=0;
198         
199         // Drawing Functions
200         /**
201          * IndexPrimitives: Renders primitives.
202          * @param vertexarrays is an array of vertex arrays
203          * @param indexarrays is an array of index arrays
204          * @param mode determines the type of primitive stored in the vertex/index arrays:
205          *              0 triangles
206          *              1 lines (default)
207          *              2 quads
208          * @param polymat (reserved)
209          * @param useObjectColor will render the object using @param rgbacolor instead of 
210          *  vertex colours.
211          */
212         virtual void    IndexPrimitives( const vecVertexArray& vertexarrays,
213                                                         const vecIndexArrays & indexarrays,
214                                                         int mode,
215                                                         class RAS_IPolyMaterial* polymat,
216                                                         class RAS_IRenderTools* rendertools,
217                                                         bool useObjectColor,
218                                                         const MT_Vector4& rgbacolor,
219                                                         class KX_ListSlot** slot)=0;
220         /**
221          * @copydoc IndexPrimitives
222          * IndexPrimitivesEx will renormalize faces if @param vertexarrays[i].getFlag() & TV_CALCFACENORMAL
223          */
224         virtual void    IndexPrimitives_Ex( const vecVertexArray& vertexarrays,
225                                                         const vecIndexArrays & indexarrays,
226                                                         int mode,
227                                                         class RAS_IPolyMaterial* polymat,
228                                                         class RAS_IRenderTools* rendertools,
229                                                         bool useObjectColor,
230                                                         const MT_Vector4& rgbacolor)=0;
231         /**
232          * IndexPrimitives_3DText will render text into the polygons.
233          * The text to be rendered is from @param rendertools client object's text property.
234          */
235         virtual void    IndexPrimitives_3DText( const vecVertexArray& vertexarrays,
236                                                         const vecIndexArrays & indexarrays,
237                                                         int mode,
238                                                         class RAS_IPolyMaterial* polymat,
239                                                         class RAS_IRenderTools* rendertools,
240                                                         bool useObjectColor,
241                                                         const MT_Vector4& rgbacolor)=0;
242
243         virtual void IndexPrimitivesMulti( 
244                                                 const vecVertexArray& vertexarrays,
245                                                 const vecIndexArrays & indexarrays,
246                                                 int mode,
247                                                 class RAS_IPolyMaterial* polymat,
248                                                 class RAS_IRenderTools* rendertools,
249                                                 bool useObjectColor,
250                                                 const MT_Vector4& rgbacolor,
251                                                 class KX_ListSlot** slot)=0;
252
253         virtual void IndexPrimitivesMulti_Ex( 
254                                                 const vecVertexArray& vertexarrays,
255                                                 const vecIndexArrays & indexarrays,
256                                                 int mode,
257                                                 class RAS_IPolyMaterial* polymat,
258                                                 class RAS_IRenderTools* rendertools,
259                                                 bool useObjectColor,
260                                                 const MT_Vector4& rgbacolor)=0;
261
262
263         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
264         /* This one should become our final version, methinks. */
265         /**
266          * Set the projection matrix for the rasterizer. This projects
267          * from camera coordinates to window coordinates.
268          * @param mat The projection matrix.
269          */
270         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat)=0;
271         /**
272          * Sets the modelview matrix.
273          */
274         virtual void    SetViewMatrix(const MT_Matrix4x4 & mat,
275                                                 const MT_Vector3& campos,
276                                                 const MT_Point3 &camLoc,
277                                                 const MT_Quaternion &camOrientQuat)=0;
278         /**
279          */
280         virtual const   MT_Point3& GetCameraPosition()=0;
281         /**
282          */
283         virtual void    LoadViewMatrix()=0;
284         /**
285          */
286         virtual void    SetFog(float start,
287                                                    float dist,
288                                                    float r,
289                                                    float g,
290                                                    float b)=0;
291         
292         virtual void    SetFogColor(float r,
293                                                                 float g,
294                                                                 float b)=0;
295
296         virtual void    SetFogStart(float start)=0;
297         /**
298          */
299         virtual void    SetFogEnd(float end)=0;
300         /**
301          */
302         virtual void    DisplayFog()=0;
303         /**
304          */
305         virtual void    DisableFog()=0;
306
307         virtual void    SetBackColor(float red,
308                                                                  float green,
309                                                                  float blue,
310                                                                  float alpha)=0;
311         
312         /**
313          * @param drawingmode = KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
314          */
315         virtual void    SetDrawingMode(int drawingmode)=0;
316         /**
317          * @return the current drawing mode: KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
318          */
319         virtual int     GetDrawingMode()=0;
320         /**
321          */
322         virtual void    EnableTextures(bool enable)=0;
323         /**
324          * Sets face culling
325          */     
326         virtual void    SetCullFace(bool enable)=0;
327         /**
328          * Sets wireframe mode.
329          */
330         virtual void    SetLines(bool enable)=0;
331         /**
332          */
333         virtual double  GetTime()=0;
334         /**
335          * Generates a projection matrix from the specified frustum.
336          * @param left the left clipping plane
337          * @param right the right clipping plane
338          * @param bottom the bottom clipping plane
339          * @param top the top clipping plane
340          * @param frustnear the near clipping plane
341          * @param frustfar the far clipping plane
342          * @return a 4x4 matrix representing the projection transform.
343          */
344         virtual MT_Matrix4x4 GetFrustumMatrix(
345                 float left,
346                 float right,
347                 float bottom,
348                 float top,
349                 float frustnear,
350                 float frustfar,
351                 bool perspective = true
352         )=0;
353         /**
354          * Sets the specular colour component of the lighting equation.
355          */
356         virtual void    SetSpecularity(float specX,
357                                                                    float specY,
358                                                                    float specZ,
359                                                                    float specval)=0;
360         
361         /**
362          * Sets the specular exponent component of the lighting equation.
363          */
364         virtual void    SetShinyness(float shiny)=0;
365         /**
366          * Sets the diffuse colour component of the lighting equation.
367          */
368         virtual void    SetDiffuse(float difX,
369                                                            float difY,
370                                                            float difZ,
371                                                            float diffuse)=0;
372         /**
373          * Sets the emissive colour component of the lighting equation.
374          */ 
375         virtual void    SetEmissive(float eX,
376                                                                 float eY,
377                                                                 float eZ,
378                                                                 float e
379                                                            )=0;
380         
381         virtual void    SetAmbientColor(float red, float green, float blue)=0;
382         virtual void    SetAmbient(float factor)=0;
383         /**
384          * Sets alpha testing
385          */
386         virtual void    SetAlphaTest(bool enable)=0;
387
388         /**
389          * Sets a polygon offset.  z depth will be: z1 = mult*z0 + add
390          */
391         virtual void    SetPolygonOffset(float mult, float add) = 0;
392         
393         virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)=0;
394
395         virtual void    SetTexCoords(TexCoGen coords, int unit) = 0;
396         virtual void    SetAttrib(int type) = 0;
397         virtual void    GetViewMatrix(MT_Matrix4x4 &mat) const = 0;
398
399         virtual bool    QueryLists(){return false;}
400         virtual bool    QueryArrays(){return false;}
401 };
402
403 #endif //__RAS_IRASTERIZER
404