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

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

using namespace std;

namespace CHCDemoEngine 
{

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

CGprogram RenderState::sCgMrtFragmentProgram = NULL;
CGprogram RenderState::sCgMrtFragmentTexProgram = NULL;


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

RenderState::RenderState():
mAlphaTestEnabled(false), 
mCullFaceEnabled(true), 
mTexturesEnabled(false), 
mMode(RENDER),
mRenderType(FIXED)
{
        Reset(); 
}

        
bool RenderState::SetState(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);

                SetState(false, false, false);
        }
        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(bool texturing, bool alphaTest, bool cullFace)
{
        if (mCullFaceEnabled && !cullFace) 
        {
                mCullFaceEnabled = false;
                glDisable(GL_CULL_FACE);
        }
        else if (!mCullFaceEnabled && cullFace)
        {
                mCullFaceEnabled = true;
                glEnable(GL_CULL_FACE);
        }

        if (mAlphaTestEnabled && !alphaTest) 
        {
                mAlphaTestEnabled = false;
                
                // not needed with GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
                //glDisable(GL_ALPHA_TEST);
                glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
        }
        else if (!mAlphaTestEnabled && alphaTest)
        {
                mAlphaTestEnabled = true;
                
                // not needed with GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
                //glEnable(GL_ALPHA_TEST);
                glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
        }

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

                if (mRenderType == DEFERRED)
                        cgGLBindProgram(sCgMrtFragmentProgram);

                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)
                                cgGLBindProgram(sCgMrtFragmentTexProgram);

                        glEnable(GL_TEXTURE_2D);
                        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                }
        }
}


void RenderState::Reset()
{
        mCurrentVboId = -1;

        SetState(false, false, true);
        SetState(RENDER);
}


}