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

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


using namespace std;


namespace CHCDemoEngine 
{


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

RenderState::RenderState():
mRenderTechnique(0),
mUseAlphaToCoverage(true),
mLockCullFaceEnabled(false),
mCurrentVboId(-1),
mCurrentTexId(0),
mCullFaceEnabled(true),
mAlphaTestEnabled(false),
mTexturesEnabled(false),
mCurrentVertexProgram(NULL),
mCurrentFragmentProgram(NULL),
mLightingEnabled(true),
mColorWriteEnabled(true),
mDepthWriteEnabled(true),
mCurrentTechnique(NULL)
{
        SetMode(RENDER);
        
        glEnable(GL_CULL_FACE);
        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
        glDisable(GL_ALPHA_TEST);
        glDisable(GL_TEXTURE_2D);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        glEnable(GL_LIGHTING);
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
        glDepthMask(GL_TRUE);
}


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);

        ShaderManager::GetSingleton()->DisableFragmentProfile();
        ShaderManager::GetSingleton()->DisableVertexProfile();

        mFragmentProgramEnabled = false;
        mVertexProgramEnabled = false;

        mLightingEnabled = true;
        glEnable(GL_LIGHTING);

        mColorWriteEnabled = true;
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        mDepthWriteEnabled = true;
        glDepthMask(GL_TRUE);

        mCurrentTechnique = NULL;
}


/** A special technique for occlusion queries. This material
        has color write, depth write, and lighting turned off
*/
static Technique GetQueryTechnique()
{
        Technique tech;
        tech.Init();

        tech.SetColorWriteEnabled(false);
        tech.SetLightingEnabled(false);
        tech.SetDepthWriteEnabled(false);

        return tech;
}


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

        if (mode == mMode) return false;

        mMode = mode;

        if (mode == QUERY)
        {
                /// the query box material
                static Technique queryTech = GetQueryTechnique();
                SetState(&queryTech);

                glDisableClientState(GL_NORMAL_ARRAY);
        }
        else
        {
                glEnableClientState(GL_NORMAL_ARRAY);
        }

        return true;
}

        
void RenderState::SetState(Technique *tech, SceneEntity *ent)
{
        //if (mCurrentTechnique == tech) return;
        mCurrentTechnique = tech;

        Texture * const tex = tech->GetTexture();

        const bool texturing = (tex != NULL);
        const bool alphaTest = tech->IsAlphaTestEnabled();
        const bool cullFace = tech->IsCullFaceEnabled();
        const bool lighting = tech->IsLightingEnabled();
        const bool colorWrite = tech->IsColorWriteEnabled();
        const bool depthWrite = tech->IsDepthWriteEnabled();


        if (mDepthWriteEnabled && !depthWrite) 
        {
                mDepthWriteEnabled = false;
                glDepthMask(GL_FALSE);
        }
        else if (!mDepthWriteEnabled && depthWrite)
        {
                mDepthWriteEnabled = true;
                glDepthMask(GL_TRUE);
        }

        if (mLightingEnabled && !lighting) 
        {
                mLightingEnabled = false;
                glDisable(GL_LIGHTING);
        }
        else if (!mLightingEnabled && lighting)
        {
                mLightingEnabled = true;
                glEnable(GL_LIGHTING);
        }

        if (mColorWriteEnabled && !colorWrite) 
        {
                mColorWriteEnabled = false;
                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
        }
        else if (!mColorWriteEnabled && colorWrite)
        {
                mColorWriteEnabled = true;
                glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
        }

        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)
        {
                mTexturesEnabled = false;
                glDisable(GL_TEXTURE_2D);

                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }
        else if (!mTexturesEnabled && texturing)
        {
                mTexturesEnabled = true;

                glEnable(GL_TEXTURE_2D);
                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        }


        // set texture for fixed function rendering
        if (tex)
        {
                if (mCurrentTexId != tex->GetId())
                {
                        tex->Bind();
                        mCurrentTexId = tex->GetId();
                }
        }
        else
        {
                mCurrentTexId = -1;
                glBindTexture(GL_TEXTURE_2D, 0);
        }


        //////////////////
        //-- fragment and vertex programs
        
        ShaderProgram *frag = tech->GetFragmentProgram();

        if (frag)
        {
                if (!mFragmentProgramEnabled)
                {
                        mFragmentProgramEnabled = true;
                        ShaderManager::GetSingleton()->EnableFragmentProfile();
                }

                if (frag != mCurrentFragmentProgram)
                {                       
                        mCurrentFragmentProgram = frag;
                        mCurrentFragmentProgram->Bind();                        
                }
                        
                tech->GetFragmentProgramParameters()->UpdateParameters(ent);
        }
        else
        {
                if (mFragmentProgramEnabled)
                {
                        mFragmentProgramEnabled = false;
                        ShaderManager::GetSingleton()->DisableFragmentProfile();
                }
        }

        ShaderProgram *vtx = tech->GetVertexProgram();

        if (vtx)
        {
                if (!mVertexProgramEnabled)
                {
                        mVertexProgramEnabled = true;
                        ShaderManager::GetSingleton()->EnableVertexProfile();
                }

                if (vtx != mCurrentVertexProgram)
                {
                        mCurrentVertexProgram = vtx;
                        mCurrentVertexProgram->Bind();
                }
                
                tech->GetVertexProgramParameters()->UpdateParameters(ent);
        }
        else
        {
                if (mVertexProgramEnabled)
                {
                        mVertexProgramEnabled = false;
                        ShaderManager::GetSingleton()->DisableVertexProfile();
                }
        }
}


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


void RenderState::SetRenderTechnique(int t) 
{ 
        mRenderTechnique = t; 
}


int RenderState::GetRenderTechnique() const 
{
        return mRenderTechnique; 
}


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



}