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