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__ */