Changeset 3038 for GTP


Ignore:
Timestamp:
10/17/08 16:32:37 (16 years ago)
Author:
mattausch
Message:

unified shader stuff, but phreetham sky not working anymore for forward rendering

Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling
Files:
1 added
16 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/FriendlyCulling.sln

    r3037 r3038  
    77EndProject 
    88Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MainApp", "MainApp.vcproj", "{A564071F-D054-4556-883B-999D7F9CC58C}" 
    9         ProjectSection(ProjectDependencies) = postProject 
    10                 {03661866-4093-4B02-B26A-028EA91AF023} = {03661866-4093-4B02-B26A-028EA91AF023} 
    11         EndProjectSection 
    12 EndProject 
    13 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "IrradianceMapping", "IrradianceMapping.vcproj", "{91680C49-A358-48AE-A02C-66CB884B7D7F}" 
    149        ProjectSection(ProjectDependencies) = postProject 
    1510                {03661866-4093-4B02-B26A-028EA91AF023} = {03661866-4093-4B02-B26A-028EA91AF023} 
    … …  
    3429                {A564071F-D054-4556-883B-999D7F9CC58C}.Release|Win32.ActiveCfg = Release|Win32 
    3530                {A564071F-D054-4556-883B-999D7F9CC58C}.Release|Win32.Build.0 = Release|Win32 
    36                 {91680C49-A358-48AE-A02C-66CB884B7D7F}.Debug|Win32.ActiveCfg = Debug|Win32 
    37                 {91680C49-A358-48AE-A02C-66CB884B7D7F}.Debug|Win32.Build.0 = Debug|Win32 
    38                 {91680C49-A358-48AE-A02C-66CB884B7D7F}.Release|Win32.ActiveCfg = Release|Win32 
    39                 {91680C49-A358-48AE-A02C-66CB884B7D7F}.Release|Win32.Build.0 = Release|Win32 
    4031        EndGlobalSection 
    4132        GlobalSection(SolutionProperties) = preSolution 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/CHCPlusPlusTraverser.cpp

    r2878 r3038  
    294294                while (!mIQueue.empty()) 
    295295                        mQueryQueue.push(GetNextMultiQuery(mIQueue)); 
    296                 } 
    297                 else 
    298                 { 
     296        } 
     297        else 
     298        { 
    299299                BvhNodeContainer::const_iterator it, it_end = mIQueue.end(); 
    300300 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.cpp

    r3036 r3038  
    99#include "ShadowMapping.h" 
    1010#include "Light.h" 
     11#include "ResourceManager.h" 
     12 
    1113 
    1214#include <IL/il.h> 
    … …  
    260262 
    261263        mFBOs.push_back(mDownSampleFbo); 
     264 
     265        InitCg(); 
    262266} 
    263267 
    … …  
    276280 
    277281 
    278 void DeferredRenderer::ReleaseCG() 
    279 { 
    280         CLEAR_CONTAINER(sShaders); 
    281 } 
    282  
    283  
    284 bool DeferredRenderer::InitProgram(ShaderProgram **program,  
    285                                                                    CGcontext context,  
    286                                                                    const std::string &filename, 
    287                                                                    const std::string &functionName) 
    288 { 
    289         const string fullName = "src/shaders/" + filename + ".cg"; 
    290  
    291         *program = new ShaderProgram(context, fullName, RenderState::sCgFragmentProfile, functionName); 
    292  
    293         sShaders.push_back(*program); 
    294  
    295         if (!(*program)->IsValid()) 
    296         { 
    297                 cerr << "Program " << functionName << " in " << fullName << " failed to load" << endl; 
    298                 return false; 
    299         } 
    300          
    301         cout << "Program " << functionName << " in " << fullName << " loaded" << endl; 
    302  
    303         return true; 
    304 } 
    305  
    306  
    307 void DeferredRenderer::InitCG(CGcontext context) 
     282 
     283void DeferredRenderer::InitCg() 
    308284{        
    309         InitProgram(&sCgDeferredProgram, context, "deferred", "main"); 
    310         InitProgram(&sCgDeferredShadowProgram, context, "deferred", "main_shadow"); 
    311         InitProgram(&sCgSsaoProgram, context, "ssao", "main"); 
    312         InitProgram(&sCgGiProgram, context, "globillum", "main"); 
    313         InitProgram(&sCgCombineIllumProgram, context, "globillum", "combine"); 
    314         InitProgram(&sCgCombineSsaoProgram, context, "ssao", "combine"); 
    315         InitProgram(&sCgAntiAliasingProgram, context, "antialiasing", "main"); 
    316         InitProgram(&sCgToneProgram, context, "tonemap", "ToneMap"); 
    317         InitProgram(&sCgDownSampleProgram, context, "tonemap", "DownSample"); 
    318         InitProgram(&sCgToneProgram, context, "tonemap", "ToneMap"); 
    319         InitProgram(&sCgLogLumProgram, context, "tonemap", "CalcAvgLogLum"); 
     285        ResourceManager *rm = ResourceManager::GetSingleton(); 
     286 
     287        sCgDeferredProgram = rm->CreateFragmentProgram("deferred", "main"); 
     288        sCgDeferredShadowProgram = rm->CreateFragmentProgram("deferred", "main_shadow"); 
     289        sCgSsaoProgram = rm->CreateFragmentProgram("ssao", "main"); 
     290        sCgGiProgram = rm->CreateFragmentProgram("globillum", "main"); 
     291        sCgCombineIllumProgram = rm->CreateFragmentProgram("globillum", "combine"); 
     292        sCgCombineSsaoProgram = rm->CreateFragmentProgram("ssao", "combine"); 
     293        sCgAntiAliasingProgram = rm->CreateFragmentProgram("antialiasing", "main"); 
     294        sCgToneProgram = rm->CreateFragmentProgram("tonemap", "ToneMap"); 
     295        sCgDownSampleProgram = rm->CreateFragmentProgram("tonemap", "DownSample"); 
     296        sCgToneProgram = rm->CreateFragmentProgram("tonemap", "ToneMap"); 
     297        sCgLogLumProgram = rm->CreateFragmentProgram("tonemap", "CalcAvgLogLum"); 
    320298 
    321299        int i; 
    … …  
    425403         
    426404 
    427         cgGLEnableProfile(RenderState::sCgFragmentProfile); 
     405        ResourceManager::GetSingleton()->EnableFragmentProfile(); 
    428406 
    429407        glDisable(GL_ALPHA_TEST); 
    … …  
    497475 
    498476        FrameBufferObject::Release(); 
    499         cgGLDisableProfile(RenderState::sCgFragmentProfile); 
     477        ResourceManager::GetSingleton()->DisableFragmentProfile(); 
    500478} 
    501479 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h

    r3027 r3038  
    2222 
    2323 
    24 typedef  std::vector<FrameBufferObject *> FBOContainer; 
    2524 
    2625/** This class implements a deferred shading algorithm that takes 
    … …  
    6463 
    6564        void SetShadingMethod(SHADING_METHOD s); 
    66          
    67         /** Initialises the deferred shader and loads the required shaders: 
    68                 This function has to be called only once. 
    69         */ 
    70         static void InitCG(CGcontext context); 
    71         /** Releases all shader resources. 
    72         */ 
    73         static void ReleaseCG(); 
    7465 
     66        // hack: store the color buffer idx for the first flipflip-mrt here 
     67        // TODO matt: make this less hacky 
    7568        static int colorBufferIdx; 
     69 
    7670 
    7771protected: 
    … …  
    9286        void FirstPassShadow(FrameBufferObject *fbo, DirectionalLight *light, ShadowMap *shadowMap); 
    9387 
    94         void ComputeToneParameters(FrameBufferObject *fbo, DirectionalLight *light, float &imageKey, float &whiteLum, float &middleGrey); 
     88        void ComputeToneParameters(FrameBufferObject *fbo,  
     89                                                           DirectionalLight *light, 
     90                                                           float &imageKey,  
     91                                                           float &whiteLum, 
     92                                                           float &middleGrey); 
    9593 
    9694        void ToneMap(FrameBufferObject *fbo, float imageKey, float whiteLum, float middleGrey); 
    … …  
    113111        void DrawQuad(ShaderProgram *p); 
    114112 
    115         static bool InitProgram(ShaderProgram **program,  
    116                                     CGcontext context,  
    117                                                         const std::string &filename, 
    118                                                         const std::string &functionName); 
     113        /** Initialises the deferred shader and loads the required shaders: 
     114                This function has to be called only once. 
     115        */ 
     116        void InitCg(); 
    119117 
    120118 
    … …  
    145143}; 
    146144 
     145 
    147146} // namespace  
    148147 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Material.cpp

    r3036 r3038  
    7979        glMaterialfv(GL_FRONT, GL_EMISSION, (float *)&mEmmisiveColor.r); 
    8080        glMaterialfv(GL_FRONT, GL_SPECULAR, (float *)&mSpecularColor.r); 
    81          
    82  
    83         if (mVertexProgram) 
    84         { 
    85                 mGPUVertexParameters->UpdateParameters(); 
    86         } 
    87          
    88         if (mFragmentProgram) 
    89         { 
    90                 mGPUFragmentParameters->UpdateParameters(); 
    91         } 
    9281} 
    9382 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.cpp

    r3036 r3038  
    44#include "ShaderProgram.h" 
    55#include "Texture.h" 
     6#include "ResourceManager.h" 
     7 
    68 
    79using namespace std; 
    810 
     11 
    912namespace CHCDemoEngine  
    1013{ 
    11  
    12 CGprofile RenderState::sCgFragmentProfile; 
    13 CGprofile RenderState::sCgVertexProfile;  
    14  
    15 ShaderProgram *RenderState::sCgMrtFragmentProgram = NULL; 
    16 ShaderProgram *RenderState::sCgMrtFragmentTexProgram = NULL; 
    17 ShaderProgram *RenderState::sCgMrtVertexProgram = NULL; 
    18  
    19  
    20 int RenderState::sTexParam; 
    21  
    2214 
    2315 
    … …  
    2921mLockCullFaceEnabled(false) 
    3022{ 
    31         Reset();  
    32 } 
    33  
    34          
     23        SetMode(RENDER); 
     24 
     25        mCurrentVboId = -1; 
     26        mCurrentTexId = 0; 
     27 
     28        mCullFaceEnabled = true; 
     29        mAlphaTestEnabled = false; 
     30        mTexturesEnabled = false; 
     31 
     32        mCurrentVertexProgram = NULL; 
     33        mCurrentFragmentProgram = NULL; 
     34 
     35        glEnable(GL_CULL_FACE); 
     36 
     37        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); 
     38        glDisable(GL_ALPHA_TEST); 
     39 
     40        glDisable(GL_TEXTURE_2D); 
     41        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     42} 
     43 
     44 
     45void RenderState::Reset() 
     46{ 
     47        SetMode(RENDER); 
     48 
     49        mCurrentVboId = -1; 
     50        mCurrentTexId = 0; 
     51 
     52        mCullFaceEnabled = true; 
     53        mAlphaTestEnabled = false; 
     54        mTexturesEnabled = false; 
     55 
     56        mCurrentVertexProgram = NULL; 
     57        mCurrentFragmentProgram = NULL; 
     58 
     59        glEnable(GL_CULL_FACE); 
     60 
     61        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); 
     62        glDisable(GL_ALPHA_TEST); 
     63 
     64        glDisable(GL_TEXTURE_2D); 
     65        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     66 
     67        //ResourceManager::GetSingleton()->DisableFragmentProfile(); 
     68        //ResourceManager::GetSingleton()->DisableVertexProfile(); 
     69} 
     70 
     71 
    3572bool RenderState::SetMode(Mode mode) 
    3673{ 
    … …  
    5188                        if (mRenderType == DEFERRED) 
    5289                        { 
    53                                 cgGLDisableProfile(sCgFragmentProfile); 
    54                                 cgGLDisableProfile(sCgVertexProfile); 
     90                                ResourceManager::GetSingleton()->DisableFragmentProfile(); 
     91                                ResourceManager::GetSingleton()->DisableFragmentProfile(); 
    5592                        } 
    5693                } 
    … …  
    73110                        if (mRenderType == DEFERRED) 
    74111                        { 
    75                                 cgGLEnableProfile(sCgFragmentProfile); 
    76                                 cgGLEnableProfile(sCgVertexProfile); 
     112                                ResourceManager::GetSingleton()->EnableFragmentProfile(); 
     113                                ResourceManager::GetSingleton()->EnableVertexProfile(); 
    77114                        } 
    78115                } 
    … …  
    152189        if (mRenderType == DEFERRED) 
    153190        { 
    154                 if (mat->GetFragmentProgram() && (mat->GetFragmentProgram() != mCurrentFragmentProgram)) 
    155                 { 
    156                         mCurrentFragmentProgram = mat->GetFragmentProgram(); 
    157                         mCurrentFragmentProgram->Bind(); 
     191                if (mat->GetFragmentProgram()) 
     192                { 
     193                        if (mat->GetFragmentProgram() != mCurrentFragmentProgram) 
     194                        {                        
     195                                mCurrentFragmentProgram = mat->GetFragmentProgram(); 
     196                                mCurrentFragmentProgram->Bind(); 
     197                        } 
     198                         
     199                        mat->GetFragmentProgramParameters()->UpdateParameters(); 
     200 
    158201                } 
    159202         
    160                 if (mat->GetVertexProgram() && (mat->GetVertexProgram() != mCurrentVertexProgram)) 
    161                 { 
    162                         mCurrentVertexProgram = mat->GetVertexProgram(); 
    163                         mCurrentVertexProgram->Bind(); 
     203                if (mat->GetVertexProgram()) 
     204                { 
     205                        if  (mat->GetVertexProgram() != mCurrentVertexProgram) 
     206                        { 
     207                                mCurrentVertexProgram = mat->GetVertexProgram(); 
     208                                mCurrentVertexProgram->Bind(); 
     209                        } 
     210 
     211                        mat->GetVertexProgramParameters()->UpdateParameters(); 
    164212                } 
    165213        } 
    … …  
    181229                } 
    182230        } 
    183 } 
    184  
    185  
    186 void RenderState::Reset() 
    187 { 
    188         SetMode(RENDER); 
    189  
    190         mCurrentVboId = -1; 
    191         mCurrentTexId = 0; 
    192  
    193         mCullFaceEnabled = true; 
    194         mAlphaTestEnabled = false; 
    195         mTexturesEnabled = false; 
    196  
    197         mCurrentVertexProgram = NULL; 
    198         mCurrentFragmentProgram = NULL; 
    199  
    200         glEnable(GL_CULL_FACE); 
    201  
    202         glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); 
    203         glDisable(GL_ALPHA_TEST); 
    204  
    205         glDisable(GL_TEXTURE_2D); 
    206         glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
    207231} 
    208232 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.h

    r3034 r3038  
    44 
    55#include "common.h" 
    6 #include "glInterface.h" 
    7 #include <Cg/cg.h> 
    8 #include <Cg/cgGL.h> 
    96 
    107 
    … …  
    7572        void LockCullFaceEnabled(bool lockCull); 
    7673         
    77          
    78         /////////////////// 
    79         //-- for deferred shading, we have to switch shaders on and off 
    80  
    81         static CGprofile sCgFragmentProfile; 
    82         static CGprofile sCgVertexProfile;  
    83  
    84         static ShaderProgram *sCgMrtFragmentProgram; 
    85         static ShaderProgram *sCgMrtFragmentTexProgram; 
    86         static ShaderProgram *sCgMrtVertexProgram; 
    87  
    88         static int sTexParam; 
    89  
    9074 
    9175protected: 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderTraverser.cpp

    r3031 r3038  
    248248        // render pending objects before changing to query mode 
    249249        if (mUseRenderQueue && (mRenderState->GetMode() == RenderState::RENDER)) 
     250        { 
    250251                ApplyRenderQueue(); 
    251          
     252        } 
    252253 
    253254        query.BeginQuery(); 
    … …  
    255256        // change to query mode and render box 
    256257        if (mRenderState->SetMode(RenderState::QUERY)) 
     258        { 
    257259                ++ mStats.mNumStateChanges; 
     260        } 
    258261 
    259262        mBvh->RenderBounds(query.GetNodes(), mRenderState, mUseTightBounds); 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ResourceManager.cpp

    r3037 r3038  
    1313#include "RenderState.h" 
    1414#include "ShaderProgram.h" 
     15#include <Cg/cg.h> 
     16#include <Cg/cgGL.h> 
    1517 
    1618 
    … …  
    3234{ 
    3335 
     36 
     37///////// 
     38//-- cg stuff 
     39 
     40static CGcontext sCgContext = NULL; 
     41 
     42static CGprofile sCgFragmentProfile; 
     43static CGprofile sCgVertexProfile;  
     44 
     45 
    3446// only instance of the resource manager 
    3547ResourceManager *ResourceManager::sResourceManager = NULL; 
     48 
     49 
     50static void cgErrorCallback() 
     51{ 
     52        CGerror lastError = cgGetError(); 
     53 
     54        if(lastError) 
     55        { 
     56                printf("%s\n\n", cgGetErrorString(lastError)); 
     57                printf("%s\n", cgGetLastListing(sCgContext)); 
     58                 
     59                printf("Cg error, exiting...\n"); 
     60 
     61                exit(0); 
     62        } 
     63} 
     64 
     65 
     66ResourceManager::ResourceManager() 
     67{  
     68        InitCg();  
     69} 
     70 
    3671 
    3772ResourceManager::~ResourceManager() 
    … …  
    4782        CLEAR_CONTAINER(mGPUParameters); 
    4883        CLEAR_CONTAINER(mShaders); 
     84         
     85        if (sCgContext) 
     86                cgDestroyContext(sCgContext); 
    4987} 
    5088 
    … …  
    188226         
    189227        str.read(reinterpret_cast<char *>(&mat->mAlphaTestEnabled), sizeof(bool)); 
    190  
    191228        str.read(reinterpret_cast<char *>(&mat->mCullFaceEnabled), sizeof(bool)); 
    192229 
    … …  
    204241        } 
    205242 
    206         mat->mVertexProgram = RenderState::sCgMrtVertexProgram; 
    207  
    208243        if (mat->GetTexture()) 
    209244        { 
    210                 mat->mFragmentProgram = RenderState::sCgMrtFragmentTexProgram; 
     245                mat->mFragmentProgram = mMrtDefaultFragmentTexProgram; 
    211246 
    212247                mat->mGPUFragmentParameters = CreateGPUProgramParameters(mat->mFragmentProgram); 
    … …  
    215250        else 
    216251        { 
    217                 mat->mFragmentProgram = RenderState::sCgMrtFragmentProgram; 
     252                mat->mFragmentProgram = mMrtDefaultFragmentProgram; 
    218253                mat->mGPUFragmentParameters = CreateGPUProgramParameters(mat->mFragmentProgram); 
    219254        } 
    220255 
    221         mat->mGPUVertexParameters = CreateGPUProgramParameters(RenderState::sCgMrtVertexProgram); 
     256        mat->mVertexProgram = mMrtDefaultVertexProgram; 
     257        mat->mGPUVertexParameters = CreateGPUProgramParameters(mat->mVertexProgram); 
    222258 
    223259        return mat; 
    … …  
    328364 
    329365 
    330 ShaderProgram *CreateShaderProgram(const std::string &filename, const std::string &funcName, bool isFragment) 
    331 { 
    332         ShaderProgram *p; 
     366ShaderProgram *ResourceManager::CreateFragmentProgram(const std::string &filename, const std::string &funcName) 
     367{ 
     368        const string fullName = "src/shaders/" + filename + ".cg"; 
     369 
     370        ShaderProgram *p = new ShaderProgram(sCgContext, fullName, sCgFragmentProfile, funcName); 
     371 
     372        mShaders.push_back(p); 
     373 
     374        if (!p->IsValid()) 
     375        { 
     376                DEL_PTR(p); 
     377                cerr << "Program " << funcName << " in " << fullName << " failed to load" << endl; 
     378        } 
     379         
     380        cout << "Program " << funcName << " in " << fullName << " loaded" << endl; 
     381 
    333382        return p; 
    334383} 
    335384 
    336 } 
    337  
     385 
     386ShaderProgram *ResourceManager::CreateVertexProgram(const std::string &filename, const std::string &funcName) 
     387{ 
     388        const string fullName = "src/shaders/" + filename + ".cg"; 
     389         
     390        ShaderProgram *p = new ShaderProgram(sCgContext, fullName, sCgVertexProfile, funcName); 
     391        mShaders.push_back(p); 
     392 
     393        if (!p->IsValid()) 
     394        { 
     395                DEL_PTR(p); 
     396                cerr << "Program " << funcName << " in " << fullName << " failed to load" << endl; 
     397        } 
     398         
     399        cout << "Program " << funcName << " in " << fullName << " loaded" << endl; 
     400 
     401        return p; 
     402} 
     403 
     404 
     405void ResourceManager::InitCg()  
     406{ 
     407        // setup cg 
     408        cgSetErrorCallback(cgErrorCallback); 
     409        // create context. 
     410        sCgContext = cgCreateContext(); 
     411        // get the optimal fragment profile 
     412        sCgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); 
     413        cgGLSetOptimalOptions(sCgFragmentProfile); 
     414        // get the optimal vertex profile 
     415        sCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX); 
     416        cgGLSetOptimalOptions(sCgVertexProfile); 
     417 
     418        // set textures to auto load 
     419        cgGLSetManageTextureParameters(sCgContext, false); 
     420 
     421        mMrtDefaultVertexProgram = CreateVertexProgram("mrt", "vtx"); 
     422        mMrtDefaultFragmentProgram = CreateFragmentProgram("mrt", "fragtex");//CreateFragmentProgram("mrt", "frag"); 
     423        mMrtDefaultFragmentTexProgram = CreateFragmentProgram("mrt", "fragtex"); 
     424        mMrtDefaultFragmentTexProgram->AddParameter("tex", 0); 
     425 
     426        cout << "cg initialization successful" << endl; 
     427} 
     428 
     429 
     430void ResourceManager::EnableFragmentProfile() 
     431{ 
     432        cgGLEnableProfile(sCgFragmentProfile); 
     433} 
     434 
     435 
     436void ResourceManager::EnableVertexProfile() 
     437{ 
     438        cgGLEnableProfile(sCgVertexProfile); 
     439} 
     440 
     441 
     442void ResourceManager::DisableFragmentProfile() 
     443{ 
     444        cgGLDisableProfile(sCgFragmentProfile); 
     445} 
     446 
     447 
     448void ResourceManager::DisableVertexProfile() 
     449{ 
     450        cgGLDisableProfile(sCgVertexProfile); 
     451         
     452} 
     453 
     454 
     455} 
     456 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ResourceManager.h

    r3037 r3038  
    6363        /** Creates a new shader program. 
    6464        */ 
    65         ShaderProgram *CreateShaderProgram(const std::string &filename, const std::string &funcName, bool isFragment); 
     65        ShaderProgram *CreateFragmentProgram(const std::string &filename, const std::string &funcName); 
     66        ShaderProgram *CreateVertexProgram(const std::string &filename, const std::string &funcName); 
     67 
     68        void EnableFragmentProfile(); 
     69        void EnableVertexProfile(); 
     70 
     71        void DisableFragmentProfile(); 
     72        void DisableVertexProfile(); 
     73 
    6674 
    6775protected: 
    … …  
    7179                singleton pattern. 
    7280        */ 
    73         ResourceManager() {} 
     81        ResourceManager(); 
    7482 
    7583        ~ResourceManager(); 
     84 
     85 
     86        void InitCg(); 
    7687 
    7788        void LoadTextures(igzstream &str); 
    … …  
    8899        //std::map<int, Shape *> mShapesTable; 
    89100 
    90         // these are kept to be able to delete these resources afterwards 
     101 
     102        ///////////// 
     103        //-- these are kept to be able to delete these resources afterwards 
     104 
    91105        TextureContainer mTextures; 
    92106        MaterialContainer mMaterials; 
    … …  
    94108        TransformContainer mTrafos; 
    95109        GPUParamContainer mGPUParameters; 
    96  
     110        ShaderContainer mShaders; 
    97111        ShapeContainer mShapes; 
    98  
    99112        LODContainer mLODs; 
    100113 
    … …  
    102115 
    103116        /// the scene entities 
     117 
    104118        SceneEntityContainer mSceneEntities; 
     119 
     120 
     121        //////////// 
     122        //-- default shader programs 
     123 
     124        ShaderProgram *mMrtDefaultVertexProgram; 
     125        ShaderProgram *mMrtDefaultFragmentProgram; 
     126        ShaderProgram *mMrtDefaultFragmentTexProgram; 
     127 
    105128 
    106129private: 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ShaderProgram.h

    r3036 r3038  
    2626typedef std::vector<CGparameter> CGParameterArray; 
    2727 
    28 struct ParameterPair1f 
    29 { 
    30         unsigned int mParameterIdx; 
    31         float mValue; 
    32 }; 
    33  
     28 
     29/** This class represents the parameter values for a given GPU program. 
     30*/ 
    3431class GPUProgramParameters 
    3532{ 
    … …  
    8582        */ 
    8683        void UpdateParameters(); 
    87          
     84 
     85 
    8886 
    8987protected: 
    … …  
    151149 
    152150 
    153  
     151/** This class represents a wrapper for a GPU shader program (vertex or fragment). 
     152*/ 
    154153class ShaderProgram 
    155154{ 
    … …  
    167166        ~ShaderProgram() { if (mProgram != NULL) cgDestroyProgram(mProgram); } 
    168167 
     168        /** Assigns a parameter to the specified index. 
     169        */ 
     170        CGparameter AddParameter(const std::string &name, int idx); 
     171 
     172 
     173        ////////////// 
     174        //-- set shader parameters per index  
     175 
    169176        void SetValue1f(int idx, float value); 
    170177        void SetValue2f(int idx, float val1, float val2); 
    … …  
    178185        void SetTexture(int idx, unsigned int tex); 
    179186 
     187 
     188        //////////// 
     189        //-- set shader parameters per parameter name (slow!) 
     190 
     191        /// Float parameters 
    180192        void SetValue1f(const std::string &name, float value); 
    181193        void SetValue2f(const std::string &name, float val1, float val2); 
    182194        void SetValue3f(const std::string &name, float val1, float val, float val3); 
    183  
     195        /// Array parameters 
    184196        void SetArray1f(const std::string &name, float *vals, int numElements); 
    185197        void SetArray2f(const std::string &name, float *vals, int numElements); 
    186198        void SetArray3f(const std::string &name, float *vals, int numElements); 
    187         /** Sets the matrix parameter. 
    188         */ 
     199        /// Sets a matrix parameter 
    189200        void SetMatrix(const std::string &name, const Matrix4x4 &mat); 
    190201        /** Sets the texture parameter. 
    … …  
    192203        void SetTexture(const std::string &name, unsigned int tex); 
    193204 
    194         CGparameter AddParameter(const std::string &name, int idx); 
    195205        /** Binds the program. 
    196206        */ 
    … …  
    226236 
    227237 
    228 typedef  std::vector<ShaderProgram *> ShaderContainer; 
    229238 
    230239} // namespace  

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ShadowMapping.cpp

    r3021 r3038  
    66#include "Polygon3.h" 
    77#include "Polyhedron.h" 
     8#include "ResourceManager.h" 
    89 
    910#include <IL/il.h> 
    … …  
    1617namespace CHCDemoEngine 
    1718{ 
    18  
    19 static CGprogram sCgShadowProgram; 
    20 static CGparameter sShadowParam; 
    21  
    2219 
    2320static Polyhedron *polyhedron = NULL; 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SkyPreetham.cpp

    r3036 r3038  
    99#include "Shape.h" 
    1010#include "Material.h" 
     11#include "ResourceManager.h" 
     12 
    1113 
    1214 
    … …  
    2224 
    2325 
     26 
     27 
    2428using namespace CHCDemoEngine; 
    2529using namespace std; 
    2630 
    2731 
    28 static ShaderProgram *sCgSkyProgram = NULL; 
    29 static ShaderProgram *sCgMrtFragmentSkyDomeProgram = NULL; 
    30  
    31 ShaderContainer SkyPreetham::sShaders; 
    32  
    3332 
    3433inline float CBQ(float x) 
    … …  
    4443 
    4544 
    46 void SkyPreetham::InitCG(CGcontext context) 
     45void SkyPreetham::InitCG() 
    4746{        
    48         sCgSkyProgram = new ShaderProgram(context,  
    49                                               "src/shaders/sky_preetham.cg", 
    50                                                                           RenderState::sCgVertexProfile,         
    51                                                                           "default_vs"); 
    52  
    53         if (sCgSkyProgram->IsValid()) 
     47        mSkyVtxProgram =  
     48                ResourceManager::GetSingleton()->CreateVertexProgram("sky_preetham", "default_vs"); 
     49                 
     50        if (mSkyVtxProgram->IsValid()) 
    5451        { 
    55                 sCgSkyProgram->AddParameter("lightDir", 0); 
    56                 sCgSkyProgram->AddParameter("thetaSun", 1); 
    57                 sCgSkyProgram->AddParameter("zenithColor", 2); 
    58                 sCgSkyProgram->AddParameter("aColor", 3); 
    59                 sCgSkyProgram->AddParameter("bColor", 4); 
    60                 sCgSkyProgram->AddParameter("cColor", 5); 
    61                 sCgSkyProgram->AddParameter("dColor", 6); 
    62                 sCgSkyProgram->AddParameter("eColor", 7); 
    63                 sCgSkyProgram->AddParameter("multiplier", 8); 
     52                mSkyVtxProgram->AddParameter("lightDir", 0); 
     53                mSkyVtxProgram->AddParameter("thetaSun", 1); 
     54                mSkyVtxProgram->AddParameter("zenithColor", 2); 
     55                mSkyVtxProgram->AddParameter("aColor", 3); 
     56                mSkyVtxProgram->AddParameter("bColor", 4); 
     57                mSkyVtxProgram->AddParameter("cColor", 5); 
     58                mSkyVtxProgram->AddParameter("dColor", 6); 
     59                mSkyVtxProgram->AddParameter("eColor", 7); 
     60                mSkyVtxProgram->AddParameter("multiplier", 8); 
    6461        } 
    6562        else 
    6663                cerr << "sky program failed to load" << endl; 
    6764 
    68                 sShaders.push_back(sCgSkyProgram); 
    69  
    70         sCgMrtFragmentSkyDomeProgram =  
    71                 new ShaderProgram(context,  
    72                                   "src/shaders/sky_preetham.cg",  
    73                                                   RenderState::sCgFragmentProfile, 
    74                                                   "frag_skydome"); 
    75  
    76         // simple shader used for just pushing out the fragments to the mrts 
    77         if (!sCgMrtFragmentSkyDomeProgram->IsValid()) 
    78                 cerr << "fragment skyprogram failed to load" << endl; 
    79          
    80         sShaders.push_back(sCgMrtFragmentSkyDomeProgram); 
    81 } 
    82  
    83  
    84 void SkyPreetham::ReleaseCG() 
    85 { 
    86         CLEAR_CONTAINER(sShaders); 
     65        mSkyFragProgram =  
     66                ResourceManager::GetSingleton()->CreateFragmentProgram("sky_preetham", "frag_skydome"); 
    8767} 
    8868 
    … …  
    9676        Shape *shape = mSkyDome->GetShape(0); 
    9777 
     78        InitCG(); 
     79 
    9880        Material *mat = shape->GetMaterial(); 
    9981 
    100         mat->SetFragmentProgram(sCgMrtFragmentSkyDomeProgram); 
    101         mat->SetVertexProgram(sCgSkyProgram); 
     82        mat->SetFragmentProgram(mSkyFragProgram); 
     83        mat->SetVertexProgram(mSkyVtxProgram); 
    10284} 
    10385 
    … …  
    148130        {        
    149131                // use tone mapping 
    150                 sCgSkyProgram->SetValue1f(8, 1.0f); 
     132                vtxParams->SetValue1f(8, 1.0f); 
    151133        } 
    152134        else 
    153135        { 
    154136                // no tone mapping => scale 
    155                 sCgSkyProgram->SetValue1f(8, 8e-5f); 
     137                vtxParams->SetValue1f(8, 8e-5f); 
    156138        } 
    157  
    158         cgGLEnableProfile(RenderState::sCgVertexProfile); 
    159139 
    160140        // Render sky dome. 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SkyPreetham.h

    r3021 r3038  
    1515        class RenderState; 
    1616        class Camera; 
     17        class ShaderProgram; 
    1718} 
    1819 
    … …  
    4041                                                 bool scaleToRange) const; 
    4142 
    42         static void InitCG(CGcontext context); 
    43         static void ReleaseCG(); 
     43        void InitCG(); 
    4444 
    4545 
    … …  
    5050 
    5151 
    52         /// Members. 
    53 /*      FEffect*                mEffect; 
     52        ////////// 
     53 
     54        /*      FEffect*                mEffect; 
    5455 
    5556        FEffect*                mSunEffect; 
    5657        FTexture2D*             mSunTexture; 
    5758        FVertexBuffer*  mSunQuad; 
    58 */ 
     59        */ 
     60 
    5961        CHCDemoEngine::SceneEntity *mSkyDome; 
    6062 
     63        /// the turbidity of the sky 
    6164        float mTurbidity; 
    6265 
    63         static CHCDemoEngine::ShaderContainer sShaders; 
     66        CHCDemoEngine::ShaderProgram *mSkyVtxProgram; 
     67        CHCDemoEngine::ShaderProgram *mSkyFragProgram; 
    6468}; 
    6569 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp

    r3037 r3038  
    1818#include <time.h> 
    1919#include "glInterface.h" 
    20  
    21 #include <Cg/cg.h> 
    22 #include <Cg/cgGL.h> 
    2320 
    2421 
    … …  
    6663#define MAX_DEPTH_CONST 10.0f 
    6764 
    68 // fbo 
     65 
     66GLuint fontTex; 
     67/// fbo 
    6968FrameBufferObject *fbo = NULL; 
    70  
    71 GLuint fontTex; 
    72  
    7369/// the renderable scene geometry 
    7470SceneEntityContainer sceneEntities; 
    75  
    7671// traverses and renders the hierarchy 
    7772RenderTraverser *traverser = NULL; 
    … …  
    9085/// the rendering algorithm 
    9186int renderMode = RenderTraverser::CHCPLUSPLUS; 
    92 // eye near plane distance 
     87/// eye near plane distance 
    9388float nearDist = 0.2f; 
     89/// eye far plane distance 
    9490float farDist = 1e6f; 
    9591/// the field of view 
    … …  
    9995 
    10096int assumedVisibleFrames = 10; 
     97 
    10198int maxBatchSize = 50; 
    10299 
    … …  
    233230void InitGLstate(); 
    234231void InitRenderTexture(); 
    235 void InitCg(); 
    236232void CleanUp(); 
    237233void SetupEyeView(); 
    … …  
    275271void RenderShadowMap(float newfar); 
    276272 
    277  
    278  
    279 ///////// 
    280 //-- cg stuff 
    281  
    282 static CGcontext sCgContext = NULL; 
    283  
    284 static CGparameter sEyePosParamTex; 
    285 static CGparameter sEyePosParam; 
    286  
    287273static Matrix4x4 viewProjMat = IdentityMatrix(); 
    288274static Matrix4x4 oldViewProjMat = IdentityMatrix(); 
    289275 
    290  
    291  
    292 static void cgErrorCallback() 
    293 { 
    294         CGerror lastError = cgGetError(); 
    295  
    296         if(lastError) 
    297         { 
    298                 printf("%s\n\n", cgGetErrorString(lastError)); 
    299                 printf("%s\n", cgGetLastListing(sCgContext)); 
    300                  
    301                 printf("Cg error, exiting...\n"); 
    302  
    303                 exit(0); 
    304         } 
    305 } 
    306276 
    307277 
    … …  
    452422        MiddleMotion(0, 0); 
    453423 
    454         // init cg shader programs 
    455         InitCg(); 
    456  
    457424        perfGraph = new PerformanceGraph(1000); 
    458425 
    … …  
    532499         
    533500        return 0; 
    534 } 
    535  
    536  
    537 void InitCg(void)  
    538 { 
    539         // setup cg 
    540         cgSetErrorCallback(cgErrorCallback); 
    541  
    542         // create context. 
    543         sCgContext = cgCreateContext(); 
    544  
    545         // get the optimal profile 
    546         RenderState::sCgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); 
    547         cgGLSetOptimalOptions(RenderState::sCgFragmentProfile); 
    548  
    549         RenderState::sCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX); 
    550         cgGLSetOptimalOptions(RenderState::sCgVertexProfile); 
    551  
    552         // set textures to auto load 
    553         cgGLSetManageTextureParameters(sCgContext, false); 
    554  
    555         RenderState::sCgMrtVertexProgram =  
    556                 new ShaderProgram(sCgContext, "src/shaders/mrt.cg", RenderState::sCgVertexProfile, "vtx"); 
    557  
    558         if (!RenderState::sCgMrtVertexProgram->IsValid()) 
    559                 cerr << "fragment program failed to load" << endl; 
    560  
    561         RenderState::sCgMrtFragmentTexProgram =  
    562                 new ShaderProgram(sCgContext, "src/shaders/mrt.cg", RenderState::sCgFragmentProfile, "fragtex"); 
    563  
    564          
    565         if (!RenderState::sCgMrtFragmentTexProgram->IsValid()) 
    566                 cerr << "fragment tex program failed to load" << endl; 
    567  
    568         RenderState::sCgMrtFragmentTexProgram->AddParameter("tex", 0); 
    569  
    570         RenderState::sCgMrtFragmentProgram =  
    571                 new ShaderProgram(sCgContext, "src/shaders/mrt.cg", RenderState::sCgFragmentProfile, "frag"); 
    572  
    573         if (!RenderState::sCgMrtFragmentProgram->IsValid()) 
    574                 cerr << "fragment program failed to load" << endl; 
    575          
    576  
    577         PrintGLerror("init"); 
    578  
    579         DeferredRenderer::InitCG(sCgContext); 
    580         SkyPreetham::InitCG(sCgContext); 
    581  
    582         cout << "cg initialization successful" << endl; 
    583501} 
    584502 
    … …  
    904822        state.SetRenderPassType(RenderState::DEFERRED); 
    905823 
    906         cgGLEnableProfile(RenderState::sCgVertexProfile); 
    907         RenderState::sCgMrtVertexProgram->Bind(); 
    908  
    909         cgGLEnableProfile(RenderState::sCgFragmentProfile); 
    910         RenderState::sCgMrtFragmentProgram->Bind(); 
     824        loader->EnableVertexProfile(); 
     825        loader->EnableFragmentProfile(); 
    911826 
    912827        const Vector3 pos = camera->GetPosition(); 
    … …  
    991906                glEnable(GL_LIGHTING); 
    992907 
    993                 cgGLDisableProfile(RenderState::sCgFragmentProfile); 
    994                 cgGLDisableProfile(RenderState::sCgVertexProfile); 
     908                loader->DisableFragmentProfile(); 
     909                loader->DisableVertexProfile(); 
    995910 
    996911                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    … …  
    1011926                glDrawBuffers(1, mrt); 
    1012927 
    1013                 cgGLDisableProfile(RenderState::sCgFragmentProfile); 
    1014                 cgGLDisableProfile(RenderState::sCgVertexProfile); 
     928                loader->DisableFragmentProfile(); 
     929                loader->DisableVertexProfile(); 
    1015930 
    1016931                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    … …  
    1027942 
    1028943                glEnable(GL_MULTISAMPLE_ARB); 
    1029  
    1030                 cgGLDisableProfile(RenderState::sCgFragmentProfile); 
    1031                 cgGLDisableProfile(RenderState::sCgVertexProfile); 
     944                 
     945                loader->DisableFragmentProfile(); 
     946                loader->DisableVertexProfile(); 
    1032947 
    1033948                state.SetRenderPassType(RenderState::DEPTH_PASS); 
    … …  
    11121027                FrameBufferObject::Release(); 
    11131028 
    1114                 cgGLDisableProfile(RenderState::sCgVertexProfile); 
    1115                 cgGLDisableProfile(RenderState::sCgFragmentProfile); 
     1029                loader->DisableVertexProfile(); 
     1030                loader->DisableFragmentProfile(); 
    11161031 
    11171032                if (!ssaoShader) ssaoShader =  
    … …  
    17411656        DEL_PTR(shadowMap); 
    17421657        DEL_PTR(shadowTraverser); 
    1743         DEL_PTR(RenderState::sCgMrtFragmentProgram); 
    1744         DEL_PTR(RenderState::sCgMrtFragmentTexProgram); 
    1745         DEL_PTR(RenderState::sCgMrtVertexProgram); 
    17461658         
    17471659        ResourceManager::DelSingleton(); 
    17481660        loader = NULL; 
    1749  
    1750         DeferredRenderer::ReleaseCG(); 
    1751         SkyPreetham::ReleaseCG(); 
    1752  
    1753         if (sCgContext) 
    1754                 cgDestroyContext(sCgContext); 
    17551661} 
    17561662 
    … …  
    19631869void RenderSky() 
    19641870{ 
    1965         cgGLEnableProfile(RenderState::sCgVertexProfile); 
     1871        loader->EnableVertexProfile(); 
     1872        loader->EnableFragmentProfile(); 
    19661873 
    19671874        if ((renderMethod == RENDER_DEFERRED) || (renderMethod == RENDER_DEPTH_PASS_DEFERRED)) 
    … …  
    19741881        preetham->RenderSkyDome(-light->GetDirection(), camera, &state, !useToneMapping); 
    19751882 
    1976         cgGLDisableProfile(RenderState::sCgVertexProfile); 
    1977         cgGLDisableProfile(RenderState::sCgFragmentProfile); 
     1883        loader->DisableVertexProfile(); 
     1884        loader->DisableFragmentProfile(); 
    19781885} 
    19791886 
    … …  
    20501957void RenderShadowMap(float newfar) 
    20511958{ 
    2052         cgGLDisableProfile(RenderState::sCgFragmentProfile); 
    2053         cgGLDisableProfile(RenderState::sCgVertexProfile); 
     1959        loader->DisableVertexProfile(); 
     1960        loader->DisableFragmentProfile(); 
    20541961 
    20551962        glDisableClientState(GL_NORMAL_ARRAY); 
    20561963 
    20571964        state.SetRenderPassType(RenderState::DEPTH_PASS); 
     1965         
     1966        // hack: disable cull face because of alpha textured balconies 
     1967        glDisable(GL_CULL_FACE); 
    20581968        state.LockCullFaceEnabled(true); 
     1969 
    20591970        state.SetUseAlphaToCoverage(false); 
    20601971 
    … …  
    20661977        // hack: temporarily change camera far plane 
    20671978        camera->SetFar(newfar); 
    2068         glDisable(GL_CULL_FACE); 
    2069          
     1979 
    20701980        // the scene is rendered withouth any shading    
    20711981        shadowMap->ComputeShadowMap(shadowTraverser, viewProjMat); 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/common.h

    r3036 r3038  
    3535class Texture; 
    3636class Material; 
     37class ShaderProgram; 
     38class FrameBufferObject; 
    3739 
    3840struct LODLevel; 
    … …  
    486488typedef std::queue<BvhNode *> BvhNodeQueue; 
    487489 
     490 
     491/////// 
     492//-- container definitions 
     493 
    488494typedef std::vector<Shape *> ShapeContainer; 
    489495typedef std::vector<Geometry *> GeometryContainer; 
    … …  
    495501typedef std::vector<Material *> MaterialContainer; 
    496502typedef std::vector<GPUProgramParameters *> GPUParamContainer; 
     503typedef  std::vector<FrameBufferObject *> FBOContainer; 
     504typedef  std::vector<ShaderProgram *> ShaderContainer; 
    497505 
    498506typedef std::vector<Vector3> VertexArray; 
Note: See TracChangeset for help on using the changeset viewer.