Encapsulate GL version and standard into a struct and enum.

src/libANGLE/Version.h

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// Version.h: Encapsulation of a GL version.
+
+#ifndef LIBANGLE_VERSION_H_
+#define LIBANGLE_VERSION_H_
+
+#include <angle_gl.h>
+
+namespace gl
+{
+
+struct Version
+{
+    Version();
+    Version(GLuint major, GLuint minor);
+
+    GLuint major;
+    GLuint minor;
+};
+
+bool operator>=(const Version &a, const Version &b);
+
+}
+
+#include "Version.inl"
+
+#endif // LIBANGLE_VERSION_H_

src/libANGLE/Version.inl

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// Version.inl: Encapsulation of a GL version.
+
+namespace gl
+{
+
+inline Version::Version()
+    : Version(0, 0)
+{
+}
+
+inline Version::Version(GLuint major, GLuint minor)
+    : major(major),
+      minor(minor)
+{
+}
+
+inline bool operator>=(const Version &a, const Version &b)
+{
+    return a.major > b.major || (a.major == b.major && a.minor >= b.minor);
+}
+
+}

src/libANGLE/renderer/gl/FunctionsGL.cpp

@@ -16,8 +16,7 @@
 namespace rx
 {
 
-static void GetGLVersion(PFNGLGETSTRINGPROC getStringFunction, GLuint *outMajorVersion, GLuint *outMinorVersion,
-                         bool *outIsES)
+static void GetGLVersion(PFNGLGETSTRINGPROC getStringFunction, gl::Version *outVersion, StandardGL *outStandard)
 {
     const std::string version = reinterpret_cast<const char*>(getStringFunction(GL_VERSION));
     if (version.find("OpenGL ES") == std::string::npos)
@@ -27,17 +26,15 @@ static void GetGLVersion(PFNGLGETSTRINGPROC getStringFunction, GLuint *outMajorV
         // The version number is either of the form major number.minor number or major
         // number.minor number.release number, where the numbers all have one or more
         // digits
-        *outIsES = false;
-        *outMajorVersion = version[0] - '0';
-        *outMinorVersion = version[2] - '0';
+        *outStandard = STANDARD_GL_DESKTOP;
+        *outVersion = gl::Version(version[0] - '0', version[2] - '0');
     }
     else
     {
         // ES spec states that the GL_VERSION string will be in the following format:
         // "OpenGL ES N.M vendor-specific information"
-        *outIsES = true;
-        *outMajorVersion = version[10] - '0';
-        *outMinorVersion = version[12] - '0';
+        *outStandard = STANDARD_GL_ES;
+        *outVersion = gl::Version(version[10] - '0', version[12] - '0');
     }
 }
 
@@ -83,9 +80,8 @@ static void AssignGLExtensionEntryPoint(const std::vector<std::string> &extensio
 }
 
 FunctionsGL::FunctionsGL()
-    : majorVersion(0),
-      minorVersion(0),
-      openGLES(false),
+    : version(),
+      standard(),
       extensions(),
 
       blendFunc(nullptr),
@@ -777,10 +773,10 @@ void FunctionsGL::initialize()
 {
     // Grab the version number
     AssignGLEntryPoint(loadProcAddress("glGetString"), &getString);
-    GetGLVersion(getString, &majorVersion, &minorVersion, &openGLES);
+    GetGLVersion(getString, &version, &standard);
 
     // Grab the GL extensions
-    if (majorVersion >= 3)
+    if (isAtLeastGL(gl::Version(3, 0)))
     {
         AssignGLEntryPoint(loadProcAddress("glGetIntegerv"), &getIntegerv);
         AssignGLEntryPoint(loadProcAddress("glGetStringi"), &getStringi);
@@ -793,7 +789,7 @@ void FunctionsGL::initialize()
     }
 
     // 1.0
-    if (majorVersion >= 1)
+    if (isAtLeastGL(gl::Version(1, 0)))
     {
         AssignGLEntryPoint(loadProcAddress("glBlendFunc"), &blendFunc);
         AssignGLEntryPoint(loadProcAddress("glClear"), &clear);
@@ -846,7 +842,7 @@ void FunctionsGL::initialize()
     }
 
     // 1.1
-    if (majorVersion > 1 || (majorVersion == 1 && minorVersion >= 1))
+    if (isAtLeastGL(gl::Version(1, 1)))
     {
         AssignGLEntryPoint(loadProcAddress("glBindTexture"), &bindTexture);
         AssignGLEntryPoint(loadProcAddress("glCopyTexImage1D"), &copyTexImage1D);
@@ -879,7 +875,7 @@ void FunctionsGL::initialize()
     }
 
     // 1.2
-    if (majorVersion > 1 || (majorVersion == 1 && minorVersion >= 2))
+    if (isAtLeastGL(gl::Version(1, 2)))
     {
         AssignGLEntryPoint(loadProcAddress("glBlendColor"), &blendColor);
         AssignGLEntryPoint(loadProcAddress("glBlendEquation"), &blendEquation);
@@ -906,7 +902,7 @@ void FunctionsGL::initialize()
     }
 
     // 1.3
-    if (majorVersion > 1 || (majorVersion == 1 && minorVersion >= 3))
+    if (isAtLeastGL(gl::Version(1, 3)))
     {
         AssignGLEntryPoint(loadProcAddress("glActiveTexture"), &activeTexture);
         AssignGLEntryPoint(loadProcAddress("glCompressedTexImage1D"), &compressedTexImage1D);
@@ -920,7 +916,7 @@ void FunctionsGL::initialize()
     }
 
     // 1.4
-    if (majorVersion > 1 || (majorVersion == 1 && minorVersion >= 4))
+    if (isAtLeastGL(gl::Version(1, 4)))
     {
         AssignGLEntryPoint(loadProcAddress("glBlendFuncSeparate"), &blendFuncSeparate);
         AssignGLEntryPoint(loadProcAddress("glMultiDrawArrays"), &multiDrawArrays);
@@ -932,7 +928,7 @@ void FunctionsGL::initialize()
     }
 
     // 1.5
-    if (majorVersion > 1 || (majorVersion == 1 && minorVersion >= 5))
+    if (isAtLeastGL(gl::Version(1, 5)))
     {
         AssignGLEntryPoint(loadProcAddress("glBeginQuery"), &beginQuery);
         AssignGLEntryPoint(loadProcAddress("glBindBuffer"), &bindBuffer);
@@ -956,7 +952,7 @@ void FunctionsGL::initialize()
     }
 
     // 2.0
-    if (majorVersion >= 2)
+    if (isAtLeastGL(gl::Version(2, 0)))
     {
         AssignGLEntryPoint(loadProcAddress("glAttachShader"), &attachShader);
         AssignGLEntryPoint(loadProcAddress("glBindAttribLocation"), &bindAttribLocation);
@@ -1054,7 +1050,7 @@ void FunctionsGL::initialize()
     }
 
     // 2.1
-    if (majorVersion > 2 || (majorVersion == 2 && minorVersion >= 1))
+    if (isAtLeastGL(gl::Version(2, 1)))
     {
         AssignGLEntryPoint(loadProcAddress("glUniformMatrix2x3fv"), &uniformMatrix2x3fv);
         AssignGLEntryPoint(loadProcAddress("glUniformMatrix2x4fv"), &uniformMatrix2x4fv);
@@ -1065,7 +1061,7 @@ void FunctionsGL::initialize()
     }
 
     // 3.0
-    if (majorVersion >= 3)
+    if (isAtLeastGL(gl::Version(3, 0)))
     {
         AssignGLEntryPoint(loadProcAddress("glBeginConditionalRender"), &beginConditionalRender);
         AssignGLEntryPoint(loadProcAddress("glBeginTransformFeedback"), &beginTransformFeedback);
@@ -1157,7 +1153,7 @@ void FunctionsGL::initialize()
     }
 
     // 3.1
-    if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 1))
+    if (isAtLeastGL(gl::Version(3, 1)))
     {
         AssignGLEntryPoint(loadProcAddress("glCopyBufferSubData"), &copyBufferSubData);
         AssignGLEntryPoint(loadProcAddress("glDrawArraysInstanced"), &drawArraysInstanced);
@@ -1184,7 +1180,7 @@ void FunctionsGL::initialize()
     }
 
     // 3.2
