X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fextension.cpp;h=b65172fc691dc4b71e8ba2d4c5dc6e03eac9bfa2;hp=c2f1f6005f02260f034fe5c5d6adf27054ddc175;hb=6a045019fbd68738b77849629e6dfd3dfd9a4d93;hpb=083578c2ca0aabfa60e8872e23d53e9101795dff diff --git a/source/extension.cpp b/source/extension.cpp index c2f1f600..b65172fc 100644 --- a/source/extension.cpp +++ b/source/extension.cpp @@ -1,34 +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 "nv_primitive_restart.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; @@ -36,26 +75,23 @@ bool is_supported(const string &ext) if(!init_done) { - if(const char *gl_ext = reinterpret_cast(glGetString(GL_EXTENSIONS))) + if(get_gl_api()==OPENGL && get_gl_version()>=Version(3, 0)) { - vector exts = split(gl_ext); - extensions.insert(exts.begin(), exts.end()); + typedef GLubyte *(APIENTRY *FPtr_glGetStringi)(GLenum, GLuint); + FPtr_glGetStringi glGetStringi = reinterpret_cast(get_proc_address("glGetStringi")); + int n_extensions; + glGetIntegerv(GL_NUM_EXTENSIONS, &n_extensions); + for(int i=0; i(glGetStringi(GL_EXTENSIONS, i))); + } + else + { + if(const char *gl_ext = reinterpret_cast(glGetString(GL_EXTENSIONS))) + { + vector exts = split(gl_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(); - if(extensions.count("GL_NV_primitive_restart")) - init_nv_primitive_restart(); init_done = true; } @@ -63,54 +99,145 @@ bool is_supported(const string &ext) return extensions.count(ext); } -void require_extension(const string &ext) +bool is_supported(const Version &core_version, const Version &deprecated_version) { - if(!is_supported(ext)) - throw UnsupportedExtension(ext); + const Version &version = get_gl_version(); + if(deprecated_version && version>=deprecated_version && get_gl_profile()==CORE_PROFILE) + return false; + return (version>=core_version); } -const Version &get_gl_version() +bool is_disabled(const string &ext) { - static Version version; + static set disabled_exts; static bool init_done = false; 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]); + if(const char *disable_ptr = getenv("MSPGL_DISABLE_EXTENSIONS")) + { + vector disable = split(disable_ptr); + disabled_exts.insert(disable.begin(), disable.end()); + } - unsigned combined = version.major*0x100+version.minor; - if(combined>=0x102) - init_version_1_2(); - if(combined>=0x103) - init_version_1_3(); + if(const char *renderer_ptr = reinterpret_cast(glGetString(GL_RENDERER))) + { + string renderer = renderer_ptr; + if(renderer.find("Radeon")!=string::npos || renderer.find("AMD")!=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. */ + disabled_exts.insert("GL_NV_primitive_restart"); + + /* AMD's uniform buffer objects only work with the core version of + shaders. */ + if(get_gl_version()=Version(3, 0)) + { + int mask; + glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask); + if(mask==GL_CONTEXT_CORE_PROFILE_BIT) + return CORE_PROFILE; + } + + return COMPATIBILITY_PROFILE; +} + +GLProfile get_gl_profile() +{ + static GLProfile profile = _get_gl_profile(); + return profile; +} + +inline Version _get_gl_version() +{ + const char *gl_ver_ptr = reinterpret_cast(glGetString(GL_VERSION)); + if(!gl_ver_ptr) + throw runtime_error("OpenGL version not available"); + + string gl_ver = gl_ver_ptr; + if(!gl_ver.compare(0, 10, "OpenGL ES ")) + gl_ver.erase(0, 10); + + Version ver(gl_ver.substr(0, gl_ver.find(' '))); + + 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; } -bool is_version_at_least(unsigned a, unsigned b) +inline Version _get_glsl_version() { - const Version &ver = get_gl_version(); - return (ver.major>a || (ver.major==a && ver.minor>=b)); + const char *glsl_ver_ptr = reinterpret_cast(glGetString(GL_SHADING_LANGUAGE_VERSION)); + if(!glsl_ver_ptr) + throw runtime_error("GLSL version not available"); + + string glsl_ver = glsl_ver_ptr; + 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() { - if(!is_version_at_least(a, b)) - throw UnsupportedExtension(format("OpenGL %d.%d", a, b)); + static Version version = _get_glsl_version(); + return version; } 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 }