RAS_IRasterizer.h

Go to the documentation of this file.

/*
 * $Id: RAS_IRasterizer.h 35390 2011-03-07 19:14:17Z dfelinto $
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __RAS_IRASTERIZER
#define __RAS_IRASTERIZER

#if defined(WIN32) && !defined(FREE_WINDOWS)
#pragma warning (disable:4786)
#endif

#include "STR_HashedString.h"

#include "MT_CmMatrix4x4.h"
#include "MT_Matrix4x4.h"

#include "RAS_TexVert.h"

#include <vector>
using namespace std;

#ifdef WITH_CXX_GUARDEDALLOC
#include "MEM_guardedalloc.h"
#endif

class RAS_ICanvas;
class RAS_IPolyMaterial;

typedef vector<unsigned short> KX_IndexArray;
typedef vector<RAS_TexVert> KX_VertexArray;
typedef vector< KX_VertexArray* >  vecVertexArray;
typedef vector< KX_IndexArray* > vecIndexArrays;

class RAS_IRasterizer
{
public:
        RAS_IRasterizer(RAS_ICanvas* canv){};
        virtual ~RAS_IRasterizer(){};
        enum    {
                        RAS_RENDER_3DPOLYGON_TEXT = 16384       /* TF_BMFONT */
        };
        enum DrawType {
                        KX_BOUNDINGBOX = 1,
                        KX_WIREFRAME,
                        KX_SOLID,
                        KX_SHADED,
                        KX_TEXTURED,
                        KX_SHADOW
        };

        enum DrawMode {
                KX_MODE_LINES = 1,
                KX_MODE_TRIANGLES,
                KX_MODE_QUADS
        };

        enum DepthMask {
                        KX_DEPTHMASK_ENABLED =1,
                        KX_DEPTHMASK_DISABLED
        };

        enum    {        
                        KX_TEX = 4,                     /* TF_TEX */
                        KX_LIGHT = 16,          /* TF_LIGHT */
                        KX_TWOSIDE = 512,       /* TF_TWOSIDE */
                        KX_LINES = 32768         
        };

        enum StereoMode {
                        RAS_STEREO_NOSTEREO = 1,
                        RAS_STEREO_QUADBUFFERED,
                        RAS_STEREO_ABOVEBELOW,
                        RAS_STEREO_INTERLACED,
                        RAS_STEREO_ANAGLYPH,
                        RAS_STEREO_SIDEBYSIDE,
                        RAS_STEREO_VINTERLACE,
                        RAS_STEREO_DOME,
                        
                        RAS_STEREO_MAXSTEREO
        };

        enum TexCoGen {
                RAS_TEXCO_GEN,          //< GPU will generate texture coordinates
                RAS_TEXCO_ORCO,         //< Vertex coordinates (object space)
                RAS_TEXCO_GLOB,         //< Vertex coordinates (world space)
                RAS_TEXCO_UV1,          //< UV coordinates
                RAS_TEXCO_OBJECT,       //< Use another object's position as coordinates
                RAS_TEXCO_LAVECTOR,     //< Light vector as coordinates
                RAS_TEXCO_VIEW,         //< View vector as coordinates
                RAS_TEXCO_STICKY,       //< Sticky coordinates
                RAS_TEXCO_WINDOW,       //< Window coordinates
                RAS_TEXCO_NORM,         //< Normal coordinates 
                RAS_TEXTANGENT,         //<
                RAS_TEXCO_UV2,          //<
                RAS_TEXCO_VCOL,         //< Vertex Color
                RAS_TEXCO_DISABLE       //< Disable this texture unit (cached)
        };

        enum StereoEye {
                        RAS_STEREO_LEFTEYE = 1,
                        RAS_STEREO_RIGHTEYE
        };

        virtual void    SetDepthMask(DepthMask depthmask)=0;
        virtual bool    SetMaterial(const RAS_IPolyMaterial& mat)=0;
        virtual bool    Init()=0;
        virtual void    Exit()=0;
        virtual bool    BeginFrame(int drawingmode, double time)=0;
        virtual void    ClearColorBuffer()=0;
        virtual void    ClearDepthBuffer()=0;
        virtual void    ClearCachingInfo(void)=0;
        virtual void    EndFrame()=0;
        virtual void    SetRenderArea()=0;

        // Stereo Functions
        virtual void    SetStereoMode(const StereoMode stereomode)=0;
        virtual bool    Stereo()=0;
    virtual StereoMode GetStereoMode()=0;
        virtual bool    InterlacedStereo()=0;
        virtual void    SetEye(const StereoEye eye)=0;
        virtual StereoEye       GetEye()=0;
        virtual void    SetEyeSeparation(const float eyeseparation)=0;
        virtual float   GetEyeSeparation() = 0;
        virtual void    SetFocalLength(const float focallength)=0;
        virtual float   GetFocalLength() = 0;
        virtual void    SwapBuffers()=0;
        
        // Drawing Functions
        virtual void IndexPrimitives(class RAS_MeshSlot& ms)=0;
        virtual void IndexPrimitivesMulti(class RAS_MeshSlot& ms)=0;

        virtual void    IndexPrimitives_3DText(class RAS_MeshSlot& ms,
                                                        class RAS_IPolyMaterial* polymat,
                                                        class RAS_IRenderTools* rendertools)=0;

        virtual void    SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0;
        /* This one should become our final version, methinks. */
        virtual void    SetProjectionMatrix(const MT_Matrix4x4 & mat)=0;
        virtual void    SetViewMatrix(const MT_Matrix4x4 & mat,
                                                                const MT_Matrix3x3 & ori,
                                                                const MT_Point3 & pos,
                                                                bool perspective)=0;
        virtual const   MT_Point3& GetCameraPosition()=0;
        virtual bool    GetCameraOrtho()=0;

        virtual void    SetFog(float start,
                                                   float dist,
                                                   float r,
                                                   float g,
                                                   float b)=0;
        
        virtual void    SetFogColor(float r,
                                                                float g,
                                                                float b)=0;

        virtual void    SetFogStart(float start)=0;
        virtual void    SetFogEnd(float end)=0;
        virtual void    DisplayFog()=0;
        virtual void    DisableFog()=0;
        virtual bool    IsFogEnabled()=0;

        virtual void    SetBackColor(float red,
                                                                 float green,
                                                                 float blue,
                                                                 float alpha)=0;
        
        virtual void    SetDrawingMode(int drawingmode)=0;
        virtual int     GetDrawingMode()=0;
        virtual void    SetCullFace(bool enable)=0;
        virtual void    SetLines(bool enable)=0;
        virtual double  GetTime()=0;
        virtual MT_Matrix4x4 GetFrustumMatrix(
                float left,
                float right,
                float bottom,
                float top,
                float frustnear,
                float frustfar,
                float focallength = 0.0f,
                bool perspective = true
        )=0;

        virtual MT_Matrix4x4 GetOrthoMatrix(
                float left,
                float right,
                float bottom,
                float top,
                float frustnear,
                float frustfar
        )=0;

        virtual void    SetSpecularity(float specX,
                                                                   float specY,
                                                                   float specZ,
                                                                   float specval)=0;
        
        virtual void    SetShinyness(float shiny)=0;
        virtual void    SetDiffuse(float difX,
                                                           float difY,
                                                           float difZ,
                                                           float diffuse)=0;
        virtual void    SetEmissive(float eX,
                                                                float eY,
                                                                float eZ,
                                                                float e
                                                           )=0;
        
        virtual void    SetAmbientColor(float red, float green, float blue)=0;
        virtual void    SetAmbient(float factor)=0;

        virtual void    SetPolygonOffset(float mult, float add) = 0;
        
        virtual void    DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)=0;
        virtual void    FlushDebugLines()=0;
        


        virtual void    SetTexCoordNum(int num) = 0;
        virtual void    SetAttribNum(int num) = 0;
        virtual void    SetTexCoord(TexCoGen coords, int unit) = 0;
        virtual void    SetAttrib(TexCoGen coords, int unit) = 0;

        virtual const MT_Matrix4x4&     GetViewMatrix() const = 0;
        virtual const MT_Matrix4x4&     GetViewInvMatrix() const = 0;

        virtual bool    QueryLists(){return false;}
        virtual bool    QueryArrays(){return false;}
        
        virtual void    EnableMotionBlur(float motionblurvalue)=0;
        virtual void    DisableMotionBlur()=0;
        
        virtual float   GetMotionBlurValue()=0;
        virtual int             GetMotionBlurState()=0;
        virtual void    SetMotionBlurState(int newstate)=0;

        virtual void    SetBlendingMode(int blendmode)=0;
        virtual void    SetFrontFace(bool ccw)=0;
        
        
#ifdef WITH_CXX_GUARDEDALLOC
public:
        void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:RAS_IRasterizer"); }
        void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

#endif //__RAS_IRASTERIZER