-    if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 2))
+    if (isAtLeastGL(gl::Version(3, 2)))
     {
         AssignGLEntryPoint(loadProcAddress("glClientWaitSync"), &clientWaitSync);
         AssignGLEntryPoint(loadProcAddress("glDeleteSync"), &deleteSync);
@@ -1208,7 +1204,7 @@ void FunctionsGL::initialize()
     }
 
     // 3.3
-    if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 3))
+    if (isAtLeastGL(gl::Version(3, 3)))
     {
         AssignGLEntryPoint(loadProcAddress("glBindFragDataLocationIndexed"), &bindFragDataLocationIndexed);
         AssignGLEntryPoint(loadProcAddress("glBindSampler"), &bindSampler);
@@ -1241,7 +1237,7 @@ void FunctionsGL::initialize()
     }
 
     // 4.0
-    if (majorVersion >= 4)
+    if (isAtLeastGL(gl::Version(4, 0)))
     {
         AssignGLEntryPoint(loadProcAddress("glBeginQueryIndexed"), &beginQueryIndexed);
         AssignGLEntryPoint(loadProcAddress("glBindTransformFeedback"), &bindTransformFeedback);
@@ -1292,7 +1288,7 @@ void FunctionsGL::initialize()
     }
 
     // 4.1
-    if (majorVersion > 4 || (majorVersion == 4 && minorVersion >= 1))
+    if (isAtLeastGL(gl::Version(4, 1)))
     {
         AssignGLEntryPoint(loadProcAddress("glActiveShaderProgram"), &activeShaderProgram);
         AssignGLEntryPoint(loadProcAddress("glBindProgramPipeline"), &bindProgramPipeline);
@@ -1385,7 +1381,7 @@ void FunctionsGL::initialize()
     }
 
     // 4.2
