Improve GLENUM names/macro/printing

Project.toml

@@ -1,6 +1,6 @@
 name = "ModernGL"
 uuid = "66fc600b-dfda-50eb-8b99-91cfa97b1301"
-version = "1.1.4"
+version = "1.2.0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://github.com/JuliaGL/ModernGL.jl/workflows/CI/badge.svg?branch=master)](https://github.com/JuliaGL/ModernGL.jl/actions)
 
-OpenGL bindings for OpenGL 3.0 and upwards. As OpenGL 3.0 has a lot of overlaps with OpenGL 2.1, OpenGL 2.1 is partly supported as well.
+OpenGL bindings for OpenGL 3.0 through 4.6. As OpenGL 3.0 has a lot of overlaps with OpenGL 2.1, OpenGL 2.1 is partly supported as well.
 
 The philosophy is to keep this library strictly a low-level wrapper, so you won't find any error handling (besides for the function loading itself) or abstractions in this package.
 
@@ -15,6 +15,11 @@ ENV["MODERNGL_DEBUGGING"] = "true"; Pkg.build("ModernGL")
 ENV["MODERNGL_DEBUGGING"] = "false"; Pkg.build("ModernGL")
 ```
 
+OpenGL constants are wrapped as enums, which allows you to print the name of a constant like this:
+GLENUM(x::GLenum).name
+This works pretty well, but keep in mind some constants actually have the same value, and only one name will be stored for each value. This leads to counterintuitive behavior in some cases, such as `GLENUM(GL_SYNC_FLUSH_COMMANDS_BIT).name == :GL_TRUE`.
+The behavior of GLENUM is manually overridden to return specific names for important constants, like `GL_TRUE` for 1 and `GL_FALSE` for 0. You can force other names using the macro `ModernGL.@custom_glenum [value] [name]`.
+
 ### Installation notes
 There are no dependencies, besides the graphic driver. If you have any problems, you should consider updating the driver first.
 
@@ -28,11 +33,6 @@ Other OpenGL abstraction packages, which make it easier to get started with Open
 
 There might be a few problems with older platforms and video cards, since it's not heavily tested on them.
 
-OpenGL constants are wrapped as enums, which allows you to print the name of a constant like this:
-GLENUM(x::GLenum).name
-This works pretty well, but some constants actually have the same value. As they're stored in one big dictionary, this leads to some enums being overwritten, resulting in a wrong name being printed.
-Most annoying example: `GLENUM(1).name` prints out: `GL_SYNC_FLUSH_COMMANDS_BIT`, but should be  `GL_TRUE`
-
 ### Some more details
 
 getProcAddress can be changed like this:

src/ModernGL.jl

@@ -59,35 +59,83 @@ isavailable(ptr::Ptr{Cvoid}) = !(
     ptr == convert(Ptr{Cvoid},  3)
 )
 
-abstract type Enum end
-
-macro GenEnums(list)
-    tmp = list.args
-    enumName = tmp[2]
-    splice!(tmp, 1:2)
-    enumType    = typeof(eval(tmp[4].args[1].args[2]))
-    enumdict1   = Dict{enumType, Symbol}()
-    for elem in tmp
-        if Meta.isexpr(elem, :const)
-            enumdict1[eval(elem.args[1].args[2])] = elem.args[1].args[1]
-        end
+struct GLENUM{Sym, T}
+    number::T
+    name::Symbol
+end
+Base.print(io::IO, e::GLENUM) = print(io,
+    "GLENUM(",
+    e.name, ", ",
+    e.number,
+    ")"
+)
+Base.show(io::IO, ::MIME"text/plain", e::GLENUM) = print(io,
+    e.name,
+    "<", e.number, ">"
+)
+
+const MGL_LOOKUP = Dict{Integer, Symbol}()
+
+"Finds the GLENUM value matching the given number"
+GLENUM(i::I) where {I<:Integer} = GLENUM(Val(UInt32(i)))
+
+"Overload this method (with a Val(::UInt32) parameter) to change the name of specific GL constants"
+function GLENUM(i::Val)
+    i_val::Integer = typeof(i).parameters[1]
+    if haskey(MGL_LOOKUP, i_val)
+        name::Symbol = MGL_LOOKUP[i_val]
+        original_type::Type{<:Integer} = typeof(getkey(MGL_LOOKUP, i_val, name))
+        return GLENUM{name, original_type}(convert(original_type, i_val), name)
+    else
+        error(i_val, " is not a valid GLenum value")
     end
-    dictname = gensym()
-    enumtype =  quote
-        struct $(enumName){Sym, T} <: Enum
-            number::T
-            name::Symbol
-        end
-        $(dictname) = $enumdict1
-        function $(enumName)(number::T) where T
-            if !haskey($(dictname), number)
-                error("$number is not a GLenum")
+end
+
+export GLENUM
+
+macro GenEnums(list::Expr)
+    if !Meta.isexpr(list, :block)
+        error("Input to @GenEnums must be a block of expressions of the form 'GL_BLAH = value', optionally with a type if not GLenum.")
+    end
+    if length(MGL_LOOKUP) > 0
+        error("It appears that @GenEnums was invoked more than once. This is not allowed.")
+    end
+
+    entries = list.args
+    # For each entry, remap it into a more complete expression,
+    #   including exports and a GLENUM() overload.
+    map!(entries, entries) do entry
+        if Meta.isexpr(entry, :(=))
+            value = entry.args[2]
+            # Find the 'name' and 'type' of the value.
+            name::Symbol = Symbol()
+            type::Symbol = Symbol()
+            if Meta.isexpr(entry.args[1], :(::))
+                name = entry.args[1].args[1]
+                type = entry.args[1].args[2]
+            else
+                name = entry.args[1]
+                type = :GLenum
             end
-            $(enumName){$(dictname)[number], T}(number, $(dictname)[number])
+            # Generate the code.
+            str_name = string(name)
+            e_name = esc(name)
+            e_type = esc(type)
+            e_value = :(convert($e_type, $(esc(value))))
+            output = quote
+                const $e_name = $e_value
+                ModernGL.MGL_LOOKUP[$e_value] = Symbol($str_name)
+                export $e_name
+            end
+            return output
+        elseif entry isa LineNumberNode
+            return entry
+        else
+            error("Unexpected statement in block (expected 'GL_BLAH[::GLtype] = value'). \"",
+                  entry, '"')
         end
-
     end
-    esc(Expr(:block, enumtype, tmp..., Expr(:export, :($(enumName)))))
+    return Expr(:block, entries...)
 end
 
 include("glTypes.jl")