TAPsDoc/html/_t_a_ps_g_l_s_l_shader_pool_8cpp_source.html

00001 /******************************************************************************
00002 TAPsGLSLShaderPool.cpp
00003
00004 GLSLShaderPool class (cpp file).
00005
00006 SUKITTI PUNAK   (02/17/2009)
00007 ******************************************************************************/
00008 #include "TAPsGLSLShaderPool.hpp"
00009 // Using Inclusion Model (i.e. definitions are included in declarations)
00010 //                       (this name.cpp is included in name.hpp)
00011 // Each friend is defined directly inside its declaration.
00012
00013 BEGIN_NAMESPACE_TAPs__OpenGL
00014 //=============================================================================
00015 // Constructors
00016 //-----------------------------------------------------------------------------
00017 GLSLShaderPool::GLSLShaderPool ()
00018 {}
00019 //-----------------------------------------------------------------------------
00020 //GLSLShaderPool::GLSLShaderPool ( GLSLShaderPool const &v )
00021 //{}
00022 //-----------------------------------------------------------------------------
00023 GLSLShaderPool::~GLSLShaderPool ()
00024 {
00025     Clear();
00026 }
00027 //-----------------------------------------------------------------------------
00028 bool GLSLShaderPool::Clear ()
00029 {
00030     // MORE CODING HERE!!!
00031     // Need to detach and delete shader programs and shader objects
00032     m_vProgramObjectList.clear();
00033     m_vVertexShaderList.clear();
00034     m_vGeometryShaderList.clear();
00035     m_vFragmentShaderList.clear();
00036
00037     return true;
00038 }
00039 //-----------------------------------------------------------------------------
00040 std::string GLSLShaderPool::StrInfo () const
00041 {
00042     std::ostringstream ss;
00043     ss << "GLSLShaderPool: ";
00044     return ss.str();
00045 }
00046 //-----------------------------------------------------------------------------
00047 //=============================================================================
00048 // Assignment Operator
00049 //-----------------------------------------------------------------------------
00050 //inline GLSLShaderPool & GLSLShaderPool::operator= ( GLSLShaderPool const &v )
00051 //{
00052 //  return *this;
00053 //}
00054
00055 //-----------------------------------------------------------------------------
00056 GLSLVertexShader * GLSLShaderPool::CreateVertexShaderFromFile   ( std::string const & vertFile )
00057 {
00058     if ( !vertFile.empty() ) {
00059         #ifdef TAPs_DEBUG_MODE
00060             #ifdef TAPs_USE_WXWIDGETS
00061                 wxLogWarning( wxT( "Load vertex shader \"%s\"" ), vertFile.c_str() );
00062             #else
00063                 std::cout << "Load vertex shader \"" << vertFile << "\"";
00064             #endif
00065         #endif
00066
00067         GLSLVertexShader * vertShader = new GLSLVertexShader();
00068         if ( !vertShader ) {
00069             #ifdef TAPs_DEBUG_MODE
00070                 #ifdef TAPs_USE_WXWIDGETS
00071                     wxLogWarning( wxT( "ERROR: Could not create vertex shader \"%s\"" ), vertFile.c_str() );
00072                 #else
00073                     std::cout << "ERROR: Could not create vertex shader \"" << vertFile << "\"";
00074                 #endif
00075             #endif
00076             return NULL;
00077         }
00078
00079         if ( vertShader->Load( vertFile.c_str() ) ) {
00080             #ifdef TAPs_USE_WXWIDGETS
00081                 wxLogError( wxT( "ERROR: Could not load a vertex shader named \"%s\"" ), vertFile );
00082             #else
00083                 std::cerr << "ERROR: Could not load a vertex shader named \"" << vertFile << "\"!\n";
00084             #endif
00085             return NULL;
00086         }
00087
00088         if ( !vertShader->Compile() ) {
00089             #ifdef TAPs_DEBUG_MODE
00090                 #ifdef TAPs_USE_WXWIDGETS
00091                     wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), vertFile.c_str() );
00092                     wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() );
00093                 #else
00094                     std::cerr << "ERROR: \"" << vertFile << "\" Compilation Error:\n";
00095                     std::cerr << vertShader->GetCompilerLog() << "\n";
00096                 #endif
00097             #endif
00098             delete vertShader;
00099             return NULL;
00100         }
00101
00102         #ifdef TAPs_DEBUG_MODE
00103             #ifdef TAPs_USE_WXWIDGETS
00104                 wxLogWarning( wxT( " is successful!" ) );
00105             #else
00106                 std::cout << " is successful!\n";
00107             #endif
00108         #endif
00109         // Add the vertex shader to the list
00110         m_vVertexShaderList.push_back( vertShader );
00111         return vertShader;
00112     }
00113     return NULL;
00114 } // END: GLSLVertexShader * GLSLShaderPool::CreateVertexShaderFromFile   ( std::string const & vertFile )
00115 //-----------------------------------------------------------------------------
00116 //-----------------------------------------------------------------------------
00117 GLSLGeometryShader * GLSLShaderPool::CreateGeometryShaderFromFile   ( std::string const & geomFile )
00118 {
00119     if ( !geomFile.empty() ) {
00120         #ifdef TAPs_DEBUG_MODE
00121             #ifdef TAPs_USE_WXWIDGETS
00122                 wxLogWarning( wxT( "Load geometry shader \"%s\"" ), geomFile.c_str() );
00123             #else
00124                 std::cout << "Load geometry shader \"" << geomFile << "\"";
00125             #endif
00126         #endif
00127
00128         GLSLGeometryShader * geomShader = new GLSLGeometryShader();
00129         if ( !geomShader ) {
00130             #ifdef TAPs_DEBUG_MODE
00131                 #ifdef TAPs_USE_WXWIDGETS
00132                     wxLogWarning( wxT( "ERROR: Could not create geometry shader \"%s\"" ), geomFile.c_str() );
00133                 #else
00134                     std::cout << "ERROR: Could not create geometry shader \"" << geomFile << "\"";
00135                 #endif
00136             #endif
00137             return NULL;
00138         }
00139
00140         if ( geomShader->Load( geomFile.c_str() ) ) {
00141             #ifdef TAPs_USE_WXWIDGETS
00142                 wxLogError( wxT( "ERROR: Could not load a geometry shader named \"%s\"" ), geomFile.c_str() );
00143             #else
00144                 std::cerr << "ERROR: Could not load a geometry shader named \"" << geomFile << "\"!\n";
00145             #endif
00146             return NULL;
00147         }
00148
00149         if ( !geomShader->Compile() ) {
00150             #ifdef TAPs_DEBUG_MODE
00151                 #ifdef TAPs_USE_WXWIDGETS
00152                     wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), geomFile.c_str() );
00153                     wxLogError( wxT( "%s" ), geomShader->GetCompilerLog() );
00154                 #else
00155                     std::cerr << "ERROR: \"" << geomFile << "\" Compilation Error:\n";
00156                     std::cerr << geomShader->GetCompilerLog() << "\n";
00157                 #endif
00158             #endif
00159             delete geomShader;
00160             return NULL;
00161         }
00162
00163         #ifdef TAPs_DEBUG_MODE
00164             #ifdef TAPs_USE_WXWIDGETS
00165                 wxLogWarning( wxT( " is successful!" ) );
00166             #else
00167                 std::cout << " is successful!\n";
00168             #endif
00169         #endif
00170
00171         // Add the geometry shader to the list
00172         m_vGeometryShaderList.push_back( geomShader );
00173         return geomShader;
00174     }
00175     return NULL;
00176 } // END: GLSLGeometryShader * GLSLShaderPool::CreateGeometryShaderFromFile   ( std::string const & geomFile )
00177 //-----------------------------------------------------------------------------
00178 //-----------------------------------------------------------------------------
00179 GLSLFragmentShader * GLSLShaderPool::CreateFragmentShaderFromFile   ( std::string const & fragFile )
00180 {
00181     if ( !fragFile.empty() ) {
00182         #ifdef TAPs_DEBUG_MODE
00183             #ifdef TAPs_USE_WXWIDGETS
00184                 wxLogWarning( wxT( "Load fragment shader \"%s\"" ), fragFile.c_str() );
00185             #else
00186                 std::cout << "Load fragment shader \"" << fragFile << "\"";
00187             #endif
00188         #endif
00189
00190         GLSLFragmentShader * fragShader = new GLSLFragmentShader();
00191         if ( !fragShader ) {
00192             #ifdef TAPs_DEBUG_MODE
00193                 #ifdef TAPs_USE_WXWIDGETS
00194                     wxLogWarning( wxT( "ERROR: Could not create fragment shader \"%s\"" ), fragFile.c_str() );
00195                 #else
00196                     std::cout << "ERROR: Could not create fragment shader \"" << fragFile << "\"";
00197                 #endif
00198             #endif
00199             return NULL;
00200         }
00201
00202         if ( fragShader->Load( fragFile.c_str() ) ) {
00203             #ifdef TAPs_USE_WXWIDGETS
00204                 wxLogError( wxT( "ERROR: Could not load a fragment shader named \"%s\"" ), fragFile.c_str() );
00205             #else
00206                 std::cerr << "ERROR: Could not load a fragment shader named \"" << fragFile << "\"!\n";
00207             #endif
00208             return NULL;
00209         }
00210
00211         if ( !fragShader->Compile() ) {
00212             #ifdef TAPs_DEBUG_MODE
00213                 #ifdef TAPs_USE_WXWIDGETS
00214                     wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), fragFile.c_str() );
00215                     wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() );
00216                 #else
00217                     std::cerr << "ERROR: \"" << fragFile << "\" Compilation Error:\n";
00218                     std::cerr << fragShader->GetCompilerLog() << "\n";
00219                 #endif
00220             #endif
00221             delete fragShader;
00222             return NULL;
00223         }
00224
00225         #ifdef TAPs_DEBUG_MODE
00226             #ifdef TAPs_USE_WXWIDGETS
00227                 wxLogWarning( wxT( " is successful!" ) );
00228             #else
00229                 std::cout << " is successful!\n";
00230             #endif
00231         #endif
00232         // Add the fragment shader to the list
00233         m_vFragmentShaderList.push_back( fragShader );
00234         return fragShader;
00235     }
00236     return NULL;
00237 } // END: GLSLFragmentShader * GLSLShaderPool::CreateFragmentShaderFromFile   ( std::string const & fragFile )
00238 //-----------------------------------------------------------------------------
00239
00240 //-----------------------------------------------------------------------------
00241 GLSLProgramObject * GLSLShaderPool::CreateShaderProgram (
00242     GLSLVertexShader   * vertShader,
00243     GLSLGeometryShader * geomShader,
00244     GLSLFragmentShader * fragShader
00245 )
00246 {
00247     GLSLProgramObject * shaderProgram = new GLSLProgramObject();
00248     if ( !shaderProgram ) {
00249         #ifdef TAPs_DEBUG_MODE
00250             #ifdef TAPs_USE_WXWIDGETS
00251                 wxLogWarning( wxT( "Couldn't create a shader program for shaders: vert: %s, geom: %s, frag: %s" ),
00252                                 vertShader->GetName(), geomShader->GetName(), fragShader->GetName() );
00253             #else
00254                 std::cout << "Load fragment shader \"" << fragFile << "\"";
00255             #endif
00256         #endif
00257         return NULL;
00258     }
00259
00260     // Add shader objects to the shader program
00261     if ( vertShader )   shaderProgram->AddShader( vertShader );
00262     if ( geomShader )   shaderProgram->AddShader( geomShader );
00263     if ( fragShader )   shaderProgram->AddShader( fragShader );
00264
00265     // Link the shader program
00266     if ( !shaderProgram->Link() ) {
00267         #ifdef TAPs_USE_WXWIDGETS
00268             wxLogError( wxT( "ERROR: Cound not link shader(s) in the program object (%d)!" ), shaderProgram->GetProgramObject() );
00269             wxLogError( wxT( "%s" ), shaderProgram->GetLinkerLog() );
00270         #else
00271             std::cerr << "ERROR: Cound not link shader(s) in the program object (" << shaderProgram->GetProgramObject() << ")!\n";
00272             std::cerr << shaderProgram->GetLinkerLog() << "\n";
00273         #endif
00274         delete shaderProgram;
00275         return NULL;
00276     }
00277
00278     #ifdef TAPs_DEBUG_MODE
00279         #ifdef TAPs_USE_WXWIDGETS
00280             wxLogWarning( wxT( "Creating the shader program is successful!" ) );
00281         #else
00282             std::cout << "Creating the shader program is successful!\n";
00283         #endif
00284     #endif
00285     // Add the shader program to the list
00286     m_vProgramObjectList.push_back( shaderProgram );
00287     return shaderProgram;
00288 }
00289 //-----------------------------------------------------------------------------
00290
00291 //-----------------------------------------------------------------------------
00292 //=============================================================================
00293 END_NAMESPACE_TAPs__OpenGL
00294 //34567890123456789012345678901234567890123456789012345678901234567890123456789
00295 //--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----