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