opengl-aux 1.0.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d62d50a90a153ae31c7313cd71317c99edab993
+  data.tar.gz: 39a962d7c4c6fa4e9397f9268036637e9eddf676
+SHA512:
+  metadata.gz: e6d810e70fcf3063e81fef2e45ddc8bbc80012d5ead1ddac9236c2d078459a6095c72b84203f023db843f8e3c870a12878daeb0ce36731e46443729dd53c99a7
+  data.tar.gz: 55e6b6a8992d9ba097cfe9998ea7ec527f66fcedcf6a4986577da24473c738deb41d57c8cfea0b35b2db6eeb74330119db2cf1ff48f32ef69c30840e6ccdd400

data/lib/opengl-aux/buffer.rb

@@ -0,0 +1,100 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  buffer.rb
+#    GL buffer object wrapper.
+
+
+require 'opengl-aux/gl'
+require 'opengl-aux/error'
+
+
+class GL::Buffer
+
+  class << self
+
+    attr_accessor :__buffer_target_getters__
+
+    def current_binding(target)
+      GL.glGetInteger(__buffer_target_getters__[target])
+    end
+
+    def preserve_binding(target)
+      current = bound_name(target)
+      begin
+        yield
+      ensure
+        GL.glBindBuffer(target, current)
+      end
+    end
+
+  end # singleton_class
+
+
+  self.__buffer_target_getters__ = {
+    GL::GL_ARRAY_BUFFER              => GL::GL_ARRAY_BUFFER_BINDING,
+    GL::GL_ATOMIC_COUNTER_BUFFER     => GL::GL_ATOMIC_COUNTER_BUFFER_BINDING,
+    GL::GL_DISPATCH_INDIRECT_BUFFER  => GL::GL_DISPATCH_INDIRECT_BUFFER_BINDING,
+    GL::GL_DRAW_INDIRECT_BUFFER      => GL::GL_DRAW_INDIRECT_BUFFER_BINDING,
+    GL::GL_ELEMENT_ARRAY_BUFFER      => GL::GL_ELEMENT_ARRAY_BUFFER_BINDING,
+    GL::GL_PIXEL_PACK_BUFFER         => GL::GL_PIXEL_PACK_BUFFER_BINDING,
+    GL::GL_PIXEL_UNPACK_BUFFER       => GL::GL_PIXEL_UNPACK_BUFFER_BINDING,
+    GL::GL_QUERY_BUFFER              => GL::GL_QUERY_BUFFER_BINDING,
+    GL::GL_SHADER_STORAGE_BUFFER     => GL::GL_SHADER_STORAGE_BUFFER_BINDING,
+    GL::GL_SHADER_STORAGE_BUFFER     => GL::GL_SHADER_STORAGE_BUFFER_BINDING,
+    GL::GL_TEXTURE_BUFFER            => GL::GL_TEXTURE_BUFFER_BINDING,
+    GL::GL_TRANSFORM_FEEDBACK_BUFFER => GL::GL_TRANSFORM_FEEDBACK_BUFFER_BINDING,
+    GL::GL_UNIFORM_BUFFER            => GL::GL_UNIFORM_BUFFER_BINDING,
+  }
+
+  __buffer_target_getters__.default_proc = -> (hash, key) do
+    raise ArgumentError, "No queryable buffer binding target for #{key}"
+  end
+
+
+  attr_reader :name
+  attr_accessor :target
+
+  def initialize(target = nil, name = nil)
+    @name = (name != 0 && name) || 0
+    @target = target
+    yield self if block_given?
+  end
+
+  def is_buffer?
+    GL::glIsBuffer(@name) != GL::GL_FALSE
+  end
+
+  def delete
+    if @name != 0
+      GL.glDeleteBuffers(@name)
+      @name = 0
+    end
+    self
+  end
+
+  def bind(target = nil)
+    target ||= (@target || GL_ARRAY_BUFFER)
+    @target ||= target
+    raise ArgumentError, "No target given and no previous target" unless target
+
+    if block_given?
+      preserve_binding(target) do
+        yield self
+      end
+    else
+      if @name == 0
+        @name = GL.glGenBuffers(1)
+        if @name == 0
+          raise GL::GLCreateError, "Unable to allocate buffer object"
+        end
+      end
+
+      GL.glBindBuffer(target, @name)
+      self
+    end
+  end
+
+end # GL::Buffer

