source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ShaderManager.cpp @ 3251

#include "Material.h"
#include "Texture.h"
#include "RenderState.h"
#include "ShaderProgram.h"
#include "ShaderManager.h"
#include "Matrix4x4.h"
#include <Cg/cg.h>
#include <Cg/cgGL.h>


#ifdef _CRT_SET
        #define _CRTDBG_MAP_ALLOC
        #include <stdlib.h>
        #include <crtdbg.h>

        // redefine new operator
        #define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
        #define new DEBUG_NEW
#endif


using namespace std;


namespace CHCDemoEngine
{


// only instance of the shader manager
ShaderManager *ShaderManager::sShaderManager = NULL;

/////////
//-- cg stuff

static CGcontext sCgContext = NULL;

static CGprofile sCgFragmentProfile;
static CGprofile sCgVertexProfile; 



static void cgErrorCallback()
{
        CGerror lastError = cgGetError();

        if (lastError)
        {
                printf("Cg error, exiting...\n");

                //Debug << "\n" << cgGetErrorString(lastError) << endl;
                //Debug << "\n" << cgGetLastListing(sCgContext) << endl;

                printf("%s\n\n", cgGetErrorString(lastError));
                printf("%s\n", cgGetLastListing(sCgContext));

                exit(0);
        }
}


ShaderManager::ShaderManager() 
{
        // setup cg
        cgSetErrorCallback(cgErrorCallback);
        // create context.
        sCgContext = cgCreateContext();
        // get the optimal fragment profile
        sCgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
        //sCgFragmentProfile = CG_PROFILE_GPU_FP;
        if (sCgFragmentProfile == CG_PROFILE_FP40)
                cout << "cg profile: fp40" << endl;
        else
                cout << "cg profile " << sCgFragmentProfile << endl;

        cgGLSetOptimalOptions(sCgFragmentProfile);
        // get the optimal vertex profile
        sCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
        cgGLSetOptimalOptions(sCgVertexProfile);

        // set textures to auto load
        cgGLSetManageTextureParameters(sCgContext, false);
        
        ///////////////
        //-- load the defaul programs for mrt (used if not defined by the user)

        ShaderProgram *vertexProgMrt, *fragmentProgMrt, *fragmentProgMrtTex;

        vertexProgMrt = CreateVertexProgram("mrt", "vtx", "defaultVertexMrt");
        fragmentProgMrt = CreateFragmentProgram("mrt", "frag", "defaultFragmentMrt");
        fragmentProgMrtTex = CreateFragmentProgram("mrt", "fragtex", "defaultFragmentTexMrt");


        // provide the current view matrix:
        // this is an automatic parameter that is updated each frame
        fragmentProgMrt->AddParameter("viewMatrix", 0);
        fragmentProgMrtTex->AddParameter("viewMatrix", 0);


        // vertex program
        vertexProgMrt->AddParameter("viewMatrix", 0);
        // needed for for ssao
        vertexProgMrt->AddParameter("modelMatrix", 1);
        vertexProgMrt->AddParameter("oldModelMatrix", 2);
        


        //////////////////////////
        //-- hack: use hardcoded tree animation (should be provided with a material script!)

        ShaderProgram *treeAnimProg, *treeAnimProgMrt;

        treeAnimProg = CreateVertexProgram("treeanimation", "animateVtx", "treeAnimation");
        treeAnimProgMrt = CreateVertexProgram("treeanimation", "animateVtxMrt", "treeAnimationMrt");

        treeAnimProg->AddParameter("timer", 0);
        treeAnimProg->AddParameter("windDir", 1);
        treeAnimProg->AddParameter("windStrength", 2);
        treeAnimProg->AddParameter("minMaxPos", 3);
        treeAnimProg->AddParameter("frequency", 4);
        treeAnimProg->AddParameter("lightDir", 5);

        treeAnimProgMrt->AddParameter("timer", 0);
        treeAnimProgMrt->AddParameter("windDir", 1);
        treeAnimProgMrt->AddParameter("windStrength", 2);
        treeAnimProgMrt->AddParameter("minMaxPos", 3);
        treeAnimProgMrt->AddParameter("frequency", 4);
        treeAnimProgMrt->AddParameter("oldTimer", 5);

        
        ShaderProgram *normalMappingVertexMrt, *normalMappingFragmentMrt;

        normalMappingVertexMrt = CreateVertexProgram("normalMapping", "vtx", "normalMappingVertexMrt");
        normalMappingFragmentMrt = CreateFragmentProgram("normalMapping", "frag", "normalMappingFragmentMrt");


        // provide the current view matrix:
        // this is an automatic parameter that is updated each frame
        normalMappingFragmentMrt->AddParameter("viewMatrix", 0);

        // vertex program
        normalMappingVertexMrt->AddParameter("viewMatrix", 0);
        // needed for for ssao
        normalMappingVertexMrt->AddParameter("modelMatrix", 1);
        normalMappingVertexMrt->AddParameter("oldModelMatrix", 2);


        cout << "cg initialization successful" << endl;
}


void ShaderManager::DelSingleton()
{
        DEL_PTR(sShaderManager);
}
        

ShaderManager::~ShaderManager()
{
        CLEAR_CONTAINER(mShaders);
        
        if (sCgContext)
                cgDestroyContext(sCgContext);
}


ShaderProgram *ShaderManager::CreateFragmentProgram(const std::string &filename, 
                                                                                                        const std::string &funcName,
                                                                                                        const std::string &name)
{
        return CreateShaderProgram(filename, funcName, name, true);
}


ShaderProgram *ShaderManager::CreateVertexProgram(const std::string &filename,
                                                                                                  const std::string &funcName,
                                                                                                  const std::string &name)
{
        return CreateShaderProgram(filename, funcName, name, false);
}


void ShaderManager::EnableFragmentProfile()
{
        cgGLEnableProfile(sCgFragmentProfile);
}


void ShaderManager::EnableVertexProfile()
{
        cgGLEnableProfile(sCgVertexProfile);
}


void ShaderManager::DisableFragmentProfile()
{
        cgGLDisableProfile(sCgFragmentProfile);
}


void ShaderManager::DisableVertexProfile()
{
        cgGLDisableProfile(sCgVertexProfile);
}


ShaderProgram *ShaderManager::CreateShaderProgram(const std::string &filename,
                                                                                                  const std::string &funcName,
                                                                                                  const std::string &name,
                                                                                                  bool isFragment)
{
        const string fullName = "src/shaders/" + filename + ".cg";
        
        ShaderProgram *p;

        if (isFragment)
        {
                p = new ShaderProgram(sCgContext, fullName, sCgFragmentProfile, funcName, ShaderProgram::FRAGMENT_PROGRAM);
        }
        else
        {
                p = new ShaderProgram(sCgContext, fullName, sCgVertexProfile, funcName, ShaderProgram::VERTEX_PROGRAM);
        }

        if (GetShaderProgram(name))
        {
                cerr << "Program name " << name << "already chosen" << endl;

                DEL_PTR(p);
                return p;
        }
        
        if (!p->IsValid())
        {
                cerr << "Program " << funcName << " in " << fullName << " failed to load" << endl;

                DEL_PTR(p);
                return p;
        }

        
        // everything ok
        cout << "Program " << funcName << " in " << fullName << " loaded" << endl;
                
        mShaders.push_back(p);
        mShaderMap[name] = p;

        return p;
}


ShaderProgram *ShaderManager::GetShaderProgram(const std::string &name)
{
        ShaderMap::const_iterator it = mShaderMap.find(name);

        if (it == mShaderMap.end())
                return NULL;
        
        return (*it).second;
}


}