 |
TAPs 0.7.7.3
|
|
TAPs 0.7.7.3
|
00001 /****************************************************************************** 00002 TAPsGLSLSupport.cpp 00003 00004 Based on 3DLabs Inc. Ltd. and aGLSL.h by Martin Christen. 00005 00006 SUKITTI PUNAK (09/09/2010) 00007 UPDATE (09/10/2010) 00008 ******************************************************************************/ 00009 #include "STAPsGLSLSupport.hpp" 00010 // Using Inclusion Model (i.e. definitions are included in declarations) 00011 // (this name.cpp is included in name.hpp) 00012 // Each friend is defined directly inside its declaration. 00013 00014 BEGIN_NAMESPACE_TAPs__OpenGL 00015 //============================================================================= 00016 // Global Variables 00017 //----------------------------------------------------------------------------- 00018 char * gbGLSLErrStr[] = { 00019 "GLSL is not supported/enabled!", // ERR00 00020 "Not a valid program object!", // ERR01 00021 "Not a valid object!", // ERR02 00022 "Out of memory!", // ERR03 00023 "Compiler log is not available!", // ERR04 00024 "Unknown compiler error!" // ERR05 00025 "Linker log is not available!", // ERR06 00026 "Unknown linker error!", // ERR07 00027 "" // ERR08 00028 }; 00029 bool gbIsGLSLSupported = false; 00030 bool gbIsInitialized = false; 00031 //----------------------------------------------------------------------------- 00032 //============================================================================= 00033 // Global Functions 00034 //----------------------------------------------------------------------------- 00035 // Get file length 00036 unsigned long GFnGetFileLength ( std::ifstream & file ) 00037 { 00038 if ( !file.good() ) return 0; 00039 //unsigned long pos = file.tellg(); 00040 file.seekg( 0, std::ios::end ); 00041 unsigned long len = file.tellg(); 00042 file.seekg( std::ios::beg ); 00043 #ifdef TAPs_DEBUG_MODE 00044 #ifdef TAPs_USE_WXWIDGETS 00045 wxLogWarning( wxT( "Length of File: %d" ), len ); 00046 #else 00047 std::cout << "Length of File: " << len << std::endl; 00048 #endif 00049 #endif 00050 return len; 00051 } 00052 //----------------------------------------------------------------------------- 00053 // Get file length 00054 unsigned long GFnGetFileLength ( const char * fileName ) 00055 { 00056 // Returns the size in bytes of the shader fileName. 00057 // If an error occurred, it returns -1. 00058 int fd; 00059 int count = -1; 00060 // 00061 // Open the file, seek to the end to find its length 00062 // 00063 #ifdef WIN32 /*[*/ 00064 fd = _open(fileName, _O_RDONLY); 00065 if (fd != -1) 00066 { 00067 count = _lseek(fd, 0, SEEK_END) + 1; 00068 _close(fd); 00069 } 00070 #else /*][*/ 00071 fd = open(fileName, O_RDONLY); 00072 if (fd != -1) 00073 { 00074 count = lseek(fd, 0, SEEK_END) + 1; 00075 close(fd); 00076 } 00077 #endif /*]*/ 00078 00079 return count; 00080 } 00081 //----------------------------------------------------------------------------- 00082 bool GFnInitGLSL () 00083 { 00084 if ( gbIsGLSLSupported ) return true; // GLSL has already been initialized 00085 //--------------------------------------------------------------- 00086 // Initialize the "OpenGL Extension Wrangler" library 00087 if ( gbIsInitialized ) return true; 00088 gbIsInitialized = true; 00089 GLenum err = glewInit(); 00090 if ( GLEW_OK != err ) { 00091 #ifdef TAPs_USE_WXWIDGETS 00092 wxLogError( wxT( "Error: %s" ), glewGetErrorString( err ) ); 00093 #else 00094 std::cerr << "Error: " << glewGetErrorString( err ) << std::endl; 00095 #endif 00096 gbIsGLSLSupported = false; 00097 return gbIsGLSLSupported; 00098 } 00099 //--------------------------------------------------------------- 00100 // OpenGL Info 00101 #ifdef TAPs_DEBUG_MODE 00102 #ifdef TAPs_USE_WXWIDGETS 00103 wxLogWarning( wxT( "OpenGL Vendor: %s" ), glGetString( GL_VENDOR ) ); 00104 wxLogWarning( wxT( "OpenGL Renderer: %s" ), glGetString( GL_RENDERER ) ); 00105 wxLogWarning( wxT( "OpenGL Version: %s" ), glGetString( GL_VERSION ) ); 00106 #else 00107 std::cout << "OpenGL Vendor: " << glGetString( GL_VENDOR ) << "\n"; 00108 std::cout << "OpenGL Renderer: " << glGetString( GL_RENDERER ) << "\n"; 00109 std::cout << "OpenGL Version: " << glGetString( GL_VERSION ) << "\n"; 00110 #endif 00111 #endif 00112 //--------------------------------------------------------------- 00113 GFnCheckGLSL(); 00114 //--------------------------------------------------------------- 00115 return gbIsGLSLSupported; 00116 } 00117 //----------------------------------------------------------------------------- 00118 bool GFnCheckGLSL () 00119 { 00120 if ( gbIsGLSLSupported ) return true; // GLSL is available and initailized 00121 //--------------------------------------------------------------- 00122 if ( !gbIsInitialized ) GFnInitGLSL(); 00123 //--------------------------------------------------------------- 00124 #ifdef TAPs_DEBUG_MODE 00125 #ifdef TAPs_USE_WXWIDGETS 00126 if ( GLEW_VERSION_4_1 ) 00127 wxLogWarning( wxT( "OpenGL 4.1 is available!" ) ); 00128 else if ( GLEW_VERSION_4_0 ) 00129 wxLogWarning( wxT( "OpenGL 4.0 is available!" ) ); 00130 else if ( GLEW_VERSION_3_3 ) 00131 wxLogWarning( wxT( "OpenGL 3.3 is available!" ) ); 00132 else if ( GLEW_VERSION_3_2 ) 00133 wxLogWarning( wxT( "OpenGL 3.2 is available!" ) ); 00134 else if ( GLEW_VERSION_3_1 ) 00135 wxLogWarning( wxT( "OpenGL 3.1 is available!" ) ); 00136 else if ( GLEW_VERSION_3_0 ) 00137 wxLogWarning( wxT( "OpenGL 3.0 is available!" ) ); 00138 else if ( GLEW_VERSION_2_1 ) 00139 wxLogWarning( wxT( "OpenGL 2.1 is available!" ) ); 00140 else if ( GLEW_VERSION_2_0 ) 00141 wxLogWarning( wxT( "OpenGL 2.0 is available!" ) ); 00142 else if ( GLEW_VERSION_1_5 ) 00143 wxLogWarning( wxT( "OpenGL 1.5 is available!" ) ); 00144 else if ( GLEW_VERSION_1_4 ) 00145 wxLogWarning( wxT( "OpenGL 1.4 is available!" ) ); 00146 else if ( GLEW_VERSION_1_3 ) 00147 wxLogWarning( wxT( "OpenGL 1.3 is available!" ) ); 00148 else if ( GLEW_VERSION_1_2 ) 00149 wxLogWarning( wxT( "OpenGL 1.2 is available!" ) ); 00150 else if ( GLEW_VERSION_1_1 ) 00151 wxLogWarning( wxT( "OpenGL 1.1 is available!" ) ); 00152 #else 00153 if ( GLEW_VERSION_4_1 ) 00154 std::cout << "OpenGL 4.1 is available!\n"; 00155 else if ( GLEW_VERSION_4_0 ) 00156 std::cout << "OpenGL 4.0 is available!\n"; 00157 else if ( GLEW_VERSION_3_3 ) 00158 std::cout << "OpenGL 3.3 is available!\n"; 00159 else if ( GLEW_VERSION_3_2 ) 00160 std::cout << "OpenGL 3.2 is available!\n"; 00161 else if ( GLEW_VERSION_3_1 ) 00162 std::cout << "OpenGL 3.1 is available!\n"; 00163 else if ( GLEW_VERSION_3_0 ) 00164 std::cout << "OpenGL 3.0 is available!\n"; 00165 else if ( GLEW_VERSION_2_1 ) 00166 std::cout << "OpenGL 2.1 is available!\n"; 00167 else if ( GLEW_VERSION_2_0 ) 00168 std::cout << "OpenGL 2.0 is available!\n"; 00169 else if ( GLEW_VERSION_1_5 ) 00170 std::cout << "OpenGL 1.5 is available!\n"; 00171 else if ( GLEW_VERSION_1_4 ) 00172 std::cout << "OpenGL 1.4 is available!\n"; 00173 else if ( GLEW_VERSION_1_3 ) 00174 std::cout << "OpenGL 1.3 is available!\n"; 00175 else if ( GLEW_VERSION_1_2 ) 00176 std::cout << "OpenGL 1.2 is available!\n"; 00177 else if ( GLEW_VERSION_1_1 ) 00178 std::cout << "OpenGL 1.1 is available!\n"; 00179 #endif 00180 #endif 00181 //--------------------------------------------------------------- 00182 // Ensure we have the necessary OpenGL Shading Language extensions. 00183 if (glewGetExtension("GL_ARB_fragment_shader") != GL_TRUE || 00184 glewGetExtension("GL_ARB_vertex_shader") != GL_TRUE || 00185 glewGetExtension("GL_ARB_shader_objects") != GL_TRUE ) //|| 00186 //glewGetExtension("GL_ARB_shading_language_100") != GL_TRUE) 00187 { 00188 #ifdef TAPs_DEBUG_MODE 00189 #ifdef TAPs_USE_WXWIDGETS 00190 wxLogError( wxT( "[FAILIED] OpenGL Shading Language is NOT available!" ) ); 00191 #else 00192 std::cerr << "[FAILIED] OpenGL Shading Language is NOT available!\n"; 00193 #endif 00194 #endif 00195 gbIsGLSLSupported = false; 00196 } 00197 else { 00198 #ifdef TAPs_DEBUG_MODE 00199 #ifdef TAPs_USE_WXWIDGETS 00200 wxLogWarning( wxT( "[OK] OpenGL Shading Language is available!" ) ); 00201 #else 00202 std::cout << "[OK] OpenGL Shading Language is available!\n"; 00203 #endif 00204 #endif 00205 gbIsGLSLSupported = true; 00206 } 00207 //--------------------------------------------------------------- 00208 // Ensure we have the geometry OpenGL Shading Language extensions. 00209 if ( glewGetExtension("GL_EXT_geometry_shader4") != GL_TRUE ) 00210 { 00211 #ifdef TAPs_DEBUG_MODE 00212 #ifdef TAPs_USE_WXWIDGETS 00213 wxLogError( wxT( "[FAILIED] GL_EXT_geometry_shader4, OpenGL Shading Language, is NOT available!" ) ); 00214 #else 00215 std::cerr << "[FAILIED] GL_EXT_geometry_shader4, OpenGL Shading Language, is NOT available!\n"; 00216 #endif 00217 #endif 00218 //gbIsGLSLSupported = false; 00219 } 00220 else { 00221 #ifdef TAPs_DEBUG_MODE 00222 #ifdef TAPs_USE_WXWIDGETS 00223 wxLogWarning( wxT( "[OK] GL_EXT_geometry_shader4, OpenGL Shading Language, is available!" ) ); 00224 #else 00225 std::cout << "[OK] GL_EXT_geometry_shader4, OpenGL Shading Language, is available!\n"; 00226 #endif 00227 #endif 00228 //gbIsGLSLSupported = true; 00229 } 00230 //--------------------------------------------------------------- 00231 return gbIsGLSLSupported; 00232 } 00233 //----------------------------------------------------------------------------- 00234 //============================================================================= 00235 00236 00237 //****************************************************************************** 00238 //============================================================================= 00239 // class GLSLProgramObject 00240 //----------------------------------------------------------------------------- 00241 // Static Variable(s) 00242 bool GLSLProgramObject::m_stcbShaderActive = true; 00243 //----------------------------------------------------------------------------- 00244 // Constructor 00245 GLSLProgramObject::GLSLProgramObject () : 00246 m_uiProgramObject( NULL ), 00247 m_bLinkStatus( false ), 00248 m_cpLinkerLog( NULL ), 00249 m_bManageMemory( false ) 00250 { 00251 if ( GFnInitGLSL() ) { 00252 m_uiProgramObject = glCreateProgram(); 00253 Fn::CHECK_GL_ERROR(); 00254 } 00255 else { 00256 #ifdef TAPs_USE_WXWIDGETS 00257 wxLogWarning( wxT( "ERROR: OpenGL Shading Language is NOT available!" ) ); 00258 #else 00259 std::cout << "ERROR: OpenGL Shading Language is NOT available!\n"; 00260 #endif 00261 } 00262 } 00263 //----------------------------------------------------------------------------- 00264 // Destructor 00265 GLSLProgramObject::~GLSLProgramObject () 00266 { 00267 /* 00268 #ifdef TAPs_DEBUG_MODE 00269 #ifdef TAPs_USE_WXWIDGETS 00270 //wxLogWarning( wxT( "START: Delete An Object of Class GLSLProgramObject." ) ); 00271 wxMessageBox( wxT( "START: Delete An Object of Class GLSLProgramObject." ) ); 00272 #else 00273 std::cout << "START: Delete An Object of Class GLSLProgramObject."; 00274 #endif 00275 #endif 00276 //*/ 00277 //--------------------------------------------------------------- 00278 if ( m_cpLinkerLog ) { 00279 delete [] m_cpLinkerLog; 00280 m_cpLinkerLog = NULL; 00281 } 00282 if ( gbIsGLSLSupported && m_uiProgramObject ) 00283 { 00284 for (unsigned int i = 0; i < m_vShaderList.size(); ++i ) { 00285 glDetachShader( m_uiProgramObject, m_vShaderList[i]->m_uiShaderObject ); 00286 Fn::CHECK_GL_ERROR(); // if get an error here, the program object is deleted first 00287 // the m_uiProgramObject must be deleted last 00288 if ( m_bManageMemory ) 00289 delete m_vShaderList[i]; 00290 } 00291 glDeleteProgram( m_uiProgramObject ); 00292 Fn::CHECK_GL_ERROR(); 00293 m_uiProgramObject = 0; 00294 } 00295 //--------------------------------------------------------------- 00296 /* 00297 #ifdef TAPs_DEBUG_MODE 00298 #ifdef TAPs_USE_WXWIDGETS 00299 //wxLogWarning( wxT( "END: Delete An Object of Class GLSLProgramObject." ) ); 00300 wxMessageBox( wxT( "END: Delete An Object of Class GLSLProgramObject." ) ); 00301 #else 00302 std::cout << "END: Delete An Object of Class GLSLProgramObject."; 00303 #endif 00304 #endif 00305 //*/ 00306 } 00307 //----------------------------------------------------------------------------- 00308 // IsGLSLEnabled 00309 bool GLSLProgramObject::IsGLSLEnabled () 00310 { 00311 return gbIsGLSLSupported; 00312 } 00313 //----------------------------------------------------------------------------- 00314 // Add a vertex or fragment shader 00315 void GLSLProgramObject::AddShader ( GLSLShader * glslShader ) 00316 { 00317 if ( !gbIsGLSLSupported ) return; 00318 if ( glslShader == NULL ) return; 00319 if ( !glslShader->m_bCompileStatus ) { 00320 #ifdef TAPs_DEBUG_MODE 00321 #ifdef TAPs_USE_WXWIDGETS 00322 wxLogWarning( wxT( "Trying to compile the shader program ... " ) ); 00323 if ( !glslShader->Compile() ) { 00324 wxLogError( wxT( " ... compile ERROR!" ) ); 00325 return; 00326 } 00327 else { 00328 wxLogWarning( wxT( " ... Compilation Passed!" ) ); 00329 } 00330 #else 00331 std::cout << "Trying to compile the shader program ... "; 00332 if ( !glslShader->Compile() ) { 00333 std::cout << " ... compile ERROR!\n"; 00334 return; 00335 } 00336 else { 00337 std::cout << " ... Compilation Passed!\n"; 00338 } 00339 #endif 00340 #endif 00341 } 00342 m_vShaderList.push_back( glslShader ); 00343 } 00344 //----------------------------------------------------------------------------- 00345 // Link 00346 bool GLSLProgramObject::Link () 00347 { 00348 if ( !gbIsGLSLSupported ) return false; 00349 unsigned int i; 00350 //---------------------------------------------------------------- 00351 if ( m_bLinkStatus ) { // already linked, detach everything 00352 #ifdef TAPs_DEBUG_MODE 00353 #ifdef TAPs_USE_WXWIDGETS 00354 wxLogWarning( wxT( "Object is already linked, trying to link it again ..." ) ); 00355 #else 00356 std::cout << "Object is already linked, trying to link it again ..."; 00357 #endif 00358 #endif 00359 for ( i = 0; i < m_vShaderList.size(); ++i ) { 00360 glDetachShader( m_uiProgramObject, m_vShaderList[i]->m_uiShaderObject ); 00361 Fn::CHECK_GL_ERROR(); 00362 } 00363 } 00364 //---------------------------------------------------------------- 00365 for ( i = 0; i < m_vShaderList.size(); ++i ) { 00366 glAttachShader( m_uiProgramObject, m_vShaderList[i]->m_uiShaderObject ); 00367 Fn::CHECK_GL_ERROR(); 00368 } 00369 //---------------------------------------------------------------- 00370 int linked; 00371 glLinkProgram( m_uiProgramObject ); 00372 Fn::CHECK_GL_ERROR(); 00373 glGetProgramiv( m_uiProgramObject, GL_LINK_STATUS, &linked ); 00374 Fn::CHECK_GL_ERROR(); 00375 //---------------------------------------------------------------- 00376 if ( linked ) { 00377 m_bLinkStatus = true; 00378 } 00379 else { 00380 m_bLinkStatus = false; 00381 #ifdef TAPs_USE_WXWIDGETS 00382 wxLogError( wxT( "ERROR: GLSL Linker Error" ) ); 00383 #else 00384 std::cerr << "ERROR: GLSL Linker Error" << std::endl; 00385 #endif 00386 } 00387 //---------------------------------------------------------------- 00388 return m_bLinkStatus; 00389 } 00390 //----------------------------------------------------------------------------- 00391 // Get linker messages 00392 char * GLSLProgramObject::GetLinkerLog () 00393 { 00394 //---------------------------------------------------------------- 00395 if ( !gbIsGLSLSupported ) return gbGLSLErrStr[0]; 00396 int bLen = 0, sLen = 0; 00397 //---------------------------------------------------------------- 00398 if ( m_uiProgramObject == NULL ) return gbGLSLErrStr[2]; 00399 glGetProgramiv( m_uiProgramObject, GL_INFO_LOG_LENGTH, &bLen ); 00400 Fn::CHECK_GL_ERROR(); 00401 //---------------------------------------------------------------- 00402 if ( bLen > 1 ) { 00403 if ( m_cpLinkerLog ) { 00404 delete [] m_cpLinkerLog; 00405 m_cpLinkerLog = NULL; 00406 } 00407 if ( (m_cpLinkerLog = new GLchar[bLen]) == NULL ) { 00408 //if ( (m_cpLinkerLog = (GLchar *) malloc (bLen*sizeof(char))) == NULL ) { 00409 #ifdef TAPs_USE_WXWIDGETS 00410 wxLogError( wxT( "ERROR: Cound not allocate linker log buffer" ) ); 00411 #else 00412 std::cerr << "ERROR: Cound not allocate linker log buffer\n"; 00413 #endif 00414 return gbGLSLErrStr[3]; 00415 } 00416 glGetProgramInfoLog( m_uiProgramObject, bLen, &sLen, m_cpLinkerLog ); 00417 Fn::CHECK_GL_ERROR(); 00418 } 00419 if ( m_cpLinkerLog ) { 00420 return static_cast<char *>( m_cpLinkerLog ); 00421 } 00422 else { 00423 return gbGLSLErrStr[6]; 00424 } 00425 //---------------------------------------------------------------- 00426 return gbGLSLErrStr[7]; 00427 } 00428 //----------------------------------------------------------------------------- 00429 // Begin this shader. OpenGL calls will go through shader 00430 void GLSLProgramObject::BeginGLSL () 00431 { 00432 if ( !gbIsGLSLSupported ) return; 00433 if ( m_uiProgramObject == NULL ) return; 00434 if ( !m_stcbShaderActive ) return; 00435 if ( m_bLinkStatus ) { 00436 glUseProgram( m_uiProgramObject ); 00437 Fn::CHECK_GL_ERROR(); 00438 } 00439 } 00440 //----------------------------------------------------------------------------- 00441 // Stop using this shader. OpenGL calls will go through regular pipeline. 00442 void GLSLProgramObject::EndGLSL () 00443 { 00444 if ( !gbIsGLSLSupported ) return; 00445 if ( !m_stcbShaderActive ) return; 00446 glUseProgram( NULL ); 00447 Fn::CHECK_GL_ERROR(); 00448 } 00449 00450 //============================================================================= 00451 // START: Float 00452 //----------------------------------------------------------------------------- 00453 bool GLSLProgramObject::SetUniform1f ( char *var, GLfloat x ) 00454 { 00455 if ( !gbIsGLSLSupported ) return false; 00456 if ( !m_stcbShaderActive ) return true; 00457 //---------------------------------------------------------------- 00458 GLint loc = GetUniLoc( var ); 00459 if ( loc == -1 ) return false; // cannot find variable 00460 //---------------------------------------------------------------- 00461 glUniform1f( loc, x ); 00462 return true; 00463 } 00464 //----------------------------------------------------------------------------- 00465 bool GLSLProgramObject::SetUniform2f ( char *var, GLfloat x, GLfloat y ) 00466 { 00467 if ( !gbIsGLSLSupported ) return false; 00468 if ( !m_stcbShaderActive ) return true; 00469 //---------------------------------------------------------------- 00470 GLint loc = GetUniLoc( var ); 00471 if ( loc == -1 ) return false; // cannot find variable 00472 //---------------------------------------------------------------- 00473 glUniform2f( loc, x, y ); 00474 return true; 00475 } 00476 //----------------------------------------------------------------------------- 00477 bool GLSLProgramObject::SetUniform3f ( char *var, GLfloat x, GLfloat y, GLfloat z ) 00478 { 00479 if ( !gbIsGLSLSupported ) return false; 00480 if ( !m_stcbShaderActive ) return true; 00481 //---------------------------------------------------------------- 00482 GLint loc = GetUniLoc( var ); 00483 if ( loc == -1 ) return false; // cannot find variable 00484 //---------------------------------------------------------------- 00485 glUniform3f( loc, x, y, z ); 00486 return true; 00487 } 00488 //----------------------------------------------------------------------------- 00489 bool GLSLProgramObject::SetUniform4f ( char *var, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) 00490 { 00491 if ( !gbIsGLSLSupported ) return false; 00492 if ( !m_stcbShaderActive ) return true; 00493 //---------------------------------------------------------------- 00494 GLint loc = GetUniLoc( var ); 00495 if ( loc == -1 ) return false; // cannot find variable 00496 //---------------------------------------------------------------- 00497 glUniform4f( loc, x, y, z, w ); 00498 return true; 00499 } 00500 //----------------------------------------------------------------------------- 00501 // END: Float 00502 //============================================================================= 00503 00504 //============================================================================= 00505 // START: Integer 00506 //----------------------------------------------------------------------------- 00507 bool GLSLProgramObject::SetUniform1i ( char *var, GLint x ) 00508 { 00509 if ( !gbIsGLSLSupported ) return false; 00510 if ( !m_stcbShaderActive ) return true; 00511 //---------------------------------------------------------------- 00512 GLint loc = GetUniLoc( var ); 00513 if ( loc == -1 ) return false; // cannot find variable 00514 //---------------------------------------------------------------- 00515 glUniform1i( loc, x ); 00516 return true; 00517 } 00518 //----------------------------------------------------------------------------- 00519 bool GLSLProgramObject::SetUniform2i ( char *var, GLint x, GLint y ) 00520 { 00521 if ( !gbIsGLSLSupported ) return false; 00522 if ( !m_stcbShaderActive ) return true; 00523 //---------------------------------------------------------------- 00524 GLint loc = GetUniLoc( var ); 00525 if ( loc == -1 ) return false; // cannot find variable 00526 //---------------------------------------------------------------- 00527 glUniform2i( loc, x, y ); 00528 return true; 00529 } 00530 //----------------------------------------------------------------------------- 00531 bool GLSLProgramObject::SetUniform3i ( char *var, GLint x, GLint y, GLint z ) 00532 { 00533 if ( !gbIsGLSLSupported ) return false; 00534 if ( !m_stcbShaderActive ) return true; 00535 //---------------------------------------------------------------- 00536 GLint loc = GetUniLoc( var ); 00537 if ( loc == -1 ) return false; // cannot find variable 00538 //---------------------------------------------------------------- 00539 glUniform3i( loc, x, y, z ); 00540 return true; 00541 } 00542 //----------------------------------------------------------------------------- 00543 bool GLSLProgramObject::SetUniform4i ( char *var, GLint x, GLint y, GLint z, GLint w ) 00544 { 00545 if ( !gbIsGLSLSupported ) return false; 00546 if ( !m_stcbShaderActive ) return true; 00547 //---------------------------------------------------------------- 00548 GLint loc = GetUniLoc( var ); 00549 if ( loc == -1 ) return false; // cannot find variable 00550 //---------------------------------------------------------------- 00551 glUniform4i( loc, x, y, z, w ); 00552 return true; 00553 } 00554 //----------------------------------------------------------------------------- 00555 // END: Integer 00556 //============================================================================= 00557 00558 //============================================================================= 00559 // START: Unsigned Integer 00560 //----------------------------------------------------------------------------- 00561 bool GLSLProgramObject::SetUniform1ui ( char *var, GLuint x ) 00562 { 00563 if ( !gbIsGLSLSupported ) return false; 00564 if ( !m_stcbShaderActive ) return true; 00565 //---------------------------------------------------------------- 00566 GLint loc = GetUniLoc( var ); 00567 if ( loc == -1 ) return false; // cannot find variable 00568 //---------------------------------------------------------------- 00569 glUniform1uiEXT( loc, x ); 00570 return true; 00571 } 00572 //----------------------------------------------------------------------------- 00573 bool GLSLProgramObject::SetUniform2ui ( char *var, GLuint x, GLuint y ) 00574 { 00575 if ( !gbIsGLSLSupported ) return false; 00576 if ( !m_stcbShaderActive ) return true; 00577 //---------------------------------------------------------------- 00578 GLint loc = GetUniLoc( var ); 00579 if ( loc == -1 ) return false; // cannot find variable 00580 //---------------------------------------------------------------- 00581 glUniform2uiEXT( loc, x, y ); 00582 return true; 00583 } 00584 //----------------------------------------------------------------------------- 00585 bool GLSLProgramObject::SetUniform3ui ( char *var, GLuint x, GLuint y, GLuint z ) 00586 { 00587 if ( !gbIsGLSLSupported ) return false; 00588 if ( !m_stcbShaderActive ) return true; 00589 //---------------------------------------------------------------- 00590 GLint loc = GetUniLoc( var ); 00591 if ( loc == -1 ) return false; // cannot find variable 00592 //---------------------------------------------------------------- 00593 glUniform3uiEXT( loc, x, y, z ); 00594 return true; 00595 } 00596 //----------------------------------------------------------------------------- 00597 bool GLSLProgramObject::SetUniform4ui ( char *var, GLuint x, GLuint y, GLuint z, GLuint w ) 00598 { 00599 if ( !gbIsGLSLSupported ) return false; 00600 if ( !m_stcbShaderActive ) return true; 00601 //---------------------------------------------------------------- 00602 GLint loc = GetUniLoc( var ); 00603 if ( loc == -1 ) return false; // cannot find variable 00604 //---------------------------------------------------------------- 00605 glUniform4uiEXT( loc, x, y, z, w ); 00606 return true; 00607 } 00608 //----------------------------------------------------------------------------- 00609 // END: Unsigned Integer 00610 //============================================================================= 00611 00612 //============================================================================= 00613 // START: Float Vector 00614 //----------------------------------------------------------------------------- 00615 bool GLSLProgramObject::SetUniform1fv ( char *var, GLsizei count, GLfloat *val ) 00616 { 00617 if ( !gbIsGLSLSupported ) return false; 00618 if ( !m_stcbShaderActive ) return true; 00619 //---------------------------------------------------------------- 00620 GLint loc = GetUniLoc( var ); 00621 if ( loc == -1 ) return false; // cannot find variable 00622 //---------------------------------------------------------------- 00623 glUniform1fv( loc, count, val ); 00624 return true; 00625 } 00626 //----------------------------------------------------------------------------- 00627 bool GLSLProgramObject::SetUniform2fv ( char *var, GLsizei count, GLfloat *val ) 00628 { 00629 if ( !gbIsGLSLSupported ) return false; 00630 if ( !m_stcbShaderActive ) return true; 00631 //---------------------------------------------------------------- 00632 GLint loc = GetUniLoc( var ); 00633 if ( loc == -1 ) return false; // cannot find variable 00634 //---------------------------------------------------------------- 00635 glUniform2fv( loc, count, val ); 00636 return true; 00637 } 00638 //----------------------------------------------------------------------------- 00639 bool GLSLProgramObject::SetUniform3fv ( char *var, GLsizei count, GLfloat *val ) 00640 { 00641 if ( !gbIsGLSLSupported ) return false; 00642 if ( !m_stcbShaderActive ) return true; 00643 //---------------------------------------------------------------- 00644 GLint loc = GetUniLoc( var ); 00645 if ( loc == -1 ) return false; // cannot find variable 00646 //---------------------------------------------------------------- 00647 glUniform3fv( loc, count, val ); 00648 return true; 00649 } 00650 //----------------------------------------------------------------------------- 00651 bool GLSLProgramObject::SetUniform4fv ( char *var, GLsizei count, GLfloat *val ) 00652 { 00653 if ( !gbIsGLSLSupported ) return false; 00654 if ( !m_stcbShaderActive ) return true; 00655 //---------------------------------------------------------------- 00656 GLint loc = GetUniLoc( var ); 00657 if ( loc == -1 ) return false; // cannot find variable 00658 //---------------------------------------------------------------- 00659 glUniform4fv( loc, count, val ); 00660 return true; 00661 } 00662 //----------------------------------------------------------------------------- 00663 // END: Float Vector 00664 //============================================================================= 00665 00666 //============================================================================= 00667 // START: Integer Vector 00668 //----------------------------------------------------------------------------- 00669 bool GLSLProgramObject::SetUniform1iv ( char *var, GLsizei count, GLint *val ) 00670 { 00671 if ( !gbIsGLSLSupported ) return false; 00672 if ( !m_stcbShaderActive ) return true; 00673 //---------------------------------------------------------------- 00674 GLint loc = GetUniLoc( var ); 00675 if ( loc == -1 ) return false; // cannot find variable 00676 //---------------------------------------------------------------- 00677 glUniform1iv( loc, count, val ); 00678 return true; 00679 } 00680 //----------------------------------------------------------------------------- 00681 bool GLSLProgramObject::SetUniform2iv ( char *var, GLsizei count, GLint *val ) 00682 { 00683 if ( !gbIsGLSLSupported ) return false; 00684 if ( !m_stcbShaderActive ) return true; 00685 //---------------------------------------------------------------- 00686 GLint loc = GetUniLoc( var ); 00687 if ( loc == -1 ) return false; // cannot find variable 00688 //---------------------------------------------------------------- 00689 glUniform2iv( loc, count, val ); 00690 return true; 00691 } 00692 //----------------------------------------------------------------------------- 00693 bool GLSLProgramObject::SetUniform3iv ( char *var, GLsizei count, GLint *val ) 00694 { 00695 if ( !gbIsGLSLSupported ) return false; 00696 if ( !m_stcbShaderActive ) return true; 00697 //---------------------------------------------------------------- 00698 GLint loc = GetUniLoc( var ); 00699 if ( loc == -1 ) return false; // cannot find variable 00700 //---------------------------------------------------------------- 00701 glUniform3iv( loc, count, val ); 00702 return true; 00703 } 00704 //----------------------------------------------------------------------------- 00705 bool GLSLProgramObject::SetUniform4iv ( char *var, GLsizei count, GLint *val ) 00706 { 00707 if ( !gbIsGLSLSupported ) return false; 00708 if ( !m_stcbShaderActive ) return true; 00709 //---------------------------------------------------------------- 00710 GLint loc = GetUniLoc( var ); 00711 if ( loc == -1 ) return false; // cannot find variable 00712 //---------------------------------------------------------------- 00713 glUniform4iv( loc, count, val ); 00714 return true; 00715 } 00716 //----------------------------------------------------------------------------- 00717 // END: Integer Vector 00718 //============================================================================= 00719 00720 //============================================================================= 00721 // START: Matrix 00722 //----------------------------------------------------------------------------- 00723 bool GLSLProgramObject::SetUniformMatrix2fv ( char *var, GLsizei count, GLboolean transpose, GLfloat *val ) 00724 { 00725 if ( !gbIsGLSLSupported ) return false; 00726 if ( !m_stcbShaderActive ) return true; 00727 //---------------------------------------------------------------- 00728 GLint loc = GetUniLoc( var ); 00729 if ( loc == -1 ) return false; // cannot find variable 00730 //---------------------------------------------------------------- 00731 glUniformMatrix2fv( loc, count, transpose, val ); 00732 return true; 00733 } 00734 //----------------------------------------------------------------------------- 00735 bool GLSLProgramObject::SetUniformMatrix3fv ( char *var, GLsizei count, GLboolean transpose, GLfloat *val ) 00736 { 00737 if ( !gbIsGLSLSupported ) return false; 00738 if ( !m_stcbShaderActive ) return true; 00739 //---------------------------------------------------------------- 00740 GLint loc = GetUniLoc( var ); 00741 if ( loc == -1 ) return false; // cannot find variable 00742 //---------------------------------------------------------------- 00743 glUniformMatrix3fv( loc, count, transpose, val ); 00744 return true; 00745 } 00746 //----------------------------------------------------------------------------- 00747 bool GLSLProgramObject::SetUniformMatrix4fv ( char *var, GLsizei count, GLboolean transpose, GLfloat *val ) 00748 { 00749 if ( !gbIsGLSLSupported ) return false; 00750 if ( !m_stcbShaderActive ) return true; 00751 //---------------------------------------------------------------- 00752 GLint loc = GetUniLoc( var ); 00753 if ( loc == -1 ) return false; // cannot find variable 00754 //---------------------------------------------------------------- 00755 glUniformMatrix4fv( loc, count, transpose, val ); 00756 return true; 00757 } 00758 //----------------------------------------------------------------------------- 00759 // END: Matrix 00760 //============================================================================= 00761 00762 //============================================================================= 00763 // START: Get Uniform 00764 //----------------------------------------------------------------------------- 00765 void GLSLProgramObject::GetUniformfv ( char *name, GLfloat *val ) 00766 { 00767 if ( !gbIsGLSLSupported ) return; 00768 GLint loc = GetUniLoc( name ); 00769 /* 00770 GLint loc = glGetUniformLocation( m_uiProgramObject, name ); 00771 if ( loc == -1 ) { 00772 #ifdef TAPs_USE_WXWIDGETS 00773 wxLogError( wxT( "ERROR: Cannot find uniform variable \"%s\"" ), 00774 name ); 00775 #else 00776 std::cerr << "ERROR: cannot find uniform variable \"" 00777 << name << "\"\n"; 00778 #endif 00779 } 00780 //*/ 00781 glGetUniformfv( m_uiProgramObject, loc, val ); 00782 } 00783 //----------------------------------------------------------------------------- 00784 void GLSLProgramObject::GetUniformiv ( char *name, GLint *val ) 00785 { 00786 if ( !gbIsGLSLSupported ) return; 00787 GLint loc = GetUniLoc( name ); 00788 /* 00789 GLint loc = glGetUniformLocation( m_uiProgramObject, name ); 00790 if ( loc == -1 ) { 00791 #ifdef TAPs_USE_WXWIDGETS 00792 wxLogError( wxT( "ERROR: Cannot find uniform variable \"%s\"" ), 00793 name ); 00794 #else 00795 std::cerr << "ERROR: cannot find uniform variable \"" 00796 << name << "\"\n"; 00797 #endif 00798 } 00799 //*/ 00800 glGetUniformiv( m_uiProgramObject, loc, val ); 00801 } 00802 //----------------------------------------------------------------------------- 00803 void GLSLProgramObject::GetUniformuiv ( char *name, GLuint *val ) 00804 { 00805 if ( !gbIsGLSLSupported ) return; 00806 GLint loc = GetUniLoc( name ); 00807 /* 00808 GLint loc = glGetUniformLocation( m_uiProgramObject, name ); 00809 if ( loc == -1 ) { 00810 #ifdef TAPs_USE_WXWIDGETS 00811 wxLogError( wxT( "ERROR: Cannot find uniform variable \"%s\"" ), 00812 name ); 00813 #else 00814 std::cerr << "ERROR: cannot find uniform variable \"" 00815 << name << "\"\n"; 00816 #endif 00817 } 00818 //*/ 00819 glGetUniformuivEXT( m_uiProgramObject, loc, val ); 00820 } 00821 //----------------------------------------------------------------------------- 00822 // END: Get Uniform 00823 //============================================================================= 00824 00825 //----------------------------------------------------------------------------- 00826 bool GLSLProgramObject::SetVertexAttrib1f ( GLuint index, GLfloat x ) 00827 { 00828 if ( !gbIsGLSLSupported ) return false; 00829 glVertexAttrib1f( index, x ); 00830 return true; 00831 } 00832 //----------------------------------------------------------------------------- 00833 bool GLSLProgramObject::SetVertexAttrib2f ( GLuint index, GLfloat x, GLfloat y ) 00834 { 00835 if ( !gbIsGLSLSupported ) return false; 00836 glVertexAttrib2f( index, x, y ); 00837 return true; 00838 } 00839 //----------------------------------------------------------------------------- 00840 bool GLSLProgramObject::SetVertexAttrib3f ( GLuint index, GLfloat x, GLfloat y, GLfloat z ) 00841 { 00842 if ( !gbIsGLSLSupported ) return false; 00843 glVertexAttrib3f( index, x, y, z ); 00844 return true; 00845 } 00846 //----------------------------------------------------------------------------- 00847 bool GLSLProgramObject::SetVertexAttrib4f ( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) 00848 { 00849 if ( !gbIsGLSLSupported ) return false; 00850 glVertexAttrib4f( index, x, y, z, w ); 00851 return true; 00852 } 00853 //----------------------------------------------------------------------------- 00854 GLint GLSLProgramObject::GetUniLoc ( const GLchar *name ) 00855 { 00856 GLint loc = glGetUniformLocation( m_uiProgramObject, name ); 00857 if ( loc == -1 ) { 00858 #ifdef TAPs_USE_WXWIDGETS 00859 wxLogError( wxT( "ERROR: Cannot find uniform variable \"%s\"" ), 00860 name ); 00861 #else 00862 std::cerr << "ERROR: Cannot find uniform variable \"" 00863 << name << "\"\n"; 00864 #endif 00865 } 00866 Fn::CHECK_GL_ERROR(); 00867 return loc; 00868 } 00869 //----------------------------------------------------------------------------- 00870 //============================================================================= 00871 //****************************************************************************** 00872 00873 00874 //****************************************************************************** 00875 //============================================================================= 00876 // class GLSLShader 00877 //----------------------------------------------------------------------------- 00878 // Constructor 00879 GLSLShader::GLSLShader () : 00880 m_iShaderType( 0 ), // 1 = Vertex Shader; 2 = Fragment Shader; else = NONE 00881 m_uiShaderObject( NULL ), // program object 00882 m_cpShaderSource( NULL ), // ASCII source code 00883 m_bCompileStatus( false ), // true if shader is compiled 00884 m_cpCompilerLog( NULL ), // compiler log message 00885 m_bMemAlloc( false ) // true if shader allocated memory 00886 { 00887 GFnInitGLSL(); 00888 } 00889 //----------------------------------------------------------------------------- 00890 // Destructor 00891 GLSLShader::~GLSLShader () 00892 { 00893 if ( m_cpCompilerLog ) { 00894 delete [] m_cpCompilerLog; 00895 m_cpCompilerLog = NULL; 00896 } 00897 if ( m_cpShaderSource ) { 00898 if ( m_bMemAlloc ) delete [] m_cpShaderSource; 00899 m_cpShaderSource = NULL; 00900 m_bMemAlloc = false; 00901 } 00902 if ( m_bCompileStatus ) { 00903 glDeleteShader( m_uiShaderObject ); 00904 Fn::CHECK_GL_ERROR(); 00905 } 00906 } 00907 /* 00908 //----------------------------------------------------------------------------- 00909 // Load a file 00910 int GLSLShader::Load ( const char *fileName ) 00911 { 00912 std::ifstream file; 00913 if ( !file ) return -1; // File name is empty 00914 unsigned long len = GFnGetFileLength( fileName ); 00915 //--------------------------------------------------------------- 00916 file.open( fileName, std::ios::in ); 00917 //file.close(); 00918 //std::cout << "file len = " << len << std::cout; 00919 //char c; 00920 //std::cout << "Press any key to continue." << std::endl; 00921 //std::cin >> c; 00922 if ( len == 0 ) return -2; // File is empty 00923 //--------------------------------------------------------------- 00924 if ( m_cpShaderSource ) { // there is a loaded source, free it 00925 if ( m_bMemAlloc ) delete [] m_cpShaderSource; 00926 } 00927 m_cpShaderSource = new GLchar[len+1]; 00928 //m_cpShaderSource = (GLchar *) malloc (len+1); 00929 if ( m_cpShaderSource == NULL ) return -3; // cannot reserve memory 00930 m_bMemAlloc = true; 00931 //--------------------------------------------------------------- 00932 // len isn't always strlen because some characters are stripped in 00933 // ASCII read. 00934 // It is important to 0-terminate the real length later, 00935 // len is just the max location. 00936 //m_cpShaderSource[len] = 0; // '\0' 00937 m_cpShaderSource[len] = '\0'; 00938 //--------------------------------------------------------------- 00939 unsigned int i = 0; 00940 //while ( !file.eof() && i < len ) { 00941 //file.open( fileName, std::ios::in ); 00942 //while ( i < len ) { 00943 while ( file.good() ) { 00944 m_cpShaderSource[i++] = file.get(); // get a char from file 00945 //std::cout << m_cpShaderSource[i-1]; 00946 if ( i > len ) i = len; 00947 } 00948 m_cpShaderSource[i] = '\0'; // 0-terminate 00949 //std::cout << "\ni = " << i << std::endl; 00950 file.close(); 00951 //---------------------------------------------------------------- 00952 return 0; 00953 } 00954 //*/ 00955 //* 00956 //----------------------------------------------------------------------------- 00957 // Load a file 00958 int GLSLShader::Load ( const char * fileName ) 00959 { 00960 if ( !fileName ) return -1; // File name is empty 00961 unsigned long len = GFnGetFileLength( fileName ); 00962 #ifdef TAPs_DEBUG_MODE 00963 #ifdef TAPs_USE_WXWIDGETS 00964 wxLogWarning( wxT( "len: %d" ), len ); 00965 #else 00966 std::cout << "len: " << len << "\n"; 00967 #endif 00968 #endif 00969 00970 if ( len == 0 ) return -2; // File is empty 00971 //---------------------------------------------------------------- 00972 if ( m_cpShaderSource ) { // there is a loaded source, free it 00973 if ( m_bMemAlloc ) delete [] m_cpShaderSource; 00974 } 00975 m_cpShaderSource = new GLchar[len+1]; 00976 //m_cpShaderSource = (GLchar *) malloc (len+1); 00977 if ( m_cpShaderSource == NULL ) return -3; // cannot reserve memory 00978 m_bMemAlloc = true; 00979 00980 // 00981 // Open the file 00982 // 00983 FILE *fh = fopen(fileName, "r"); 00984 if (!fh) 00985 return -1; 00986 00987 // 00988 // Get the shader from a file. 00989 // 00990 fseek(fh, 0, SEEK_SET); 00991 int count = static_cast<int>( fread(m_cpShaderSource, 1, len, fh) ); 00992 m_cpShaderSource[count] = '\0'; 00993 00994 // DEBUG 00995 //for ( int i = 0; i < len; ++i ) { 00996 // std::cout << m_cpShaderSource[i]; 00997 //} 00998 00999 if (ferror(fh)) 01000 count = 0; 01001 01002 fclose(fh); 01003 //---------------------------------------------------------------- 01004 return 0; 01005 } 01006 //*/ 01007 //----------------------------------------------------------------------------- 01008 // Load a file 01009 void GLSLShader::LoadFromMemory ( const char *program ) 01010 { 01011 if ( m_cpShaderSource == NULL ) { // there is a loaded source, free it 01012 if ( m_bMemAlloc ) delete [] m_cpShaderSource; 01013 } 01014 m_bMemAlloc = false; 01015 m_cpShaderSource = (GLchar *) program; 01016 } 01017 //----------------------------------------------------------------------------- 01018 // Get compiler log messages 01019 char * GLSLShader::GetCompilerLog () 01020 { 01021 if ( !gbIsGLSLSupported ) return gbGLSLErrStr[0]; 01022 if ( m_uiShaderObject == NULL ) return gbGLSLErrStr[1]; 01023 //---------------------------------------------------------------- 01024 int bLen = 0; int sLen = 0; 01025 glGetShaderiv( m_uiShaderObject, GL_INFO_LOG_LENGTH, &bLen ); 01026 Fn::CHECK_GL_ERROR(); 01027 //---------------------------------------------------------------- 01028 if ( bLen > 1 ) { 01029 if ( m_cpCompilerLog == NULL ) { 01030 delete [] m_cpCompilerLog; 01031 m_cpCompilerLog = NULL; 01032 } 01033 if ( (m_cpCompilerLog = new GLchar[bLen]) == NULL ) { 01034 //if ( (m_cpCompilerLog = (GLchar *) malloc (bLen*sizeof(char))) == NULL ) { 01035 #ifdef TAPs_USE_WXWIDGETS 01036 wxLogError( wxT( "ERROR: Could not allocate memory for compiler log buffer" ) ); 01037 #else 01038 std::cerr << "ERROR: Could not allocate memory for compiler log buffer\n"; 01039 #endif 01040 return gbGLSLErrStr[3]; 01041 } 01042 glGetShaderInfoLog( m_uiShaderObject, bLen, &sLen, m_cpCompilerLog ); 01043 Fn::CHECK_GL_ERROR(); 01044 } 01045 if ( m_cpCompilerLog == NULL ) return static_cast<char *>( m_cpCompilerLog ); 01046 else return gbGLSLErrStr[4]; 01047 //---------------------------------------------------------------- 01048 #ifdef TAPs_DEBUG_MODE 01049 #ifdef TAPs_USE_WXWIDGETS 01050 wxLogWarning( wxT( "blen: %d" ), bLen ); 01051 wxLogWarning( wxT( "slen: %d" ), sLen ); 01052 #else 01053 std::cout << "blen: " << bLen << std::endl; 01054 std::cout << "slen: " << sLen << std::endl; 01055 #endif 01056 #endif 01057 01058 return gbGLSLErrStr[5]; 01059 } 01060 //----------------------------------------------------------------------------- 01061 // Get compiler log messages 01062 bool GLSLShader::Compile () 01063 { 01064 if ( !gbIsGLSLSupported ) { 01065 #ifdef TAPs_DEBUG_MODE 01066 #ifdef TAPs_USE_WXWIDGETS 01067 wxLogWarning( wxT( "gbIsGLSLSupported == false" ) ); 01068 #else 01069 std::cout << "gbIsGLSLSupported == false\n" << std::endl; 01070 #endif 01071 #endif 01072 return false; 01073 } 01074 m_bCompileStatus = false; 01075 int compiled = 0; 01076 if ( m_cpShaderSource == NULL ) { 01077 #ifdef TAPs_DEBUG_MODE 01078 #ifdef TAPs_USE_WXWIDGETS 01079 wxLogWarning( wxT( "m_cpShaderSource == NULL (i.e. Shader is empty!)" ) ); 01080 #else 01081 std::cout << "m_cpShaderSource == NULL (i.e. Shader is empty!)\n" << std::endl; 01082 #endif 01083 #endif 01084 return false; // Shader is empty 01085 } 01086 //---------------------------------------------------------------- 01087 GLint length = static_cast<GLint>( strlen( (const char*) m_cpShaderSource ) ); 01088 #ifdef TAPs_DEBUG_MODE 01089 #ifdef TAPs_USE_WXWIDGETS 01090 wxLogWarning( wxT( "Source (Length %d ):" ), length ); 01091 wxLogWarning( wxT( "-------------------------------------------------------------" ) ); 01092 wxLogWarning( wxT( "%s" ), m_cpShaderSource ); 01093 wxLogWarning( wxT( "-------------------------------------------------------------" ) ); 01094 #else 01095 std::cout << "Source (Length " << length << "):\n"; 01096 std::cout << "-------------------------------------------------------------\n"; 01097 std::cout << m_cpShaderSource << "\n"; 01098 std::cout << "-------------------------------------------------------------\n"; 01099 #endif 01100 #endif 01101 glShaderSource( m_uiShaderObject, 1, (const GLchar **) &m_cpShaderSource, &length ); 01102 //glShaderSource( m_uiShaderObject, 1, (const GLchar **) &m_cpShaderSource, NULL ); 01103 #ifdef TAPs_DEBUG_MODE 01104 #ifdef TAPs_USE_WXWIDGETS 01105 wxLogWarning( wxT( "Pass glShaderSource" ) ); 01106 #else 01107 std::cout << "Pass glShaderSource\n"; 01108 #endif 01109 #endif 01110 Fn::CHECK_GL_ERROR(); 01111 01112 glCompileShader( m_uiShaderObject ); 01113 #ifdef TAPs_DEBUG_MODE 01114 #ifdef TAPs_USE_WXWIDGETS 01115 wxLogWarning( wxT( "Pass glCompileShader" ) ); 01116 #else 01117 std::cout << "Pass glCompileShader\n"; 01118 #endif 01119 #endif 01120 Fn::CHECK_GL_ERROR(); 01121 01122 glGetShaderiv( m_uiShaderObject, GL_COMPILE_STATUS, &compiled ); 01123 #ifdef TAPs_DEBUG_MODE 01124 #ifdef TAPs_USE_WXWIDGETS 01125 wxLogWarning( wxT( "Pass glGetObjectParameteriv" ) ); 01126 #else 01127 std::cout << "Pass glGetObjectParameteriv\n"; 01128 #endif 01129 #endif 01130 Fn::CHECK_GL_ERROR(); 01131 //---------------------------------------------------------------- 01132 if ( compiled ) m_bCompileStatus = true; 01133 return m_bCompileStatus; 01134 } 01135 //----------------------------------------------------------------------------- 01136 // Get localtion of the attribute 01137 GLint GLSLShader::GetAttribLoc ( char * cpAttribName ) 01138 { 01139 return glGetAttribLocation( m_uiShaderObject, cpAttribName ); 01140 } 01141 //----------------------------------------------------------------------------- 01142 //============================================================================= 01143 //****************************************************************************** 01144 01145 //****************************************************************************** 01146 //============================================================================= 01147 // class GLSLVertexShader 01148 //----------------------------------------------------------------------------- 01149 // Constructor 01150 GLSLVertexShader::GLSLVertexShader () 01151 { 01152 m_iShaderType = 1; 01153 if ( gbIsGLSLSupported ) { 01154 m_uiShaderObject = glCreateShader( GL_VERTEX_SHADER ); 01155 Fn::CHECK_GL_ERROR(); 01156 } 01157 } 01158 //----------------------------------------------------------------------------- 01159 // Destructor 01160 GLSLVertexShader::~GLSLVertexShader () 01161 {} 01162 //----------------------------------------------------------------------------- 01163 //============================================================================= 01164 //****************************************************************************** 01165 01166 //****************************************************************************** 01167 //============================================================================= 01168 // class GLSLGeometryShader 01169 //----------------------------------------------------------------------------- 01170 // Constructor 01171 GLSLGeometryShader::GLSLGeometryShader () 01172 { 01173 m_iShaderType = 1; 01174 if ( gbIsGLSLSupported ) { 01175 m_uiShaderObject = glCreateShader( GL_GEOMETRY_SHADER_EXT ); 01176 Fn::CHECK_GL_ERROR(); 01177 } 01178 } 01179 //----------------------------------------------------------------------------- 01180 // Destructor 01181 GLSLGeometryShader::~GLSLGeometryShader () 01182 {} 01183 //----------------------------------------------------------------------------- 01184 //============================================================================= 01185 //****************************************************************************** 01186 01187 //****************************************************************************** 01188 //============================================================================= 01189 // class GLSLFragmentShader 01190 //----------------------------------------------------------------------------- 01191 // Constructor 01192 GLSLFragmentShader::GLSLFragmentShader () 01193 { 01194 m_iShaderType = 2; 01195 if ( gbIsGLSLSupported ) { 01196 m_uiShaderObject = glCreateShader( GL_FRAGMENT_SHADER ); 01197 Fn::CHECK_GL_ERROR(); 01198 } 01199 } 01200 //----------------------------------------------------------------------------- 01201 // Destructor 01202 GLSLFragmentShader::~GLSLFragmentShader () 01203 {} 01204 //----------------------------------------------------------------------------- 01205 //============================================================================= 01206 //****************************************************************************** 01207 01208 01209 //****************************************************************************** 01210 //============================================================================= 01211 // class GLSLShaderManager 01212 //----------------------------------------------------------------------------- 01213 // Constructor 01214 GLSLShaderManager::GLSLShaderManager () 01215 {} 01216 //----------------------------------------------------------------------------- 01217 // Destructor 01218 GLSLShaderManager::~GLSLShaderManager () 01219 { 01220 // Delete objects 01221 std::vector<GLSLProgramObject *>::iterator pos = m_vProgramObjectList.begin(); 01222 while ( pos != m_vProgramObjectList.end() ) { 01223 GLSLProgramObject *obj = *pos; 01224 pos = m_vProgramObjectList.erase( pos ); 01225 delete obj; 01226 } 01227 } 01228 //----------------------------------------------------------------------------- 01229 // Create a GLSLProgramObject 01230 bool GLSLShaderManager::CreateGLSLProgramObject ( GLSLProgramObject * (&progObj) ) 01231 { 01232 progObj = new GLSLProgramObject(); 01233 progObj->MemageMemory(); 01234 m_vProgramObjectList.push_back( progObj ); 01235 return progObj != NULL; 01236 } 01237 //----------------------------------------------------------------------------- 01238 // Attach (load & compile) a shader read from file 01239 bool GLSLShaderManager::AttachShaderFromFile ( 01240 GLSLProgramObject * progObj, char const * shaderFile, GLuint shaderType ) 01241 { 01242 if ( !progObj ) return false; 01243 //--------------------------------------------------------------- 01244 // Arranging order is according to the GPU pipeline. 01245 //--------------------------------------------------------------- 01246 // Vertex Shader 01247 if ( shaderType == GL_VERTEX_SHADER ) { 01248 GLSLVertexShader * vertShader = new GLSLVertexShader(); 01249 if ( !vertShader ) return false; 01250 if ( !LoadVertexShaderFromFile( vertShader, shaderFile ) ) { 01251 delete vertShader; 01252 return false; 01253 } 01254 if ( !CompileVertexShaderFromFile( vertShader, shaderFile ) ) { 01255 delete vertShader; 01256 return false; 01257 } 01258 //------------------------------------------------- 01259 // Add the vertex shader to the program object 01260 progObj->AddShader( vertShader ); 01261 } 01262 //--------------------------------------------------------------- 01263 // Geometry Shader 01264 else if ( shaderType == GL_GEOMETRY_SHADER_EXT ) { 01265 //std::cout << "\tSTART: Geometry Shader" << std::endl; 01266 GLSLGeometryShader * geomShader = new GLSLGeometryShader(); 01267 //std::cout << "\tgeomShader created" << std::endl; 01268 if ( !geomShader ) return false; 01269 //std::cout << "\tgeomShader is not NULL." << std::endl; 01270 if ( !LoadGeometryShaderFromFile( geomShader, shaderFile ) ) { 01271 delete geomShader; 01272 return false; 01273 } 01274 //std::cout << "\tgeomShader is LOADED." << std::endl; 01275 if ( !CompileGeometryShaderFromFile( geomShader, shaderFile ) ) { 01276 delete geomShader; 01277 return false; 01278 } 01279 //std::cout << "\tgeomShader is Compiled." << std::endl; 01280 //------------------------------------------------- 01281 // Add the geometry shader to the program object 01282 progObj->AddShader( geomShader ); 01283 //std::cout << "\tEND: Geometry Shader" << std::endl; 01284 } 01285 //--------------------------------------------------------------- 01286 // Fragment Shader 01287 else if ( shaderType == GL_FRAGMENT_SHADER ) { 01288 GLSLFragmentShader * fragShader = new GLSLFragmentShader(); 01289 if ( !fragShader ) return false; 01290 if ( !LoadFragmentShaderFromFile( fragShader, shaderFile ) ) { 01291 delete fragShader; 01292 return false; 01293 } 01294 if ( !CompileFragmentShaderFromFile( fragShader, shaderFile ) ) { 01295 delete fragShader; 01296 return false; 01297 } 01298 //------------------------------------------------- 01299 // Add the fragment shader to the program object 01300 progObj->AddShader( fragShader ); 01301 } 01302 //--------------------------------------------------------------- 01303 // Unrecognized shader type 01304 else { 01305 return false; 01306 } 01307 //--------------------------------------------------------------- 01308 return true; 01309 } 01310 //----------------------------------------------------------------------------- 01311 // Link the program object 01312 bool GLSLShaderManager::Link ( GLSLProgramObject * progObj ) 01313 { 01314 //{ return progObj->Link(); } 01315 //---------------------------------------------------------------- 01316 // Link 01317 if ( !progObj->Link() ) { 01318 #ifdef TAPs_USE_WXWIDGETS 01319 wxLogError( wxT( "ERROR: Cound not link shader(s) in the program object (%d)!" ), 01320 progObj->GetProgramObject() ); 01321 wxLogError( wxT( "%s" ), progObj->GetLinkerLog() ); 01322 #else 01323 std::cerr << "ERROR: Cound not link shader(s) in the program object (" 01324 << progObj->GetProgramObject() << ")!\n"; 01325 std::cerr << progObj->GetLinkerLog() << "\n"; 01326 #endif 01327 return false; 01328 } 01329 //---------------------------------------------------------------- 01330 return true; 01331 } 01332 //----------------------------------------------------------------------------- 01333 // Load vertex/fragment shader from file 01334 GLSLProgramObject * GLSLShaderManager::LoadVertexGeometryAndFragmentShadersFromFile ( 01335 char * vertFile, char * geomFile, char * fragFile ) 01336 { 01337 GLSLProgramObject * obj = new GLSLProgramObject(); 01338 GLSLVertexShader * vertShader = new GLSLVertexShader(); 01339 GLSLGeometryShader * geomShader = new GLSLGeometryShader(); 01340 GLSLFragmentShader * fragShader = new GLSLFragmentShader(); 01341 //---------------------------------------------------------------- 01342 // Load vertex shader 01343 //* 01344 if ( !LoadVertexShaderFromFile( vertShader, vertFile ) ) { 01345 delete obj; 01346 delete vertShader; 01347 delete geomShader; 01348 delete fragShader; 01349 return NULL; 01350 } 01351 //*/ 01352 /* 01353 if ( vertFile ) { 01354 #ifdef TAPs_DEBUG_MODE 01355 #ifdef TAPs_USE_WXWIDGETS 01356 wxLogWarning( wxT( "Load vertex shader \"%s\"" ), vertFile ); 01357 #else 01358 std::cout << "Load vertex shader \"" << vertFile << "\""; 01359 #endif 01360 #endif 01361 if ( vertShader->Load( vertFile ) ) { 01362 #ifdef TAPs_USE_WXWIDGETS 01363 wxLogError( wxT( "ERROR: Could not load a vertex shader named \"%s\"" ), 01364 vertFile ); 01365 #else 01366 std::cerr << "ERROR: Could not load a vertex shader named \"" 01367 << vertFile << "\"!\n"; 01368 #endif 01369 delete obj; 01370 delete vertShader; 01371 delete geomShader; 01372 delete fragShader; 01373 return NULL; 01374 } 01375 #ifdef TAPs_DEBUG_MODE 01376 #ifdef TAPs_USE_WXWIDGETS 01377 wxLogWarning( wxT( " is successful!" ) ); 01378 #else 01379 std::cout << " is successful!\n"; 01380 #endif 01381 #endif 01382 } 01383 //*/ 01384 //---------------------------------------------------------------- 01385 // Load geometry shader 01386 //* 01387 if ( !LoadGeometryShaderFromFile( geomShader, geomFile ) ) { 01388 delete obj; 01389 delete vertShader; 01390 delete geomShader; 01391 delete fragShader; 01392 return NULL; 01393 } 01394 //*/ 01395 /* 01396 if ( geomFile ) { 01397 #ifdef TAPs_DEBUG_MODE 01398 #ifdef TAPs_USE_WXWIDGETS 01399 wxLogWarning( wxT( "Load geometry shader \"%s\"" ), geomFile ); 01400 #else 01401 std::cout << "Load geometry shader \"" << geomFile << "\""; 01402 #endif 01403 #endif 01404 if ( geomShader->Load( geomFile ) ) { 01405 #ifdef TAPs_USE_WXWIDGETS 01406 wxLogError( wxT( "ERROR: Could not load a geometry shader named \"%s\"" ), 01407 geomFile ); 01408 #else 01409 std::cerr << "ERROR: Could not load a geometry shader named \"" 01410 << geomFile << "\"!\n"; 01411 #endif 01412 delete obj; 01413 delete vertShader; 01414 delete geomShader; 01415 delete fragShader; 01416 return NULL; 01417 } 01418 #ifdef TAPs_DEBUG_MODE 01419 #ifdef TAPs_USE_WXWIDGETS 01420 wxLogWarning( wxT( " is successful!" ) ); 01421 #else 01422 std::cout << " is successful!\n"; 01423 #endif 01424 #endif 01425 } 01426 //*/ 01427 //---------------------------------------------------------------- 01428 // Load fragment shader 01429 //* 01430 if ( !LoadFragmentShaderFromFile( fragShader, fragFile ) ) { 01431 delete obj; 01432 delete vertShader; 01433 delete geomShader; 01434 delete fragShader; 01435 return NULL; 01436 } 01437 //*/ 01438 /* 01439 if ( fragFile ) { 01440 #ifdef TAPs_DEBUG_MODE 01441 #ifdef TAPs_USE_WXWIDGETS 01442 wxLogWarning( wxT( "Load fragment shader \"%s\"" ), fragFile ); 01443 #else 01444 std::cout << "Load fragment shader \"" << fragFile << "\""; 01445 #endif 01446 #endif 01447 if ( fragShader->Load( fragFile ) ) { 01448 #ifdef TAPs_USE_WXWIDGETS 01449 wxLogError( wxT( "ERROR: Could not load a fragment shader named \"%s\"" ), 01450 fragFile ); 01451 #else 01452 std::cerr << "ERROR: Could not load a fragment shader named \"" 01453 << fragFile << "\"!\n"; 01454 #endif 01455 delete obj; 01456 delete vertShader; 01457 delete geomShader; 01458 delete fragShader; 01459 return NULL; 01460 } 01461 #ifdef TAPs_DEBUG_MODE 01462 #ifdef TAPs_USE_WXWIDGETS 01463 wxLogWarning( wxT( " is successful!" ) ); 01464 #else 01465 std::cout << " is successful!\n"; 01466 #endif 01467 #endif 01468 } 01469 //*/ 01470 //---------------------------------------------------------------- 01471 // Compile vertex program 01472 //* 01473 if ( !CompileVertexShaderFromFile( vertShader, vertFile ) ) { 01474 delete obj; 01475 delete vertShader; 01476 delete geomShader; 01477 delete fragShader; 01478 return NULL; 01479 } 01480 //*/ 01481 /* 01482 if ( vertFile ) { 01483 #ifdef TAPs_DEBUG_MODE 01484 #ifdef TAPs_USE_WXWIDGETS 01485 wxLogWarning( wxT( "Compile vertex program \"%s\"" ), vertFile ); 01486 #else 01487 std::cout << "Compile vertex program \"" << vertFile << "\""; 01488 #endif 01489 #endif 01490 if ( !vertShader->Compile() ) { 01491 #ifdef TAPs_USE_WXWIDGETS 01492 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), vertFile ); 01493 wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() ); 01494 #else 01495 std::cerr << "ERROR: \"" << vertFile << "\" Compilation Error:\n"; 01496 std::cerr << vertShader->GetCompilerLog() << "\n"; 01497 #endif 01498 delete obj; 01499 delete vertShader; 01500 delete geomShader; 01501 delete fragShader; 01502 return NULL; 01503 } 01504 #ifdef TAPs_DEBUG_MODE 01505 #ifdef TAPs_USE_WXWIDGETS 01506 wxLogWarning( wxT( " is successful!" ) ); 01507 #else 01508 std::cout << " is successful!\n"; 01509 #endif 01510 #endif 01511 } 01512 //*/ 01513 //---------------------------------------------------------------- 01514 // Compile geometry program 01515 //* 01516 if ( !CompileGeometryShaderFromFile( geomShader, geomFile ) ) { 01517 delete obj; 01518 delete vertShader; 01519 delete geomShader; 01520 delete fragShader; 01521 return NULL; 01522 } 01523 //*/ 01524 /* 01525 if ( geomFile ) { 01526 #ifdef TAPs_DEBUG_MODE 01527 #ifdef TAPs_USE_WXWIDGETS 01528 wxLogWarning( wxT( "Compile geometry program \"%s\"" ), geomFile ); 01529 #else 01530 std::cout << "Compile geometry program \"" << geomFile << "\""; 01531 #endif 01532 #endif 01533 if ( !geomShader->Compile() ) { 01534 #ifdef TAPs_USE_WXWIDGETS 01535 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), geomFile ); 01536 wxLogError( wxT( "%s" ), geomShader->GetCompilerLog() ); 01537 #else 01538 std::cerr << "ERROR: \"" << geomFile << "\" Compilation Error:\n"; 01539 std::cerr << geomShader->GetCompilerLog() << "\n"; 01540 #endif 01541 delete obj; 01542 delete vertShader; 01543 delete geomShader; 01544 delete fragShader; 01545 return NULL; 01546 } 01547 #ifdef TAPs_DEBUG_MODE 01548 #ifdef TAPs_USE_WXWIDGETS 01549 wxLogWarning( wxT( " is successful!" ) ); 01550 #else 01551 std::cout << " is successful!\n"; 01552 #endif 01553 #endif 01554 } 01555 //*/ 01556 //---------------------------------------------------------------- 01557 // Compile fragment program 01558 //* 01559 if ( !CompileFragmentShaderFromFile( fragShader, fragFile ) ) { 01560 delete obj; 01561 delete vertShader; 01562 delete geomShader; 01563 delete fragShader; 01564 return NULL; 01565 } 01566 //*/ 01567 /* 01568 if ( fragFile ) { 01569 #ifdef TAPs_DEBUG_MODE 01570 #ifdef TAPs_USE_WXWIDGETS 01571 wxLogWarning( wxT( "Compile fragment program \"%s\"" ), fragFile ); 01572 #else 01573 std::cout << "Compile fragment program \"" << fragFile << "\""; 01574 #endif 01575 #endif 01576 if ( !fragShader->Compile() ) { 01577 #ifdef TAPs_USE_WXWIDGETS 01578 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), fragFile ); 01579 wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() ); 01580 #else 01581 std::cerr << "ERROR: \"" << fragFile << "\" Compilation Error:\n"; 01582 std::cerr << fragShader->GetCompilerLog() << "\n"; 01583 #endif 01584 delete obj; 01585 delete vertShader; 01586 delete geomShader; 01587 delete fragShader; 01588 return NULL; 01589 } 01590 #ifdef TAPs_DEBUG_MODE 01591 #ifdef TAPs_USE_WXWIDGETS 01592 wxLogWarning( wxT( " is successful!" ) ); 01593 #else 01594 std::cout << " is successful!\n"; 01595 #endif 01596 #endif 01597 } 01598 //*/ 01599 //--------------------------------------------------------------- 01600 // Add to the object 01601 if ( vertFile ) obj->AddShader( vertShader ); 01602 if ( geomFile ) obj->AddShader( geomShader ); 01603 if ( fragFile ) obj->AddShader( fragShader ); 01604 //---------------------------------------------------------------- 01605 // Link 01606 //* 01607 if ( !Link( obj ) ) { 01608 delete obj; 01609 delete vertShader; 01610 delete geomShader; 01611 delete fragShader; 01612 return NULL; 01613 } 01614 //*/ 01615 /* 01616 if ( !obj->Link() ) { 01617 #ifdef TAPs_USE_WXWIDGETS 01618 wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\", \"%s\", and \"%s\"" ), 01619 vertFile, geomFile, fragFile ); 01620 wxLogError( wxT( "%s" ), obj->GetLinkerLog() ); 01621 #else 01622 std::cerr << "ERROR: Cound not link a shader object created from " 01623 << "\"" << vertFile << "\"," << "\"" << vertFile << "\", and \"" << fragFile << "\"\n"; 01624 std::cerr << obj->GetLinkerLog() << "\n"; 01625 #endif 01626 delete obj; 01627 delete vertShader; 01628 delete geomShader; 01629 delete fragShader; 01630 return NULL; 01631 } 01632 //*/ 01633 //---------------------------------------------------------------- 01634 m_vProgramObjectList.push_back( obj ); 01635 obj->MemageMemory(); 01636 //---------------------------------------------------------------- 01637 return obj; 01638 } // END: GLSLProgramObject * GLSLShaderManager::LoadVertexGeometryAndFragmentShadersFromFile ( char * vertFile, char * geomFile, char * fragFile ) 01639 01640 01641 //----------------------------------------------------------------------------- 01642 // Load vertex/fragment shader from file 01643 GLSLProgramObject * GLSLShaderManager::LoadFromFile ( char * vertFile, char * fragFile ) 01644 { 01645 GLSLProgramObject * obj = new GLSLProgramObject(); 01646 GLSLVertexShader * vertShader = new GLSLVertexShader(); 01647 GLSLFragmentShader * fragShader = new GLSLFragmentShader(); 01648 //---------------------------------------------------------------- 01649 // Load vertex program 01650 //* 01651 if ( !LoadVertexShaderFromFile( vertShader, vertFile ) ) { 01652 delete obj; 01653 delete vertShader; 01654 delete fragShader; 01655 return NULL; 01656 } 01657 //*/ 01658 /* 01659 if ( vertFile ) { 01660 #ifdef TAPs_DEBUG_MODE 01661 #ifdef TAPs_USE_WXWIDGETS 01662 wxLogWarning( wxT( "Load vertex program \"%s\"" ), vertFile ); 01663 #else 01664 std::cout << "Load vertex program \"" << vertFile << "\""; 01665 #endif 01666 #endif 01667 if ( vertShader->Load( vertFile ) ) { 01668 #ifdef TAPs_USE_WXWIDGETS 01669 wxLogError( wxT( "ERROR: Could not load a vertex shader named \"%s\"" ), 01670 vertFile ); 01671 #else 01672 std::cerr << "ERROR: Could not load a vertex shader named \"" 01673 << vertFile << "\"!\n"; 01674 #endif 01675 delete obj; 01676 delete vertShader; 01677 delete fragShader; 01678 return NULL; 01679 } 01680 #ifdef TAPs_DEBUG_MODE 01681 #ifdef TAPs_USE_WXWIDGETS 01682 wxLogWarning( wxT( " is successful!" ) ); 01683 #else 01684 std::cout << " is successful!\n"; 01685 #endif 01686 #endif 01687 } 01688 //*/ 01689 //---------------------------------------------------------------- 01690 // Load fragment program 01691 //* 01692 if ( !LoadFragmentShaderFromFile( fragShader, fragFile ) ) { 01693 delete obj; 01694 delete vertShader; 01695 delete fragShader; 01696 return NULL; 01697 } 01698 //*/ 01699 /* 01700 if ( fragFile ) { 01701 #ifdef TAPs_DEBUG_MODE 01702 #ifdef TAPs_USE_WXWIDGETS 01703 wxLogWarning( wxT( "Load fragment program \"%s\"" ), fragFile ); 01704 #else 01705 std::cout << "Load fragment program \"" << fragFile << "\""; 01706 #endif 01707 #endif 01708 if ( fragShader->Load( fragFile ) ) { 01709 #ifdef TAPs_USE_WXWIDGETS 01710 wxLogError( wxT( "ERROR: Could not load a fragment shader named \"%s\"" ), 01711 fragFile ); 01712 #else 01713 std::cerr << "ERROR: Could not load a fragment shader named \"" 01714 << fragFile << "\"!\n"; 01715 #endif 01716 delete obj; 01717 delete vertShader; 01718 delete fragShader; 01719 return NULL; 01720 } 01721 #ifdef TAPs_DEBUG_MODE 01722 #ifdef TAPs_USE_WXWIDGETS 01723 wxLogWarning( wxT( " is successful!" ) ); 01724 #else 01725 std::cout << " is successful!\n"; 01726 #endif 01727 #endif 01728 } 01729 //*/ 01730 //---------------------------------------------------------------- 01731 // Compile vertex program 01732 //* 01733 if ( !CompileVertexShaderFromFile( vertShader, vertFile ) ) { 01734 delete obj; 01735 delete vertShader; 01736 delete fragShader; 01737 return NULL; 01738 } 01739 //*/ 01740 /* 01741 if ( vertFile ) { 01742 #ifdef TAPs_DEBUG_MODE 01743 #ifdef TAPs_USE_WXWIDGETS 01744 wxLogWarning( wxT( "Compile vertex program \"%s\"" ), vertFile ); 01745 #else 01746 std::cout << "Compile vertex program \"" << vertFile << "\""; 01747 #endif 01748 #endif 01749 if ( !vertShader->Compile() ) { 01750 #ifdef TAPs_USE_WXWIDGETS 01751 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), vertFile ); 01752 wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() ); 01753 #else 01754 std::cerr << "ERROR: \"" << vertFile << "\" Compilation Error:\n"; 01755 std::cerr << vertShader->GetCompilerLog() << "\n"; 01756 #endif 01757 delete obj; 01758 delete vertShader; 01759 delete fragShader; 01760 return NULL; 01761 } 01762 #ifdef TAPs_DEBUG_MODE 01763 #ifdef TAPs_USE_WXWIDGETS 01764 wxLogWarning( wxT( " is successful!" ) ); 01765 #else 01766 std::cout << " is successful!\n"; 01767 #endif 01768 #endif 01769 } 01770 //*/ 01771 //---------------------------------------------------------------- 01772 // Compile fragment program 01773 //* 01774 if ( !CompileFragmentShaderFromFile( fragShader, fragFile ) ) { 01775 delete obj; 01776 delete vertShader; 01777 delete fragShader; 01778 return NULL; 01779 } 01780 //*/ 01781 /* 01782 if ( fragFile ) { 01783 #ifdef TAPs_DEBUG_MODE 01784 #ifdef TAPs_USE_WXWIDGETS 01785 wxLogWarning( wxT( "Compile fragment program \"%s\"" ), fragFile ); 01786 #else 01787 std::cout << "Compile fragment program \"" << fragFile << "\""; 01788 #endif 01789 #endif 01790 if ( !fragShader->Compile() ) { 01791 #ifdef TAPs_USE_WXWIDGETS 01792 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), fragFile ); 01793 wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() ); 01794 #else 01795 std::cerr << "ERROR: \"" << fragFile << "\" Compilation Error:\n"; 01796 std::cerr << fragShader->GetCompilerLog() << "\n"; 01797 #endif 01798 delete obj; 01799 delete vertShader; 01800 delete fragShader; 01801 return NULL; 01802 } 01803 #ifdef TAPs_DEBUG_MODE 01804 #ifdef TAPs_USE_WXWIDGETS 01805 wxLogWarning( wxT( " is successful!" ) ); 01806 #else 01807 std::cout << " is successful!\n"; 01808 #endif 01809 #endif 01810 } 01811 //*/ 01812 //--------------------------------------------------------------- 01813 // Add to the object 01814 if ( vertFile ) obj->AddShader( vertShader ); 01815 if ( fragFile ) obj->AddShader( fragShader ); 01816 //---------------------------------------------------------------- 01817 // Link 01818 //* 01819 if ( !Link( obj ) ) { 01820 delete obj; 01821 delete vertShader; 01822 delete fragShader; 01823 return NULL; 01824 } 01825 //*/ 01826 /* 01827 if ( !obj->Link() ) { 01828 #ifdef TAPs_USE_WXWIDGETS 01829 wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\" and \"%s\"" ), 01830 vertFile, fragFile ); 01831 wxLogError( wxT( "%s" ), obj->GetLinkerLog() ); 01832 #else 01833 std::cerr << "ERROR: Cound not link a shader object created from \"" 01834 << vertFile << "\" and \"" << fragFile << "\"\n"; 01835 std::cerr << obj->GetLinkerLog() << "\n"; 01836 #endif 01837 delete obj; 01838 delete vertShader; 01839 delete fragShader; 01840 return NULL; 01841 } 01842 //*/ 01843 //---------------------------------------------------------------- 01844 m_vProgramObjectList.push_back( obj ); 01845 obj->MemageMemory(); 01846 //---------------------------------------------------------------- 01847 return obj; 01848 } // END: GLSLProgramObject * GLSLShaderManager::LoadFromFile ( char * vertFile, char * fragFile ) 01849 01850 01851 //----------------------------------------------------------------------------- 01852 // Load only a vertex shader from file 01853 GLSLProgramObject * GLSLShaderManager::LoadOnlyAVertexShaderFromFile ( char * vertFile ) 01854 { 01855 GLSLProgramObject * obj = new GLSLProgramObject(); 01856 GLSLVertexShader * vertShader = new GLSLVertexShader(); 01857 //---------------------------------------------------------------- 01858 // Load vertex program 01859 if ( vertFile ) { 01860 #ifdef TAPs_DEBUG_MODE 01861 #ifdef TAPs_USE_WXWIDGETS 01862 wxLogWarning( wxT( "Load vertex program \"%s\"" ), vertFile ); 01863 #else 01864 std::cout << "Load vertex program \"" << vertFile << "\""; 01865 #endif 01866 #endif 01867 if ( vertShader->Load( vertFile ) ) { 01868 #ifdef TAPs_USE_WXWIDGETS 01869 wxLogError( wxT( "ERROR: Could not load a vertex shader named \"%s\"" ), 01870 vertFile ); 01871 #else 01872 std::cerr << "ERROR: Could not load a vertex shader named \"" 01873 << vertFile << "\"!\n"; 01874 #endif 01875 delete obj; 01876 delete vertShader; 01877 return NULL; 01878 } 01879 #ifdef TAPs_DEBUG_MODE 01880 #ifdef TAPs_USE_WXWIDGETS 01881 wxLogWarning( wxT( " is successful!" ) ); 01882 #else 01883 std::cout << " is successful!\n"; 01884 #endif 01885 #endif 01886 } 01887 //---------------------------------------------------------------- 01888 // Compile vertex program 01889 if ( vertFile ) { 01890 #ifdef TAPs_DEBUG_MODE 01891 #ifdef TAPs_USE_WXWIDGETS 01892 wxLogWarning( wxT( "Compile vertex program \"%s\"" ), vertFile ); 01893 #else 01894 std::cout << "Compile vertex program \"" << vertFile << "\""; 01895 #endif 01896 #endif 01897 if ( !vertShader->Compile() ) { 01898 #ifdef TAPs_USE_WXWIDGETS 01899 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), vertFile ); 01900 wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() ); 01901 #else 01902 std::cerr << "ERROR: \"" << vertFile << "\" Compilation Error:\n"; 01903 std::cerr << vertShader->GetCompilerLog() << "\n"; 01904 #endif 01905 delete obj; 01906 delete vertShader; 01907 return NULL; 01908 } 01909 #ifdef TAPs_DEBUG_MODE 01910 #ifdef TAPs_USE_WXWIDGETS 01911 wxLogWarning( wxT( " is successful!" ) ); 01912 #else 01913 std::cout << " is successful!\n"; 01914 #endif 01915 #endif 01916 } 01917 //--------------------------------------------------------------- 01918 // Add to the object 01919 if ( vertFile ) obj->AddShader( vertShader ); 01920 //---------------------------------------------------------------- 01921 // Link 01922 if ( !obj->Link() ) { 01923 #ifdef TAPs_USE_WXWIDGETS 01924 wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\"!" ), vertFile ); 01925 wxLogError( wxT( "%s" ), obj->GetLinkerLog() ); 01926 #else 01927 std::cerr << "ERROR: Cound not link a shader object created from \"" 01928 << vertFile << "\"\n"; 01929 std::cerr << obj->GetLinkerLog() << "\n"; 01930 #endif 01931 delete obj; 01932 delete vertShader; 01933 return NULL; 01934 } 01935 //---------------------------------------------------------------- 01936 m_vProgramObjectList.push_back( obj ); 01937 obj->MemageMemory(); 01938 //---------------------------------------------------------------- 01939 return obj; 01940 } // END: GLSLProgramObject * GLSLShaderManager::LoadOnlyAVertexShaderFromFile ( char * vertFile ) 01941 01942 01943 01944 //----------------------------------------------------------------------------- 01945 // Load only a geometry shader from file 01946 GLSLProgramObject * GLSLShaderManager::LoadOnlyAGeometryShaderFromFile ( char * geomFile ) 01947 { 01948 GLSLProgramObject * obj = new GLSLProgramObject(); 01949 GLSLGeometryShader * geomShader = new GLSLGeometryShader(); 01950 //---------------------------------------------------------------- 01951 // Load geometry shader 01952 if ( geomFile ) { 01953 #ifdef TAPs_DEBUG_MODE 01954 #ifdef TAPs_USE_WXWIDGETS 01955 wxLogWarning( wxT( "Load geometry shader \"%s\"" ), geomFile ); 01956 #else 01957 std::cout << "Load geometry shader \"" << geomFile << "\""; 01958 #endif 01959 #endif 01960 if ( geomShader->Load( geomFile ) ) { 01961 #ifdef TAPs_USE_WXWIDGETS 01962 wxLogError( wxT( "ERROR: Could not load a geometry shader named \"%s\"" ), 01963 geomFile ); 01964 #else 01965 std::cerr << "ERROR: Could not load a geometry shader named \"" 01966 << geomFile << "\"!\n"; 01967 #endif 01968 delete obj; 01969 delete geomShader; 01970 return NULL; 01971 } 01972 #ifdef TAPs_DEBUG_MODE 01973 #ifdef TAPs_USE_WXWIDGETS 01974 wxLogWarning( wxT( " is successful!" ) ); 01975 #else 01976 std::cout << " is successful!\n"; 01977 #endif 01978 #endif 01979 } 01980 //---------------------------------------------------------------- 01981 // Compile geometry shader 01982 if ( geomFile ) { 01983 #ifdef TAPs_DEBUG_MODE 01984 #ifdef TAPs_USE_WXWIDGETS 01985 wxLogWarning( wxT( "Compile geometry shader \"%s\"" ), geomFile ); 01986 #else 01987 std::cout << "Compile geometry shader \"" << geomFile << "\""; 01988 #endif 01989 #endif 01990 if ( !geomShader->Compile() ) { 01991 #ifdef TAPs_USE_WXWIDGETS 01992 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), geomFile ); 01993 wxLogError( wxT( "%s" ), geomShader->GetCompilerLog() ); 01994 #else 01995 std::cerr << "ERROR: \"" << geomFile << "\" Compilation Error:\n"; 01996 std::cerr << geomShader->GetCompilerLog() << "\n"; 01997 #endif 01998 delete obj; 01999 delete geomShader; 02000 return NULL; 02001 } 02002 #ifdef TAPs_DEBUG_MODE 02003 #ifdef TAPs_USE_WXWIDGETS 02004 wxLogWarning( wxT( " is successful!" ) ); 02005 #else 02006 std::cout << " is successful!\n"; 02007 #endif 02008 #endif 02009 } 02010 //--------------------------------------------------------------- 02011 // Add to the object 02012 if ( geomFile ) obj->AddShader( geomShader ); 02013 //---------------------------------------------------------------- 02014 // Link 02015 if ( !obj->Link() ) { 02016 #ifdef TAPs_USE_WXWIDGETS 02017 wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\"!" ), geomFile ); 02018 wxLogError( wxT( "%s" ), obj->GetLinkerLog() ); 02019 #else 02020 std::cerr << "ERROR: Cound not link a shader object created from \"" 02021 << geomFile << "\"\n"; 02022 std::cerr << obj->GetLinkerLog() << "\n"; 02023 #endif 02024 delete obj; 02025 delete geomShader; 02026 return NULL; 02027 } 02028 //---------------------------------------------------------------- 02029 m_vProgramObjectList.push_back( obj ); 02030 obj->MemageMemory(); 02031 //---------------------------------------------------------------- 02032 return obj; 02033 } // END: GLSLProgramObject * GLSLShaderManager::LoadOnlyAGeometryShaderFromFile ( char * geomFile ) 02034 02035 02036 //----------------------------------------------------------------------------- 02037 // Load only a fragment shader from file 02038 GLSLProgramObject * GLSLShaderManager::LoadOnlyAFragmentShaderFromFile ( char * fragFile ) 02039 { 02040 GLSLProgramObject * obj = new GLSLProgramObject(); 02041 GLSLFragmentShader * fragShader = new GLSLFragmentShader(); 02042 //---------------------------------------------------------------- 02043 // Load fragment shader 02044 if ( fragFile ) { 02045 #ifdef TAPs_DEBUG_MODE 02046 #ifdef TAPs_USE_WXWIDGETS 02047 wxLogWarning( wxT( "Load fragment shader \"%s\"" ), fragFile ); 02048 #else 02049 std::cout << "Load fragment shader \"" << fragFile << "\""; 02050 #endif 02051 #endif 02052 if ( fragShader->Load( fragFile ) ) { 02053 #ifdef TAPs_USE_WXWIDGETS 02054 wxLogError( wxT( "ERROR: Could not load a fragment shader named \"%s\"" ), 02055 fragFile ); 02056 #else 02057 std::cerr << "ERROR: Could not load a fragment shader named \"" 02058 << fragFile << "\"!\n"; 02059 #endif 02060 delete obj; 02061 delete fragShader; 02062 return NULL; 02063 } 02064 #ifdef TAPs_DEBUG_MODE 02065 #ifdef TAPs_USE_WXWIDGETS 02066 wxLogWarning( wxT( " is successful!" ) ); 02067 #else 02068 std::cout << " is successful!\n"; 02069 #endif 02070 #endif 02071 } 02072 //---------------------------------------------------------------- 02073 // Compile fragment shader 02074 if ( fragFile ) { 02075 #ifdef TAPs_DEBUG_MODE 02076 #ifdef TAPs_USE_WXWIDGETS 02077 wxLogWarning( wxT( "Compile fragment shader \"%s\"" ), fragFile ); 02078 #else 02079 std::cout << "Compile fragment shader \"" << fragFile << "\""; 02080 #endif 02081 #endif 02082 if ( !fragShader->Compile() ) { 02083 #ifdef TAPs_USE_WXWIDGETS 02084 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), fragFile ); 02085 wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() ); 02086 #else 02087 std::cerr << "ERROR: \"" << fragFile << "\" Compilation Error:\n"; 02088 std::cerr << fragShader->GetCompilerLog() << "\n"; 02089 #endif 02090 delete obj; 02091 delete fragShader; 02092 return NULL; 02093 } 02094 #ifdef TAPs_DEBUG_MODE 02095 #ifdef TAPs_USE_WXWIDGETS 02096 wxLogWarning( wxT( " is successful!" ) ); 02097 #else 02098 std::cout << " is successful!\n"; 02099 #endif 02100 #endif 02101 } 02102 //--------------------------------------------------------------- 02103 // Add to the object 02104 if ( fragFile ) obj->AddShader( fragShader ); 02105 //---------------------------------------------------------------- 02106 // Link 02107 if ( !obj->Link() ) { 02108 #ifdef TAPs_USE_WXWIDGETS 02109 wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\"!" ), fragFile ); 02110 wxLogError( wxT( "%s" ), obj->GetLinkerLog() ); 02111 #else 02112 std::cerr << "ERROR: Cound not link a shader object created from \"" 02113 << fragFile << "\"\n"; 02114 std::cerr << obj->GetLinkerLog() << "\n"; 02115 #endif 02116 delete obj; 02117 delete fragShader; 02118 return NULL; 02119 } 02120 //---------------------------------------------------------------- 02121 m_vProgramObjectList.push_back( obj ); 02122 obj->MemageMemory(); 02123 //---------------------------------------------------------------- 02124 return obj; 02125 } // END: GLSLProgramObject * GLSLShaderManager::LoadOnlyAFragmentShaderFromFile ( char * fragFile ) 02126 //----------------------------------------------------------------------------- 02127 // Load vertex/fragment shader from memory 02128 GLSLProgramObject * GLSLShaderManager::LoadFromMemory ( const char *vertMem, const char *fragMem ) 02129 { 02130 GLSLProgramObject *obj = new GLSLProgramObject(); 02131 GLSLVertexShader *vertShader = new GLSLVertexShader; 02132 GLSLFragmentShader *fragShader = new GLSLFragmentShader; 02133 //---------------------------------------------------------------- 02134 // Load vertex program 02135 if ( vertMem ) { 02136 vertShader->LoadFromMemory( vertMem ); 02137 } 02138 //---------------------------------------------------------------- 02139 // Load fragment program 02140 if ( fragMem ) { 02141 fragShader->LoadFromMemory( fragMem ); 02142 } 02143 //---------------------------------------------------------------- 02144 // Compile vertex program 02145 if ( vertMem ) { 02146 if ( !vertShader->Compile() ) { 02147 #ifdef TAPs_USE_WXWIDGETS 02148 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), 02149 vertMem ); 02150 wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() ); 02151 #else 02152 std::cerr << "ERROR: \"" << vertMem << "\" Compilation Error:\n"; 02153 std::cerr << vertShader->GetCompilerLog() << "\n"; 02154 #endif 02155 delete obj; 02156 delete vertShader; 02157 delete fragShader; 02158 return NULL; 02159 } 02160 } 02161 //---------------------------------------------------------------- 02162 // Compile fragment program 02163 if ( fragMem ) { 02164 if ( !fragShader->Compile() ) { 02165 #ifdef TAPs_USE_WXWIDGETS 02166 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), 02167 fragMem ); 02168 wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() ); 02169 #else 02170 std::cerr << "ERROR: \"" << fragMem << "\" Compilation Error:\n"; 02171 std::cerr << fragShader->GetCompilerLog() << "\n"; 02172 #endif 02173 delete obj; 02174 delete vertShader; 02175 delete fragShader; 02176 return NULL; 02177 } 02178 } 02179 //---------------------------------------------------------------- 02180 // Add to the object 02181 if ( vertMem ) obj->AddShader( vertShader ); 02182 if ( fragMem ) obj->AddShader( fragShader ); 02183 //---------------------------------------------------------------- 02184 // Link 02185 if ( !obj->Link() ) { 02186 #ifdef TAPs_USE_WXWIDGETS 02187 wxLogError( wxT( "ERROR: Cound not link a shader object created from \"%s\" and \"%s\"" ), 02188 vertMem, fragMem ); 02189 wxLogError( wxT( "%s" ), obj->GetLinkerLog() ); 02190 #else 02191 std::cerr << "ERROR: Cound not link a shader object created from \"" 02192 << vertMem << "\"\n and \"\n" << fragMem << "\"\n"; 02193 std::cerr << obj->GetLinkerLog() << "\n"; 02194 #endif 02195 delete obj; 02196 delete vertShader; 02197 delete fragShader; 02198 return NULL; 02199 } 02200 //---------------------------------------------------------------- 02201 m_vProgramObjectList.push_back( obj ); 02202 obj->MemageMemory(); 02203 //---------------------------------------------------------------- 02204 return obj; 02205 } // END: GLSLProgramObject * GLSLShaderManager::LoadFromMemory ( const char *vertMem, const char *fragMem ) 02206 //----------------------------------------------------------------------------- 02207 // Delete all shader objects 02208 bool GLSLShaderManager::Delete ( GLSLProgramObject *obj ) 02209 { 02210 std::vector<GLSLProgramObject *>::iterator pos; 02211 for ( pos = m_vProgramObjectList.begin(); pos != m_vProgramObjectList.end(); ++pos ) { 02212 if ( *pos == obj ) { 02213 m_vProgramObjectList.erase( pos ); 02214 delete obj; 02215 obj = NULL; 02216 return true; 02217 } 02218 } 02219 return false; 02220 } // END: bool GLSLShaderManager::Delete ( GLSLProgramObject *obj ) 02221 //----------------------------------------------------------------------------- 02222 // Load a vertex shader from file 02223 bool GLSLShaderManager::LoadVertexShaderFromFile ( 02224 GLSLVertexShader * vertShader, const char * vertFile ) 02225 { 02226 //---------------------------------------------------------------- 02227 // Load vertex shader 02228 if ( vertFile ) { 02229 #ifdef TAPs_DEBUG_MODE 02230 #ifdef TAPs_USE_WXWIDGETS 02231 wxLogWarning( wxT( "Load vertex shader \"%s\"" ), vertFile ); 02232 #else 02233 std::cout << "Load vertex shader \"" << vertFile << "\""; 02234 #endif 02235 #endif 02236 if ( vertShader->Load( vertFile ) ) { 02237 #ifdef TAPs_USE_WXWIDGETS 02238 wxLogError( wxT( "ERROR: Could not load a vertex shader named \"%s\"" ), 02239 vertFile ); 02240 #else 02241 std::cerr << "ERROR: Could not load a vertex shader named \"" 02242 << vertFile << "\"!\n"; 02243 #endif 02244 return false; 02245 } 02246 #ifdef TAPs_DEBUG_MODE 02247 #ifdef TAPs_USE_WXWIDGETS 02248 wxLogWarning( wxT( " is successful!" ) ); 02249 #else 02250 std::cout << " is successful!\n"; 02251 #endif 02252 #endif 02253 return true; 02254 } 02255 return false; 02256 } // END: bool LoadVertexShaderFromFile ( GLSLVertexShader * vertShader, const char * vertFile ); 02257 //----------------------------------------------------------------------------- 02258 // Load a geometry shader from file 02259 bool GLSLShaderManager::LoadGeometryShaderFromFile ( 02260 GLSLGeometryShader * geomShader, const char * geomFile ) 02261 { 02262 //---------------------------------------------------------------- 02263 // Load geometry shader 02264 if ( geomFile ) { 02265 #ifdef TAPs_DEBUG_MODE 02266 #ifdef TAPs_USE_WXWIDGETS 02267 wxLogWarning( wxT( "Load geometry shader \"%s\"" ), geomFile ); 02268 #else 02269 std::cout << "Load geometry shader \"" << geomFile << "\""; 02270 #endif 02271 #endif 02272 if ( geomShader->Load( geomFile ) ) { 02273 #ifdef TAPs_USE_WXWIDGETS 02274 wxLogError( wxT( "ERROR: Could not load a geometry shader named \"%s\"" ), 02275 geomFile ); 02276 #else 02277 std::cerr << "ERROR: Could not load a geometry shader named \"" 02278 << geomFile << "\"!\n"; 02279 #endif 02280 return false; 02281 } 02282 #ifdef TAPs_DEBUG_MODE 02283 #ifdef TAPs_USE_WXWIDGETS 02284 wxLogWarning( wxT( " is successful!" ) ); 02285 #else 02286 std::cout << " is successful!\n"; 02287 #endif 02288 #endif 02289 return true; 02290 } 02291 return false; 02292 } // END: bool LoadGeometryShaderFromFile ( GLSLGeometryShader * geomShader, const char * geomFile ); 02293 //----------------------------------------------------------------------------- 02294 // Load a fragment shader from file 02295 bool GLSLShaderManager::LoadFragmentShaderFromFile ( 02296 GLSLFragmentShader * fragShader, const char * fragFile ) 02297 { 02298 //---------------------------------------------------------------- 02299 // Load fragment shader 02300 if ( fragFile ) { 02301 #ifdef TAPs_DEBUG_MODE 02302 #ifdef TAPs_USE_WXWIDGETS 02303 wxLogWarning( wxT( "Load fragment shader \"%s\"" ), fragFile ); 02304 #else 02305 std::cout << "Load fragment shader \"" << fragFile << "\""; 02306 #endif 02307 #endif 02308 if ( fragShader->Load( fragFile ) ) { 02309 #ifdef TAPs_USE_WXWIDGETS 02310 wxLogError( wxT( "ERROR: Could not load a fragment shader named \"%s\"" ), 02311 fragFile ); 02312 #else 02313 std::cerr << "ERROR: Could not load a fragment shader named \"" 02314 << fragFile << "\"!\n"; 02315 #endif 02316 return false; 02317 } 02318 #ifdef TAPs_DEBUG_MODE 02319 #ifdef TAPs_USE_WXWIDGETS 02320 wxLogWarning( wxT( " is successful!" ) ); 02321 #else 02322 std::cout << " is successful!\n"; 02323 #endif 02324 #endif 02325 return true; 02326 } 02327 return false; 02328 } // END: bool LoadFragmentShaderFromFile ( GLSLFragmentShader * fragShader, const char * fragFile ); 02329 //----------------------------------------------------------------------------- 02330 // Load a vertex shader from file 02331 bool GLSLShaderManager::CompileVertexShaderFromFile ( 02332 GLSLVertexShader * vertShader, const char * vertFile ) 02333 { 02334 //---------------------------------------------------------------- 02335 // Compile vertex program 02336 if ( vertFile ) { 02337 #ifdef TAPs_DEBUG_MODE 02338 #ifdef TAPs_USE_WXWIDGETS 02339 wxLogWarning( wxT( "Compile vertex program \"%s\"" ), vertFile ); 02340 #else 02341 std::cout << "Compile vertex program \"" << vertFile << "\""; 02342 #endif 02343 #endif 02344 if ( !vertShader->Compile() ) { 02345 #ifdef TAPs_USE_WXWIDGETS 02346 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), vertFile ); 02347 wxLogError( wxT( "%s" ), vertShader->GetCompilerLog() ); 02348 #else 02349 std::cerr << "ERROR: \"" << vertFile << "\" Compilation Error:\n"; 02350 std::cerr << vertShader->GetCompilerLog() << "\n"; 02351 #endif 02352 return false; 02353 } 02354 #ifdef TAPs_DEBUG_MODE 02355 #ifdef TAPs_USE_WXWIDGETS 02356 wxLogWarning( wxT( " is successful!" ) ); 02357 #else 02358 std::cout << " is successful!\n"; 02359 #endif 02360 #endif 02361 return true; 02362 } 02363 return false; 02364 } // END: bool CompileVertexShaderFromFile ( GLSLVertexShader * vertShader, const char * vertFile ); 02365 //----------------------------------------------------------------------------- 02366 // Load a fragment shader from file 02367 bool GLSLShaderManager::CompileGeometryShaderFromFile ( 02368 GLSLGeometryShader * geomShader, const char * geomFile ) 02369 { 02370 //---------------------------------------------------------------- 02371 // Compile geometry program 02372 if ( geomFile ) { 02373 #ifdef TAPs_DEBUG_MODE 02374 #ifdef TAPs_USE_WXWIDGETS 02375 wxLogWarning( wxT( "Compile geometry program \"%s\"" ), geomFile ); 02376 #else 02377 std::cout << "Compile geometry program \"" << geomFile << "\""; 02378 #endif 02379 #endif 02380 if ( !geomShader->Compile() ) { 02381 #ifdef TAPs_USE_WXWIDGETS 02382 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), geomFile ); 02383 wxLogError( wxT( "%s" ), geomShader->GetCompilerLog() ); 02384 #else 02385 std::cerr << "ERROR: \"" << geomFile << "\" Compilation Error:\n"; 02386 std::cerr << geomShader->GetCompilerLog() << "\n"; 02387 #endif 02388 return false; 02389 } 02390 #ifdef TAPs_DEBUG_MODE 02391 #ifdef TAPs_USE_WXWIDGETS 02392 wxLogWarning( wxT( " is successful!" ) ); 02393 #else 02394 std::cout << " is successful!\n"; 02395 #endif 02396 #endif 02397 return true; 02398 } 02399 return false; 02400 } // END: bool CompileGeometryShaderFromFile ( GLSLGeometyrShader * geomShader, const char * geomFile ); 02401 //----------------------------------------------------------------------------- 02402 // Load a fragment shader from file 02403 bool GLSLShaderManager::CompileFragmentShaderFromFile ( 02404 GLSLFragmentShader * fragShader, const char * fragFile ) 02405 { 02406 //---------------------------------------------------------------- 02407 // Compile fragment program 02408 if ( fragFile ) { 02409 #ifdef TAPs_DEBUG_MODE 02410 #ifdef TAPs_USE_WXWIDGETS 02411 wxLogWarning( wxT( "Compile fragment program \"%s\"" ), fragFile ); 02412 #else 02413 std::cout << "Compile fragment program \"" << fragFile << "\""; 02414 #endif 02415 #endif 02416 if ( !fragShader->Compile() ) { 02417 #ifdef TAPs_USE_WXWIDGETS 02418 wxLogError( wxT( "ERROR: \"%s\" Compilation Error:" ), fragFile ); 02419 wxLogError( wxT( "%s" ), fragShader->GetCompilerLog() ); 02420 #else 02421 std::cerr << "ERROR: \"" << fragFile << "\" Compilation Error:\n"; 02422 std::cerr << fragShader->GetCompilerLog() << "\n"; 02423 #endif 02424 return false; 02425 } 02426 #ifdef TAPs_DEBUG_MODE 02427 #ifdef TAPs_USE_WXWIDGETS 02428 wxLogWarning( wxT( " is successful!" ) ); 02429 #else 02430 std::cout << " is successful!\n"; 02431 #endif 02432 #endif 02433 return true; 02434 } 02435 return false; 02436 } // END: bool CompileFragmentShaderFromFile ( GLSLFragmentShader * fragShader, const char * fragFile ); 02437 //----------------------------------------------------------------------------- 02438 //============================================================================= 02439 //****************************************************************************** 02440 02441 //============================================================================= 02442 END_NAMESPACE_TAPs__OpenGL 02443 //345678901234567890123456789012345678901234567890123456789012345678901234567890 02444 //--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8
1.7.4 