data/lib/opengl-aux/error.rb

@@ -0,0 +1,57 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  error.rb
+#    Error types used by opengl-aux.
+
+
+module GL
+
+  # Generic error that should probably be subclassed for more specific errors.
+  # Can be used as a catch-all for GL-specific errors.
+  class GLError < StandardError ; end
+
+  # An error that should be raised if a call to a glGen* or glCreate* function
+  # fails.
+  class GLCreateError < GLError ; end
+
+  # State error raised for errors returned by glGetError.
+  class GLStateError < GLError
+    attr_reader :code
+
+    def self.exception(msg = nil, code = GL::GL_NO_ERROR)
+      new(code, msg)
+    end
+
+    def initialize(code, msg = nil)
+      @code = code
+      super(msg)
+    end
+
+    def exception(msg = nil)
+      if msg
+        self.class.exception(msg, code)
+      else
+        self
+      end
+    end
+
+    def to_s
+      code_str =
+        case self.code
+        when GL::GL_NO_ERROR                      then 'NO_ERROR'
+        when GL::GL_INVALID_ENUM                  then 'INVALID_ENUM'
+        when GL::GL_INVALID_VALUE                 then 'INVALID_VALUE'
+        when GL::GL_INVALID_OPERATION             then 'INVALID_OPERATION'
+        when GL::GL_INVALID_FRAMEBUFFER_OPERATION then 'INVALID_FRAMEBUFFER_OPERATION'
+        when GL::GL_OUT_OF_MEMORY                 then 'OUT_OF_MEMORY'
+        when GL::GL_STACK_UNDERFLOW               then 'STACK_UNDERFLOW'
+        when GL::GL_STACK_OVERFLOW                then 'STACK_OVERFLOW'
+        end
+      "#{code_str}: #{super}"
+    end
+  end # GLStateError
+
+end # GL

data/lib/opengl-aux/gl.rb

