Edgaru089/SFML
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moved platform OpenGL loading code into their respective context implementations.

Browse Source
This commit is contained in:
binary1248 2015-01-12 18:32:28 +01:00
parent 38f0464ab0
commit c30a3da8d5
13 changed files with 153 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/SFML/Window/Context.hpp
View File

@ -41,6 +41,8 @@ namespace priv
class GlContext;
}
typedef void (*GlFunctionPointer)();
////////////////////////////////////////////////////////////
/// \brief Class holding a valid drawing context
///
@ -76,6 +78,15 @@ public:
bool setActive(bool active);
public:
////////////////////////////////////////////////////////////
/// \brief Get the address of an OpenGL function
///
/// \param name Name of the function to get the address of
///
/// \return Address of the OpenGL function, 0 on failure
///
////////////////////////////////////////////////////////////
static GlFunctionPointer getFunction(const char* name);
////////////////////////////////////////////////////////////
/// \brief Construct a in-memory context

94
src/SFML/Graphics/GLLoader.cpp
View File

@ -1,91 +1,17 @@
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Graphics/GLLoader.hpp>
#include <SFML/Window/Context.hpp>
#include <cstdlib>
#include <cstring>
#include <cstddef>
#if defined(__APPLE__)
#include <dlfcn.h>
static void* AppleGLGetProcAddress (const char *name)
static sf::GlFunctionPointer IntGetProcAddress(const char* name)
{
static void* image = NULL;
if (NULL == image)
image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
return (image ? dlsym(image, name) : NULL);
return sf::Context::getFunction(name);
}
#define IntGetProcAddress(name) AppleGLGetProcAddress(name)
#endif /* __APPLE__ */
#if defined(__sgi) || defined (__sun)
#include <dlfcn.h>
#include <stdio.h>
static void* SunGetProcAddress (const GLubyte* name)
{
static void* h = NULL;
static void* gpa;
if (h == NULL)
{
if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL;
gpa = dlsym(h, "glXGetProcAddress");
}
if (gpa != NULL)
return ((void*(*)(const GLubyte*))gpa)(name);
else
return dlsym(h, (const char*)name);
}
#endif /* __sgi || __sun */
#if defined(_WIN32)
#ifdef _MSC_VER
#pragma warning(disable: 4055)
#pragma warning(disable: 4054)
#pragma warning(disable: 4996)
#endif
static int TestPointer(const PROC pTest)
{
ptrdiff_t iTest;
if(!pTest) return 0;
iTest = (ptrdiff_t)pTest;
if(iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1) return 0;
return 1;
}
static PROC WinGetProcAddress(const char *name)
{
static HMODULE glMod = NULL;
PROC pFunc = wglGetProcAddress((LPCSTR)name);
if (TestPointer(pFunc)) return pFunc;
if (NULL == glMod)
glMod = GetModuleHandleA("OpenGL32.dll");
return (PROC)GetProcAddress(glMod, (LPCSTR)name);
}
#define IntGetProcAddress(name) WinGetProcAddress(name)
#else
#if defined(__APPLE__)
#define IntGetProcAddress(name) AppleGLGetProcAddress(name)
#else
#if defined(__sgi) || defined(__sun)
#define IntGetProcAddress(name) SunGetProcAddress(name)
#else /* GLX */
#include <GL/glx.h>
#define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
#endif
#endif
#endif
int sfogl_ext_EXT_blend_minmax = sfogl_LOAD_FAILED;
int sfogl_ext_EXT_blend_subtract = sfogl_LOAD_FAILED;

7
src/SFML/Window/Context.cpp
View File

