source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.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 #ifndef __RAS_OPENGLRASTERIZER
  30 #define __RAS_OPENGLRASTERIZER
  31
  32 #if defined(WIN32) && !defined(FREE_WINDOWS)
  33 #pragma warning (disable:4786)
  34 #endif
  35
  36 #include "MT_CmMatrix4x4.h"
  37 #include <vector>
  38 using namespace std;
  39
  40 #include "RAS_IRasterizer.h"
  41 #include "RAS_MaterialBucket.h"
  42 #include "RAS_ICanvas.h"
  43
  44 #define RAS_MAX_TEXCO   8       // match in BL_Material
  45 #define RAS_MAX_ATTRIB  16      // match in BL_BlenderShader
  46
  47 struct  OglDebugLine
  48 {
  49         MT_Vector3      m_from;
  50         MT_Vector3      m_to;
  51         MT_Vector3      m_color;
  52 };
  53
  54 /**
  55  * 3D rendering device context.
  56  */
  57 class RAS_OpenGLRasterizer : public RAS_IRasterizer
  58 {
  59
  60         RAS_ICanvas*    m_2DCanvas;
  61
  62         // fogging vars
  63         bool                    m_fogenabled;
  64         float                   m_fogstart;
  65         float                   m_fogdist;
  66         float                   m_fogr;
  67         float                   m_fogg;
  68         float                   m_fogb;
  69
  70         float                   m_redback;
  71         float                   m_greenback;
  72         float                   m_blueback;
  73         float                   m_alphaback;
  74
  75         float                   m_ambr;
  76         float                   m_ambg;
  77         float                   m_ambb;
  78
  79         double                  m_time;
  80         MT_Matrix4x4    m_viewmatrix;
  81         MT_Matrix4x4    m_viewinvmatrix;
  82         MT_Point3               m_campos;
  83         bool                    m_camortho;
  84
  85         StereoMode              m_stereomode;
  86         StereoEye               m_curreye;
  87         float                   m_eyeseparation;
  88         float                   m_focallength;
  89         bool                    m_setfocallength;
  90         int                             m_noOfScanlines;
  91
  92         //motion blur
  93         int     m_motionblur;
  94         float   m_motionblurvalue;
  95
  96 protected:
  97         int                             m_drawingmode;
  98         TexCoGen                m_texco[RAS_MAX_TEXCO];
  99         TexCoGen                m_attrib[RAS_MAX_ATTRIB];
 100         int                             m_texco_num;
 101         int                             m_attrib_num;
 102         //int                           m_last_blendmode;
 103         bool                    m_last_frontface;
 104
 105         /** Stores the caching information for the last material activated. */
 106         RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;
 107
 108 public:
 109         double GetTime();
 110         RAS_OpenGLRasterizer(RAS_ICanvas* canv);
 111         virtual ~RAS_OpenGLRasterizer();
 112
 113         /*enum DrawType
 114         {
 115                         KX_BOUNDINGBOX = 1,
 116                         KX_WIREFRAME,
 117                         KX_SOLID,
 118                         KX_SHADED,
 119                         KX_TEXTURED
 120         };
 121
 122         enum DepthMask
 123         {
 124                         KX_DEPTHMASK_ENABLED =1,
 125                         KX_DEPTHMASK_DISABLED,
 126         };*/
 127         virtual void    SetDepthMask(DepthMask depthmask);
 128
 129         virtual bool    SetMaterial(const RAS_IPolyMaterial& mat);
 130         virtual bool    Init();
 131         virtual void    Exit();
 132         virtual bool    BeginFrame(int drawingmode, double time);
 133         virtual void    ClearColorBuffer();
 134         virtual void    ClearDepthBuffer();
 135         virtual void    ClearCachingInfo(void);
 136         virtual void    EndFrame();
 137         virtual void    SetRenderArea();
 138
 139         virtual void    SetStereoMode(const StereoMode stereomode);
 140     virtual RAS_IRasterizer::StereoMode GetStereoMode();
 141         virtual bool    Stereo();
 142         virtual bool    InterlacedStereo();
 143         virtual void    SetEye(const StereoEye eye);
 144         virtual StereoEye       GetEye();
 145         virtual void    SetEyeSeparation(const float eyeseparation);
 146         virtual float   GetEyeSeparation();
 147         virtual void    SetFocalLength(const float focallength);
 148         virtual float   GetFocalLength();
 149
 150         virtual void    SwapBuffers();
 151
 152         virtual void    IndexPrimitives(class RAS_MeshSlot& ms);
 153         virtual void    IndexPrimitivesMulti(class RAS_MeshSlot& ms);
 154         virtual void    IndexPrimitives_3DText(
 155                                                 class RAS_MeshSlot& ms,
 156                                                 class RAS_IPolyMaterial* polymat,
 157                                                 class RAS_IRenderTools* rendertools);
 158
 159         void                    IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi);
 160
 161         virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat);
 162         virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat);
 163         virtual void    SetViewMatrix(
 164                                                 const MT_Matrix4x4 & mat,
 165                                                 const MT_Matrix3x3 & ori,
 166                                                 const MT_Point3 & pos,
 167                                                 bool perspective
 168                                         );
 169
 170         virtual const   MT_Point3& GetCameraPosition();
 171         virtual bool    GetCameraOrtho();
 172
 173         virtual void    SetFog(
 174                                                 float start,
 175                                                 float dist,
 176                                                 float r,
 177                                                 float g,
 178                                                 float b
 179                                         );
 180
 181         virtual void    SetFogColor(
 182                                                 float r,
 183                                                 float g,
 184                                                 float b
 185                                         );
 186
 187         virtual void    SetFogStart(float fogstart);
 188         virtual void    SetFogEnd(float fogend);
 189
 190         void                    DisableFog();
 191         virtual void    DisplayFog();
 192         virtual bool    IsFogEnabled();
 193
 194         virtual void    SetBackColor(
 195                                                 float red,
 196                                                 float green,
 197                                                 float blue,
 198                                                 float alpha
 199                                         );
 200
 201         virtual void    SetDrawingMode(int drawingmode);
 202         virtual int             GetDrawingMode();
 203
 204         virtual void    SetCullFace(bool enable);
 205         virtual void    SetLines(bool enable);
 206
 207         virtual MT_Matrix4x4 GetFrustumMatrix(
 208                                                         float left,
 209                                                         float right,
 210                                                         float bottom,
 211                                                         float top,
 212                                                         float frustnear,
 213                                                         float frustfar,
 214                                                         float focallength,
 215                                                         bool perspective
 216                                                 );
 217
 218         virtual MT_Matrix4x4 GetOrthoMatrix(
 219                                                         float left,
 220                                                         float right,
 221                                                         float bottom,
 222                                                         float top,
 223                                                         float frustnear,
 224                                                         float frustfar
 225                                                 );
 226
 227         virtual void    SetSpecularity(
 228                                                 float specX,
 229                                                 float specY,
 230                                                 float specZ,
 231                                                 float specval
 232                                         );
 233
 234         virtual void    SetShinyness(float shiny);
 235         virtual void    SetDiffuse(
 236                                                 float difX,
 237                                                 float difY,
 238                                                 float difZ,
 239                                                 float diffuse
 240                                         );
 241         virtual void    SetEmissive(float eX,
 242                                                                 float eY,
 243                                                                 float eZ,
 244                                                                 float e
 245                                                            );
 246
 247         virtual void    SetAmbientColor(float red, float green, float blue);
 248         virtual void    SetAmbient(float factor);
 249
 250         virtual void    SetPolygonOffset(float mult, float add);
 251
 252         virtual void    FlushDebugLines();
 253
 254         virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)
 255         {
 256                 OglDebugLine line;
 257                 line.m_from = from;
 258                 line.m_to = to;
 259                 line.m_color = color;
 260                 m_debugLines.push_back(line);
 261         }
 262
 263         std::vector <OglDebugLine>      m_debugLines;
 264
 265         virtual void SetTexCoordNum(int num);
 266         virtual void SetAttribNum(int num);
 267         virtual void SetTexCoord(TexCoGen coords, int unit);
 268         virtual void SetAttrib(TexCoGen coords, int unit);
 269
 270         void TexCoord(const RAS_TexVert &tv);
 271
 272         const MT_Matrix4x4&     GetViewMatrix() const;
 273         const MT_Matrix4x4&     GetViewInvMatrix() const;
 274
 275         virtual void    EnableMotionBlur(float motionblurvalue);
 276         virtual void    DisableMotionBlur();
 277         virtual float   GetMotionBlurValue(){return m_motionblurvalue;};
 278         virtual int             GetMotionBlurState(){return m_motionblur;};
 279         virtual void    SetMotionBlurState(int newstate)
 280         {
 281                 if(newstate<0)
 282                         m_motionblur = 0;
 283                 else if(newstate>2)
 284                         m_motionblur = 2;
 285                 else
 286                         m_motionblur = newstate;
 287         };
 288
 289         virtual void    SetBlendingMode(int blendmode);
 290         virtual void    SetFrontFace(bool ccw);
 291
 292
 293 #ifdef WITH_CXX_GUARDEDALLOC
 294 public:
 295         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:RAS_OpenGLRasterizer"); }
 296         void operator delete( void *mem ) { MEM_freeN(mem); }
 297 #endif
 298 };
 299
 300 #endif //__RAS_OPENGLRASTERIZER
 301
 302