@@ -0,0 +1,372 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  gl.rb
+#    Basic GL functions and typedefs for snow-data.
+
+
+require 'opengl-core'
+require 'snow-data'
+require 'opengl-aux/error'
+
+
+# Extensions to the opengl-core Gl module.
+module GL
+
+  # Define snow-data typedefs for OpenGL
+  Snow::CStruct.alias_type(:gl_short, :short)
+  Snow::CStruct.alias_type(:gl_ushort, :unsigned_short)
+  Snow::CStruct.alias_type(:gl_half, :unsigned_short)
+  Snow::CStruct.alias_type(:gl_enum, :unsigned_int)
+  Snow::CStruct.alias_type(:gl_uint, :unsigned_int)
+  Snow::CStruct.alias_type(:gl_int, :int)
+  Snow::CStruct.alias_type(:gl_fixed, :int)
+  Snow::CStruct.alias_type(:gl_uint64, :uint64_t)
+  Snow::CStruct.alias_type(:gl_int64, :int64_t)
+  Snow::CStruct.alias_type(:gl_sizei, :int)
+  Snow::CStruct.alias_type(:gl_float, :float)
+  Snow::CStruct.alias_type(:gl_clampf, :float)
+  Snow::CStruct.alias_type(:gl_double, :double)
+  Snow::CStruct.alias_type(:gl_clampd, :double)
+
+  GLObject = Snow::CStruct.new { gl_uint :name }
+
+  def assert_no_gl_error(msg = nil)
+    error = glGetError
+
+    if error != GL_NO_ERROR
+      raise GLStateError.new(error), msg
+    end
+  end
+
+  class << self
+
+    # @api private
+    attr_accessor :__box_types__
+
+    # @api private
+    #
+    # Temporarily allocates the given type, yields it to a block, and releases
+    # the allocated memory. Uses alloca if available. Any additional arguments
+    # to this function are forwarded to the type's allocator.
+    #
+    def __temp_alloc__(type, *args, &block)
+      result = nil
+
+      if type.respond_to?(:alloca)
+        result = type.alloca(*args, &block)
+      else
+        type.new(*args) do |p|
+          begin
+            result = yield[p]
+          ensure
+            p.free!
+          end
+        end
+      end
+
+      result
+    end
+
+    # @api private
+    #
+    # Returns a boxed type for the given typename. All boxed types contain a
+    # single member, 'name', which is of the boxed type. Boxed types are created
+    # on demand and cached.
+    #
+    def __boxed_type__(typename, &block)
+      box_types = (__box_types__ ||= Hash.new do |hash, type|
+        hash[type] = Snow::CStruct.new { __send__(type, :name) }
+      end)
+
+      box_types[typename]
+    end
+
+    # @api private
+    #
+    # Wraps a previously-defined native glGen* function that returns the given
+    # type of object. The glGen function returns one or more GL object names.
+    # If returning a single name, the return type is Fixnum, otherwise it's an
+    # array of Fixnums.
+    #
+    def __define_gl_gen_object_method__(name, type)
+      self.module_exec(name, :"#{name}__", GL.__boxed_type__(type)) do
+        |func_name, raw_name, box_type|
+
+        define_method(func_name, -> (count) do
+          return nil if count <= 0
+
+          if count == 1
+            GL.__temp_alloc__(box_type) do |p|
+              send(raw_name, count, p.address)
+              p.name
+            end
+          else
+            GL.__temp_alloc__(box_type::Array, count) do |p|
+              send(raw_name, count, p.address)
+              Array.new(count) { |i| p[i].name }
+            end
+          end
+        end) # define_method
+
+      end # module_exec
+    end # __define_gl_get_method__
+
+    # @api private
+    #
+    # Similar to __define_gl_gen_object_method__, except for deletion. Takes
+    # four possible types of objects to delete: a GLObject or an array of
+    # GLObjects, a Fixnum, or an array of Fixnums. Any other types will raise
+    # an error, and any type contained by an Array that is not implicitly
+    # convertible to a Fixnum will also raise an error.
+    #
+    def __define_gl_delete_object_method__(name, type)
+      self.module_exec(name, :"#{name}__") do |func_name, raw_name|
+
+        define_method(func_name, -> (objects) do
+          case objects
+          when GLObject
+            send(raw_name, 1, objects.address)
+          when GLObject::Array
+            send(raw_name, objects.length, objects.address)
+          when Fixnum
+            GL.__temp_alloc__(GLObject) do |p|
+              p.name = objects
+              send(raw_name, 1, p.address)
+            end
+          when Array # Assumes an array of fixnums
+            GL.__temp_alloc__(GLObject::Array, objects.length) do |p|
+              objects.each_with_index { |e, i| p[i].name = e }
+              send(raw_name, p.length, p.address)
+            end
+          else
+            raise ArgumentError,
+            "Invalid object passed to #{name} for deletion: #{objects.inspect}"
+          end
+          self
+        end) # define_method
+
+      end # module_exec
+    end # __define_gl_get_method__
+
+    # @api private
+    #
+    # Defines a glGet* method that returns a single value of the given type.
+    #
+    def __define_gl_get_method__(name, type)
+      self.module_exec(name, :"#{name}v__", GL.__boxed_type__(type)) do
+        |func_name, raw_name, box_type|
+
+        define_method(func_name, -> (pname) do
+          GL.__temp_alloc__(box_type) do |p|
+            send(raw_name, pname, p.address)
+            p.name
+          end
+        end) # define_method
+
+      end # module_exec
+    end # __define_gl_get_method__
+
+  end # singleton_class
+
+
+  # @!method self.glGenTextures(count)
+  #   Returns an array of generated texture names.
+  __define_gl_gen_object_method__ :glGenTextures, :gl_uint
+  # @!method self.glDeleteTextures(count, objects)
+  __define_gl_delete_object_method__ :glDeleteTextures, :gl_uint
+
+  # @!method self.glGenVertexArrays(count)
+  #   Returns an array of generated vertex array object names.
+  __define_gl_gen_object_method__ :glGenVertexArrays, :gl_uint
+  # @!method self.glDeleteVertexArrays(count, objects)
+  __define_gl_delete_object_method__ :glDeleteVertexArrays, :gl_uint
+
+  # @!method self.glGenBuffers(count)
+  #   Returns an array of generated buffer object names.
+  __define_gl_gen_object_method__ :glGenBuffers, :gl_uint
+  # @!method self.glDeleteBuffers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteBuffers, :gl_uint
+
+  # @!method self.glGenQueries(count)
+  #   Returns an array of generated query object names.
+  __define_gl_gen_object_method__ :glGenQueries, :gl_uint
+  # @!method self.glDeleteQueries(count, objects)
+  __define_gl_delete_object_method__ :glDeleteQueries, :gl_uint
+
+  # @!method self.glGenSamplers(count)
+  #   Returns an array of generated sampler object names.
+  __define_gl_gen_object_method__ :glGenSamplers, :gl_uint
+  # @!method self.glDeleteSamplers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteSamplers, :gl_uint
+
+  # @!method self.glGenFramebuffers(count)
+  #   Returns an array of generated framebuffer object names.
+  __define_gl_gen_object_method__ :glGenFramebuffers, :gl_uint
+  # @!method self.glDeleteFramebuffers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteFramebuffers, :gl_uint
+
+  # @!method self.glGenRenderbuffers(count)
+  #   Returns an array of generated renderbuffer object names.
+  __define_gl_gen_object_method__ :glGenRenderbuffers, :gl_uint
+  # @!method self.glDeleteRenderbuffers(count, objects)
+  __define_gl_delete_object_method__ :glDeleteRenderbuffers, :gl_uint
+
+  # @!method self.glGenRenderbuffersProgramPipelines(count)
+  #   Returns an array of generated program pipeline object names.
+  __define_gl_gen_object_method__ :glGenProgramPipelines, :gl_uint
+  # @!method self.glDeleteRenderbuffersProgramPipelines(count, objects)
+  __define_gl_delete_object_method__ :glDeleteProgramPipelines, :gl_uint
+
+  # @!method self.glGenRenderbuffersTrasnformFeedbacks(count)
+  #   Returns an array of generated transform feedback objects
+  __define_gl_gen_object_method__ :glGenTransformFeedbacks, :gl_uint
+  # @!method self.glDeleteRenderbuffersTrasnformFeedbacks(count, objects)
+  __define_gl_delete_object_method__ :glDeleteTransformFeedbacks, :gl_uint
+
+  __define_gl_get_method__ :glGetInteger, :gl_int
+  __define_gl_get_method__ :glGetInteger64, :gl_int64
+  __define_gl_get_method__ :glGetFloat, :float
+  __define_gl_get_method__ :glGetDouble, :double
+
+  # @return [Boolean] Returns the boolean value of the given parameter name.
+  def glGetBoolean(pname)
+    GL.__temp_alloc__(GL.__boxed_type__(:gl_boolean)) do |p|
+      p.name = 0
+      glGetBooleanv(pname, p.address)
+      p.name != GL_FALSE
+    end
+  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
+
+  # Assumes sources is a
+  def glShaderSource(shader, sources)
+    ary_len = (source_array = sources.kind_of?(Array)) ? sources.length : 1
+
+    lengths = GL.__boxed_type__(:gl_sizei)[ary_len]
+    pointers = GL.__boxed_type__(:intptr_t)[ary_len]
+
+    begin
+      assign_block = -> (src, index) do
+        lengths[index].name = src.bytesize
+        pointers[index].name = Fiddle::Pointer[src].to_i
+      end
+
+      if source_array
+        sources.each_with_index(&assign_block)
+      else
+        assign_block[sources, 0]
+      end
+
+      glShaderSource__(shader, ary_len, pointers.address, lengths.address)
+
+    ensure
+      lengths.free!
+      pointers.free!
+    end
+
+    self
+  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
+    Array.new(glGetInteger(GL_NUM_EXTENSIONS)) do |index|
+      glGetStringi(GL_EXTENSIONS, index)
+    end
+  end
+
+  def glGetShader(shader, pname)
+    GL.__temp_alloc__(GL.__boxed_type__(:gl_int)) do |p|
+      glGetShaderiv__(shader, pname, p.address)
+      p.name
+    end
+  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)
+    GL.__temp_alloc__(GL.__boxed_type__(:gl_int)) do |p|
+      glGetProgramiv__(program, pname, p.address)
+      p.name
+    end
+  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
+
+  GLProgramBinary = Struct.new(:format, :data)
+
+  def glGetProgramBinary(program)
+    binary_length = glGetProgram(program, GL_PROGRAM_BINARY_LENGTH)
+
+    return nil if binary_length <= 0
+
+    GL.__temp_alloc__(GL.__boxed_type__(:gl_enum)) do |format_buffer; binary_buffer|
+      binary_buffer = ' ' * binary_length
+
+      glGetProgramBinary(
+        program,
+        binary_buffer.bytesize,
+        0,
+        format_buffer.address,
+        binary_buffer.address
+        )
+
+      GLProgramBinary[format_buffer.name, binary_buffer]
+    end
+  end
+
+  extend self
+
+end # GL