-    if (majorVersion > 4 || (majorVersion == 4 && minorVersion >= 2))
+    if (isAtLeastGL(gl::Version(4, 2)))
     {
         AssignGLEntryPoint(loadProcAddress("glBindImageTexture"), &bindImageTexture);
         AssignGLEntryPoint(loadProcAddress("glDrawArraysInstancedBaseInstance"), &drawArraysInstancedBaseInstance);
@@ -1402,7 +1398,7 @@ void FunctionsGL::initialize()
     }
 
     // 4.3
-    if (majorVersion > 4 || (majorVersion == 4 && minorVersion >= 3))
+    if (isAtLeastGL(gl::Version(4, 3)))
     {
         AssignGLEntryPoint(loadProcAddress("glBindVertexBuffer"), &bindVertexBuffer);
         AssignGLEntryPoint(loadProcAddress("glClearBufferData"), &clearBufferData);
@@ -1451,7 +1447,7 @@ void FunctionsGL::initialize()
     }
 
     // 4.4
-    if (majorVersion > 4 || (majorVersion == 4 && minorVersion >= 4))
+    if (isAtLeastGL(gl::Version(4, 4)))
     {
         AssignGLEntryPoint(loadProcAddress("glBindBuffersBase"), &bindBuffersBase);
         AssignGLEntryPoint(loadProcAddress("glBindBuffersRange"), &bindBuffersRange);
@@ -1465,7 +1461,7 @@ void FunctionsGL::initialize()
     }
 
     // 4.5
-    if (majorVersion > 4 || (majorVersion == 4 && minorVersion >= 5))
+    if (isAtLeastGL(gl::Version(4, 5)))
     {
         AssignGLEntryPoint(loadProcAddress("glBindTextureUnit"), &bindTextureUnit);
         AssignGLEntryPoint(loadProcAddress("glBlitNamedFramebuffer"), &blitNamedFramebuffer);
@@ -1580,6 +1576,16 @@ void FunctionsGL::initialize()
     }
 }
 
