opengl-core 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55bdceadec316a5cd6b73898cc0ab222ad09df0f
-  data.tar.gz: c06ce592e0f3bfcab2d897c3ea5e87359350aa03
+  metadata.gz: c407076d78ec2776bf4d930d623b95f2c761c70b
+  data.tar.gz: d4685fda0b7fa879b6de9a3bb3871b5fa4d077b3
 SHA512:
-  metadata.gz: 54176bf34be034bfb3e7cdf613d1efb23bb0a0b30a56cf8324372b06cdb93cd5768f03281c2c121b5d08c116f14588770ed3f06f8d522a0f8e4426f547ef697a
-  data.tar.gz: b77fe84a6e9303886a09d850182e033a274f6647f1d2fc729b5e5d98e15e4be24406b87c39a4e487c9049e30f435e3466b01788eb281f857c9da27b372c26422
+  metadata.gz: 998d1e941a7d72130eb9a45ee307694d247d28f2639e6dc30083b49edaf34ddb8d320a692197105e5c9668c04a3a21c77e00aa6cf3d8764574b0fdecadead5c9
+  data.tar.gz: 112b7d8abd9e5dc7620fdfb82b82f08a88b336e95fbbd80a2148c8136ebdfc428c0d21d2887031c11fc8bde533a5aa9743004d8351656598d030444b6f47123e

data/ext/opengl-core/opengl_stub.c

@@ -1,6 +1,7 @@
 #include "ruby.h"
 
 
+/* @api private */
 static VALUE plat_is_apple(VALUE self)
 {
   #if defined(__APPLE__)
@@ -11,6 +12,7 @@ static VALUE plat_is_apple(VALUE self)
 }
 
 
+/* @api private */
 static VALUE plat_is_windows(VALUE self)
 {
   #if defined(_WIN32) || defined(__MINGW32__) || defined(__CYGWIN__)
@@ -21,6 +23,7 @@ static VALUE plat_is_windows(VALUE self)
 }
 
 
+/* @api private */
 static VALUE plat_is_unix(VALUE self)
 {
   #if defined(__unix) || defined(__unix__) || defined(unix) || defined(__APPLE__)
@@ -31,6 +34,7 @@ static VALUE plat_is_unix(VALUE self)
 }
 
 
+/* @api private */
 static VALUE plat_is_linux(VALUE self)
 {
   #if defined(__linux__) || defined(linux) || defined(__linux)
@@ -43,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);
 }

data/lib/opengl-core.rb

@@ -4,4 +4,25 @@ require 'opengl-core/gl_enums'
 require 'opengl-core/gl_commands'
 
 module Gl
+
+  # Checks if a GL command is availalbe to use. This necessarily loads the
+  # command if it's not yet loaded just to check if it exists, so do not call
+  # this from multiple threads when other Gl commands are being loaded. If you
+  # want to ensure this only reads, you can call load_all_gl_commands! ahead of
+  # time and query it afterward.
+  def have_gl_command?(command)
+    !!GlSym.__load_gl_sym__(command.intern)
+  end
+
+  # Does what it says on the tin. Should only be called once, preferably from
+  # the main thread, though I'm not aware of any thread requirements re: symbol
+  # loading. If you're using Gl commands from multiple threads with multiple
+  # contexts, you should call this before using any Gl commands.
+  def load_all_gl_commands!()
+    GlSym::GL_COMMAND_TYPES.each_key { |fnsym| GlSym.__load_gl_sym__(fnsym) }
+    self
+  end
+
+  extend self
+
 end

data/lib/opengl-core/aux.rb

@@ -0,0 +1,7 @@
+require 'opengl-core'
+require 'opengl-core/aux/gl'
+require 'opengl-core/aux/vertex_array'
+require 'opengl-core/aux/buffer'
+require 'opengl-core/aux/texture'
+require 'opengl-core/aux/shader'
+require 'opengl-core/aux/program'

data/lib/opengl-core/aux/buffer.rb