data/lib/opengl-aux/program.rb

@@ -0,0 +1,161 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  program.rb
+#    GL program object wrapper.
+
+
+require 'opengl-aux/gl'
+
+
+# Declare it just for type checking
+class GL::Shader ; end
+
+class GL::Program
+
+
+  class << self
+
+    def current_program
+      GL::glGetInteger(GL::GL_CURRENT_PROGRAM)
+    end
+
+    def preserve_binding
+      raise ArgumentError, "No block given" unless block_given?
+      current = current_program
+      begin
+        yield
+      ensure
+        GL.glUseProgram(current)
+      end
+    end
+
+  end # singleton_class
+
+
+  attr_reader :name
+
+  def initialize(name = nil)
+    if name
+      @name = name
+    else
+      @name = GL.glCreateProgram()
+      raise GL::GLCreateError, "Unable to allocate shader" if @name == 0
+    end
+
+    @uniform_locations = {}
+
+    yield self if block_given?
+  end
+
+  def delete
+    if @name != 0
+      GL.glDeleteProgram(@name)
+      @name = 0
+    end
+    self
+  end
+
+  def is_program?
+    GL::glIsProgram(@name) != GL::GL_FALSE
+  end
+
+  def load_binary(binary_format, binary_string)
+    GL.glProgramBinary(@name, binary_format, binary_string, binary_string.bytesize)
+    __reload_uniforms__ if (link_successful = linked?)
+    link_successful
+  end
+
+  def binary
+    GL.glGetProgramBinary(@name)
+  end
+
+  def __reload_uniforms__
+    locs = @uniform_locations
+    locs.each_key do |key|
+      locs[key] = GL.glGetUniformLocation(@name, key.to_s)
+    end
+  end
+
+  def link
+    GL.glLinkProgram(@name)
+    @link_status = nil
+    __reload_uniforms__ if (link_successful = linked?)
+    link_successful
+  end
+
+  def linked?
+    GL.glGetProgram(@name, GL::GL_LINK_STATUS) != GL::GL_FALSE
+  end
+
+  def valid?
+    GL.glValidateProgram(@name)
+    GL.glGetProgram(@name, GL::GL_VALIDATE_STATUS) != GL::GL_FALSE
+  end
+
+  def info_log
+    GL.glGetProgramInfoLog(@name)
+  end
+
+  def use
+    if block_given?
+      preserve_binding do
+        use
+        yield self
+      end
+    else
+      GL.glUseProgram(@name)
+      self
+    end
+  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 detach_shader(shader)
+    case shader
+    when ::GL::Shader then GL.glDetachShader(@name, shader.name)
+    else GL.glDetachShader(@name, shader)
+    end
+    self
+  end
+
+  def hint_uniform(name)
+    name = name.to_sym
+    @uniform_locations[name] ||= nil
+    self
+  end
+
+  def uniform_location(name)
+    uniform_sym = name.to_sym
+    locations = @uniform_locations
+    locations[uniform_sym] ||= GL.glGetUniformLocation(@name, name.to_s)
+  end
+  alias_method :[], :uniform_location
+
+  def clear_uniform_location_cache
+    @uniform_locations.clear
+  end
+
+  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