+bool FunctionsGL::isAtLeastGL(const gl::Version &glVersion) const
+{
+    return standard == STANDARD_GL_DESKTOP && version >= glVersion;
+}
+
+bool FunctionsGL::isAtLeastGLES(const gl::Version &glesVersion) const
+{
+    return standard == STANDARD_GL_ES && version >= glesVersion;
+}
+
 bool FunctionsGL::hasExtension(const std::string &ext) const
 {
     return std::find(extensions.begin(), extensions.end(), ext) != extensions.end();

src/libANGLE/renderer/gl/FunctionsGL.h

@@ -10,12 +10,19 @@
 #define LIBANGLE_RENDERER_GL_FUNCTIONSGL_H_
 
 #include "common/debug.h"
+#include "libANGLE/Version.h"
 #include "libANGLE/renderer/gl/functionsgl_enums.h"
 #include "libANGLE/renderer/gl/functionsgl_typedefs.h"
 
 namespace rx
 {
 
+enum StandardGL
+{
+    STANDARD_GL_DESKTOP,
+    STANDARD_GL_ES,
+};
+
 class FunctionsGL
 {
   public:
@@ -25,9 +32,10 @@ class FunctionsGL
     void initialize();
 
     // Version information
-    GLuint majorVersion;
-    GLuint minorVersion;
-    bool openGLES;
+    gl::Version version;
+    StandardGL standard;
+    bool isAtLeastGL(const gl::Version &glVersion) const;
+    bool isAtLeastGLES(const gl::Version &glesVersion) const;
 
     // Extensions
     std::vector<std::string> extensions;

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -254,11 +254,11 @@ std::string RendererGL::getRendererDescription() const
 
     std::ostringstream rendererString;
     rendererString << nativeVendorString << " " << nativeRendererString << " OpenGL";
-    if (mFunctions->openGLES)
+    if (mFunctions->standard == STANDARD_GL_ES)
     {
         rendererString << " ES";
     }
-    rendererString << " " << mFunctions->majorVersion << "." << mFunctions->minorVersion;
+    rendererString << " " << mFunctions->version.major << "." << mFunctions->version.minor;
 
     return rendererString.str();
 }

src/libANGLE/renderer/gl/formatutilsgl.cpp

@@ -21,8 +21,7 @@ namespace nativegl
 {
 
 SupportRequirement::SupportRequirement()
-    : majorVersion(std::numeric_limits<GLuint>::max()),
-      minorVersion(std::numeric_limits<GLuint>::max()),
+    : version(std::numeric_limits<GLuint>::max(), std::numeric_limits<GLuint>::max()),
       versionExtensions(),
       requiredExtensions()
 {
@@ -39,8 +38,8 @@ InternalFormat::InternalFormat()
 static inline SupportRequirement VersionOrExts(GLuint major, GLuint minor, const std::string &versionExt)
 {
     SupportRequirement requirement;
-    requirement.majorVersion = major;
-    requirement.minorVersion = minor;
+    requirement.version.major = major;
+    requirement.version.minor = minor;
     angle::SplitStringAlongWhitespace(versionExt, &requirement.versionExtensions);
     return requirement;
 }
@@ -48,8 +47,8 @@ static inline SupportRequirement VersionOrExts(GLuint major, GLuint minor, const
 static inline SupportRequirement VersionAndExts(GLuint major, GLuint minor, const std::string &requiredExt)
 {
     SupportRequirement requirement;
-    requirement.majorVersion = major;
-    requirement.minorVersion = minor;
+    requirement.version.major = major;
+    requirement.version.minor = minor;
     angle::SplitStringAlongWhitespace(requiredExt, &requirement.requiredExtensions);
     return requirement;
 }
@@ -57,8 +56,8 @@ static inline SupportRequirement VersionAndExts(GLuint major, GLuint minor, cons
 static inline SupportRequirement VersionOrExtsAndExts(GLuint major, GLuint minor, const std::string &versionExt,
                                                       const std::string &requiredExt)
 {    SupportRequirement requirement;
-    requirement.majorVersion = major;
-    requirement.minorVersion = minor;
+    requirement.version.major = major;
+    requirement.version.minor = minor;
     angle::SplitStringAlongWhitespace(versionExt, &requirement.versionExtensions);
     angle::SplitStringAlongWhitespace(requiredExt, &requirement.requiredExtensions);
     return requirement;
@@ -67,8 +66,8 @@ static inline SupportRequirement VersionOrExtsAndExts(GLuint major, GLuint minor
 static inline SupportRequirement VersionOnly(GLuint major, GLuint minor)
 {
     SupportRequirement requirement;
-    requirement.majorVersion = major;
-    requirement.minorVersion = minor;
+    requirement.version.major = major;
+    requirement.version.minor = minor;
     return requirement;
 }
 
@@ -82,16 +81,16 @@ static inline SupportRequirement ExtsOnly(const std::string &ext)
 static inline SupportRequirement Always()
 {
     SupportRequirement requirement;
-    requirement.majorVersion = 0;
-    requirement.minorVersion = 0;
+    requirement.version.major = 0;
+    requirement.version.minor = 0;
     return requirement;
 }
 
 static inline SupportRequirement Never()
 {
     SupportRequirement requirement;
-    requirement.majorVersion = std::numeric_limits<GLuint>::max();
-    requirement.minorVersion = std::numeric_limits<GLuint>::max();
+    requirement.version.major = std::numeric_limits<GLuint>::max();
+    requirement.version.minor = std::numeric_limits<GLuint>::max();
     return requirement;
 }
 
@@ -234,20 +233,23 @@ static const InternalFormatInfoMap &GetInternalFormatMap()
     return formatMap;
 }
 
-const InternalFormat &GetInternalFormatInfo(GLenum internalFormat, bool es)
+const InternalFormat &GetInternalFormatInfo(GLenum internalFormat, StandardGL standard)
 {
     const InternalFormatInfoMap &formatMap = GetInternalFormatMap();
     InternalFormatInfoMap::const_iterator iter = formatMap.find(internalFormat);
     if (iter != formatMap.end())
     {
         const InternalFormatInfo &info = iter->second;
-        return es ? info.glesInfo : info.glInfo;
-    }
-    else
+        switch (standard)
         {
+          case STANDARD_GL_ES:      return info.glesInfo;
+          case STANDARD_GL_DESKTOP: return info.glInfo;
+          default: UNREACHABLE();   break;
+        }
+    }
+
     static const InternalFormat defaultInternalFormat;
     return defaultInternalFormat;
-    }
 }
 
 }

src/libANGLE/renderer/gl/formatutilsgl.h

@@ -14,6 +14,8 @@
 #include <vector>
 
 #include "angle_gl.h"
+#include "libANGLE/Version.h"
+#include "libANGLE/renderer/gl/FunctionsGL.h"
 
 namespace rx
 {
@@ -26,8 +28,7 @@ struct SupportRequirement
     SupportRequirement();
 
     // Version that this format became supported without extensions
-    GLuint majorVersion;
-    GLuint minorVersion;
+    gl::Version version;
 
     // Extensions that are required if the minimum version is not met
     std::vector<std::string> versionExtensions;
@@ -45,7 +46,7 @@ struct InternalFormat
     SupportRequirement renderbuffer;
     SupportRequirement framebufferAttachment;
 };
-const InternalFormat &GetInternalFormatInfo(GLenum internalFormat, bool es);
+const InternalFormat &GetInternalFormatInfo(GLenum internalFormat, StandardGL standard);
 
 }
 

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -35,8 +35,7 @@ static bool MeetsRequirements(const FunctionsGL *functions, const nativegl::Supp
         }
     }
 
-    if (functions->majorVersion > requirements.majorVersion ||
-        (functions->majorVersion == requirements.majorVersion && functions->minorVersion >= requirements.minorVersion))
+    if (functions->version >= requirements.version)
     {
         return true;
     }
@@ -61,7 +60,7 @@ static gl::TextureCaps GenerateTextureFormatCaps(const FunctionsGL *functions, G
 {
     gl::TextureCaps textureCaps;
 
-    const nativegl::InternalFormat &formatInfo = nativegl::GetInternalFormatInfo(internalFormat, functions->openGLES);
+    const nativegl::InternalFormat &formatInfo = nativegl::GetInternalFormatInfo(internalFormat, functions->standard);
     textureCaps.texturable = MeetsRequirements(functions, formatInfo.texture);
     textureCaps.filterable = textureCaps.texturable && MeetsRequirements(functions, formatInfo.filter);
     textureCaps.renderable = MeetsRequirements(functions, formatInfo.framebufferAttachment);

src/libGLESv2.gypi

@@ -109,6 +109,8 @@
             'libANGLE/TransformFeedback.h',
             'libANGLE/Uniform.cpp',
             'libANGLE/Uniform.h',
+            'libANGLE/Version.h',
+            'libANGLE/Version.inl',
             'libANGLE/VertexArray.cpp',
             'libANGLE/VertexArray.h',
             'libANGLE/VertexAttribute.cpp',