OpenGL_Debug.c

#include<dbghelp.h>


void getStackTrace(char *funcName,int *lineNumber)
    {

    unsigned int i;
    void * stack[ 100 ];
    unsigned short frames;
    SYMBOL_INFO * symbol;
    HANDLE process;
    char name[256];
    char fname[256];
    IMAGEHLP_LINE64 line;  
    DWORD64 displace_local;    
    DWORD64 displace;



    line.SizeOfStruct = sizeof(IMAGEHLP_LINE64); 

    process = GetCurrentProcess();
    SymInitialize( process, NULL, TRUE );

    frames = CaptureStackBackTrace( 0, 100, stack, NULL );

    symbol = ( SYMBOL_INFO * )calloc( sizeof( SYMBOL_INFO ) + 256 * sizeof( char ), 1 );
    symbol->MaxNameLen = 255;
    symbol->SizeOfStruct = sizeof( SYMBOL_INFO );
    strcpy(name,__FUNCTION__);

    //To get Address and stack trace of user function which called gl function causing error
    for( i = 0; i < frames; i++ )
        {

        SymFromAddr( process, ( DWORD64 )( stack[ i ] ),&displace, symbol );
        //this is to skip current function driver function and dll function calls in between
        if(strcmp( symbol->Name,name)!=0 
            && strstr(symbol->Name , "Drv")==NULL 
            && strstr(symbol->Name , "Dll")==NULL 
            && strstr(symbol->Name , "openglCallbackFunction")==NULL)
            {
           
            if (SymGetLineFromAddr64(process,  
                symbol->Address+displace,  
                &displace_local,  
                &line))  
                {  

                *lineNumber=line.LineNumber;
                strcpy(funcName,symbol->Name);
                break;
                }   
           

            }
        }


    free( symbol );


    }


void writeLog(int lineno,char*funcName,char* message)
    {
      FILE *fp=NULL;

      fp=fopen("Hello.txt","a+");
      if(fp!=NULL)
          {
          fprintf(fp,"%d : %s : %s  \n",lineno,funcName,message);
          }
      fclose(fp);
    }

void APIENTRY openglCallbackFunction(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar* message,void* userParam)
    {
    char sourceString[256];
    char typeString[256];
    char severityString[256];
    char funcName[256];
    int lineno;

    switch (source) {

        case GL_DEBUG_SOURCE_API_ARB: {
            *sourceString = "API";
            break;
            }

        case GL_DEBUG_SOURCE_APPLICATION_ARB: {
            *sourceString = "Application";
            break;
            }

        case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB: {
            *sourceString = "Window System";
            break;
            }

        case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: {
            *sourceString = "Shader Compiler";
            break;
            }
        case GL_DEBUG_SOURCE_THIRD_PARTY_ARB: {
            *sourceString = "Third Party";
            break;
            }

        case GL_DEBUG_SOURCE_OTHER_ARB: {
            *sourceString = "Other";
            break;
            }
        default: {
            *sourceString = "Unknown";
            break;
            }
        }

    switch (type) {
        case GL_DEBUG_TYPE_ERROR_ARB: {
            *typeString = "Error";
            break;
            }

        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: {
            *typeString = "Deprecated Behavior";
            break;
            }
        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: {
            *typeString = "Undefined Behavior";
            break;
            }
        
        case GL_DEBUG_TYPE_PERFORMANCE_ARB: {
            *typeString = "Performance";
            break;
            }

        case GL_DEBUG_TYPE_PORTABILITY_ARB: {
            *typeString = "Portability Issue";
            break;

            }

        case GL_DEBUG_TYPE_MARKER_ARB: {
            *typeString = " Maker Issue";
            }
        case GL_DEBUG_TYPE_OTHER_ARB: {
            *typeString = "Other";
            break;
            }
        default: {
            *typeString = "Unknown";
            break;
            }
        }

    switch (severity) {
        case GL_DEBUG_SEVERITY_HIGH_ARB: {
            *severityString = "High";
            break;
            }
        case GL_DEBUG_SEVERITY_MEDIUM_ARB: {
            *severityString = "Medium";
            break;
            }
        case GL_DEBUG_SEVERITY_LOW_ARB: {
            *severityString = "Low";
            break;
            }
        default: {
            *severityString = "Unknown";
            break;
            }
        }

     getStackTrace(&funcName,&lineno);
     writeLog(lineno,funcName,message);
    }

int ipglOpenglStartDebugging()
    {
     GLuint unusedIds = 0;
      int NumberOfExtensions;
      int i=0;
      
      void (*glDebugMessageCallbackARB)(DEBUGPROCARB callback, const void *userParam);
      void (*glDebugMessageControlARB)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, int enabled);
      
      const GLubyte* (*glGetStringi)(GLenum, GLuint);
      
     
      glGetStringi = (PFNGLGETSTRINGIPROC)wglGetProcAddress("glGetStringi");
      if(glGetStringi)
	  return -1;
	  
	  //This enables debugging context
      glEnable(GL_DEBUG_OUTPUT_ARB);
	  //This tells driver to report back errors immediately when regitered
	  //There is another way of logging messages
      glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
      glGetIntegerv(GL_NUM_EXTENSIONS, &NumberOfExtensions);

      for(i=0; i<NumberOfExtensions; i++) 
          {
          const GLubyte *ccc=glGetStringi(GL_EXTENSIONS, i);
          if ( strcmp(ccc, (const GLubyte *)"GL_ARB_debug_output") == 0 )
              {
              
              glDebugMessageCallbackARB  = (PFNGLDEBUGMESSAGECALLBACKARBPROC) wglGetProcAddress("glDebugMessageCallbackARB");
              if(glDebugMessageCallbackARB)
			  return -1;
			  glDebugMessageControlARB   =  (PFNGLDEBUGMESSAGECONTROLARBPROC) wglGetProcAddress("glDebugMessageControlARB");
			  if(glDebugMessageControlARB)
			  return -1;
              }
         
          }
      
	  //Register Callback function to driver
      glDebugMessageCallbackARB(openglCallbackFunction, NULL);
	  //This sets debugging context 
      glDebugMessageControlARB(GL_DONT_CARE,
            GL_DONT_CARE,
            GL_DONT_CARE,
            0,
            &unusedIds,
            1);
    }