data/lib/opengl-aux/shader.rb

@@ -0,0 +1,64 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  shader.rb
+#    GL shader object wrapper.
+
+
+require 'opengl-aux/gl'
+
+
+class GL::Shader
+
+  attr_reader :name
+  attr_reader :kind
+
+  def initialize(kind, name = nil)
+    if name
+      @name = name
+    else
+      @name = GL.glCreateShader(kind)
+      raise GL::GLCreateError, "Unable to allocate shader" if @name == 0
+    end
+
+    @kind = kind
+    yield self if block_given?
+  end
+
+  def delete
+    if @name != 0
+      GL.glDeleteShader(@name)
+      @name = 0
+    end
+    self
+  end
+
+  def is_shader?
+    GL::glIsShader(@name) != GL::GL_FALSE
+  end
+
+  def source=(sources)
+    GL.glShaderSource(@name, sources)
+    sources
+  end
+
+  def source
+    GL.glGetShaderSource(@name)
+  end
+
+  def compile
+    GL.glCompileShader(@name)
+    compiled?
+  end
+
+  def compiled?
+    GL.glGetShader(@name, GL::GL_COMPILE_STATUS) != GL::GL_FALSE
+  end
+
+  def info_log
+    GL.glGetShaderInfoLog(@name)
+  end
+
+end