@@ -0,0 +1,44 @@
+require 'opengl-core/aux/gl'
+require 'opengl-core/aux/marked'
+
+class Gl::Buffer < Gl::GlInternalMarked
+
+  attr_reader :name
+  attr_reader :target
+
+  def initialize(target, name = nil)
+    super()
+    @name = (name != 0 && name) || 0
+    @target = target
+    __mark__ if @name != 0
+  end
+
+  def delete
+    if @name != 0
+      Gl.glDeleteBuffers(@name)
+      @name = 0
+      super
+    end
+    self
+  end
+
+  def bind(target = nil)
+    if @name == 0
+      @name = Gl.glGenBuffers(1)[0]
+      __mark__
+    end
+    Gl.glBindBuffer(target || @target, @name)
+    self
+  end
+
+  def self.unbind(target)
+    Gl.glBindBuffer(target, 0)
+    self
+  end
+
+  def unbind(target = nil)
+    self.class.unbind(target || @target)
+    self
+  end
+
+end

data/lib/opengl-core/aux/gl.rb

@@ -0,0 +1,238 @@
+require 'opengl-core'
+
+module Gl
+
+  # @api private
+  UINT_BASE   = { :packed => [0].pack('I!').freeze,   :unpack => 'I!*' }
+  UINT16_BASE = { :packed => [0].pack('S').freeze,    :unpack => 'S*' }
+  UINT32_BASE = { :packed => [0].pack('L').freeze,    :unpack => 'L*' }
+  UINT64_BASE = { :packed => [0].pack('Q').freeze,    :unpack => 'Q*' }
+  INT_BASE    = { :packed => [0].pack('i!').freeze,   :unpack => 'i!*' }
+  INT16_BASE  = { :packed => [0].pack('s').freeze,    :unpack => 's*' }
+  INT32_BASE  = { :packed => [0].pack('l').freeze,    :unpack => 'l*' }
+  INT64_BASE  = { :packed => [0].pack('q').freeze,    :unpack => 'q*' }
+  USHORT_BASE = { :packed => [0].pack('S!').freeze,   :unpack => 'S!*' }
+  SHORT_BASE  = { :packed => [0].pack('s!').freeze,   :unpack => 's!*' }
+  FLOAT_BASE  = { :packed => [0.0].pack('F').freeze,  :unpack => 'F*' }
+  DOUBLE_BASE = { :packed => [0.0].pack('D').freeze,  :unpack => 'D*' }
+  POINTER_BASE = case Fiddle::SIZEOF_VOIDP
+  when 2 then   { :packed => [0.0].pack('S').freeze,  :unpack => 'S*' }
+  when 4 then   { :packed => [0.0].pack('L').freeze,  :unpack => 'L*' }
+  when 8 then   { :packed => [0.0].pack('Q').freeze,  :unpack => 'Q*' }
+  else raise "Pointer size is incompatible with opengl-core"
+  end
+
+  # @api private
+  def self.__define_gl_gen_object_method__(name, type_base)
+    pack_string = type_base[:packed]
+    unpack_kind = type_base[:unpack]
+
+    self.module_exec(name, :"#{name}__", pack_string, unpack_kind) {
+      |func_name, raw_name, buffer_elem, pack_as|
+      define_method(func_name) {
+        |count|
+        output_buffer = buffer_elem * count
+        send(raw_name, count, output_buffer)
+        output_buffer.unpack(pack_as)
+      }
+    }
+  end
+
+  # @api private
+  def self.__define_gl_delete_object_method__(name, type_base)
+    unpack_kind = type_base[:unpack]
+
+    self.module_exec(name, :"#{name}__", unpack_kind) {
+      |func_name, raw_name, pack_as|
+      define_method(func_name) {
+        |objects|
+        objects = [objects] unless objects.kind_of?(Array)
+        input_buffer = objects.pack(pack_as)
+        send(raw_name, objects.length, input_buffer)
+      }
+    }
+  end
+
+  # @api private
+  def self.__define_gl_get_method__(name, type_base)
+    pack_string = type_base[:packed]
+    unpack_kind = type_base[:unpack]
+
+    self.module_exec(name, :"#{name}v__", pack_string, unpack_kind) {
+      |func_name, raw_name, buffer_elem, pack_as|
+      define_method(func_name) {
+        |pname|
+        output_buffer = String.new(buffer_elem)
+        send(raw_name, pname, output_buffer)
+        output_buffer.unpack(pack_as)[0]
+      }
+    }
+  end
+
+
+  # @!method self.glGenTextures(count)
+  #   Returns an array of generated texture names.
+  __define_gl_gen_object_method__ :glGenTextures, UINT_BASE
+  # @!method self.glDeleteTextures(count, objects)
+  __define_gl_delete_object_method__ :glDeleteTextures, UINT_BASE
+
+  # @!method self.glGenVertexArrays(count)
+  #   Returns an array of generated vertex array object names.
+  __define_gl_gen_object_method__ :glGenVertexArrays, UINT_BASE
+  # @!method self.glDeleteVertexArrays(count, objects)
+  __define_gl_delete_object_method__ :glDeleteVertexArrays, UINT_BASE
+
+  # @!method self.glGenBuffers(count)
+  #   Returns an array of generated buffer object names.
+  __define_gl_gen_object_method__ :glGenBuffers, UINT_BASE
+  # @!method self.glDeleteBuffers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteBuffers, UINT_BASE
+
+  # @!method self.glGenQueries(count)
+  #   Returns an array of generated query object names.
+  __define_gl_gen_object_method__ :glGenQueries, UINT_BASE
+  # @!method self.glDeleteQueries(count, objects)
+  __define_gl_delete_object_method__ :glDeleteQueries, UINT_BASE
+
+  # @!method self.glGenSamplers(count)
+  #   Returns an array of generated sampler object names.
+  __define_gl_gen_object_method__ :glGenSamplers, UINT_BASE
+  # @!method self.glDeleteSamplers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteSamplers, UINT_BASE
+
+  # @!method self.glGenFramebuffers(count)
+  #   Returns an array of generated framebuffer object names.
+  __define_gl_gen_object_method__ :glGenFramebuffers, UINT_BASE
+  # @!method self.glDeleteFramebuffers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteFramebuffers, UINT_BASE
+
+  # @!method self.glGenRenderbuffers(count)
+  #   Returns an array of generated renderbuffer object names.
+  __define_gl_gen_object_method__ :glGenRenderbuffers, UINT_BASE
+  # @!method self.glDeleteRenderbuffers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteRenderbuffers, UINT_BASE
+
+  # @!method self.glGenRenderbuffersProgramPipelines(count)
+  #   Returns an array of generated program pipeline object names.
+  __define_gl_gen_object_method__ :glGenProgramPipelines, UINT_BASE
+  # @!method self.glDeleteRenderbuffersProgramPipelines(count, objects)
+  __define_gl_delete_object_method__ :glDeleteProgramPipelines, UINT_BASE
+
+  # @!method self.glGenRenderbuffersTrasnformFeedbacks(count)
+  #   Returns an array of generated transform feedback objects
+  __define_gl_gen_object_method__ :glGenTransformFeedbacks, UINT_BASE
+  # @!method self.glDeleteRenderbuffersTrasnformFeedbacks(count, objects)
+  __define_gl_delete_object_method__ :glDeleteTransformFeedbacks, UINT_BASE
+
+  __define_gl_get_method__ :glGetInteger, UINT_BASE
+  __define_gl_get_method__ :glGetInteger64, INT64_BASE
+  __define_gl_get_method__ :glGetFloat, FLOAT_BASE
+  __define_gl_get_method__ :glGetDouble, DOUBLE_BASE
+
+  # @return [Boolean] Returns the boolean value of the given parameter name.
+  def glGetBoolean(pname)
+    buffer = '0'
+    glGetBooleanv(pname, buffer)
+    !!buffer.unpack('C')[0]
+  end
+
+  # @return [String] Returns the string value of the given parameter name.
+  def glGetString(name)
+    glGetString__(name).to_s
+  end
+
+  # @return [String] Returns the string value of a parameter name at a given index.
+  def glGetStringi(name, index)
+    glGetStringi__(name, index).to_s
+  end
+
+  def glVertexAttribPointer(index, size, type, normalized, stride, offset)
+    offset = case offset
+    when Fiddle::Pointer then offset
+    when Numeric then Fiddle::Pointer.new(offset)
+    else offset
+    end
+    glVertexAttribPointer__ index, size, type, normalized, stride, offset
+  end
+
+  def glShaderSource(shader, sources)
+    sources = [sources] unless sources.kind_of?(Array)
+    source_lengths = sources.map { |s| s.bytesize }.pack('i*')
+    source_pointers = sources.pack('p')
+    glShaderSource__(shader, sources.length, source_pointers, source_lengths)
+  end
+
+  # Returns the version or release number. Calls glGetString.
+  def gl_version()
+    glGetString(GL_VERSION)
+  end
+
+  # Returns the implementation vendor. Calls glGetString.
+  def gl_vendor()
+    glGetString(GL_VENDOR)
+  end
+
+  # Returns the renderer. Calls glGetString.
+  def gl_renderer()
+    glGetString(GL_RENDERER)
+  end
+
+  # Returns the shading language version. Calls glGetString.
+  def gl_shading_language_version()
+    glGetString(GL_SHADING_LANGUAGE_VERSION)
+  end
+
+  # Gets an array of GL extensions. This calls glGetIntegerv and glGetStringi,
+  # so be aware that you should probably cache the results.
+  def gl_extensions()
+    (0 ... glGetInteger(GL_NUM_EXTENSIONS)).map { |index| glGetStringi(GL_EXTENSIONS, index) }
+  end
+
+  def glGetShader(shader, pname)
+    base = String.new(INT_BASE[:packed])
+    glGetShaderiv__(shader, pname, base)
+    base.unpack(INT_BASE[:unpack])[0]
+  end
+
+  def glGetShaderInfoLog(shader)
+    length = glGetShader(shader, GL_INFO_LOG_LENGTH)
+    return '' if length == 0
+    output = ' ' * length
+    glGetShaderInfoLog__(shader, output.bytesize, 0, output)
+    output
+  end
+
+  def glGetShaderSource(shader)
+    length = glGetShader(shader, GL_SHADER_SOURCE_LENGTH)
+    return '' if length == 0
+    output = ' ' * length
+    glGetShaderInfoLog__(shader, output.bytesize, 0, output)
+    output
+  end
+
+  def glGetProgram(program, pname)
+    base = String.new(INT_BASE[:packed])
+    glGetProgramiv__(program, pname, base)
+    base.unpack(INT_BASE[:unpack])[0]
+  end
+
+  def glGetProgramInfoLog(program)
+    length = glGetProgram(program, GL_INFO_LOG_LENGTH)
+    return '' if length == 0
+    output = ' ' * length
+    glGetProgramInfoLog__(program, output.bytesize, 0, output)
+    output
+  end
+
+  def glGetProgramBinary(program)
+    binary_length = glGetProgram(program, GL_PROGRAM_BINARY_LENGTH)
+    return [nil, nil] if binary_length == 0
+    format_buffer = String.new(UINT_BASE[:packed])
+    binary_buffer = ' ' * binary_length
+    glGetProgramBinary(program, binary_buffer.bytesize, 0, format_buffer, binary_buffer)
+    [format_buffer.unpack(UINT_BASE[:unpack])[0], binary_buffer]
+  end
+
+  extend self
+
+end

