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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
  30 /** \file RAS_IRasterizer.h
  31  *  \ingroup bgerast
  32  */
  33
  34 #ifndef __RAS_IRASTERIZER
  35 #define __RAS_IRASTERIZER
  36
  37 #if defined(WIN32) && !defined(FREE_WINDOWS)
  38 #pragma warning (disable:4786)
  39 #endif
  40
  41 #include "STR_HashedString.h"
  42
  43 #include "MT_CmMatrix4x4.h"
  44 #include "MT_Matrix4x4.h"
  45
  46 #include "RAS_TexVert.h"
  47
  48 #include <vector>
  49 using namespace std;
  50
  51 #ifdef WITH_CXX_GUARDEDALLOC
  52 #include "MEM_guardedalloc.h"
  53 #endif
  54
  55 class RAS_ICanvas;
  56 class RAS_IPolyMaterial;
  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         RAS_IRasterizer(RAS_ICanvas* canv){};
  70         virtual ~RAS_IRasterizer(){};
  71         /**
  72          */
  73         enum    {
  74                         RAS_RENDER_3DPOLYGON_TEXT = 16384       /* TF_BMFONT */
  75         };
  76         /**
  77          * Drawing types
  78          */
  79         enum DrawType {
  80                         KX_BOUNDINGBOX = 1,
  81                         KX_WIREFRAME,
  82                         KX_SOLID,
  83                         KX_SHADED,
  84                         KX_TEXTURED,
  85                         KX_SHADOW
  86         };
  87
  88         /**
  89          * Drawing modes
  90          */
  91
  92         enum DrawMode {
  93                 KX_MODE_LINES = 1,
  94                 KX_MODE_TRIANGLES,
  95                 KX_MODE_QUADS
  96         };
  97
  98         /**
  99          * Valid SetDepthMask parameters
 100          */
 101         enum DepthMask {
 102                         KX_DEPTHMASK_ENABLED =1,
 103                         KX_DEPTHMASK_DISABLED
 104         };
 105
 106         /**
 107          */
 108         enum    {
 109                         KX_TEX = 4,                     /* TF_TEX */
 110                         KX_LIGHT = 16,          /* TF_LIGHT */
 111                         KX_TWOSIDE = 512,       /* TF_TWOSIDE */
 112                         KX_LINES = 32768
 113         };
 114
 115         /**
 116          * Stereo mode types
 117          */
 118         enum StereoMode {
 119                         RAS_STEREO_NOSTEREO = 1,
 120                         RAS_STEREO_QUADBUFFERED,
 121                         RAS_STEREO_ABOVEBELOW,
 122                         RAS_STEREO_INTERLACED,
 123                         RAS_STEREO_ANAGLYPH,
 124                         RAS_STEREO_SIDEBYSIDE,
 125                         RAS_STEREO_VINTERLACE,
 126                         RAS_STEREO_DOME,
 127
 128                         RAS_STEREO_MAXSTEREO
 129         };
 130
 131         /**
 132          * Texture gen modes.
 133          */
 134         enum TexCoGen {
 135                 RAS_TEXCO_GEN,          //< GPU will generate texture coordinates
 136                 RAS_TEXCO_ORCO,         //< Vertex coordinates (object space)
 137                 RAS_TEXCO_GLOB,         //< Vertex coordinates (world space)
 138                 RAS_TEXCO_UV1,          //< UV coordinates
 139                 RAS_TEXCO_OBJECT,       //< Use another object's position as coordinates
 140                 RAS_TEXCO_LAVECTOR,     //< Light vector as coordinates
 141                 RAS_TEXCO_VIEW,         //< View vector as coordinates
 142                 RAS_TEXCO_STICKY,       //< Sticky coordinates
 143                 RAS_TEXCO_WINDOW,       //< Window coordinates
 144                 RAS_TEXCO_NORM,         //< Normal coordinates
 145                 RAS_TEXTANGENT,         //<
 146                 RAS_TEXCO_UV2,          //<
 147                 RAS_TEXCO_VCOL,         //< Vertex Color
 148                 RAS_TEXCO_DISABLE       //< Disable this texture unit (cached)
 149         };
 150
 151         /**
 152          * Render pass identifiers for stereo.
 153          */
 154         enum StereoEye {
 155                         RAS_STEREO_LEFTEYE = 1,
 156                         RAS_STEREO_RIGHTEYE
 157         };
 158
 159         /**
 160          * SetDepthMask enables or disables writing a fragment's depth value
 161          * to the Z buffer.
 162          */
 163         virtual void    SetDepthMask(DepthMask depthmask)=0;
 164         /**
 165          * SetMaterial sets the material settings for subsequent primitives
 166          * to be rendered with.
 167          * The material will be cached.
 168          */
 169         virtual bool    SetMaterial(const RAS_IPolyMaterial& mat)=0;
 170         /**
 171          * Init initialises the renderer.
 172          */
 173         virtual bool    Init()=0;
 174         /**
 175          * Exit cleans up the renderer.
 176          */
 177         virtual void    Exit()=0;
 178         /**
 179          * BeginFrame is called at the start of each frame.
 180          */
 181         virtual bool    BeginFrame(int drawingmode, double time)=0;
 182         /**
 183          * ClearColorBuffer clears the color buffer.
 184          */
 185         virtual void    ClearColorBuffer()=0;
 186         /**
 187          * ClearDepthBuffer clears the depth buffer.
 188          */
 189         virtual void    ClearDepthBuffer()=0;
 190         /**
 191          * ClearCachingInfo clears the currently cached material.
 192          */
 193         virtual void    ClearCachingInfo(void)=0;
 194         /**
 195          * EndFrame is called at the end of each frame.
 196          */
 197         virtual void    EndFrame()=0;
 198         /**
 199          * SetRenderArea sets the render area from the 2d canvas.
 200          * Returns true if only of subset of the canvas is used.
 201          */
 202         virtual void    SetRenderArea()=0;
 203
 204         // Stereo Functions
 205         /**
 206          * SetStereoMode will set the stereo mode
 207          */
 208         virtual void    SetStereoMode(const StereoMode stereomode)=0;
 209         /**
 210          * Stereo can be used to query if the rasterizer is in stereo mode.
 211          * @return true if stereo mode is enabled.
 212          */
 213         virtual bool    Stereo()=0;
 214     virtual StereoMode GetStereoMode()=0;
 215         virtual bool    InterlacedStereo()=0;
 216         /**
 217          * Sets which eye buffer subsequent primitives will be rendered to.
 218          */
 219         virtual void    SetEye(const StereoEye eye)=0;
 220         virtual StereoEye       GetEye()=0;
 221         /**
 222          * Sets the distance between eyes for stereo mode.
 223          */
 224         virtual void    SetEyeSeparation(const float eyeseparation)=0;
 225         virtual float   GetEyeSeparation() = 0;
 226         /**
 227          * Sets the focal length for stereo mode.
 228          */
 229         virtual void    SetFocalLength(const float focallength)=0;
 230         virtual float   GetFocalLength() = 0;
 231         /**
 232          * SwapBuffers swaps the back buffer with the front buffer.
 233          */
 234         virtual void    SwapBuffers()=0;
 235
 236         // Drawing Functions
 237         /**
 238          * IndexPrimitives: Renders primitives from mesh slot.
 239          */
 240         virtual void IndexPrimitives(class RAS_MeshSlot& ms)=0;
 241         virtual void IndexPrimitivesMulti(class RAS_MeshSlot& ms)=0;
 242
 243         /**
 244          * IndexPrimitives_3DText will render text into the polygons.
 245          * The text to be rendered is from @param rendertools client object's text property.
 246          */
 247         virtual void    IndexPrimitives_3DText(class RAS_MeshSlot& ms,
 248                                                         class RAS_IPolyMaterial* polymat,
 249                                                         class RAS_IRenderTools* rendertools)=0;
 250
 251         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
 252         /* This one should become our final version, methinks. */
 253         /**
 254          * Set the projection matrix for the rasterizer. This projects
 255          * from camera coordinates to window coordinates.
 256          * @param mat The projection matrix.
 257          */
 258         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat)=0;
 259         /**
 260          * Sets the modelview matrix.
 261          */
 262         virtual void    SetViewMatrix(const MT_Matrix4x4 & mat,
 263                                                                 const MT_Matrix3x3 & ori,
 264                                                                 const MT_Point3 & pos,
 265                                                                 bool perspective)=0;
 266         /**
 267          */
 268         virtual const   MT_Point3& GetCameraPosition()=0;
 269         virtual bool    GetCameraOrtho()=0;
 270
 271         /**
 272          */
 273         virtual void    SetFog(float start,
 274                                                    float dist,
 275                                                    float r,
 276                                                    float g,
 277                                                    float b)=0;
 278
 279         virtual void    SetFogColor(float r,
 280                                                                 float g,
 281                                                                 float b)=0;
 282
 283         virtual void    SetFogStart(float start)=0;
 284         /**
 285          */
 286         virtual void    SetFogEnd(float end)=0;
 287         /**
 288          */
 289         virtual void    DisplayFog()=0;
 290         /**
 291          */
 292         virtual void    DisableFog()=0;
 293         virtual bool    IsFogEnabled()=0;
 294
 295         virtual void    SetBackColor(float red,
 296                                                                  float green,
 297                                                                  float blue,
 298                                                                  float alpha)=0;
 299
 300         /**
 301          * @param drawingmode = KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
 302          */
 303         virtual void    SetDrawingMode(int drawingmode)=0;
 304         /**
 305          * @return the current drawing mode: KX_BOUNDINGBOX, KX_WIREFRAME, KX_SOLID, KX_SHADED or KX_TEXTURED.
 306          */
 307         virtual int     GetDrawingMode()=0;
 308         /**
 309          * Sets face culling
 310          */
 311         virtual void    SetCullFace(bool enable)=0;
 312         /**
 313          * Sets wireframe mode.
 314          */
 315         virtual void    SetLines(bool enable)=0;
 316         /**
 317          */
 318         virtual double  GetTime()=0;
 319         /**
 320          * Generates a projection matrix from the specified frustum.
 321          * @param left the left clipping plane
 322          * @param right the right clipping plane
 323          * @param bottom the bottom clipping plane
 324          * @param top the top clipping plane
 325          * @param frustnear the near clipping plane
 326          * @param frustfar the far clipping plane
 327          * @return a 4x4 matrix representing the projection transform.
 328          */
 329         virtual MT_Matrix4x4 GetFrustumMatrix(
 330                 float left,
 331                 float right,
 332                 float bottom,
 333                 float top,
 334                 float frustnear,
 335                 float frustfar,
 336                 float focallength = 0.0f,
 337                 bool perspective = true
 338         )=0;
 339
 340         /**
 341          * Generates a orthographic projection matrix from the specified frustum.
 342          * @param left the left clipping plane
 343          * @param right the right clipping plane
 344          * @param bottom the bottom clipping plane
 345          * @param top the top clipping plane
 346          * @param frustnear the near clipping plane
 347          * @param frustfar the far clipping plane
 348          * @return a 4x4 matrix representing the projection transform.
 349          */
 350         virtual MT_Matrix4x4 GetOrthoMatrix(
 351                 float left,
 352                 float right,
 353                 float bottom,
 354                 float top,
 355                 float frustnear,
 356                 float frustfar
 357         )=0;
 358
 359         /**
 360          * Sets the specular color component of the lighting equation.
 361          */
 362         virtual void    SetSpecularity(float specX,
 363                                                                    float specY,
 364                                                                    float specZ,
 365                                                                    float specval)=0;
 366
 367         /**
 368          * Sets the specular exponent component of the lighting equation.
 369          */
 370         virtual void    SetShinyness(float shiny)=0;
 371         /**
 372          * Sets the diffuse color component of the lighting equation.
 373          */
 374         virtual void    SetDiffuse(float difX,
 375                                                            float difY,
 376                                                            float difZ,
 377                                                            float diffuse)=0;
 378         /**
 379          * Sets the emissive color component of the lighting equation.
 380          */
 381         virtual void    SetEmissive(float eX,
 382                                                                 float eY,
 383                                                                 float eZ,
 384                                                                 float e
 385                                                            )=0;
 386
 387         virtual void    SetAmbientColor(float red, float green, float blue)=0;
 388         virtual void    SetAmbient(float factor)=0;
 389
 390         /**
 391          * Sets a polygon offset.  z depth will be: z1 = mult*z0 + add
 392          */
 393         virtual void    SetPolygonOffset(float mult, float add) = 0;
 394
 395         virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)=0;
 396         virtual void    FlushDebugLines()=0;
 397
 398
 399
 400         virtual void    SetTexCoordNum(int num) = 0;
 401         virtual void    SetAttribNum(int num) = 0;
 402         virtual void    SetTexCoord(TexCoGen coords, int unit) = 0;
 403         virtual void    SetAttrib(TexCoGen coords, int unit) = 0;
 404
 405         virtual const MT_Matrix4x4&     GetViewMatrix() const = 0;
 406         virtual const MT_Matrix4x4&     GetViewInvMatrix() const = 0;
 407
 408         virtual bool    QueryLists(){return false;}
 409         virtual bool    QueryArrays(){return false;}
 410
 411         virtual void    EnableMotionBlur(float motionblurvalue)=0;
 412         virtual void    DisableMotionBlur()=0;
 413
 414         virtual float   GetMotionBlurValue()=0;
 415         virtual int             GetMotionBlurState()=0;
 416         virtual void    SetMotionBlurState(int newstate)=0;
 417
 418         virtual void    SetBlendingMode(int blendmode)=0;
 419         virtual void    SetFrontFace(bool ccw)=0;
 420
 421
 422 #ifdef WITH_CXX_GUARDEDALLOC
 423 public:
 424         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:RAS_IRasterizer"); }
 425         void operator delete( void *mem ) { MEM_freeN(mem); }
 426 #endif
 427 };
 428
 429 #endif //__RAS_IRASTERIZER
 430
 431