6f5273f035f59bbb02aaf0f037b53a892c49816f
[blender.git] / source / gameengine / Rasterizer / RAS_IRasterizer.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file RAS_IRasterizer.h
29  *  \ingroup bgerast
30  */
31
32 #ifndef __RAS_IRASTERIZER_H__
33 #define __RAS_IRASTERIZER_H__
34
35 #ifdef _MSC_VER
36 #  pragma warning (disable:4786)
37 #endif
38
39 #include "STR_HashedString.h"
40
41 #include "MT_CmMatrix4x4.h"
42 #include "MT_Matrix4x4.h"
43
44 #include "RAS_TexVert.h"
45
46 #include <vector>
47 using namespace std;
48
49 #ifdef WITH_CXX_GUARDEDALLOC
50 #include "MEM_guardedalloc.h"
51 #endif
52
53 class RAS_ICanvas;
54 class RAS_IPolyMaterial;
55 class RAS_MeshSlot;
56 class RAS_ILightObject;
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         enum RAS_TEXT_RENDER_MODE {
70                 RAS_TEXT_RENDER_NODEF = 0,
71                 RAS_TEXT_NORMAL,
72                 RAS_TEXT_PADDED,
73                 RAS_TEXT_MAX,
74         };
75
76         RAS_IRasterizer(RAS_ICanvas* canv) {};
77         virtual ~RAS_IRasterizer() {};
78
79         /**
80          * Drawing types
81          */
82         enum DrawType {
83                 KX_BOUNDINGBOX = 1,
84                 KX_WIREFRAME,
85                 KX_SOLID,
86                 KX_SHADED,
87                 KX_TEXTURED,
88                 KX_SHADOW,
89         };
90
91         /**
92          * Drawing modes
93          */
94
95         enum DrawMode {
96                 KX_MODE_LINES = 1,
97                 KX_MODE_TRIANGLES,
98                 KX_MODE_QUADS,
99         };
100
101         /**
102          * Valid SetDepthMask parameters
103          */
104         enum DepthMask {
105                 KX_DEPTHMASK_ENABLED = 1,
106                 KX_DEPTHMASK_DISABLED,
107         };
108
109         /**
110          */
111         enum {
112                 RAS_RENDER_3DPOLYGON_TEXT = 64, /* GEMAT_TEXT */
113                 KX_BACKCULL = 16,               /* GEMAT_BACKCULL */
114                 KX_TEX = 4096,                  /* GEMAT_TEX */
115                 KX_LINES = 32768,
116         };
117
118         /**
119          * Stereo mode types
120          */
121         enum StereoMode {
122                 RAS_STEREO_NOSTEREO = 1,
123                 RAS_STEREO_QUADBUFFERED,
124                 RAS_STEREO_ABOVEBELOW,
125                 RAS_STEREO_INTERLACED,
126                 RAS_STEREO_ANAGLYPH,
127                 RAS_STEREO_SIDEBYSIDE,
128                 RAS_STEREO_VINTERLACE,
129                 RAS_STEREO_DOME,
130                 RAS_STEREO_3DTVTOPBOTTOM,
131
132                 RAS_STEREO_MAXSTEREO
133         };
134
135         /**
136          * Texture gen modes.
137          */
138         enum TexCoGen {
139                 RAS_TEXCO_GEN,      /* < GPU will generate texture coordinates */
140                 RAS_TEXCO_ORCO,     /* < Vertex coordinates (object space) */
141                 RAS_TEXCO_GLOB,     /* < Vertex coordinates (world space) */
142                 RAS_TEXCO_UV,       /* < UV coordinates */
143                 RAS_TEXCO_OBJECT,   /* < Use another object's position as coordinates */
144                 RAS_TEXCO_LAVECTOR, /* < Light vector as coordinates */
145                 RAS_TEXCO_VIEW,     /* < View vector as coordinates */
146                 RAS_TEXCO_STICKY,   /* < Sticky coordinates */
147                 RAS_TEXCO_WINDOW,   /* < Window coordinates */
148                 RAS_TEXCO_NORM,     /* < Normal coordinates */
149                 RAS_TEXTANGENT,     /* < */
150                 RAS_TEXCO_VCOL,     /* < Vertex Color */
151                 RAS_TEXCO_DISABLE,  /* < Disable this texture unit (cached) */
152         };
153
154         /**
155          * Render pass identifiers for stereo.
156          */
157         enum StereoEye {
158                 RAS_STEREO_LEFTEYE = 1,
159                 RAS_STEREO_RIGHTEYE,
160         };
161
162         /**
163          * Mipmap options
164          */
165         enum MipmapOption {
166                 RAS_MIPMAP_NONE,
167                 RAS_MIPMAP_NEAREST,
168                 RAS_MIPMAP_LINEAR,
169
170                 RAS_MIPMAP_MAX,  /* Should always be last */
171         };
172
173         /**
174          * SetDepthMask enables or disables writing a fragment's depth value
175          * to the Z buffer.
176          */
177         virtual void SetDepthMask(DepthMask depthmask) = 0;
178
179         /**
180          * SetMaterial sets the material settings for subsequent primitives
181          * to be rendered with.
182          * The material will be cached.
183          */
184         virtual bool SetMaterial(const RAS_IPolyMaterial &mat) = 0;
185
186         /**
187          * Init initializes the renderer.
188          */
189         virtual bool Init() = 0;
190
191         /**
192          * Exit cleans up the renderer.
193          */
194         virtual void Exit() = 0;
195
196         /**
197          * BeginFrame is called at the start of each frame.
198          */
199         virtual bool BeginFrame(double time) = 0;
200
201         /**
202          * ClearColorBuffer clears the color buffer.
203          */
204         virtual void ClearColorBuffer() = 0;
205
206         /**
207          * ClearDepthBuffer clears the depth buffer.
208          */
209         virtual void ClearDepthBuffer() = 0;
210
211         /**
212          * ClearCachingInfo clears the currently cached material.
213          */
214         virtual void ClearCachingInfo(void) = 0;
215
216         /**
217          * EndFrame is called at the end of each frame.
218          */
219         virtual void EndFrame() = 0;
220
221         /**
222          * SetRenderArea sets the render area from the 2d canvas.
223          * Returns true if only of subset of the canvas is used.
224          */
225         virtual void SetRenderArea() = 0;
226
227         // Stereo Functions
228         /**
229          * SetStereoMode will set the stereo mode
230          */
231         virtual void SetStereoMode(const StereoMode stereomode) = 0;
232
233         /**
234          * Stereo can be used to query if the rasterizer is in stereo mode.
235          * \return true if stereo mode is enabled.
236          */
237         virtual bool Stereo() = 0;
238         virtual StereoMode GetStereoMode() = 0;
239         virtual bool InterlacedStereo() = 0;
240
241         /**
242          * Sets which eye buffer subsequent primitives will be rendered to.
243          */
244         virtual void SetEye(const StereoEye eye) = 0;
245         virtual StereoEye GetEye() = 0;
246
247         /**
248          * Sets the distance between eyes for stereo mode.
249          */
250         virtual void SetEyeSeparation(const float eyeseparation) = 0;
251         virtual float GetEyeSeparation() = 0;
252
253         /**
254          * Sets the focal length for stereo mode.
255          */
256         virtual void SetFocalLength(const float focallength) = 0;
257         virtual float GetFocalLength() = 0;
258
259         /**
260          * SwapBuffers swaps the back buffer with the front buffer.
261          */
262         virtual void SwapBuffers() = 0;
263         
264         // Drawing Functions
265         /**
266          * IndexPrimitives: Renders primitives from mesh slot.
267          */
268         virtual void IndexPrimitives(class RAS_MeshSlot &ms) = 0;
269         virtual void IndexPrimitivesMulti(class RAS_MeshSlot &ms) = 0;
270
271         /**
272          * IndexPrimitives_3DText will render text into the polygons.
273          */
274         virtual void IndexPrimitives_3DText(class RAS_MeshSlot &ms, class RAS_IPolyMaterial *polymat) = 0;
275  
276         virtual void SetProjectionMatrix(MT_CmMatrix4x4 &mat) = 0;
277
278         /* This one should become our final version, methinks. */
279         /**
280          * Set the projection matrix for the rasterizer. This projects
281          * from camera coordinates to window coordinates.
282          * \param mat The projection matrix.
283          */
284         virtual void SetProjectionMatrix(const MT_Matrix4x4 &mat) = 0;
285
286         /**
287          * Sets the modelview matrix.
288          */
289         virtual void SetViewMatrix(const MT_Matrix4x4 &mat, const MT_Matrix3x3 &ori,
290                                    const MT_Point3 &pos, bool perspective) = 0;
291
292         /**
293          */
294         virtual const MT_Point3& GetCameraPosition() = 0;
295         virtual bool GetCameraOrtho() = 0;
296
297         /**
298          * Fog
299          */
300         virtual void SetFog(float start, float dist, float r, float g, float b) = 0;
301         virtual void SetFogColor(float r, float g,float b) = 0;
302         virtual void SetFogStart(float start) = 0;
303         virtual void SetFogEnd(float end) = 0;
304         virtual void DisplayFog() = 0;
305         virtual void EnableFog(bool enable) = 0;
306         virtual bool IsFogEnabled() = 0;
307
308         virtual void SetBackColor(float red, float green, float blue, float alpha) = 0;
309         
310         /**
311          * \param drawingmode = KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
312          */
313         virtual void SetDrawingMode(int drawingmode) = 0;
314
315         /**
316          * \return the current drawing mode: KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
317          */
318         virtual int GetDrawingMode() = 0;
319
320         /**
321          * Sets face culling
322          */
323         virtual void SetCullFace(bool enable) = 0;
324
325         /**
326          * Sets wireframe mode.
327          */
328         virtual void SetLines(bool enable) = 0;
329
330         /**
331          */
332         virtual double GetTime() = 0;
333
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, float right, float bottom, float top,
346                 float frustnear, float frustfar,
347                 float focallength = 0.0f, bool perspective = true) = 0;
348
349         /**
350          * Generates a orthographic projection matrix from the specified frustum.
351          * \param left the left clipping plane
352          * \param right the right clipping plane
353          * \param bottom the bottom clipping plane
354          * \param top the top clipping plane
355          * \param frustnear the near clipping plane
356          * \param frustfar the far clipping plane
357          * \return a 4x4 matrix representing the projection transform.
358          */
359         virtual MT_Matrix4x4 GetOrthoMatrix(
360                 float left, float right, float bottom, float top,
361                 float frustnear, float frustfar) = 0;
362
363         /**
364          * Sets the specular color component of the lighting equation.
365          */
366         virtual void SetSpecularity(float specX, float specY, float specZ, float specval) = 0;
367         
368         /**
369          * Sets the specular exponent component of the lighting equation.
370          */
371         virtual void SetShinyness(float shiny) = 0;
372
373         /**
374          * Sets the diffuse color component of the lighting equation.
375          */
376         virtual void SetDiffuse(float difX,float difY, float difZ, float diffuse) = 0;
377
378         /**
379          * Sets the emissive color component of the lighting equation.
380          */ 
381         virtual void SetEmissive(float eX, float eY, float eZ, float e) = 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         virtual void SetTexCoordNum(int num) = 0;
397         virtual void SetAttribNum(int num) = 0;
398         virtual void SetTexCoord(TexCoGen coords, int unit) = 0;
399         virtual void SetAttrib(TexCoGen coords, int unit, int layer = 0) = 0;
400
401         virtual const MT_Matrix4x4 &GetViewMatrix() const = 0;
402         virtual const MT_Matrix4x4 &GetViewInvMatrix() const = 0;
403
404         virtual bool QueryLists() { return false; }
405         virtual bool QueryArrays() { return false; }
406         
407         virtual void EnableMotionBlur(float motionblurvalue) = 0;
408         virtual void DisableMotionBlur() = 0;
409         
410         virtual float GetMotionBlurValue() = 0;
411         virtual int GetMotionBlurState() = 0;
412         virtual void SetMotionBlurState(int newstate) = 0;
413
414         virtual void SetAlphaBlend(int alphablend) = 0;
415         virtual void SetFrontFace(bool ccw) = 0;
416
417         virtual void SetAnisotropicFiltering(short level) = 0;
418         virtual short GetAnisotropicFiltering() = 0;
419
420         virtual void SetMipmapping(MipmapOption val) = 0;
421         virtual MipmapOption GetMipmapping() = 0;
422
423         virtual void SetUsingOverrideShader(bool val) = 0;
424         virtual bool GetUsingOverrideShader() = 0;
425
426         /**
427          * Render Tools
428          */
429         virtual void applyTransform(double *oglmatrix, int drawingmode) = 0;
430
431         /**
432          * Renders 2D boxes.
433          * \param xco                   Position on the screen (origin in lower left corner).
434          * \param yco                   Position on the screen (origin in lower left corner).
435          * \param width                 Width of the canvas to draw to.
436          * \param height                Height of the canvas to draw to.
437          * \param percentage    Percentage of bar.
438          */
439         virtual void RenderBox2D(int xco, int yco, int width, int height, float percentage) = 0;
440
441         /**
442          * Renders 3D text string using BFL.
443          * \param fontid        The id of the font.
444          * \param text          The string to render.
445          * \param size          The size of the text.
446          * \param dpi           The resolution of the text.
447          * \param color         The color of the object.
448          * \param mat           The Matrix of the text object.
449          * \param aspect        A scaling factor to compensate for the size.
450          */
451         virtual void RenderText3D(
452                 int fontid, const char *text, int size, int dpi,
453                 const float color[4], const double mat[16], float aspect) = 0;
454
455         /**
456          * Renders 2D text string.
457          * \param mode      The type of text
458          * \param text          The string to render.
459          * \param xco           Position on the screen (origin in lower left corner).
460          * \param yco           Position on the screen (origin in lower left corner).
461          * \param width         Width of the canvas to draw to.
462          * \param height        Height of the canvas to draw to.
463          */
464         virtual void RenderText2D(
465                 RAS_TEXT_RENDER_MODE mode, const char *text,
466                 int xco, int yco, int width, int height) = 0;
467
468         virtual void ProcessLighting(bool uselights, const MT_Transform &trans) = 0;
469
470         virtual void PushMatrix() = 0;
471
472         virtual void PopMatrix() = 0;
473
474         virtual RAS_ILightObject *CreateLight() = 0;
475
476         virtual void AddLight(RAS_ILightObject *lightobject) = 0;
477
478         virtual void RemoveLight(RAS_ILightObject *lightobject) = 0;
479
480         virtual void MotionBlur() = 0;
481
482         virtual void SetClientObject(void *obj) = 0;
483
484         virtual void SetAuxilaryClientInfo(void *inf) = 0;
485
486 #ifdef WITH_CXX_GUARDEDALLOC
487         MEM_CXX_CLASS_ALLOC_FUNCS("GE:RAS_IRasterizer")
488 #endif
489 };
490
491 #endif  /* __RAS_IRASTERIZER_H__ */