data/lib/opengl-core/aux/marked.rb

@@ -0,0 +1,66 @@
+module Gl ; end
+
+class Gl::GlInternalMarked
+
+  @@allocated__ = {}
+
+  def ==(other)
+    (self.kind_of?(other.class) || other.kind_of?(self.class)) && (self.name == other.name)
+  end
+
+  # Should be overridden by subclasses to handle freeing resources when marked.
+  # If unmarked, should be a no-op.
+  def delete
+    __unmark__
+    self
+  end
+
+  # Deletes all objects of the given type. Should be used carefully if at all.
+  def self.delete_all
+    __marked_allocated__.keys.each { |marked| marked.delete }
+  end
+
+  # Clears all marked objects. If deletion is already guaranteed for all marked
+  # objects, you may use this to let all marked objects of this type get GC'd.
+  def self.clear_all
+    __marked_allocated__.clear
+  end
+
+  # @api private
+  # Marks the class to prevent it from being garbage collected.
+  def __mark__
+    self.class.__marked_allocated__[self] = true
+  end
+
+  # @api private
+  # Unmarks the class and allows it to be garbage collected.
+  def __unmark__
+    self.class.__marked_allocated__.delete(self)
+  end
+
+  # @api private
+  # Returns whether the object is currently marked to keep it from being GC'd.
+  def marked?
+    self.class.__marked_allocated__.include?(self)
+  end
+
+  # @api private
+  # Allocates a hash for the subclass. This will be done regardless of whether
+  # this function is called.
+  def self.inherited(subclass)
+    @@allocated__[subclass] = @@allocated__[subclass] || {}
+  end
+
+  # @api private
+  # Returns a Hash of marked objects.
+  def self.__marked_allocated__
+    (@@allocated__[self.class] || (@@allocated__[self.class] = {}))
+  end
+
+  # @api private
+  # Returns all allocated marked objects for this class.
+  def self.allocated
+    __marked_allocated__.keys
+  end
+
+end

