X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fextension.cpp;h=023510da4bdce0d751317735800eb06329477559;hb=9dc2c20e8c7ac91d932b12492591b65786e24b0f;hp=9ed1777914b9076c89f8c55ba58f0a6012ca54db;hpb=b617c5d7b5283ad260a77f01e42e6170cabbc03d;p=libs%2Fgl.git diff --git a/source/extension.cpp b/source/extension.cpp index 9ed17779..023510da 100644 --- a/source/extension.cpp +++ b/source/extension.cpp @@ -1,33 +1,73 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007, 2009-2010 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - #include -#ifndef WIN32 +#include +#if defined(__ANDROID__) +#include +#elif !defined(WIN32) && !defined(__APPLE__) #define GLX_GLXEXT_PROTOTYPES #include #endif -#include +#include #include -#include "arb_shader_objects.h" -#include "arb_vertex_buffer_object.h" -#include "arb_vertex_program.h" -#include "arb_vertex_shader.h" -#include "ext_framebuffer_object.h" -#include "except.h" +#include "error.h" #include "extension.h" #include "gl.h" -#include "version_1_2.h" -#include "version_1_3.h" using namespace std; namespace Msp { namespace GL { +Version::Version() +{ + major = 0; + minor = 0; +} + +Version::Version(unsigned short a, unsigned short i) +{ + major = a; + minor = i; +} + +Version::Version(const string &s) +{ + vector parts = split(s, '.'); + major = lexical_cast(parts[0]); + minor = lexical_cast(parts[1]); +} + +bool Version::operator>=(const Version &other) const +{ + return major>other.major || (major==other.major && minor>=other.minor); +} + + +Extension::Extension(const char *n, InitFunc f): + name(n), + init_func(f), + init_done(false), + support(UNSUPPORTED) +{ } + +Extension::operator bool() const +{ + if(!init_done) + { + support = init_func(); + init_done = true; + } + + return support>UNSUPPORTED; +} + + +Require::Require(const Extension &ext) +{ + if(!ext) + throw unsupported_extension(ext.get_name()); +} + + bool is_supported(const string &ext) { static set extensions; @@ -41,18 +81,26 @@ bool is_supported(const string &ext) extensions.insert(exts.begin(), exts.end()); } - /* XXX Conceptually a bit weird place for this, but I couldn't really come up - with anything better that would still be transparent. */ - if(extensions.count("GL_ARB_shader_objects")) - init_arb_shader_objects(); - if(extensions.count("GL_ARB_vertex_shader")) - init_arb_vertex_shader(); - if(extensions.count("GL_ARB_vertex_program")) - init_arb_vertex_program(); - if(extensions.count("GL_EXT_framebuffer_object")) - init_ext_framebuffer_object(); - if(extensions.count("GL_ARB_vertex_buffer_object")) - init_arb_vertex_buffer_object(); + string renderer = reinterpret_cast(glGetString(GL_RENDERER)); + if(renderer.find("Radeon")!=string::npos) + { + /* Radeon doesn't process NV_primitive_restart correctly and treats + the restart index as a normal element if the indices are stored in a + buffer. */ + extensions.erase("GL_NV_primitive_restart"); + + /* AMD's uniform buffer objects only work with the core version of + shaders. */ + if(!(get_gl_version()>=Version(2, 0))) + extensions.erase("GL_ARB_uniform_buffer_object"); + } + + if(const char *disable_ptr = getenv("MSPGL_DISABLE_EXTENSIONS")) + { + vector disable = split(disable_ptr); + for(vector::const_iterator i=disable.begin(); i!=disable.end(); ++i) + extensions.erase(*i); + } init_done = true; } @@ -60,49 +108,79 @@ bool is_supported(const string &ext) return extensions.count(ext); } -const Version &get_gl_version() +GLApi get_gl_api() { - static Version version; - static bool init_done = false; +#ifdef GL_ES_VERSION_2_0 + return OPENGL_ES2; +#else + return OPENGL; +#endif +} - if(!init_done) - { - string gl_ver = reinterpret_cast(glGetString(GL_VERSION)); - vector parts = split(gl_ver.substr(0, gl_ver.find(' ')), '.'); - version.major = lexical_cast(parts[0]); - version.minor = lexical_cast(parts[1]); +inline Version _get_gl_version() +{ + string gl_ver = reinterpret_cast(glGetString(GL_VERSION)); + if(!gl_ver.compare(0, 10, "OpenGL ES ")) + gl_ver.erase(0, 10); - unsigned combined = version.major*0x100+version.minor; - if(combined>=0x102) - init_version_1_2(); - if(combined>=0x103) - init_version_1_3(); + Version ver(gl_ver.substr(0, gl_ver.find(' '))); - init_done = true; + if(const char *force_ver_ptr = getenv("MSPGL_FORCE_VERSION")) + { + Version force_ver(force_ver_ptr); + if(!(force_ver>=ver)) + ver = force_ver; } + return ver; +} + +const Version &get_gl_version() +{ + static Version version = _get_gl_version(); return version; } -void require_extension(const string &ext) +inline Version _get_glsl_version() { - if(!is_supported(ext)) - throw UnsupportedExtension(ext); + string glsl_ver = reinterpret_cast(glGetString(GL_SHADING_LANGUAGE_VERSION)); + if(!glsl_ver.compare(0, 18, "OpenGL ES GLSL ES ")) + glsl_ver.erase(0, 18); + + Version ver(glsl_ver.substr(0, glsl_ver.find(' '))); + + if(const char *force_ver_ptr = getenv("MSPGL_FORCE_GLSL_VERSION")) + { + Version force_ver(force_ver_ptr); + if(!(force_ver>=ver)) + ver = force_ver; + } + + return ver; } -void require_version(unsigned a, unsigned b) +const Version &get_glsl_version() { - const Version &ver = get_gl_version(); - if(ver.major=Version(a, b); } ExtFunc *get_proc_address(const string &name) { -#ifndef WIN32 - return glXGetProcAddressARB(reinterpret_cast(name.c_str())); -#else +#if defined(WIN32) return reinterpret_cast(wglGetProcAddress(name.c_str())); +#elif defined(__APPLE__) + (void)name; + return 0; // Not supported +#elif defined(__ANDROID__) + return eglGetProcAddress(name.c_str()); +#else + return glXGetProcAddressARB(reinterpret_cast(name.c_str())); #endif }