data/lib/opengl-aux/texture.rb

@@ -0,0 +1,115 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  texture.rb
+#    GL texture object wrapper.
+
+
+require 'opengl-aux/gl'
+require 'opengl-aux/error'
+
+
+class GL::Texture
+
+  class << self
+
+    attr_accessor :__texture_target_getters__
+
+    def current_unit
+      GL.glGetInteger(GL::GL_ACTIVE_TEXTURE)
+    end
+
+    def current_binding(target)
+      GL.glGetInteger(__texture_target_getters__[target])
+    end
+
+    def preserve_unit
+      unit = current_unit
+      begin
+        yield
+      ensure
+        GL.glActiveTexture(unit)
+      end
+    end
+
+    # Implied preserve_unit
+    def preserve_binding(target)
+      preserve_unit do
+        binding = current_binding(target)
+        begin
+          yield
+        ensure
+          GL.glBindTexture(target, binding)
+        end
+      end
+    end
+
+  end # singleton_class
+
+
+  self.__texture_target_getters__ = {
+    GL::GL_TEXTURE_1D                   => GL::GL_TEXTURE_BINDING_1D,
+    GL::GL_TEXTURE_2D                   => GL::GL_TEXTURE_BINDING_2D,
+    GL::GL_TEXTURE_3D                   => GL::GL_TEXTURE_BINDING_3D,
+    GL::GL_TEXTURE_1D_ARRAY             => GL::GL_TEXTURE_BINDING_1D_ARRAY,
+    GL::GL_TEXTURE_2D_ARRAY             => GL::GL_TEXTURE_BINDING_2D_ARRAY,
+    GL::GL_TEXTURE_RECTANGLE            => GL::GL_TEXTURE_BINDING_RECTANGLE,
+    GL::GL_TEXTURE_CUBE_MAP             => GL::GL_TEXTURE_BINDING_CUBE_MAP,
+    GL::GL_TEXTURE_CUBE_MAP_ARRAY       => GL::GL_TEXTURE_BINDING_CUBE_MAP_ARRAY,
+    GL::GL_TEXTURE_BUFFER               => GL::GL_TEXTURE_BINDING_BUFFER,
+    GL::GL_TEXTURE_2D_MULTISAMPLE       => GL::GL_TEXTURE_BINDING_2D_MULTISAMPLE,
+    GL::GL_TEXTURE_2D_MULTISAMPLE_ARRAY => GL::GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY,
+  }
+
+  self.__texture_target_getters__.default_proc = -> (hash, key) do
+    raise ArgumentError, "No queryable texture binding target for #{key}"
+  end
+
+
+  attr_reader   :name
+  attr_accessor :target
+
+  def initialize(target = nil, name = nil)
+    @name = name || 0
+    @target = target
+    yield self if block_given?
+  end
+
+  def is_texture?
+    GL::glIsTexture(@name) != GL::GL_FALSE
+  end
+
+  def delete
+    if @name != 0
+      GL.glDeleteTextures(@name)
+      @name = 0
+    end
+  end
+
+  def bind(target = nil)
+    # You may think this is insane, but I assure you, it isn't.
+    target ||= (@target || GL_TEXTURE_2D)
+    @target ||= target
+    raise ArgumentError, "No target given and no previous target" unless target
+
+    if block_given?
+      self.class.preserve_binding(target) do
+        bind(target)
+        yield self
+      end
+    else
+      if @name == 0
+        @name ||= GL.glGenTextures(1)
+        if @name == 0
+          raise GL::GLCreateError, "Unable to allocate texture object"
+        end
+      end
+
+      GL.glBindTexture(target, @name)
+      self
+    end
+  end
+
+end # GL::Texture

