Change the generated commands script.

Commands and their type info are now kept in a hash of function names to
hashes of data types (GL_COMMAND_TYPES). This effectively allows me to query a function's info rather than just loading it and hoping it exists. As a result, the loading code can be reduce to a call to __load_gl_sym__, which is also included in the generated code. I should probably break it off into the GlSym code but for now this'll do.

The upshot to this is that loading a symbol no longer raises exceptions
if it doesn't exist. It simply returns the wrapped function if loaded or
false if not. So, if you load a symbol and it's not there, the exception
only comes from attempting to use that symbol. So, it's better now to
query whether the function is loaded first rather than using it if I
can't be certain it's available.

Also, Gl#have_gl_command? is now a thing, so the above query is now doable as well. There's also Gl#load_all_gl_commands!, which does what it says on the tin.

--

GlSym is now a submodule of Gl. __load_gl_sym__ caches the loaded function. It also stores the command types because I didn't want to make those part of the Gl module (and thereby accidentally infect the global namespace if someone does `include Gl`, which sounds pretty reasonable to me).

Author: nilium

ext/opengl-core/opengl_stub.c

@@ -47,9 +47,10 @@ static VALUE plat_is_linux(VALUE self)
 
 void Init_opengl_stub(void)
 {
-  VALUE module = rb_define_module("GlSym");
-  rb_define_singleton_method(module, "apple?", plat_is_apple, 0);
-  rb_define_singleton_method(module, "windows?", plat_is_windows, 0);
-  rb_define_singleton_method(module, "unix?", plat_is_unix, 0);
-  rb_define_singleton_method(module, "linux?", plat_is_linux, 0);
+  VALUE gl_module = rb_define_module("Gl");
+  VALUE gl_sym_module = rb_define_module_under(gl_module, "GlSym");
+  rb_define_singleton_method(gl_sym_module, "apple?", plat_is_apple, 0);
+  rb_define_singleton_method(gl_sym_module, "windows?", plat_is_windows, 0);
+  rb_define_singleton_method(gl_sym_module, "unix?", plat_is_unix, 0);
+  rb_define_singleton_method(gl_sym_module, "linux?", plat_is_linux, 0);
 }

gen_from_xml.rb

@@ -224,33 +224,34 @@ module Gl
 require 'opengl-core/gl_sym'
 
 module Gl
-EOS
 
-    filtered_commands.each {
-      |name, cmd|
-      io.puts "  # @api private\n  @@#{name}__fnptr__ = nil"
-    }
+#{
+  filtered_commands.map {
+    |name, cmd|
+    # Put a _ on the end of each argument to avoid conflicts with reserved words
+    param_string = cmd.parameters.map { |p| "#{p.name}_" }.join(', ')
 
-    filtered_commands.each {
-      |name, cmd|
-      # Put a _ on the end of each argument to avoid conflicts with reserved words
-      param_string = cmd.parameters.map { |p| "#{p.name}_" }.join(', ')
-      io.puts <<-EOS
+    <<-EOS_INNER
+  GlSym::GL_COMMAND_TYPES[:#{name}] = {
+    :parameter_types => [#{cmd.parameters.map { |p| fiddle_type(p) }.join(', ') }],
+    :return_type     => #{ fiddle_type(cmd.type) }
+  }
 
-  # @api private
+  # @api raw
   def #{name}__(#{param_string})
-    if @@#{name}__fnptr__.nil?
-      sym = GlSym.load_gl_sym__('#{name}')
-      @@#{name}__fnptr__ = Fiddle::Function.new(sym, [#{
-        cmd.parameters.map { |p| fiddle_type(p) }.join(', ') }], #{ fiddle_type(cmd.type) })
+    unless (fn = GlSym.__load_gl_sym__(:#{name}))
+      raise NotImplementedError, "GL function #{name} is not available."
     end
-    @@#{name}__fnptr__.call(#{param_string})
+    fn.call(#{param_string})
   end
+
   alias_method :'#{name}', :'#{name}__'
-EOS
-    }
 
-    io.puts "end # module Gl"
+    EOS_INNER
+  }.join('')
+}
+end # module Gl
+EOS
   }
 end
 

lib/opengl-core.rb

@@ -4,5 +4,16 @@
 require 'opengl-core/gl_commands'
 
 module Gl
+
+  def have_gl_command?(command)
+    !!GlSym.__load_gl_sym__(command.intern)
+  end
+
+  def load_all_gl_commands!()
+    GlSym::GL_COMMAND_TYPES.each_key { |fnsym| GlSym.__load_gl_sym__(fnsym) }
+    self
+  end
+
   extend self
+
 end

lib/opengl-core/gl_sym.rb

@@ -1,15 +1,25 @@
 require 'fiddle'
 require 'opengl-core/opengl_stub'
 
+module Gl ; end
+
 # @api private
-module GlSym
+module Gl::GlSym
+
+  # Filled by gl_commands.rb
+  GL_COMMAND_TYPES = {}
+  # Filled by __load_gl_sym__
+  GL_COMMAND_FUNCTIONS = {}
 
   # OpenGL library handle.
   @@opengl_lib = nil
 
   # Loads a symbol from the GL library. If the GL library hasn't yet been loaded
-  # it will also do that.
-  def self.load_gl_sym__(name)
+  # it will also do that. The returned function will be a wrapped Fiddle
+  # function using the types that function name is associated with in
+  # GL_COMMAND_TYPES. The returned value is cached in GL_COMMAND_FUNCTIONS and
+  # returned if __load_gl_sym__ is called for the same name again.
+  def self.__load_gl_sym__(name)
     if @@opengl_lib.nil?
       lib_path = case
       when apple?
@@ -24,7 +34,18 @@ def self.load_gl_sym__(name)
       @@opengl_lib = Fiddle.dlopen(lib_path)
     end
 
-    @@opengl_lib[name]
+    fn = GL_COMMAND_FUNCTIONS[name]
+    if fn.nil?
+      fn = (GL_COMMAND_FUNCTIONS[name] = begin
+        sym = @@opengl_lib[name.to_s]
+        types = GL_COMMAND_TYPES[name]
+        Fiddle::Function.new(sym, types[:parameter_types], types[:return_type])
+      rescue
+        false
+      end)
+    end
+
+    fn
   end
 
 end # module GlSym