void
S9xOpenGLDisplayDriver::swap_control (int enable)
{
glSwapIntervalProc glSwapInterval = NULL;
const char *ext_str;
ext_str = glXQueryExtensionsString (display, DefaultScreen (display));
/* We try to set this with both extensions since some cards pretend
* to support both, but ignore one. */
if (strstr (ext_str, "GLX_MESA_swap_control"))
{
glSwapInterval = (glSwapIntervalProc)
glGetProcAddress ((GLubyte *) "glXSwapIntervalMESA");
if (glSwapInterval)
glSwapInterval (enable ? 1 : 0);
}
else if (strstr (ext_str, "GLX_SGI_swap_control"))
{
glSwapInterval = (glSwapIntervalProc)
glGetProcAddress ((GLubyte *) "glXSwapIntervalSGI");
if (glSwapInterval)
{
glSwapInterval (enable ? 1 : 0);
}
}
return;
}
void
S9xOpenGLDisplayDriver::swap_control (int enable)
{
static glSwapIntervalProc glSwapInterval = NULL;
static glXSwapIntervalEXTProc glXSwapIntervalEXT = NULL;
static int queried = FALSE;
const char *ext_str;
enable = enable ? 1 : 0;
if (!queried)
{
ext_str = glXQueryExtensionsString (display, DefaultScreen (display));
/* We try to set this with both extensions since some cards pretend
* to support both, but ignore one. */
if (strstr (ext_str, "GLX_MESA_swap_control"))
{
glSwapInterval = (glSwapIntervalProc)
glGetProcAddress ((GLubyte *) "glXSwapIntervalMESA");
}
if (strstr (ext_str, "GLX_SGI_swap_control"))
{
glSwapInterval = (glSwapIntervalProc)
glGetProcAddress ((GLubyte *) "glXSwapIntervalSGI");
}
if (strstr (ext_str, "GLX_EXT_swap_control"))
{
glXSwapIntervalEXT = (glXSwapIntervalEXTProc)
glGetProcAddress ((GLubyte *) "glXSwapIntervalEXT");
}
queried = TRUE;
}
if (glXSwapIntervalEXT)
{
if (glSwapInterval)
glSwapInterval (0);
glXSwapIntervalEXT (display, xwindow, enable);
}
else if (glSwapInterval)
{
glSwapInterval (enable);
}
return;
}
__eglMustCastToProperFunctionPointerType __stdcall eglGetProcAddress(const char *procname)
{
EVENT("(const char *procname = \"%s\")", procname);
ANGLE_TRY
{
struct Extension
{
const char *name;
__eglMustCastToProperFunctionPointerType address;
};
static const Extension eglExtensions[] =
{
{"eglQuerySurfacePointerANGLE", (__eglMustCastToProperFunctionPointerType)eglQuerySurfacePointerANGLE},
{"eglPostSubBufferNV", (__eglMustCastToProperFunctionPointerType)eglPostSubBufferNV},
{"", NULL},
};
for (unsigned int ext = 0; ext < ArraySize(eglExtensions); ext++)
{
if (strcmp(procname, eglExtensions[ext].name) == 0)
{
return (__eglMustCastToProperFunctionPointerType)eglExtensions[ext].address;
}
}
return glGetProcAddress(procname);
}
ANGLE_CATCH_ALL
{
return egl::error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL);
}
}
__eglMustCastToProperFunctionPointerType __stdcall eglGetProcAddress(const char *procname)
{
EVENT("(const char *procname = \"%s\")", procname);
try
{
struct Extension
{
const char *name;
__eglMustCastToProperFunctionPointerType address;
};
static const Extension eglExtensions[] =
{
{"eglQuerySurfacePointerANGLE", (__eglMustCastToProperFunctionPointerType)eglQuerySurfacePointerANGLE},
{"eglPostSubBufferNV", (__eglMustCastToProperFunctionPointerType)eglPostSubBufferNV},
{"", NULL},
};
for (int ext = 0; ext < sizeof(eglExtensions) / sizeof(Extension); ext++)
{
if (strcmp(procname, eglExtensions[ext].name) == 0)
{
return (__eglMustCastToProperFunctionPointerType)eglExtensions[ext].address;
}
}
return glGetProcAddress(procname);
}
catch(std::bad_alloc&)
{
return error(EGL_BAD_ALLOC, (__eglMustCastToProperFunctionPointerType)NULL);
}
}
Func getPointer(const char* name) {
#ifdef OS_WIN
void* ptr = glGetProcAddress(name);
if (ptr == NULL)
ptr = libgl.getFunc(name);
#elif defined(OS_UNIX)
void* ptr = libgl.getFunc(name);
#endif
return reinterpret_cast<Func>(ptr);
}
bool GLExtHandler::loadGLExtPointParameter()
{
if (pointParameterGLExt == UNCHECKED)
{
pointParameterGLExt = UNSUPPORTED;
std::string version = reinterpret_cast<const char*>(glGetString(GL_VERSION));
std::string extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
// openGL 1.4 and higher
if (((int(version[0] - '0') == 1)&&(int(version[2] - '0') >= 4))
||(int(version[0] - '0') > 1))
{
SPK_glPointParameterf = (SPK_PFNGLPOINTPARAMETERFPROC)glGetProcAddress("glPointParameterf");
SPK_glPointParameterfv = (SPK_PFNGLPOINTPARAMETERFVPROC)glGetProcAddress("glPointParameterfv");
}
// point parameter ARB
if (((SPK_glPointParameterf == NULL)||(SPK_glPointParameterfv == NULL))
&&(extensions.find("GL_ARB_point_parameters") != std::string::npos))
{
SPK_glPointParameterf = (SPK_PFNGLPOINTPARAMETERFPROC)glGetProcAddress("glPointParameterfARB");
SPK_glPointParameterfv = (SPK_PFNGLPOINTPARAMETERFVPROC)glGetProcAddress("glPointParameterfvARB");
}
// point parameter EXT
if (((SPK_glPointParameterf == NULL)||(SPK_glPointParameterfv == NULL))
&&(extensions.find("GL_EXT_point_parameters") != std::string::npos))
{
SPK_glPointParameterf = (SPK_PFNGLPOINTPARAMETERFPROC)glGetProcAddress("glPointParameterfEXT");
SPK_glPointParameterfv = (SPK_PFNGLPOINTPARAMETERFVPROC)glGetProcAddress("glPointParameterfvEXT");
}
// point parameter SGIS
if (((SPK_glPointParameterf == NULL)||(SPK_glPointParameterfv == NULL))
&&(extensions.find("GL_SGIS_point_parameters") != std::string::npos))
{
SPK_glPointParameterf = (SPK_PFNGLPOINTPARAMETERFPROC)glGetProcAddress("glPointParameterfSGIS");
SPK_glPointParameterfv = (SPK_PFNGLPOINTPARAMETERFVPROC)glGetProcAddress("glPointParameterfvSGIS");
}
if ((SPK_glPointParameterf != NULL)&&(SPK_glPointParameterfv != NULL))
pointParameterGLExt = SUPPORTED;
}
return pointParameterGLExt == SUPPORTED;
}
sageDisplay::sageDisplay(displayContext *dct, struct sageDisplayConfig &cfg): context(dct),
dirty(false), drawObj(dirty, cfg.displayID)
{
configStruct = cfg;
tileNum = cfg.dimX * cfg.dimY;
if (tileNum > MAX_TILES_PER_NODE) {
sage::printLog("sageDisplay::init() : The tile number exceeds the maximum");
}
for (int i=0; i<tileNum; i++) {
noOfMontages[i] = 0;
for (int j=0; j<MAX_MONTAGE_NUM; j++)
montages[i][j] = NULL;
}
#if defined(WIN32)
fprintf(stderr, "Init GL functions: %p %p\n", glCompressedTexImage2D, glCompressedTexSubImage2D);
glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)
glGetProcAddress("glCompressedTexImage2D");
glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)
glGetProcAddress("glCompressedTexSubImage2D");
fprintf(stderr, "----> GL functions: %p %p\n", glCompressedTexImage2D, glCompressedTexSubImage2D);
#endif
}
gl_proc
S9xOpenGLDisplayDriver::get_aliased_extension (const char **name)
{
gl_proc ext_proc = NULL;
for (int i = 0; name[i]; i++)
{
ext_proc = glGetProcAddress ((GLubyte *) name[i]);
if (ext_proc)
break;
}
return ext_proc;
}
bool GLExtHandler::loadGLExtTexture3D()
{
if (texture3DGLExt == UNCHECKED)
{
texture3DGLExt = UNSUPPORTED;
std::string version = reinterpret_cast<const char*>(glGetString(GL_VERSION));
std::string extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
// openGL 1.2 and higher
if (((int(version[0] - '0') == 1)&&(int(version[2] - '0') >= 4))
||(int(version[0] - '0') > 1))
SPK_glTexImage3D = (SPK_PFNGLTEXIMAGE3DPROC)glGetProcAddress("glTexImage3D");
// texture 3D EXT
if ((SPK_glTexImage3D == NULL)&&(extensions.find("GL_EXT_texture3D") != std::string::npos))
SPK_glTexImage3D = (SPK_PFNGLTEXIMAGE3DPROC)glGetProcAddress("glTexImage3DEXT");
if (SPK_glTexImage3D != NULL)
texture3DGLExt = SUPPORTED;
}
return texture3DGLExt == SUPPORTED;
}
void run()
{
running = true;
window.setCaption( "OpenGL window" );
window.setWidth( 640 );
window.setHeight( 480 );
window.addEventHandler( this );
window.create();
Limbus::Keyboard keyboard;
keyboard.addEventHandler( this );
window.addInputDevice(&keyboard);
Limbus::Mouse mouse;
mouse.addEventHandler( this );
window.addInputDevice(&mouse);
glClearColor( 0.5f, 0.5f, 1.0f, 1.0f );
Vertex vertices[3];
memset( vertices, 0, sizeof vertices );
vertices[0].position[0] = -.5f;
vertices[0].position[1] = -.5f;
vertices[1].position[0] = .5f;
vertices[1].position[1] = -.5f;
vertices[2].position[0] = 0.0f;
vertices[2].position[1] = .5f;
vertices[0].color[0] = 1.0f;
vertices[1].color[2] = 1.0f;
vertices[2].color[1] = 1.0f;
GLGENBUFFERSPROC glGenBuffers = (GLGENBUFFERSPROC)glGetProcAddress( "glGenBuffers" );
GLDELETEBUFFERSPROC glDeleteBuffers = (GLDELETEBUFFERSPROC)glGetProcAddress( "glDeleteBuffers" );
GLBINDBUFFERPROC glBindBuffer = (GLBINDBUFFERPROC)glGetProcAddress( "glBindBuffer" );
GLBUFFERDATAPROC glBufferData = (GLBUFFERDATAPROC)glGetProcAddress( "glBufferData" );
GLBUFFERSUBDATAPROC glBufferSubData = (GLBUFFERSUBDATAPROC)glGetProcAddress( "glBufferSubData" );
GLuint buffer;
glGenBuffers( 1, &buffer );
glBindBuffer( GL_ARRAY_BUFFER, buffer );
glBufferData( GL_ARRAY_BUFFER, sizeof vertices, NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof vertices, vertices );
glEnableClientState( GL_COLOR_ARRAY );
glEnableClientState( GL_VERTEX_ARRAY );
while (running)
{
window.pollEvents();
keyboard.pollEvents();
mouse.pollEvents();
glClear( GL_COLOR_BUFFER_BIT );
glColorPointer( 4, GL_FLOAT, sizeof( Vertex ), BUFFER_OFFSET( 8 ) );
glVertexPointer( 2, GL_FLOAT, sizeof( Vertex ), BUFFER_OFFSET( 0 ) );
glDrawArrays( GL_TRIANGLES, 0, sizeof vertices / sizeof vertices[0] );
window.swapBuffers();
}
glDeleteBuffers( 1, &buffer );
}
BIT_API Bool BindOpenGLExtensions( const Uint32 p_Major, const Uint32 p_Minor )
{
// Get all the available extensions
std::list< std::string > availableExtensions;
GLint availableExtensionCount = 0;
// Get the available extension count
glGetIntegerv( GL_NUM_EXTENSIONS, &availableExtensionCount );
// Get the proc address for glGetStringi
__glGetStringi = (PFNGLGETSTRINGIPROC)glGetProcAddress( "glGetStringi" );
// Get all the available extensions
for( SizeType i = 0; i < (SizeType)availableExtensionCount; i++ )
{
availableExtensions.push_back( ( char * )( __glGetStringi( GL_EXTENSIONS, i ) ) );
}
// Go through some of the extensions to confirm some of them.
for( std::list< std::string >::iterator it = availableExtensions.begin( );
it != availableExtensions.end( ); it++ )
{
if( *it == "GL_ARB_vertex_buffer_object" )
{
BIT_ARB_vertex_buffer_object = true;
}
else if( *it == "GL_ARB_vertex_array_object" )
{
BIT_ARB_vertex_array_object = true;
}
else if( *it == "GL_ARB_framebuffer_object" )
{
BIT_ARB_framebuffer_object = true;
}
// Checking for shader extensions
else if( *it == "GL_ARB_shading_language_100" )
{
BIT_ARB_shading_language_100 = true;
}
else if( *it == "GL_ARB_shader_objects" )
{
BIT_ARB_shader_objects = true;
}
else if( *it == "GL_ARB_vertex_shader" )
{
BIT_ARB_vertex_shader = true;
}
else if( *it == "GL_ARB_fragment_shader" )
{
BIT_ARB_fragment_shader = true;
}
// Check for texture extensions
else if( *it == "GL_EXT_texture_filter_anisotropic" )
{
BIT_EXT_texture_filter_anisotropic = true;
// Get the max level
GLfloat levels;
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &levels );
g_AnisotropicMaxLevel = static_cast<Uint32>( levels + 0.5f );
}
}
// Use a boolean to check if any attempt in getting
// any OpenGL function failed
Bool Ret = 0;
// Get the texture functions
if( BIT_ARB_framebuffer_object )
{
Ret |= (__glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)
glGetProcAddress("glClearBufferfv")) == NULL;
Ret |= (__glDrawBuffers = (PFNGLDRAWBUFFERSPROC)
glGetProcAddress("glDrawBuffers")) == NULL;
Ret |= (__glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)
glGetProcAddress("glBlitFramebuffer")) == NULL;
Ret |= ( __glGenerateMipmap = ( PFNGLGENERATEMIPMAPPROC )
glGetProcAddress( "glGenerateMipmap" ) ) == NULL;
Ret |= ( __glBindFramebuffer = ( PFNGLBINDFRAMEBUFFERPROC )
glGetProcAddress( "glBindFramebuffer" ) ) == NULL;
Ret |= ( __glBindRenderbuffer = ( PFNGLBINDRENDERBUFFERPROC )
glGetProcAddress( "glBindRenderbuffer" ) ) == NULL;
Ret |= ( __glCheckFramebufferStatus = ( PFNGLCHECKFRAMEBUFFERSTATUSPROC )
glGetProcAddress( "glCheckFramebufferStatus" ) ) == NULL;
Ret |= ( __glDeleteFramebuffers = ( PFNGLDELETEFRAMEBUFFERSPROC )
glGetProcAddress( "glDeleteFramebuffers" ) ) == NULL;
Ret |= ( __glDeleteRenderbuffers = ( PFNGLDELETERENDERBUFFERSPROC )
glGetProcAddress( "glDeleteRenderbuffers" ) ) == NULL;
Ret |= ( __glFramebufferRenderbuffer = ( PFNGLFRAMEBUFFERRENDERBUFFERPROC )
glGetProcAddress( "glFramebufferRenderbuffer" ) ) == NULL;
Ret |= ( __glFramebufferTexture2D = ( PFNGLFRAMEBUFFERTEXTURE2DPROC )
glGetProcAddress( "glFramebufferTexture2D" ) ) == NULL;
Ret |= ( __glGenFramebuffers = ( PFNGLGENFRAMEBUFFERSPROC )
glGetProcAddress( "glGenFramebuffers" ) ) == NULL;
Ret |= ( __glGenRenderbuffers = ( PFNGLGENRENDERBUFFERSPROC )
glGetProcAddress( "glGenRenderbuffers" ) ) == NULL;
Ret |= ( __glRenderbufferStorage = ( PFNGLRENDERBUFFERSTORAGEPROC )
glGetProcAddress( "glRenderbufferStorage" ) ) == NULL;
Ret |= ( __glRenderbufferStorageMultisample = ( PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC )
glGetProcAddress( "glRenderbufferStorageMultisample" ) ) == NULL;
Ret |= ( __glTexImage2DMultisample = ( PFNGLTEXIMAGE2DMULTISAMPLEPROC )
glGetProcAddress( "glTexImage2DMultisample" ) ) == NULL;
if( Ret )
{
BIT_ARB_framebuffer_object = false;
}
}
// Reset the return flag
Ret = 0;
if( p_Major > 1 || ( p_Major == 1 && p_Minor >= 3 ) )
{
Ret |= ( __glActiveTexture = ( PFNGLACTIVETEXTUREPROC )
glGetProcAddress( "glActiveTexture" ) ) == NULL;
if( !Ret )
{
s_GeneralTextureFunctions = true;
}
}
// Reset the return flag
Ret = 0;
// Get the buffer functions
if( p_Major > 1 || ( p_Major == 1 && p_Minor >= 5 ) )
{
Ret |= ( __glBindBuffer = ( PFNGLBINDBUFFERPROC )
glGetProcAddress( "glBindBuffer" ) ) == NULL;
Ret |= ( __glBufferData = ( PFNGLBUFFERDATAPROC )
glGetProcAddress( "glBufferData" ) ) == NULL;
Ret |= ( __glBufferSubData = ( PFNGLBUFFERSUBDATAPROC )
glGetProcAddress( "glBufferSubData" ) ) == NULL;
Ret |= ( __glDeleteBuffers = ( PFNGLDELETEBUFFERSPROC )
glGetProcAddress( "glDeleteBuffers" ) ) == NULL;
Ret |= ( __glGenBuffers = ( PFNGLGENBUFFERSPROC )
glGetProcAddress( "glGenBuffers" ) ) == NULL;
if( !Ret )
{
s_GeneralBuffersFunctions = true;
}
}
// Reset the return flag
Ret = 0;
// Get the vertex array object functions if they are available
if( BIT_ARB_vertex_array_object )
{
Ret |= ( __glBindVertexArray = ( PFNGLBINDVERTEXARRAYPROC )
glGetProcAddress( "glBindVertexArray" ) ) == NULL;
Ret |= ( __glDeleteVertexArrays = ( PFNGLDELETEVERTEXARRAYSPROC )
glGetProcAddress( "glDeleteVertexArrays" ) ) == NULL;
Ret |= ( __glGenVertexArrays = ( PFNGLGENVERTEXARRAYSPROC )
glGetProcAddress( "glGenVertexArrays" ) ) == NULL;
Ret |= ( __glIsVertexArray = ( PFNGLISVERTEXARRAYPROC )
glGetProcAddress( "glIsVertexArray" ) ) == NULL;
if( Ret )
{
BIT_ARB_vertex_array_object = false;
}
}
// Reset the return flag
Ret = 0;
// Load the shader functions if the shader extenstions are available
// and we are using the right verison of OpenGL
// WARNING: comparison of unsigned expression >= 0 is always true [-Wtype-limits]|
if( p_Major >= 2 )
{
// Needed for the vertex objects.
Ret |= ( __glEnableVertexAttribArray = ( PFNGLENABLEVERTEXATTRIBARRAYPROC )
glGetProcAddress( "glEnableVertexAttribArray" ) ) == NULL;
Ret |= ( __glVertexAttribPointer = ( PFNGLVERTEXATTRIBPOINTERPROC )
glGetProcAddress( "glVertexAttribPointer" ) ) == NULL;
Ret |= ( __glAttachShader = ( PFNGLATTACHSHADERPROC )
glGetProcAddress( "glAttachShader" ) ) == NULL;
Ret |= ( __glCompileShader = ( PFNGLCOMPILESHADERPROC )
glGetProcAddress( "glCompileShader" ) ) == NULL;
Ret |= ( __glCreateProgram = ( PFNGLCREATEPROGRAMPROC )
glGetProcAddress( "glCreateProgram" ) ) == NULL;
Ret |= ( __glCreateShader = ( PFNGLCREATESHADERPROC )
glGetProcAddress( "glCreateShader" ) ) == NULL;
Ret |= ( __glDeleteProgram = ( PFNGLDELETEPROGRAMPROC )
glGetProcAddress( "glDeleteProgram" ) ) == NULL;
Ret |= ( __glDeleteShader = ( PFNGLDELETESHADERPROC )
glGetProcAddress( "glDeleteShader" ) ) == NULL;
Ret |= ( __glGetProgramInfoLog = ( PFNGLGETPROGRAMINFOLOGPROC )
glGetProcAddress( "glGetProgramInfoLog" ) ) == NULL;
Ret |= ( __glGetProgramiv = ( PFNGLGETPROGRAMIVPROC )
glGetProcAddress( "glGetProgramiv" ) ) == NULL;
Ret |= ( __glGetShaderInfoLog = ( PFNGLGETSHADERINFOLOGPROC )
glGetProcAddress( "glGetShaderInfoLog" ) ) == NULL;
Ret |= ( __glGetShaderiv = ( PFNGLGETSHADERIVPROC )
glGetProcAddress( "glGetShaderiv" ) ) == NULL;
Ret |= ( __glGetUniformLocation = ( PFNGLGETUNIFORMLOCATIONPROC )
glGetProcAddress( "glGetUniformLocation" ) ) == NULL;
Ret |= ( __glLinkProgram = ( PFNGLLINKPROGRAMPROC )
glGetProcAddress( "glLinkProgram" ) ) == NULL;
Ret |= ( __glShaderSource = ( PFNGLSHADERSOURCEPROC )
glGetProcAddress( "glShaderSource" ) ) == NULL;
Ret |= ( __glValidateProgram = ( PFNGLVALIDATEPROGRAMPROC )
glGetProcAddress( "glValidateProgram" ) ) == NULL;
Ret |= ( __glBindAttribLocation = ( PFNGLBINDATTRIBLOCATIONPROC )
glGetProcAddress( "glBindAttribLocation" ) ) == NULL;
Ret |= ( __glGetAttribLocation = ( PFNGLGETATTRIBLOCATIONPROC )
glGetProcAddress( "glGetAttribLocation" ) ) == NULL;
Ret |= ( __glUseProgram = ( PFNGLUSEPROGRAMPROC )
glGetProcAddress( "glUseProgram" ) ) == NULL;
// Uniforms
Ret |= ( __glUniform1f = ( PFNGLUNIFORM1FPROC )
glGetProcAddress( "glUniform1f" ) ) == NULL;
Ret |= ( __glUniform1fv = ( PFNGLUNIFORM1FVPROC )
glGetProcAddress( "glUniform1fv" ) ) == NULL;
Ret |= ( __glUniform1i = ( PFNGLUNIFORM1IPROC )
glGetProcAddress( "glUniform1i" ) ) == NULL;
Ret |= ( __glUniform1iv = ( PFNGLUNIFORM1IVPROC )
glGetProcAddress( "glUniform1iv" ) ) == NULL;
Ret |= ( __glUniform2f = ( PFNGLUNIFORM2FPROC )
glGetProcAddress( "glUniform2f" ) ) == NULL;
Ret |= ( __glUniform2fv = ( PFNGLUNIFORM2FVPROC )
glGetProcAddress( "glUniform2fv" ) ) == NULL;
Ret |= ( __glUniform2i = ( PFNGLUNIFORM2IPROC )
glGetProcAddress( "glUniform2i" ) ) == NULL;
Ret |= ( __glUniform2iv = ( PFNGLUNIFORM2IVPROC )
glGetProcAddress( "glUniform2iv" ) ) == NULL;
Ret |= ( __glUniform3f = ( PFNGLUNIFORM3FPROC )
glGetProcAddress( "glUniform3f" ) ) == NULL;
Ret |= ( __glUniform3fv = ( PFNGLUNIFORM3FVPROC )
glGetProcAddress( "glUniform3fv" ) ) == NULL;
Ret |= ( __glUniform3i = ( PFNGLUNIFORM3IPROC )
glGetProcAddress( "glUniform3i" ) ) == NULL;
Ret |= ( __glUniform3iv = ( PFNGLUNIFORM3IVPROC )
glGetProcAddress( "glUniform3iv" ) ) == NULL;
Ret |= ( __glUniform4f = ( PFNGLUNIFORM4FPROC )
glGetProcAddress( "glUniform4f" ) ) == NULL;
Ret |= ( __glUniform4fv = ( PFNGLUNIFORM4FVPROC )
glGetProcAddress( "glUniform4fv" ) ) == NULL;
Ret |= ( __glUniform4i = ( PFNGLUNIFORM4IPROC )
glGetProcAddress( "glUniform4i" ) ) == NULL;
Ret |= ( __glUniform4iv = ( PFNGLUNIFORM4IVPROC )
glGetProcAddress( "glUniform4iv" ) ) == NULL;
Ret |= ( __glUniformMatrix2fv = ( PFNGLUNIFORMMATRIX2FVPROC )
glGetProcAddress( "glUniformMatrix2fv" ) ) == NULL;
Ret |= ( __glUniformMatrix3fv = ( PFNGLUNIFORMMATRIX3FVPROC )
glGetProcAddress( "glUniformMatrix3fv" ) ) == NULL;
Ret |= ( __glUniformMatrix4fv = ( PFNGLUNIFORMMATRIX4FVPROC )
glGetProcAddress( "glUniformMatrix4fv" ) ) == NULL;
// Error check the OpenGL shader functions
if( Ret == 0 )
{
s_AllShaderFunctions = true;
}
}
return true;
}
int
S9xOpenGLDisplayDriver::load_shader_functions (void)
{
const char *extensions = (const char *) glGetString (GL_EXTENSIONS);
if (!extensions)
return 0;
if (strstr (extensions, "fragment_program"))
{
glCreateProgram = (glCreateProgramProc) glGetProcAddress ((GLubyte *) "glCreateProgram");
glCreateShader = (glCreateShaderProc) glGetProcAddress ((GLubyte *) "glCreateShader");
glCompileShader = (glCompileShaderProc) glGetProcAddress ((GLubyte *) "glCompileShader");
glDeleteShader = (glDeleteShaderProc) glGetProcAddress ((GLubyte *) "glDeleteShader");
glDeleteProgram = (glDeleteProgramProc) glGetProcAddress ((GLubyte *) "glDeleteProgram");
glAttachShader = (glAttachShaderProc) glGetProcAddress ((GLubyte *) "glAttachShader");
glDetachShader = (glDetachShaderProc) glGetProcAddress ((GLubyte *) "glDetachShader");
glLinkProgram = (glLinkProgramProc) glGetProcAddress ((GLubyte *) "glLinkProgram");
glUseProgram = (glUseProgramProc) glGetProcAddress ((GLubyte *) "glUseProgram");
glShaderSource = (glShaderSourceProc) glGetProcAddress ((GLubyte *) "glShaderSource");
glGetUniformLocation = (glGetUniformLocationProc) glGetProcAddress ((GLubyte *) "glGetUniformLocation");
glUniform2fv = (glUniform2fvProc) glGetProcAddress ((GLubyte *) "glUniform2fv");
if (glCreateProgram &&
glCreateShader &&
glCompileShader &&
glDeleteShader &&
glDeleteProgram &&
glAttachShader &&
glDetachShader &&
glLinkProgram &&
glUseProgram &&
glShaderSource &&
glGetUniformLocation &&
glUniform2fv)
{
return 1;
}
}
return 0;
}
int LoadGLCoreFunctions()
{
_glCreateShader = (PFNGLCreateShader)glGetProcAddress("glCreateShader");
_glDeleteShader = (PFNGLDeleteShader)glGetProcAddress("glDeleteShader");
_glShaderSource = (PFNGLShaderSource)glGetProcAddress("glShaderSource");
_glCompileShader = (PFNGLCompileShader)glGetProcAddress("glCompileShader");
_glAttachShader = (PFNGLAttachShader)glGetProcAddress("glAttachShader");
_glCreateProgram = (PFNGLCreateProgram)glGetProcAddress("glCreateProgram");
_glLinkProgram = (PFNGLLinkProgram)glGetProcAddress("glLinkProgram");
_glUseProgram = (PFNGLUseProgram)glGetProcAddress("glUseProgram");
_glDeleteProgram = (PFNGLDeleteProgram)glGetProcAddress("glDeleteProgram");
_glGenBuffers = (PFNGLGenBuffers)glGetProcAddress("glGenBuffers");
_glBindBuffer = (PFNGLBindBuffer)glGetProcAddress("glBindBuffer");
_glVertexAttribPointer = (PFNGLVertexAttribPointer)glGetProcAddress("glVertexAttribPointer");
_glEnableVertexAttribArray = (PFNGLEnableVertexAttribArray)glGetProcAddress("glEnableVertexAttribArray");
_glGenVertexArrays = (PFNGLGenVertexArrays)glGetProcAddress("glGenVertexArrays");
_glBindVertexArray = (PFNGLBindVertexArray)glGetProcAddress("glBindVertexArray");
_glDeleteVertexArrays = (PFNGLDeleteVertexArrays)glGetProcAddress("glDeleteVertexArrays");
_glGetAttribLocation = (PFNGLGetAttribLocation)glGetProcAddress("glGetAttribLocation");
_glGetUniformLocation = (PFNGLGetUniformLocation)glGetProcAddress("glGetUniformLocation");
_glUniform1f = (PFNGLUniform1f)glGetProcAddress("glUniform1f");
_glUniform3f = (PFNGLUniform3f)glGetProcAddress("glUniform3f");
_glBufferData = (PFNGLBufferData)glGetProcAddress("glBufferData");
_glDeleteBuffers = (PFNGLDeleteBuffers)glGetProcAddress("glDeleteBuffers");
if (_glCreateShader == NULL || _glDeleteShader == NULL || _glShaderSource == NULL || _glCompileShader == NULL
|| _glAttachShader == NULL || _glCreateProgram == NULL || _glLinkProgram == NULL || _glUseProgram == NULL
|| _glDeleteProgram == NULL || _glGenBuffers == NULL || _glBindBuffer == NULL || _glVertexAttribPointer == NULL
|| _glEnableVertexAttribArray == NULL || _glGenVertexArrays == NULL || _glBindVertexArray == NULL
|| _glDeleteVertexArrays == NULL || _glGetAttribLocation == NULL || _glGetUniformLocation == NULL
|| _glUniform1f == NULL || _glUniform3f == NULL || _glBufferData == NULL || _glDeleteBuffers == NULL)
return 0;
else
return 1;
}
void initMinGL()
{
pv_glCreateShader = (pv_glCreateShaderFunction)glGetProcAddress("glCreateShader");
pv_glShaderSource = (pv_glShaderSourceFunction)glGetProcAddress("glShaderSource");
pv_glCompileShader = (pv_glCompileShaderFunction)glGetProcAddress("glCompileShader");
pv_glDeleteShader = (pv_glDeleteShaderFunction)glGetProcAddress("glDeleteShader");
pv_glGetShaderiv = (pv_glGetShaderivFunction)glGetProcAddress("glGetShaderiv");
pv_glGetShaderInfoLog = (pv_glGetShaderInfoLogFunction)glGetProcAddress("glGetShaderInfoLog");
pv_glCreateProgram = (pv_glCreateProgramFunction)glGetProcAddress("glCreateProgram");
pv_glAttachShader = (pv_glAttachShaderFunction)glGetProcAddress("glAttachShader");
pv_glLinkProgram = (pv_glLinkProgramFunction)glGetProcAddress("glLinkProgram");
pv_glUseProgram = (pv_glUseProgramFunction)glGetProcAddress("glUseProgram");
pv_glGetProgramiv = (pv_glGetProgramivFunction)glGetProcAddress("glGetProgramiv");
pv_glGetProgramInfoLog = (pv_glGetProgramInfoLogFunction)glGetProcAddress("glGetProgramInfoLog");
pv_glGetUniformLocation = (pv_glGetUniformLocationFunction)glGetProcAddress("glGetUniformLocation");
pv_glUniform1f = (pv_glUniform1fFunction)glGetProcAddress("glUniform1f");
pv_glUniform2f = (pv_glUniform2fFunction)glGetProcAddress("glUniform2f");
pv_glUniform3f = (pv_glUniform3fFunction)glGetProcAddress("glUniform3f");
pv_glUniform4f = (pv_glUniform4fFunction)glGetProcAddress("glUniform4f");
pv_glUniformMatrix4fv = (pv_glUniformMatrix4fvFunction)glGetProcAddress("glUniformMatrix4fv");
pv_glGenVertexArrays = (pv_glGenVertexArraysFunction)glGetProcAddress("glGenVertexArrays");
pv_glBindVertexArray = (pv_glBindVertexArrayFunction)glGetProcAddress("glBindVertexArray");
pv_glGenBuffers = (pv_glGenBuffersFunction)glGetProcAddress("glGenBuffers");
pv_glBindBuffer = (pv_glBindBufferFunction)glGetProcAddress("glBindBuffer");
pv_glBufferData = (pv_glBufferDataFunction)glGetProcAddress("glBufferData");
pv_glEnableVertexAttribArray = (pv_glEnableVertexAttribArrayFunction)glGetProcAddress("glEnableVertexAttribArray");
pv_glDisableVertexAttribArray = (pv_glDisableVertexAttribArrayFunction)glGetProcAddress("glDisableVertexAttribArray");
pv_glVertexAttribPointer = (pv_glVertexAttribPointerFunction)glGetProcAddress("glVertexAttribPointer");
pv_glActiveTexture = (pv_glActiveTextureFunction)glGetProcAddress("glActiveTexture");
pv_glBindAttribLocation = (pv_glBindAttribLocationFunction)glGetProcAddress("glBindAttribLocation");
pv_glBindFragDataLocation = (pv_glBindFragDataLocationFunction)glGetProcAddress("glBindFragDataLocation");
pv_glGenFramebuffers = (pv_glGenFramebuffersFunction)glGetProcAddress("glGenFramebuffers");
pv_glBindFramebuffer = (pv_glBindFramebufferFunction)glGetProcAddress("glBindFramebuffer");
pv_glFramebufferTexture2D = (pv_glFramebufferTexture2DFunction)glGetProcAddress("glFramebufferTexture2D");
pv_glGenRenderbuffers = (pv_glGenRenderbuffersFunction)glGetProcAddress("glGenRenderbuffers");
pv_glBindRenderbuffer = (pv_glBindRenderbufferFunction)glGetProcAddress("glBindRenderbuffer");
pv_glRenderbufferStorage = (pv_glRenderbufferStorageFunction)glGetProcAddress("glRenderbufferStorage");
pv_glFramebufferRenderbuffer = (pv_glFramebufferRenderbufferFunction)glGetProcAddress("glFramebufferRenderbuffer");
pv_glCheckFramebufferStatus = (pv_glCheckFramebufferStatusFunction)glGetProcAddress("glCheckFramebufferStatus");
pv_glGenerateMipmap = (pv_glGenerateMipmapFunction)glGetProcAddress("glGenerateMipmap");
}
bool GLExtHandler::loadGLExtShader()
{
if (shaderGLExt == UNCHECKED)
{
shaderGLExt = UNSUPPORTED;
std::string version = reinterpret_cast<const char*>(glGetString(GL_VERSION));
// openGL 2.0 and higher
if (int(version[0] - '0') >= 2)
{
bool ok = true;
if (ok && ((SPK_glCreateShader = (SPK_PFNGLCREATESHADERPROC)glGetProcAddress("glCreateShader")) == NULL)) ok = false;
if (ok && ((SPK_glDeleteShader = (SPK_PFNGLDELETESHADERPROC)glGetProcAddress("glDeleteShader")) == NULL)) ok = false;
if (ok && ((SPK_glShaderSource = (SPK_PFNGLSHADERSOURCEPROC)glGetProcAddress("glShaderSource")) == NULL)) ok = false;
if (ok && ((SPK_glCompileShader = (SPK_PFNGLCOMPILESHADERPROC)glGetProcAddress("glCompileShader")) == NULL)) ok = false;
if (ok && ((SPK_glCreateProgram = (SPK_PFNGLCREATEPROGRAMPROC)glGetProcAddress("glCreateProgram")) == NULL)) ok = false;
if (ok && ((SPK_glDeleteProgram = (SPK_PFNGLDELETEPROGRAMPROC)glGetProcAddress("glDeleteProgram")) == NULL)) ok = false;
if (ok && ((SPK_glAttachShader = (SPK_PFNGLATTACHSHADERPROC)glGetProcAddress("glAttachShader")) == NULL)) ok = false;
if (ok && ((SPK_glDetachShader = (SPK_PFNGLDETACHSHADERPROC)glGetProcAddress("glDetachShader")) == NULL)) ok = false;
if (ok && ((SPK_glLinkProgram = (SPK_PFNGLLINKPROGRAMPROC)glGetProcAddress("glLinkProgram")) == NULL)) ok = false;
if (ok && ((SPK_glUseProgram = (SPK_PFNGLUSEPROGRAMPROC)glGetProcAddress("glUseProgram")) == NULL)) ok = false;
if (ok) shaderGLExt = SUPPORTED;
}
if (shaderGLExt == UNSUPPORTED)
{
std::string extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
if ((extensions.find("GL_ARB_shading_language_100") != std::string::npos)&&
(extensions.find("GL_ARB_shader_objects") != std::string::npos)&&
(extensions.find("GL_ARB_vertex_shader") != std::string::npos)&&
(extensions.find("GL_ARB_fragment_shader") != std::string::npos))
{
bool ok = true;
if (ok && ((SPK_glCreateShader = (SPK_PFNGLCREATESHADERPROC)glGetProcAddress("glCreateShaderObjectARB")) == NULL)) ok = false;
if (ok && ((SPK_glDeleteShader = SPK_glDeleteProgram = (SPK_PFNGLDELETESHADERPROC)glGetProcAddress("glDeleteObjectARB")) == NULL)) ok = false;
if (ok && ((SPK_glShaderSource = (SPK_PFNGLSHADERSOURCEPROC)glGetProcAddress("glShaderSourceARB")) == NULL)) ok = false;
if (ok && ((SPK_glCompileShader = (SPK_PFNGLCOMPILESHADERPROC)glGetProcAddress("glCompileShaderARB")) == NULL)) ok = false;
if (ok && ((SPK_glCreateProgram = (SPK_PFNGLCREATEPROGRAMPROC)glGetProcAddress("glCreateProgramObjectARB")) == NULL)) ok = false;
if (ok && ((SPK_glAttachShader = (SPK_PFNGLATTACHSHADERPROC)glGetProcAddress("glAttachObjectARB")) == NULL)) ok = false;
if (ok && ((SPK_glDetachShader = (SPK_PFNGLDETACHSHADERPROC)glGetProcAddress("glDetachObjectARB")) == NULL)) ok = false;
if (ok && ((SPK_glLinkProgram = (SPK_PFNGLLINKPROGRAMPROC)glGetProcAddress("glLinkProgramARB")) == NULL)) ok = false;
if (ok && ((SPK_glUseProgram = (SPK_PFNGLUSEPROGRAMPROC)glGetProcAddress("glUseProgramObjectARB")) == NULL)) ok = false;
if (ok) shaderGLExt = SUPPORTED;
}
}
}
return shaderGLExt == SUPPORTED;
}
void OpenGL::init(int w, int h) {
//disable unused features
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glDisable(GL_POLYGON_SMOOTH);
glDisable(GL_STENCIL_TEST);
//enable useful and required features
glEnable(GL_DITHER);
glEnable(GL_TEXTURE_2D);
#ifndef __NO_SHADERS
//bind shader functions
#ifndef __APPLE__
glCreateProgram = (PFNGLCREATEPROGRAMPROC)glGetProcAddress("glCreateProgram");
glUseProgram = (PFNGLUSEPROGRAMPROC)glGetProcAddress("glUseProgram");
glCreateShader = (PFNGLCREATESHADERPROC)glGetProcAddress("glCreateShader");
glDeleteShader = (PFNGLDELETESHADERPROC)glGetProcAddress("glDeleteShader");
glShaderSource = (PFNGLSHADERSOURCEPROC)glGetProcAddress("glShaderSource");
glCompileShader = (PFNGLCOMPILESHADERPROC)glGetProcAddress("glCompileShader");
glAttachShader = (PFNGLATTACHSHADERPROC)glGetProcAddress("glAttachShader");
glDetachShader = (PFNGLDETACHSHADERPROC)glGetProcAddress("glDetachShader");
glLinkProgram = (PFNGLLINKPROGRAMPROC)glGetProcAddress("glLinkProgram");
glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glGetProcAddress("glGetUniformLocation");
glUniform1i = (PFNGLUNIFORM1IPROC)glGetProcAddress("glUniform1i");
glUniform2fv = (PFNGLUNIFORM2FVPROC)glGetProcAddress("glUniform2fv");
glUniform4fv = (PFNGLUNIFORM4FVPROC)glGetProcAddress("glUniform4fv");
#endif
glXGetCurrentDisplay = (void* (APIENTRYP)())glGetProcAddress("glXGetCurrentDisplay");
glXGetCurrentDrawable = (Uint32 (APIENTRYP)())glGetProcAddress("glXGetCurrentDrawable");
glXSwapIntervalEXT = (void (APIENTRYP)(void*, Uint32, int))glGetProcAddress("glXSwapIntervalEXT");
wglSwapIntervalEXT = (Uint32 (APIENTRYP)(int))glGetProcAddress("wglSwapIntervalEXT");
shader_support = glCreateProgram && glUseProgram && glCreateShader
&& glDeleteShader && glShaderSource && glCompileShader && glAttachShader
&& glDetachShader && glLinkProgram && glGetUniformLocation
&& glUniform1i && glUniform2fv && glUniform4fv;
if(shader_support) glprogram = glCreateProgram();
#endif
//create surface texture
resize(w, h);
}