data/lib/opengl-core/aux/program.rb

@@ -0,0 +1,116 @@
+require 'opengl-core/aux/gl'
+require 'opengl-core/aux/marked'
+
+# Needed even if the class isn't actually used
+class Gl::Shader ; end
+
+class Gl::Program < Gl::GlInternalMarked
+
+  attr_reader :name
+  attr_reader :kind
+
+  def initialize(name = nil)
+    super()
+    @name = (name != 0 && name) || Gl.glCreateProgram()
+    @validate_status = nil
+    @link_status = nil
+    @uniform_locations = {}
+    __mark__
+  end
+
+  def load_binary(binary_format, binary_string)
+    Gl.glProgramBinary(@name, binary_format, binary_string, binary_string.bytesize)
+    @link_status = nil
+    __reload_uniforms__  if (link_successful = linked?)
+    link_successful
+  end
+
+  def binary
+    Gl.glGetProgramBinary(@name)
+  end
+
+  def delete
+    if @name != 0
+      Gl.glDeleteProgram(@name)
+      @name = 0
+      super
+    end
+    self
+  end
+
+  def __reload_uniforms__
+    @uniform_locations.keys.each {
+      |key|
+      @uniform_locations[key] = uniform_location(key)
+    }
+  end
+
+  def link
+    Gl.glLinkProgram(@name)
+    @link_status = nil
+    __reload_uniforms__ if (link_successful = linked?)
+    link_successful
+  end
+
+  def linked?
+    @link_status = (!@link_status.nil? && @link_status) ||
+      Gl.glGetProgram(@name, Gl::GL_LINK_STATUS) == GL_TRUE
+  end
+
+  def validate
+    Gl.glValidateProgram(@name)
+    @validate_status = nil
+    valid?
+  end
+
+  def valid?
+    @validate_status = (!@validate_status.nil? && @validate_status) ||
+      Gl.glGetProgram(@name, Gl::GL_VALIDATE_STATUS) == GL_TRUE
+  end
+
+  def info_log
+    Gl.glGetProgramInfoLog(@name)
+  end
+
+  def use
+    Gl.glUseProgram(@name)
+    self
+  end
+
+  def attach_shader(shader)
+    case shader
+    when ::Gl::Shader then Gl.glAttachShader(@name, shader.name)
+    else Gl.glAttachShader(@name, shader)
+    end
+    self
+  end
+
+  def hint_uniform(uniform_name)
+    @uniform_locations[uniform_name.to_sym] =
+      (@uniform_locations[uniform_name.to_sym] || -1)
+    self
+  end
+
+  def uniform_location(uniform_name)
+    uniform_sym = uniform_name.to_sym
+    @uniform_locations[uniform_sym] ||
+      (@uniform_locations[uniform_sym] =
+        Gl.glGetUniformLocation(@name, uniform_name.to_s))
+  end
+  alias_method :[], :uniform_location
+
+  def subroutine_uniform_location(shader_kind, uniform_name)
+    Gl.glGetSubroutineUniformLocation(@name, shader_kind, uniform_name)
+  end
+
+  def bind_attrib_location(attrib_index, attrib_name)
+    Gl.glBindAttribLocation(@name, attrib_index, attrib_name.to_s)
+    self
+  end
+
+  def bind_frag_data_location(color_number, frag_data_name)
+    Gl.glBindFragDataLocation(@name, color_number, frag_data_name.to_s)
+    self
+  end
+
+end