Restructure the extension detection code

Extension disabling is now more forceful and will prevent the use of the
relevant functionality even if it was promoted to core.

diff --git a/scripts/extgen.py b/scripts/extgen.py
index e6edd42bf944aad566c811202873282dc730f072..b3ed9c8f6d6fa033fc9916cebbf778d98a7f61b6 100755 (executable)
--- a/scripts/extgen.py
+++ b/scripts/extgen.py
@@ -517,17 +517,14 @@ for f in funcs:
 
 out.write("\nExtension::SupportLevel init_%s()\n{\n"%target_ext.name.lower())
 if core_version:
+       out.write("\tif(is_disabled(\"GL_%s\"))\n\t\treturn Extension::UNSUPPORTED;\n"%target_ext.name)
        out.write("\tif(")
-       if deprecated_version and backport_ext:
-               out.write("(")
-       out.write("is_version_at_least(%d, %d)"%tuple(core_version))
-       if deprecated_version:
-               out.write(" && (get_gl_profile()!=CORE_PROFILE || !is_version_at_least(%d, %d))"%tuple(deprecated_version))
-               if backport_ext:
-                       out.write(")")
        if backport_ext:
-               out.write(" || is_supported(\"GL_%s\")"%backport_ext.name)
-       out.write(")\n\t{\n")
+               out.write("is_supported(\"GL_%s\") || "%backport_ext.name)
+       out.write("is_supported(Version(%d, %d)"%tuple(core_version))
+       if deprecated_version:
+               out.write(", Version(%d, %d)"%tuple(deprecated_version))
+       out.write("))\n\t{\n")
        for f in funcs:
                if target_api in f.supported_apis:
                        gpa_suffix = ""

diff --git a/source/extension.cpp b/source/extension.cpp
index fda183d22f374ea309851019fbcc4f271d8d430a..b65172fc691dc4b71e8ba2d4c5dc6e03eac9bfa2 100644 (file)
--- a/source/extension.cpp
+++ b/source/extension.cpp
@@ -93,6 +93,33 @@ bool is_supported(const string &ext)
                        }
                }
 
+               init_done = true;
+       }
+
+       return extensions.count(ext);
+}
+
+bool is_supported(const Version &core_version, const Version &deprecated_version)
+{
+       const Version &version = get_gl_version();
+       if(deprecated_version && version>=deprecated_version && get_gl_profile()==CORE_PROFILE)
+               return false;
+       return (version>=core_version);
+}
+
+bool is_disabled(const string &ext)
+{
+       static set<string> disabled_exts;
+       static bool init_done = false;
+
+       if(!init_done)
+       {
+               if(const char *disable_ptr = getenv("MSPGL_DISABLE_EXTENSIONS"))
+               {
+                       vector<string> disable = split(disable_ptr);
+                       disabled_exts.insert(disable.begin(), disable.end());
+               }
+
                if(const char *renderer_ptr = reinterpret_cast<const char *>(glGetString(GL_RENDERER)))
                {
                        string renderer = renderer_ptr;
@@ -101,26 +128,19 @@ bool is_supported(const string &ext)
                                /* 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");
+                               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(2, 0))
-                                       extensions.erase("GL_ARB_uniform_buffer_object");
+                                       disabled_exts.insert("GL_ARB_uniform_buffer_object");
                        }
                }
 
-               if(const char *disable_ptr = getenv("MSPGL_DISABLE_EXTENSIONS"))
-               {
-                       vector<string> disable = split(disable_ptr);
-                       for(vector<string>::const_iterator i=disable.begin(); i!=disable.end(); ++i)
-                               extensions.erase(*i);
-               }
-
                init_done = true;
        }
 
-       return extensions.count(ext);
+       return disabled_exts.count(ext);
 }
 
 GLApi get_gl_api()
@@ -207,11 +227,6 @@ const Version &get_glsl_version()
        return version;
 }
 
-bool is_version_at_least(unsigned a, unsigned b)
-{
-       return get_gl_version()>=Version(a, b);
-}
-
 ExtFunc *get_proc_address(const string &name)
 {
 #if defined(WIN32)

diff --git a/source/extension.h b/source/extension.h
index b44d89007c12610344347632c441d175cc5ff89a..1b149367eecd7ef9c5978138a0a41a837ee7b9c4 100644 (file)
--- a/source/extension.h
+++ b/source/extension.h
@@ -30,6 +30,7 @@ struct Version
 
        bool operator>=(const Version &) const;
        bool operator<(const Version &o) const { return !(*this>=o); }
+       operator bool() const { return major || minor; }
 };
 
 
@@ -67,9 +68,17 @@ struct Require
 
 typedef void ExtFunc();
 
-/** Indicates whether an extension is supported. */
+/** Checks for extension support.  Only intended for internal use. */
 bool is_supported(const std::string &);
 
+/** Checks for OpenGL version support.  Only intended for internal use. */
+bool is_supported(const Version &, const Version & = Version());
+
+/** Indicates whether an extension has been disabled, either explicitly through
+the MSPGL_DISABLE_EXTENSIONS environment variable or implicitly as a workaround
+for a driver bug.  Only intended for internal use. */
+bool is_disabled(const std::string &);
+
 /** Returns the API for which the library was compiled. */
 GLApi get_gl_api();
 
@@ -82,9 +91,6 @@ const Version &get_gl_version();
 /** Returns the GLSL version number, as reported by the implementation. */
 const Version &get_glsl_version();
 
-/** Indicates whether the OpenGL version is at least a.b. */
-bool is_version_at_least(unsigned a, unsigned b);
-
 /** Returns the address of an extension function.  Only indended for internal
 use. */
 ExtFunc *get_proc_address(const std::string &);