@ -53,6 +53,13 @@ bool Context::setActive(bool active)
}
////////////////////////////////////////////////////////////
GlFunctionPointer Context::getFunction(const char* name)
{
return priv::GlContext::getFunction(name);
}
////////////////////////////////////////////////////////////
Context::Context(const ContextSettings& settings, unsigned int width, unsigned int height)
{

17
src/SFML/Window/GlContext.cpp
View File

@ -159,7 +159,7 @@ void GlContext::globalCleanup()
sharedContext = NULL;
// Destroy the internal contexts
sf::Lock lock(internalContextsMutex);
Lock internalContextsLock(internalContextsMutex);
for (std::set<GlContext*>::iterator it = internalContexts.begin(); it != internalContexts.end(); ++it)
delete *it;
internalContexts.clear();
@ -213,6 +213,21 @@ GlContext* GlContext::create(const ContextSettings& settings, unsigned int width
}
////////////////////////////////////////////////////////////
GlFunctionPointer GlContext::getFunction(const char* name)
{
#if !defined(SFML_OPENGL_ES)
return ContextType::getFunction(name);
#else
return 0;
#endif
}
////////////////////////////////////////////////////////////
GlContext::~GlContext()
{

10
src/SFML/Window/GlContext.hpp
View File

@ -29,6 +29,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <SFML/Window/Context.hpp>
#include <SFML/Window/ContextSettings.hpp>
#include <SFML/System/NonCopyable.hpp>
@ -119,6 +120,15 @@ public:
static GlContext* create(const ContextSettings& settings, unsigned int width, unsigned int height);
public:
////////////////////////////////////////////////////////////
/// \brief Get the address of an OpenGL function
///
/// \param name Name of the function to get the address of
///
/// \return Address of the OpenGL function, 0 on failure
///
////////////////////////////////////////////////////////////
static GlFunctionPointer getFunction(const char* name);
////////////////////////////////////////////////////////////
/// \brief Destructor

10
src/SFML/Window/OSX/SFContext.hpp
View File

@ -103,6 +103,16 @@ public:
////////////////////////////////////////////////////////////
~SFContext();
////////////////////////////////////////////////////////////
/// \brief Get the address of an OpenGL function
///
/// \param name Name of the function to get the address of
///
/// \return Address of the OpenGL function, 0 on failure
///
////////////////////////////////////////////////////////////
static GlFunctionPointer getFunction(const char* name);
////////////////////////////////////////////////////////////
/// \brief Display what has been rendered to the context so far
///

14
src/SFML/Window/OSX/SFContext.mm
View File

@ -29,6 +29,8 @@
#include <SFML/Window/OSX/SFContext.hpp>
#include <SFML/Window/OSX/WindowImplCocoa.hpp>
#include <SFML/System/Err.hpp>
#include <dlfcn.h>
#include <stdint.h>
#import <SFML/Window/OSX/AutoreleasePoolWrapper.h>
@ -111,6 +113,18 @@ SFContext::~SFContext()
}
////////////////////////////////////////////////////////////
GlFunctionPointer SFContext::getFunction(const char* name)
{
static void* image = NULL;
if (!image)
image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
return (image ? reinterpret_cast<GlFunctionPointer>(reinterpret_cast<intptr_t>(dlsym(image, name))) : 0);
}
////////////////////////////////////////////////////////////
bool SFContext::makeCurrent()
{

7
src/SFML/Window/Unix/GlxContext.cpp
View File

@ -177,6 +177,13 @@ GlxContext::~GlxContext()
}
////////////////////////////////////////////////////////////
GlFunctionPointer GlxContext::getFunction(const char* name)
{
return reinterpret_cast<GlFunctionPointer>(glXGetProcAddressARB(reinterpret_cast<const GLubyte*>(name)));
}
////////////////////////////////////////////////////////////
bool GlxContext::makeCurrent()
{

10
src/SFML/Window/Unix/GlxContext.hpp
View File

@ -81,6 +81,16 @@ public:
////////////////////////////////////////////////////////////
~GlxContext();
////////////////////////////////////////////////////////////
/// \brief Get the address of an OpenGL function
///
/// \param name Name of the function to get the address of
///
/// \return Address of the OpenGL function, 0 on failure
///
////////////////////////////////////////////////////////////
static GlFunctionPointer getFunction(const char* name);
////////////////////////////////////////////////////////////
/// \brief Activate the context as the current target for rendering
///

18
src/SFML/Window/Unix/GlxExtensions.cpp
View File

@ -1,11 +1,17 @@
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Unix/GlxExtensions.hpp>
#include <SFML/Window/Context.hpp>
#include <cstdlib>
#include <cstring>
#include <cstddef>
#include <GL/glx.h>
#define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
static sf::GlFunctionPointer IntGetProcAddress(const char* name)
{
return sf::Context::getFunction(name);
}
int sfglx_ext_EXT_swap_control = sfglx_LOAD_FAILED;
int sfglx_ext_MESA_swap_control = sfglx_LOAD_FAILED;

26
src/SFML/Window/Win32/WglContext.cpp
View File

@ -153,6 +153,32 @@ WglContext::~WglContext()
}
////////////////////////////////////////////////////////////
GlFunctionPointer WglContext::getFunction(const char* name)
{
GlFunctionPointer address = reinterpret_cast<GlFunctionPointer>(wglGetProcAddress(reinterpret_cast<LPCSTR>(name)));
if (address)
{
// Test whether the returned value is a valid error code
ptrdiff_t errorCode = reinterpret_cast<ptrdiff_t>(address);
if ((errorCode != -1) && (errorCode != 1) && (errorCode != 2) && (errorCode != 3))
return address;
}
static HMODULE module = NULL;
if (!module)
module = GetModuleHandleA("OpenGL32.dll");
if (module)
return reinterpret_cast<GlFunctionPointer>(GetProcAddress(module, reinterpret_cast<LPCSTR>(name)));
return 0;
}
////////////////////////////////////////////////////////////
bool WglContext::makeCurrent()
{

10
src/SFML/Window/Win32/WglContext.hpp
View File

@ -81,6 +81,16 @@ public:
////////////////////////////////////////////////////////////
~WglContext();
////////////////////////////////////////////////////////////
/// \brief Get the address of an OpenGL function
///
/// \param name Name of the function to get the address of
///
/// \return Address of the OpenGL function, 0 on failure
///
////////////////////////////////////////////////////////////
static GlFunctionPointer getFunction(const char* name);
////////////////////////////////////////////////////////////
/// \brief Activate the context as the current target for rendering
///

31
src/SFML/Window/Win32/WglExtensions.cpp
View File

@ -1,29 +1,18 @@
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Win32/WglExtensions.hpp>
#include <SFML/Window/Context.hpp>
#include <cstdlib>
#include <cstring>
#include <cstddef>
#ifdef _MSC_VER
#pragma warning(disable: 4055)
#pragma warning(disable: 4054)
#pragma warning(disable: 4996)
#endif
static PROC WinGetProcAddress(const char *name)
static sf::GlFunctionPointer IntGetProcAddress(const char* name)
{
static HMODULE glMod = NULL;
PROC pFunc = wglGetProcAddress((LPCSTR)name);
if (pFunc) return pFunc;
if (NULL == glMod)
glMod = GetModuleHandleA("OpenGL32.dll");
return (PROC)GetProcAddress(glMod, (LPCSTR)name);
return sf::Context::getFunction(name);
}
#define IntGetProcAddress(name) WinGetProcAddress(name)
int sfwgl_ext_EXT_swap_control = sfwgl_LOAD_FAILED;
int sfwgl_ext_ARB_multisample = sfwgl_LOAD_FAILED;
int sfwgl_ext_ARB_pixel_format = sfwgl_LOAD_FAILED;