data/lib/opengl-aux/version.rb

@@ -0,0 +1,12 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  version.rb
+#    Version codes for opengl-aux
+
+
+module GL
+  OPENGL_AUX_VERSION = '1.0.0.pre1'
+end

data/lib/opengl-aux/vertex_array.rb

@@ -0,0 +1,73 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  vertex_array.rb
+#    GL vertex array object wrapper.
+
+
+require 'opengl-aux/gl'
+require 'opengl-aux/error'
+
+
+class GL::VertexArray
+
+  class << self
+
+    def current_binding
+      GL.glGetInteger(GL::GL_VERTEX_ARRAY_BINDING)
+    end
+
+    def preserve_binding
+      raise ArgumentError, "No block given" unless block_given?
+      binding = current_binding
+      begin
+        yield
+      ensure
+        GL.glBindVertexArray(binding)
+      end
+    end
+
+  end # singleton_class
+
+
+  attr_reader :name
+
+  def initialize(name = nil)
+    @name = name || 0
+    yield self if block_given?
+  end
+
+  def delete
+    if @name != 0
+      GL.glDeleteVertexArrays(@name)
+      @name = 0
+    end
+    self
+  end
+
+  def is_vertex_array?
+    GL::glIsVertexArray(@name) != GL::GL_FALSE
+  end
+
+  def bind
+    if block_given?
+      self.class.preserve_binding do
+        bind
+        yield self
+      end
+    else
+      if @name == 0
+        @name = GL.glGenVertexArrays(1)
+        if @name == 0
+          raise GL::GLCreateError, "Unable to allocate vertex array object"
+        end
+      end
+
+      GL.glBindVertexArray(@name)
+      self
+    end
+  end
+
+end # GL::VertexArray

data/lib/opengl-aux.rb

@@ -0,0 +1,16 @@
+#  This file is part of the opengl-aux project.
+#  <https://github.com/nilium/opengl-aux>
+#
+#  -----------------------------------------------------------------------------
+#
+#  opengl-aux.rb
+#    Root file of opengl-aux -- requires all relevant sub-files.
+
+
+require 'opengl-aux/gl'
+require 'opengl-aux/error'
+require 'opengl-aux/vertex_array'
+require 'opengl-aux/buffer'
+require 'opengl-aux/texture'
+require 'opengl-aux/shader'
+require 'opengl-aux/program'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: opengl-aux
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre1
+platform: ruby
+authors:
+- Noel Raymond Cower
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opengl-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: snow-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description: A collection auxiliary of functions and types to simplify using the opengl-core
+  gem.
+email: ncower@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/opengl-aux.rb
+- lib/opengl-aux/buffer.rb
+- lib/opengl-aux/error.rb
+- lib/opengl-aux/gl.rb
+- lib/opengl-aux/program.rb
+- lib/opengl-aux/shader.rb
+- lib/opengl-aux/texture.rb
+- lib/opengl-aux/version.rb
+- lib/opengl-aux/vertex_array.rb
+homepage: https://github.com/nilium/opengl-aux
+licenses:
+- Simplified BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Auxiliary types and functions for OpenGL use.
+test_files: []
+has_rdoc: