source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.cpp @ 3036

#include "RenderState.h"
#include "Geometry.h"
#include "Material.h"
#include "ShaderProgram.h"
#include "Texture.h"

using namespace std;

namespace CHCDemoEngine 
{

CGprofile RenderState::sCgFragmentProfile;
CGprofile RenderState::sCgVertexProfile; 

ShaderProgram *RenderState::sCgMrtFragmentProgram = NULL;
ShaderProgram *RenderState::sCgMrtFragmentTexProgram = NULL;
ShaderProgram *RenderState::sCgMrtVertexProgram = NULL;


int RenderState::sTexParam;



/////////////////

RenderState::RenderState():
mRenderType(FIXED),
mUseAlphaToCoverage(true),
mLockCullFaceEnabled(false)
{
        Reset(); 
}

        
bool RenderState::SetMode(Mode mode)
{
        ///////////
        //-- just change the modewhen necessary

        if (mode == mMode) return false;

        mMode = mode;

        if (mode == QUERY)
        {
                if (mRenderType != DEPTH_PASS)
                {
                        glDisable(GL_LIGHTING);
                        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

                        if (mRenderType == DEFERRED)
                        {
                                cgGLDisableProfile(sCgFragmentProfile);
                                cgGLDisableProfile(sCgVertexProfile);
                        }
                }

                glDepthMask(GL_FALSE);

                static Material defaultMat;
                SetState(&defaultMat);
        }
        else // mode returns to render
        {
                /////////////
                //-- restore render state

                if (mRenderType != DEPTH_PASS)
                {
                        glEnable(GL_LIGHTING);
                        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

                        if (mRenderType == DEFERRED)
                        {
                                cgGLEnableProfile(sCgFragmentProfile);
                                cgGLEnableProfile(sCgVertexProfile);
                        }
                }

                glDepthMask(GL_TRUE);
        }

        return true;
}

        
void RenderState::SetState(Material *mat)
{
        Texture *tex = mat->GetTexture();

        const bool texturing = (tex != NULL);

        bool alphaTest = mat->IsAlphaTestEnabled();
        bool cullFace = mat->IsCullFaceEnabled();

        if (!mLockCullFaceEnabled)
        {
                if (mCullFaceEnabled && !cullFace) 
                {
                        mCullFaceEnabled = false;
                        glDisable(GL_CULL_FACE);
                }
                else if (!mCullFaceEnabled && cullFace)
                {
                        mCullFaceEnabled = true;
                        glEnable(GL_CULL_FACE);
                }
        }
        if (mAlphaTestEnabled && !alphaTest) 
        {
                mAlphaTestEnabled = false;
                
                if (mUseAlphaToCoverage)
                        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
                else
                        glDisable(GL_ALPHA_TEST);
        }
        else if (!mAlphaTestEnabled && alphaTest)
        {
                mAlphaTestEnabled = true;
                
                if (mUseAlphaToCoverage)
                        glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
                else
                        glEnable(GL_ALPHA_TEST);
        }

        if (mTexturesEnabled && 
                (!texturing || (mRenderType == DEPTH_PASS) && !mAlphaTestEnabled))
        {
                mTexturesEnabled = false;

                if (mRenderType != DEFERRED)//!mat->mFragmentProgram)
                        glDisable(GL_TEXTURE_2D);

                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }
        else if (!mTexturesEnabled && texturing)
        {
                // support only alpha textures in depth pass
                if ((mRenderType != DEPTH_PASS) || mAlphaTestEnabled)
                {
                        mTexturesEnabled = true;

                        if (mRenderType != DEFERRED)//!mat->mFragmentProgram)
                                glEnable(GL_TEXTURE_2D);

                        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                }
        }

        if (mRenderType == DEFERRED)
        {
                if (mat->GetFragmentProgram() && (mat->GetFragmentProgram() != mCurrentFragmentProgram))
                {
                        mCurrentFragmentProgram = mat->GetFragmentProgram();
                        mCurrentFragmentProgram->Bind();
                }
        
                if (mat->GetVertexProgram() && (mat->GetVertexProgram() != mCurrentVertexProgram))
                {
                        mCurrentVertexProgram = mat->GetVertexProgram();
                        mCurrentVertexProgram->Bind();
                }
        }
        else
        {
                // set fixed texture
                if (tex)
                {
                        if (mCurrentTexId != tex->GetId())
                        {
                                tex->Bind();
                                mCurrentTexId = tex->GetId();
                        }
                }
                else
                {
                        mCurrentTexId = 0;
                        glBindTexture(GL_TEXTURE_2D, 0);
                }
        }
}


void RenderState::Reset()
{
        SetMode(RENDER);

        mCurrentVboId = -1;
        mCurrentTexId = 0;

        mCullFaceEnabled = true;
        mAlphaTestEnabled = false;
        mTexturesEnabled = false;

        mCurrentVertexProgram = NULL;
        mCurrentFragmentProgram = NULL;

        glEnable(GL_CULL_FACE);

        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
        glDisable(GL_ALPHA_TEST);

        glDisable(GL_TEXTURE_2D);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}


void RenderState::SetUseAlphaToCoverage(bool useAlphaToCoverage)
{
        mUseAlphaToCoverage = useAlphaToCoverage;
}


void RenderState::SetRenderPassType(RenderPassType t) 
{ 
        mRenderType = t; 
}


RenderState::RenderPassType RenderState::GetRenderPassType() const 
{
        return mRenderType; 
}


void RenderState::LockCullFaceEnabled(bool lockCull)
{ 
        mLockCullFaceEnabled =  lockCull; 
}


}