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